text: module.exports =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			exports: {},
  /******/ 			id: moduleId,
  /******/ 			loaded: false
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(1);
  
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  "use strict";
  	  var builder, defaults, parser, processors,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  defaults = __webpack_require__(2);
  
  	  builder = __webpack_require__(3);
  
  	  parser = __webpack_require__(37);
  
  	  processors = __webpack_require__(71);
  
  	  exports.defaults = defaults.defaults;
  
  	  exports.processors = processors;
  
  	  exports.ValidationError = (function(superClass) {
  	    extend(ValidationError, superClass);
  
  	    function ValidationError(message) {
  	      this.message = message;
  	    }
  
  	    return ValidationError;
  
  	  })(Error);
  
  	  exports.Builder = builder.Builder;
  
  	  exports.Parser = parser.Parser;
  
  	  exports.parseString = parser.parseString;
  
  	  exports.parseStringPromise = parser.parseStringPromise;
  
  	}).call(this);
  
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  exports.defaults = {
  	    "0.1": {
  	      explicitCharkey: false,
  	      trim: true,
  	      normalize: true,
  	      normalizeTags: false,
  	      attrkey: "@",
  	      charkey: "#",
  	      explicitArray: false,
  	      ignoreAttrs: false,
  	      mergeAttrs: false,
  	      explicitRoot: false,
  	      validator: null,
  	      xmlns: false,
  	      explicitChildren: false,
  	      childkey: '@@',
  	      charsAsChildren: false,
  	      includeWhiteChars: false,
  	      async: false,
  	      strict: true,
  	      attrNameProcessors: null,
  	      attrValueProcessors: null,
  	      tagNameProcessors: null,
  	      valueProcessors: null,
  	      emptyTag: ''
  	    },
  	    "0.2": {
  	      explicitCharkey: false,
  	      trim: false,
  	      normalize: false,
  	      normalizeTags: false,
  	      attrkey: "$",
  	      charkey: "_",
  	      explicitArray: true,
  	      ignoreAttrs: false,
  	      mergeAttrs: false,
  	      explicitRoot: true,
  	      validator: null,
  	      xmlns: false,
  	      explicitChildren: false,
  	      preserveChildrenOrder: false,
  	      childkey: '$$',
  	      charsAsChildren: false,
  	      includeWhiteChars: false,
  	      async: false,
  	      strict: true,
  	      attrNameProcessors: null,
  	      attrValueProcessors: null,
  	      tagNameProcessors: null,
  	      valueProcessors: null,
  	      rootName: 'root',
  	      xmldec: {
  	        'version': '1.0',
  	        'encoding': 'UTF-8',
  	        'standalone': true
  	      },
  	      doctype: null,
  	      renderOpts: {
  	        'pretty': true,
  	        'indent': '  ',
  	        'newline': '\n'
  	      },
  	      headless: false,
  	      chunkSize: 10000,
  	      emptyTag: '',
  	      cdata: false
  	    }
  	  };
  
  	}).call(this);
  
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  "use strict";
  	  var builder, defaults, escapeCDATA, requiresCDATA, wrapCDATA,
  	    hasProp = {}.hasOwnProperty;
  
  	  builder = __webpack_require__(4);
  
  	  defaults = __webpack_require__(2).defaults;
  
  	  requiresCDATA = function(entry) {
  	    return typeof entry === "string" && (entry.indexOf('&') >= 0 || entry.indexOf('>') >= 0 || entry.indexOf('<') >= 0);
  	  };
  
  	  wrapCDATA = function(entry) {
  	    return "<![CDATA[" + (escapeCDATA(entry)) + "]]>";
  	  };
  
  	  escapeCDATA = function(entry) {
  	    return entry.replace(']]>', ']]]]><![CDATA[>');
  	  };
  
  	  exports.Builder = (function() {
  	    function Builder(opts) {
  	      var key, ref, value;
  	      this.options = {};
  	      ref = defaults["0.2"];
  	      for (key in ref) {
  	        if (!hasProp.call(ref, key)) continue;
  	        value = ref[key];
  	        this.options[key] = value;
  	      }
  	      for (key in opts) {
  	        if (!hasProp.call(opts, key)) continue;
  	        value = opts[key];
  	        this.options[key] = value;
  	      }
  	    }
  
  	    Builder.prototype.buildObject = function(rootObj) {
  	      var attrkey, charkey, render, rootElement, rootName;
  	      attrkey = this.options.attrkey;
  	      charkey = this.options.charkey;
  	      if ((Object.keys(rootObj).length === 1) && (this.options.rootName === defaults['0.2'].rootName)) {
  	        rootName = Object.keys(rootObj)[0];
  	        rootObj = rootObj[rootName];
  	      } else {
  	        rootName = this.options.rootName;
  	      }
  	      render = (function(_this) {
  	        return function(element, obj) {
  	          var attr, child, entry, index, key, value;
  	          if (typeof obj !== 'object') {
  	            if (_this.options.cdata && requiresCDATA(obj)) {
  	              element.raw(wrapCDATA(obj));
  	            } else {
  	              element.txt(obj);
  	            }
  	          } else if (Array.isArray(obj)) {
  	            for (index in obj) {
  	              if (!hasProp.call(obj, index)) continue;
  	              child = obj[index];
  	              for (key in child) {
  	                entry = child[key];
  	                element = render(element.ele(key), entry).up();
  	              }
  	            }
  	          } else {
  	            for (key in obj) {
  	              if (!hasProp.call(obj, key)) continue;
  	              child = obj[key];
  	              if (key === attrkey) {
  	                if (typeof child === "object") {
  	                  for (attr in child) {
  	                    value = child[attr];
  	                    element = element.att(attr, value);
  	                  }
  	                }
  	              } else if (key === charkey) {
  	                if (_this.options.cdata && requiresCDATA(child)) {
  	                  element = element.raw(wrapCDATA(child));
  	                } else {
  	                  element = element.txt(child);
  	                }
  	              } else if (Array.isArray(child)) {
  	                for (index in child) {
  	                  if (!hasProp.call(child, index)) continue;
  	                  entry = child[index];
  	                  if (typeof entry === 'string') {
  	                    if (_this.options.cdata && requiresCDATA(entry)) {
  	                      element = element.ele(key).raw(wrapCDATA(entry)).up();
  	                    } else {
  	                      element = element.ele(key, entry).up();
  	                    }
  	                  } else {
  	                    element = render(element.ele(key), entry).up();
  	                  }
  	                }
  	              } else if (typeof child === "object") {
  	                element = render(element.ele(key), child).up();
  	              } else {
  	                if (typeof child === 'string' && _this.options.cdata && requiresCDATA(child)) {
  	                  element = element.ele(key).raw(wrapCDATA(child)).up();
  	                } else {
  	                  if (child == null) {
  	                    child = '';
  	                  }
  	                  element = element.ele(key, child.toString()).up();
  	                }
  	              }
  	            }
  	          }
  	          return element;
  	        };
  	      })(this);
  	      rootElement = builder.create(rootName, this.options.xmldec, this.options.doctype, {
  	        headless: this.options.headless,
  	        allowSurrogateChars: this.options.allowSurrogateChars
  	      });
  	      return render(rootElement, rootObj).end(this.options.renderOpts);
  	    };
  
  	    return Builder;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, WriterState, XMLDOMImplementation, XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;
  
  	  ref = __webpack_require__(5), assign = ref.assign, isFunction = ref.isFunction;
  
  	  XMLDOMImplementation = __webpack_require__(6);
  
  	  XMLDocument = __webpack_require__(7);
  
  	  XMLDocumentCB = __webpack_require__(35);
  
  	  XMLStringWriter = __webpack_require__(32);
  
  	  XMLStreamWriter = __webpack_require__(36);
  
  	  NodeType = __webpack_require__(13);
  
  	  WriterState = __webpack_require__(34);
  
  	  module.exports.create = function(name, xmldec, doctype, options) {
  	    var doc, root;
  	    if (name == null) {
  	      throw new Error("Root element needs a name.");
  	    }
  	    options = assign({}, xmldec, doctype, options);
  	    doc = new XMLDocument(options);
  	    root = doc.element(name);
  	    if (!options.headless) {
  	      doc.declaration(options);
  	      if ((options.pubID != null) || (options.sysID != null)) {
  	        doc.dtd(options);
  	      }
  	    }
  	    return root;
  	  };
  
  	  module.exports.begin = function(options, onData, onEnd) {
  	    var ref1;
  	    if (isFunction(options)) {
  	      ref1 = [options, onData], onData = ref1[0], onEnd = ref1[1];
  	      options = {};
  	    }
  	    if (onData) {
  	      return new XMLDocumentCB(options, onData, onEnd);
  	    } else {
  	      return new XMLDocument(options);
  	    }
  	  };
  
  	  module.exports.stringWriter = function(options) {
  	    return new XMLStringWriter(options);
  	  };
  
  	  module.exports.streamWriter = function(stream, options) {
  	    return new XMLStreamWriter(stream, options);
  	  };
  
  	  module.exports.implementation = new XMLDOMImplementation();
  
  	  module.exports.nodeType = NodeType;
  
  	  module.exports.writerState = WriterState;
  
  	}).call(this);
  
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var assign, getValue, isArray, isEmpty, isFunction, isObject, isPlainObject,
  	    slice = [].slice,
  	    hasProp = {}.hasOwnProperty;
  
  	  assign = function() {
  	    var i, key, len, source, sources, target;
  	    target = arguments[0], sources = 2 <= arguments.length ? slice.call(arguments, 1) : [];
  	    if (isFunction(Object.assign)) {
  	      Object.assign.apply(null, arguments);
  	    } else {
  	      for (i = 0, len = sources.length; i < len; i++) {
  	        source = sources[i];
  	        if (source != null) {
  	          for (key in source) {
  	            if (!hasProp.call(source, key)) continue;
  	            target[key] = source[key];
  	          }
  	        }
  	      }
  	    }
  	    return target;
  	  };
  
  	  isFunction = function(val) {
  	    return !!val && Object.prototype.toString.call(val) === '[object Function]';
  	  };
  
  	  isObject = function(val) {
  	    var ref;
  	    return !!val && ((ref = typeof val) === 'function' || ref === 'object');
  	  };
  
  	  isArray = function(val) {
  	    if (isFunction(Array.isArray)) {
  	      return Array.isArray(val);
  	    } else {
  	      return Object.prototype.toString.call(val) === '[object Array]';
  	    }
  	  };
  
  	  isEmpty = function(val) {
  	    var key;
  	    if (isArray(val)) {
  	      return !val.length;
  	    } else {
  	      for (key in val) {
  	        if (!hasProp.call(val, key)) continue;
  	        return false;
  	      }
  	      return true;
  	    }
  	  };
  
  	  isPlainObject = function(val) {
  	    var ctor, proto;
  	    return isObject(val) && (proto = Object.getPrototypeOf(val)) && (ctor = proto.constructor) && (typeof ctor === 'function') && (ctor instanceof ctor) && (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
  	  };
  
  	  getValue = function(obj) {
  	    if (isFunction(obj.valueOf)) {
  	      return obj.valueOf();
  	    } else {
  	      return obj;
  	    }
  	  };
  
  	  module.exports.assign = assign;
  
  	  module.exports.isFunction = isFunction;
  
  	  module.exports.isObject = isObject;
  
  	  module.exports.isArray = isArray;
  
  	  module.exports.isEmpty = isEmpty;
  
  	  module.exports.isPlainObject = isPlainObject;
  
  	  module.exports.getValue = getValue;
  
  	}).call(this);
  
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLDOMImplementation;
  
  	  module.exports = XMLDOMImplementation = (function() {
  	    function XMLDOMImplementation() {}
  
  	    XMLDOMImplementation.prototype.hasFeature = function(feature, version) {
  	      return true;
  	    };
  
  	    XMLDOMImplementation.prototype.createDocumentType = function(qualifiedName, publicId, systemId) {
  	      throw new Error("This DOM method is not implemented.");
  	    };
  
  	    XMLDOMImplementation.prototype.createDocument = function(namespaceURI, qualifiedName, doctype) {
  	      throw new Error("This DOM method is not implemented.");
  	    };
  
  	    XMLDOMImplementation.prototype.createHTMLDocument = function(title) {
  	      throw new Error("This DOM method is not implemented.");
  	    };
  
  	    XMLDOMImplementation.prototype.getFeature = function(feature, version) {
  	      throw new Error("This DOM method is not implemented.");
  	    };
  
  	    return XMLDOMImplementation;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLDOMConfiguration, XMLDOMImplementation, XMLDocument, XMLNode, XMLStringWriter, XMLStringifier, isPlainObject,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  isPlainObject = __webpack_require__(5).isPlainObject;
  
  	  XMLDOMImplementation = __webpack_require__(6);
  
  	  XMLDOMConfiguration = __webpack_require__(8);
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLStringifier = __webpack_require__(31);
  
  	  XMLStringWriter = __webpack_require__(32);
  
  	  module.exports = XMLDocument = (function(superClass) {
  	    extend(XMLDocument, superClass);
  
  	    function XMLDocument(options) {
  	      XMLDocument.__super__.constructor.call(this, null);
  	      this.name = "#document";
  	      this.type = NodeType.Document;
  	      this.documentURI = null;
  	      this.domConfig = new XMLDOMConfiguration();
  	      options || (options = {});
  	      if (!options.writer) {
  	        options.writer = new XMLStringWriter();
  	      }
  	      this.options = options;
  	      this.stringify = new XMLStringifier(options);
  	    }
  
  	    Object.defineProperty(XMLDocument.prototype, 'implementation', {
  	      value: new XMLDOMImplementation()
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'doctype', {
  	      get: function() {
  	        var child, i, len, ref;
  	        ref = this.children;
  	        for (i = 0, len = ref.length; i < len; i++) {
  	          child = ref[i];
  	          if (child.type === NodeType.DocType) {
  	            return child;
  	          }
  	        }
  	        return null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'documentElement', {
  	      get: function() {
  	        return this.rootObject || null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'inputEncoding', {
  	      get: function() {
  	        return null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'strictErrorChecking', {
  	      get: function() {
  	        return false;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'xmlEncoding', {
  	      get: function() {
  	        if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
  	          return this.children[0].encoding;
  	        } else {
  	          return null;
  	        }
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'xmlStandalone', {
  	      get: function() {
  	        if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
  	          return this.children[0].standalone === 'yes';
  	        } else {
  	          return false;
  	        }
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'xmlVersion', {
  	      get: function() {
  	        if (this.children.length !== 0 && this.children[0].type === NodeType.Declaration) {
  	          return this.children[0].version;
  	        } else {
  	          return "1.0";
  	        }
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'URL', {
  	      get: function() {
  	        return this.documentURI;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'origin', {
  	      get: function() {
  	        return null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'compatMode', {
  	      get: function() {
  	        return null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'characterSet', {
  	      get: function() {
  	        return null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocument.prototype, 'contentType', {
  	      get: function() {
  	        return null;
  	      }
  	    });
  
  	    XMLDocument.prototype.end = function(writer) {
  	      var writerOptions;
  	      writerOptions = {};
  	      if (!writer) {
  	        writer = this.options.writer;
  	      } else if (isPlainObject(writer)) {
  	        writerOptions = writer;
  	        writer = this.options.writer;
  	      }
  	      return writer.document(this, writer.filterOptions(writerOptions));
  	    };
  
  	    XMLDocument.prototype.toString = function(options) {
  	      return this.options.writer.document(this, this.options.writer.filterOptions(options));
  	    };
  
  	    XMLDocument.prototype.createElement = function(tagName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createDocumentFragment = function() {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createTextNode = function(data) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createComment = function(data) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createCDATASection = function(data) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createProcessingInstruction = function(target, data) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createAttribute = function(name) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createEntityReference = function(name) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.getElementsByTagName = function(tagname) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.importNode = function(importedNode, deep) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createElementNS = function(namespaceURI, qualifiedName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createAttributeNS = function(namespaceURI, qualifiedName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.getElementById = function(elementId) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.adoptNode = function(source) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.normalizeDocument = function() {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.renameNode = function(node, namespaceURI, qualifiedName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.getElementsByClassName = function(classNames) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createEvent = function(eventInterface) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createRange = function() {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createNodeIterator = function(root, whatToShow, filter) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLDocument.prototype.createTreeWalker = function(root, whatToShow, filter) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    return XMLDocument;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLDOMConfiguration, XMLDOMErrorHandler, XMLDOMStringList;
  
  	  XMLDOMErrorHandler = __webpack_require__(9);
  
  	  XMLDOMStringList = __webpack_require__(10);
  
  	  module.exports = XMLDOMConfiguration = (function() {
  	    function XMLDOMConfiguration() {
  	      var clonedSelf;
  	      this.defaultParams = {
  	        "canonical-form": false,
  	        "cdata-sections": false,
  	        "comments": false,
  	        "datatype-normalization": false,
  	        "element-content-whitespace": true,
  	        "entities": true,
  	        "error-handler": new XMLDOMErrorHandler(),
  	        "infoset": true,
  	        "validate-if-schema": false,
  	        "namespaces": true,
  	        "namespace-declarations": true,
  	        "normalize-characters": false,
  	        "schema-location": '',
  	        "schema-type": '',
  	        "split-cdata-sections": true,
  	        "validate": false,
  	        "well-formed": true
  	      };
  	      this.params = clonedSelf = Object.create(this.defaultParams);
  	    }
  
  	    Object.defineProperty(XMLDOMConfiguration.prototype, 'parameterNames', {
  	      get: function() {
  	        return new XMLDOMStringList(Object.keys(this.defaultParams));
  	      }
  	    });
  
  	    XMLDOMConfiguration.prototype.getParameter = function(name) {
  	      if (this.params.hasOwnProperty(name)) {
  	        return this.params[name];
  	      } else {
  	        return null;
  	      }
  	    };
  
  	    XMLDOMConfiguration.prototype.canSetParameter = function(name, value) {
  	      return true;
  	    };
  
  	    XMLDOMConfiguration.prototype.setParameter = function(name, value) {
  	      if (value != null) {
  	        return this.params[name] = value;
  	      } else {
  	        return delete this.params[name];
  	      }
  	    };
  
  	    return XMLDOMConfiguration;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLDOMErrorHandler;
  
  	  module.exports = XMLDOMErrorHandler = (function() {
  	    function XMLDOMErrorHandler() {}
  
  	    XMLDOMErrorHandler.prototype.handleError = function(error) {
  	      throw new Error(error);
  	    };
  
  	    return XMLDOMErrorHandler;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 10 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLDOMStringList;
  
  	  module.exports = XMLDOMStringList = (function() {
  	    function XMLDOMStringList(arr) {
  	      this.arr = arr || [];
  	    }
  
  	    Object.defineProperty(XMLDOMStringList.prototype, 'length', {
  	      get: function() {
  	        return this.arr.length;
  	      }
  	    });
  
  	    XMLDOMStringList.prototype.item = function(index) {
  	      return this.arr[index] || null;
  	    };
  
  	    XMLDOMStringList.prototype.contains = function(str) {
  	      return this.arr.indexOf(str) !== -1;
  	    };
  
  	    return XMLDOMStringList;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 11 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var DocumentPosition, NodeType, XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLNamedNodeMap, XMLNode, XMLNodeList, XMLProcessingInstruction, XMLRaw, XMLText, getValue, isEmpty, isFunction, isObject, ref1,
  	    hasProp = {}.hasOwnProperty;
  
  	  ref1 = __webpack_require__(5), isObject = ref1.isObject, isFunction = ref1.isFunction, isEmpty = ref1.isEmpty, getValue = ref1.getValue;
  
  	  XMLElement = null;
  
  	  XMLCData = null;
  
  	  XMLComment = null;
  
  	  XMLDeclaration = null;
  
  	  XMLDocType = null;
  
  	  XMLRaw = null;
  
  	  XMLText = null;
  
  	  XMLProcessingInstruction = null;
  
  	  XMLDummy = null;
  
  	  NodeType = null;
  
  	  XMLNodeList = null;
  
  	  XMLNamedNodeMap = null;
  
  	  DocumentPosition = null;
  
  	  module.exports = XMLNode = (function() {
  	    function XMLNode(parent1) {
  	      this.parent = parent1;
  	      if (this.parent) {
  	        this.options = this.parent.options;
  	        this.stringify = this.parent.stringify;
  	      }
  	      this.value = null;
  	      this.children = [];
  	      this.baseURI = null;
  	      if (!XMLElement) {
  	        XMLElement = __webpack_require__(12);
  	        XMLCData = __webpack_require__(16);
  	        XMLComment = __webpack_require__(18);
  	        XMLDeclaration = __webpack_require__(19);
  	        XMLDocType = __webpack_require__(20);
  	        XMLRaw = __webpack_require__(25);
  	        XMLText = __webpack_require__(26);
  	        XMLProcessingInstruction = __webpack_require__(27);
  	        XMLDummy = __webpack_require__(28);
  	        NodeType = __webpack_require__(13);
  	        XMLNodeList = __webpack_require__(29);
  	        XMLNamedNodeMap = __webpack_require__(15);
  	        DocumentPosition = __webpack_require__(30);
  	      }
  	    }
  
  	    Object.defineProperty(XMLNode.prototype, 'nodeName', {
  	      get: function() {
  	        return this.name;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'nodeType', {
  	      get: function() {
  	        return this.type;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'nodeValue', {
  	      get: function() {
  	        return this.value;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'parentNode', {
  	      get: function() {
  	        return this.parent;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'childNodes', {
  	      get: function() {
  	        if (!this.childNodeList || !this.childNodeList.nodes) {
  	          this.childNodeList = new XMLNodeList(this.children);
  	        }
  	        return this.childNodeList;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'firstChild', {
  	      get: function() {
  	        return this.children[0] || null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'lastChild', {
  	      get: function() {
  	        return this.children[this.children.length - 1] || null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'previousSibling', {
  	      get: function() {
  	        var i;
  	        i = this.parent.children.indexOf(this);
  	        return this.parent.children[i - 1] || null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'nextSibling', {
  	      get: function() {
  	        var i;
  	        i = this.parent.children.indexOf(this);
  	        return this.parent.children[i + 1] || null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'ownerDocument', {
  	      get: function() {
  	        return this.document() || null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLNode.prototype, 'textContent', {
  	      get: function() {
  	        var child, j, len, ref2, str;
  	        if (this.nodeType === NodeType.Element || this.nodeType === NodeType.DocumentFragment) {
  	          str = '';
  	          ref2 = this.children;
  	          for (j = 0, len = ref2.length; j < len; j++) {
  	            child = ref2[j];
  	            if (child.textContent) {
  	              str += child.textContent;
  	            }
  	          }
  	          return str;
  	        } else {
  	          return null;
  	        }
  	      },
  	      set: function(value) {
  	        throw new Error("This DOM method is not implemented." + this.debugInfo());
  	      }
  	    });
  
  	    XMLNode.prototype.setParent = function(parent) {
  	      var child, j, len, ref2, results;
  	      this.parent = parent;
  	      if (parent) {
  	        this.options = parent.options;
  	        this.stringify = parent.stringify;
  	      }
  	      ref2 = this.children;
  	      results = [];
  	      for (j = 0, len = ref2.length; j < len; j++) {
  	        child = ref2[j];
  	        results.push(child.setParent(this));
  	      }
  	      return results;
  	    };
  
  	    XMLNode.prototype.element = function(name, attributes, text) {
  	      var childNode, item, j, k, key, lastChild, len, len1, ref2, ref3, val;
  	      lastChild = null;
  	      if (attributes === null && (text == null)) {
  	        ref2 = [{}, null], attributes = ref2[0], text = ref2[1];
  	      }
  	      if (attributes == null) {
  	        attributes = {};
  	      }
  	      attributes = getValue(attributes);
  	      if (!isObject(attributes)) {
  	        ref3 = [attributes, text], text = ref3[0], attributes = ref3[1];
  	      }
  	      if (name != null) {
  	        name = getValue(name);
  	      }
  	      if (Array.isArray(name)) {
  	        for (j = 0, len = name.length; j < len; j++) {
  	          item = name[j];
  	          lastChild = this.element(item);
  	        }
  	      } else if (isFunction(name)) {
  	        lastChild = this.element(name.apply());
  	      } else if (isObject(name)) {
  	        for (key in name) {
  	          if (!hasProp.call(name, key)) continue;
  	          val = name[key];
  	          if (isFunction(val)) {
  	            val = val.apply();
  	          }
  	          if (!this.options.ignoreDecorators && this.stringify.convertAttKey && key.indexOf(this.stringify.convertAttKey) === 0) {
  	            lastChild = this.attribute(key.substr(this.stringify.convertAttKey.length), val);
  	          } else if (!this.options.separateArrayItems && Array.isArray(val) && isEmpty(val)) {
  	            lastChild = this.dummy();
  	          } else if (isObject(val) && isEmpty(val)) {
  	            lastChild = this.element(key);
  	          } else if (!this.options.keepNullNodes && (val == null)) {
  	            lastChild = this.dummy();
  	          } else if (!this.options.separateArrayItems && Array.isArray(val)) {
  	            for (k = 0, len1 = val.length; k < len1; k++) {
  	              item = val[k];
  	              childNode = {};
  	              childNode[key] = item;
  	              lastChild = this.element(childNode);
  	            }
  	          } else if (isObject(val)) {
  	            if (!this.options.ignoreDecorators && this.stringify.convertTextKey && key.indexOf(this.stringify.convertTextKey) === 0) {
  	              lastChild = this.element(val);
  	            } else {
  	              lastChild = this.element(key);
  	              lastChild.element(val);
  	            }
  	          } else {
  	            lastChild = this.element(key, val);
  	          }
  	        }
  	      } else if (!this.options.keepNullNodes && text === null) {
  	        lastChild = this.dummy();
  	      } else {
  	        if (!this.options.ignoreDecorators && this.stringify.convertTextKey && name.indexOf(this.stringify.convertTextKey) === 0) {
  	          lastChild = this.text(text);
  	        } else if (!this.options.ignoreDecorators && this.stringify.convertCDataKey && name.indexOf(this.stringify.convertCDataKey) === 0) {
  	          lastChild = this.cdata(text);
  	        } else if (!this.options.ignoreDecorators && this.stringify.convertCommentKey && name.indexOf(this.stringify.convertCommentKey) === 0) {
  	          lastChild = this.comment(text);
  	        } else if (!this.options.ignoreDecorators && this.stringify.convertRawKey && name.indexOf(this.stringify.convertRawKey) === 0) {
  	          lastChild = this.raw(text);
  	        } else if (!this.options.ignoreDecorators && this.stringify.convertPIKey && name.indexOf(this.stringify.convertPIKey) === 0) {
  	          lastChild = this.instruction(name.substr(this.stringify.convertPIKey.length), text);
  	        } else {
  	          lastChild = this.node(name, attributes, text);
  	        }
  	      }
  	      if (lastChild == null) {
  	        throw new Error("Could not create any elements with: " + name + ". " + this.debugInfo());
  	      }
  	      return lastChild;
  	    };
  
  	    XMLNode.prototype.insertBefore = function(name, attributes, text) {
  	      var child, i, newChild, refChild, removed;
  	      if (name != null ? name.type : void 0) {
  	        newChild = name;
  	        refChild = attributes;
  	        newChild.setParent(this);
  	        if (refChild) {
  	          i = children.indexOf(refChild);
  	          removed = children.splice(i);
  	          children.push(newChild);
  	          Array.prototype.push.apply(children, removed);
  	        } else {
  	          children.push(newChild);
  	        }
  	        return newChild;
  	      } else {
  	        if (this.isRoot) {
  	          throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
  	        }
  	        i = this.parent.children.indexOf(this);
  	        removed = this.parent.children.splice(i);
  	        child = this.parent.element(name, attributes, text);
  	        Array.prototype.push.apply(this.parent.children, removed);
  	        return child;
  	      }
  	    };
  
  	    XMLNode.prototype.insertAfter = function(name, attributes, text) {
  	      var child, i, removed;
  	      if (this.isRoot) {
  	        throw new Error("Cannot insert elements at root level. " + this.debugInfo(name));
  	      }
  	      i = this.parent.children.indexOf(this);
  	      removed = this.parent.children.splice(i + 1);
  	      child = this.parent.element(name, attributes, text);
  	      Array.prototype.push.apply(this.parent.children, removed);
  	      return child;
  	    };
  
  	    XMLNode.prototype.remove = function() {
  	      var i, ref2;
  	      if (this.isRoot) {
  	        throw new Error("Cannot remove the root element. " + this.debugInfo());
  	      }
  	      i = this.parent.children.indexOf(this);
  	      [].splice.apply(this.parent.children, [i, i - i + 1].concat(ref2 = [])), ref2;
  	      return this.parent;
  	    };
  
  	    XMLNode.prototype.node = function(name, attributes, text) {
  	      var child, ref2;
  	      if (name != null) {
  	        name = getValue(name);
  	      }
  	      attributes || (attributes = {});
  	      attributes = getValue(attributes);
  	      if (!isObject(attributes)) {
  	        ref2 = [attributes, text], text = ref2[0], attributes = ref2[1];
  	      }
  	      child = new XMLElement(this, name, attributes);
  	      if (text != null) {
  	        child.text(text);
  	      }
  	      this.children.push(child);
  	      return child;
  	    };
  
  	    XMLNode.prototype.text = function(value) {
  	      var child;
  	      if (isObject(value)) {
  	        this.element(value);
  	      }
  	      child = new XMLText(this, value);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLNode.prototype.cdata = function(value) {
  	      var child;
  	      child = new XMLCData(this, value);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLNode.prototype.comment = function(value) {
  	      var child;
  	      child = new XMLComment(this, value);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLNode.prototype.commentBefore = function(value) {
  	      var child, i, removed;
  	      i = this.parent.children.indexOf(this);
  	      removed = this.parent.children.splice(i);
  	      child = this.parent.comment(value);
  	      Array.prototype.push.apply(this.parent.children, removed);
  	      return this;
  	    };
  
  	    XMLNode.prototype.commentAfter = function(value) {
  	      var child, i, removed;
  	      i = this.parent.children.indexOf(this);
  	      removed = this.parent.children.splice(i + 1);
  	      child = this.parent.comment(value);
  	      Array.prototype.push.apply(this.parent.children, removed);
  	      return this;
  	    };
  
  	    XMLNode.prototype.raw = function(value) {
  	      var child;
  	      child = new XMLRaw(this, value);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLNode.prototype.dummy = function() {
  	      var child;
  	      child = new XMLDummy(this);
  	      return child;
  	    };
  
  	    XMLNode.prototype.instruction = function(target, value) {
  	      var insTarget, insValue, instruction, j, len;
  	      if (target != null) {
  	        target = getValue(target);
  	      }
  	      if (value != null) {
  	        value = getValue(value);
  	      }
  	      if (Array.isArray(target)) {
  	        for (j = 0, len = target.length; j < len; j++) {
  	          insTarget = target[j];
  	          this.instruction(insTarget);
  	        }
  	      } else if (isObject(target)) {
  	        for (insTarget in target) {
  	          if (!hasProp.call(target, insTarget)) continue;
  	          insValue = target[insTarget];
  	          this.instruction(insTarget, insValue);
  	        }
  	      } else {
  	        if (isFunction(value)) {
  	          value = value.apply();
  	        }
  	        instruction = new XMLProcessingInstruction(this, target, value);
  	        this.children.push(instruction);
  	      }
  	      return this;
  	    };
  
  	    XMLNode.prototype.instructionBefore = function(target, value) {
  	      var child, i, removed;
  	      i = this.parent.children.indexOf(this);
  	      removed = this.parent.children.splice(i);
  	      child = this.parent.instruction(target, value);
  	      Array.prototype.push.apply(this.parent.children, removed);
  	      return this;
  	    };
  
  	    XMLNode.prototype.instructionAfter = function(target, value) {
  	      var child, i, removed;
  	      i = this.parent.children.indexOf(this);
  	      removed = this.parent.children.splice(i + 1);
  	      child = this.parent.instruction(target, value);
  	      Array.prototype.push.apply(this.parent.children, removed);
  	      return this;
  	    };
  
  	    XMLNode.prototype.declaration = function(version, encoding, standalone) {
  	      var doc, xmldec;
  	      doc = this.document();
  	      xmldec = new XMLDeclaration(doc, version, encoding, standalone);
  	      if (doc.children.length === 0) {
  	        doc.children.unshift(xmldec);
  	      } else if (doc.children[0].type === NodeType.Declaration) {
  	        doc.children[0] = xmldec;
  	      } else {
  	        doc.children.unshift(xmldec);
  	      }
  	      return doc.root() || doc;
  	    };
  
  	    XMLNode.prototype.dtd = function(pubID, sysID) {
  	      var child, doc, doctype, i, j, k, len, len1, ref2, ref3;
  	      doc = this.document();
  	      doctype = new XMLDocType(doc, pubID, sysID);
  	      ref2 = doc.children;
  	      for (i = j = 0, len = ref2.length; j < len; i = ++j) {
  	        child = ref2[i];
  	        if (child.type === NodeType.DocType) {
  	          doc.children[i] = doctype;
  	          return doctype;
  	        }
  	      }
  	      ref3 = doc.children;
  	      for (i = k = 0, len1 = ref3.length; k < len1; i = ++k) {
  	        child = ref3[i];
  	        if (child.isRoot) {
  	          doc.children.splice(i, 0, doctype);
  	          return doctype;
  	        }
  	      }
  	      doc.children.push(doctype);
  	      return doctype;
  	    };
  
  	    XMLNode.prototype.up = function() {
  	      if (this.isRoot) {
  	        throw new Error("The root node has no parent. Use doc() if you need to get the document object.");
  	      }
  	      return this.parent;
  	    };
  
  	    XMLNode.prototype.root = function() {
  	      var node;
  	      node = this;
  	      while (node) {
  	        if (node.type === NodeType.Document) {
  	          return node.rootObject;
  	        } else if (node.isRoot) {
  	          return node;
  	        } else {
  	          node = node.parent;
  	        }
  	      }
  	    };
  
  	    XMLNode.prototype.document = function() {
  	      var node;
  	      node = this;
  	      while (node) {
  	        if (node.type === NodeType.Document) {
  	          return node;
  	        } else {
  	          node = node.parent;
  	        }
  	      }
  	    };
  
  	    XMLNode.prototype.end = function(options) {
  	      return this.document().end(options);
  	    };
  
  	    XMLNode.prototype.prev = function() {
  	      var i;
  	      i = this.parent.children.indexOf(this);
  	      if (i < 1) {
  	        throw new Error("Already at the first node. " + this.debugInfo());
  	      }
  	      return this.parent.children[i - 1];
  	    };
  
  	    XMLNode.prototype.next = function() {
  	      var i;
  	      i = this.parent.children.indexOf(this);
  	      if (i === -1 || i === this.parent.children.length - 1) {
  	        throw new Error("Already at the last node. " + this.debugInfo());
  	      }
  	      return this.parent.children[i + 1];
  	    };
  
  	    XMLNode.prototype.importDocument = function(doc) {
  	      var clonedRoot;
  	      clonedRoot = doc.root().clone();
  	      clonedRoot.parent = this;
  	      clonedRoot.isRoot = false;
  	      this.children.push(clonedRoot);
  	      return this;
  	    };
  
  	    XMLNode.prototype.debugInfo = function(name) {
  	      var ref2, ref3;
  	      name = name || this.name;
  	      if ((name == null) && !((ref2 = this.parent) != null ? ref2.name : void 0)) {
  	        return "";
  	      } else if (name == null) {
  	        return "parent: <" + this.parent.name + ">";
  	      } else if (!((ref3 = this.parent) != null ? ref3.name : void 0)) {
  	        return "node: <" + name + ">";
  	      } else {
  	        return "node: <" + name + ">, parent: <" + this.parent.name + ">";
  	      }
  	    };
  
  	    XMLNode.prototype.ele = function(name, attributes, text) {
  	      return this.element(name, attributes, text);
  	    };
  
  	    XMLNode.prototype.nod = function(name, attributes, text) {
  	      return this.node(name, attributes, text);
  	    };
  
  	    XMLNode.prototype.txt = function(value) {
  	      return this.text(value);
  	    };
  
  	    XMLNode.prototype.dat = function(value) {
  	      return this.cdata(value);
  	    };
  
  	    XMLNode.prototype.com = function(value) {
  	      return this.comment(value);
  	    };
  
  	    XMLNode.prototype.ins = function(target, value) {
  	      return this.instruction(target, value);
  	    };
  
  	    XMLNode.prototype.doc = function() {
  	      return this.document();
  	    };
  
  	    XMLNode.prototype.dec = function(version, encoding, standalone) {
  	      return this.declaration(version, encoding, standalone);
  	    };
  
  	    XMLNode.prototype.e = function(name, attributes, text) {
  	      return this.element(name, attributes, text);
  	    };
  
  	    XMLNode.prototype.n = function(name, attributes, text) {
  	      return this.node(name, attributes, text);
  	    };
  
  	    XMLNode.prototype.t = function(value) {
  	      return this.text(value);
  	    };
  
  	    XMLNode.prototype.d = function(value) {
  	      return this.cdata(value);
  	    };
  
  	    XMLNode.prototype.c = function(value) {
  	      return this.comment(value);
  	    };
  
  	    XMLNode.prototype.r = function(value) {
  	      return this.raw(value);
  	    };
  
  	    XMLNode.prototype.i = function(target, value) {
  	      return this.instruction(target, value);
  	    };
  
  	    XMLNode.prototype.u = function() {
  	      return this.up();
  	    };
  
  	    XMLNode.prototype.importXMLBuilder = function(doc) {
  	      return this.importDocument(doc);
  	    };
  
  	    XMLNode.prototype.replaceChild = function(newChild, oldChild) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.removeChild = function(oldChild) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.appendChild = function(newChild) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.hasChildNodes = function() {
  	      return this.children.length !== 0;
  	    };
  
  	    XMLNode.prototype.cloneNode = function(deep) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.normalize = function() {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.isSupported = function(feature, version) {
  	      return true;
  	    };
  
  	    XMLNode.prototype.hasAttributes = function() {
  	      return this.attribs.length !== 0;
  	    };
  
  	    XMLNode.prototype.compareDocumentPosition = function(other) {
  	      var ref, res;
  	      ref = this;
  	      if (ref === other) {
  	        return 0;
  	      } else if (this.document() !== other.document()) {
  	        res = DocumentPosition.Disconnected | DocumentPosition.ImplementationSpecific;
  	        if (Math.random() < 0.5) {
  	          res |= DocumentPosition.Preceding;
  	        } else {
  	          res |= DocumentPosition.Following;
  	        }
  	        return res;
  	      } else if (ref.isAncestor(other)) {
  	        return DocumentPosition.Contains | DocumentPosition.Preceding;
  	      } else if (ref.isDescendant(other)) {
  	        return DocumentPosition.Contains | DocumentPosition.Following;
  	      } else if (ref.isPreceding(other)) {
  	        return DocumentPosition.Preceding;
  	      } else {
  	        return DocumentPosition.Following;
  	      }
  	    };
  
  	    XMLNode.prototype.isSameNode = function(other) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.lookupPrefix = function(namespaceURI) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.isDefaultNamespace = function(namespaceURI) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.lookupNamespaceURI = function(prefix) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.isEqualNode = function(node) {
  	      var i, j, ref2;
  	      if (node.nodeType !== this.nodeType) {
  	        return false;
  	      }
  	      if (node.children.length !== this.children.length) {
  	        return false;
  	      }
  	      for (i = j = 0, ref2 = this.children.length - 1; 0 <= ref2 ? j <= ref2 : j >= ref2; i = 0 <= ref2 ? ++j : --j) {
  	        if (!this.children[i].isEqualNode(node.children[i])) {
  	          return false;
  	        }
  	      }
  	      return true;
  	    };
  
  	    XMLNode.prototype.getFeature = function(feature, version) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.setUserData = function(key, data, handler) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.getUserData = function(key) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLNode.prototype.contains = function(other) {
  	      if (!other) {
  	        return false;
  	      }
  	      return other === this || this.isDescendant(other);
  	    };
  
  	    XMLNode.prototype.isDescendant = function(node) {
  	      var child, isDescendantChild, j, len, ref2;
  	      ref2 = this.children;
  	      for (j = 0, len = ref2.length; j < len; j++) {
  	        child = ref2[j];
  	        if (node === child) {
  	          return true;
  	        }
  	        isDescendantChild = child.isDescendant(node);
  	        if (isDescendantChild) {
  	          return true;
  	        }
  	      }
  	      return false;
  	    };
  
  	    XMLNode.prototype.isAncestor = function(node) {
  	      return node.isDescendant(this);
  	    };
  
  	    XMLNode.prototype.isPreceding = function(node) {
  	      var nodePos, thisPos;
  	      nodePos = this.treePosition(node);
  	      thisPos = this.treePosition(this);
  	      if (nodePos === -1 || thisPos === -1) {
  	        return false;
  	      } else {
  	        return nodePos < thisPos;
  	      }
  	    };
  
  	    XMLNode.prototype.isFollowing = function(node) {
  	      var nodePos, thisPos;
  	      nodePos = this.treePosition(node);
  	      thisPos = this.treePosition(this);
  	      if (nodePos === -1 || thisPos === -1) {
  	        return false;
  	      } else {
  	        return nodePos > thisPos;
  	      }
  	    };
  
  	    XMLNode.prototype.treePosition = function(node) {
  	      var found, pos;
  	      pos = 0;
  	      found = false;
  	      this.foreachTreeNode(this.document(), function(childNode) {
  	        pos++;
  	        if (!found && childNode === node) {
  	          return found = true;
  	        }
  	      });
  	      if (found) {
  	        return pos;
  	      } else {
  	        return -1;
  	      }
  	    };
  
  	    XMLNode.prototype.foreachTreeNode = function(node, func) {
  	      var child, j, len, ref2, res;
  	      node || (node = this.document());
  	      ref2 = node.children;
  	      for (j = 0, len = ref2.length; j < len; j++) {
  	        child = ref2[j];
  	        if (res = func(child)) {
  	          return res;
  	        } else {
  	          res = this.foreachTreeNode(child, func);
  	          if (res) {
  	            return res;
  	          }
  	        }
  	      }
  	    };
  
  	    return XMLNode;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 12 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLAttribute, XMLElement, XMLNamedNodeMap, XMLNode, getValue, isFunction, isObject, ref,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  ref = __webpack_require__(5), isObject = ref.isObject, isFunction = ref.isFunction, getValue = ref.getValue;
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLAttribute = __webpack_require__(14);
  
  	  XMLNamedNodeMap = __webpack_require__(15);
  
  	  module.exports = XMLElement = (function(superClass) {
  	    extend(XMLElement, superClass);
  
  	    function XMLElement(parent, name, attributes) {
  	      var child, j, len, ref1;
  	      XMLElement.__super__.constructor.call(this, parent);
  	      if (name == null) {
  	        throw new Error("Missing element name. " + this.debugInfo());
  	      }
  	      this.name = this.stringify.name(name);
  	      this.type = NodeType.Element;
  	      this.attribs = {};
  	      this.schemaTypeInfo = null;
  	      if (attributes != null) {
  	        this.attribute(attributes);
  	      }
  	      if (parent.type === NodeType.Document) {
  	        this.isRoot = true;
  	        this.documentObject = parent;
  	        parent.rootObject = this;
  	        if (parent.children) {
  	          ref1 = parent.children;
  	          for (j = 0, len = ref1.length; j < len; j++) {
  	            child = ref1[j];
  	            if (child.type === NodeType.DocType) {
  	              child.name = this.name;
  	              break;
  	            }
  	          }
  	        }
  	      }
  	    }
  
  	    Object.defineProperty(XMLElement.prototype, 'tagName', {
  	      get: function() {
  	        return this.name;
  	      }
  	    });
  
  	    Object.defineProperty(XMLElement.prototype, 'namespaceURI', {
  	      get: function() {
  	        return '';
  	      }
  	    });
  
  	    Object.defineProperty(XMLElement.prototype, 'prefix', {
  	      get: function() {
  	        return '';
  	      }
  	    });
  
  	    Object.defineProperty(XMLElement.prototype, 'localName', {
  	      get: function() {
  	        return this.name;
  	      }
  	    });
  
  	    Object.defineProperty(XMLElement.prototype, 'id', {
  	      get: function() {
  	        throw new Error("This DOM method is not implemented." + this.debugInfo());
  	      }
  	    });
  
  	    Object.defineProperty(XMLElement.prototype, 'className', {
  	      get: function() {
  	        throw new Error("This DOM method is not implemented." + this.debugInfo());
  	      }
  	    });
  
  	    Object.defineProperty(XMLElement.prototype, 'classList', {
  	      get: function() {
  	        throw new Error("This DOM method is not implemented." + this.debugInfo());
  	      }
  	    });
  
  	    Object.defineProperty(XMLElement.prototype, 'attributes', {
  	      get: function() {
  	        if (!this.attributeMap || !this.attributeMap.nodes) {
  	          this.attributeMap = new XMLNamedNodeMap(this.attribs);
  	        }
  	        return this.attributeMap;
  	      }
  	    });
  
  	    XMLElement.prototype.clone = function() {
  	      var att, attName, clonedSelf, ref1;
  	      clonedSelf = Object.create(this);
  	      if (clonedSelf.isRoot) {
  	        clonedSelf.documentObject = null;
  	      }
  	      clonedSelf.attribs = {};
  	      ref1 = this.attribs;
  	      for (attName in ref1) {
  	        if (!hasProp.call(ref1, attName)) continue;
  	        att = ref1[attName];
  	        clonedSelf.attribs[attName] = att.clone();
  	      }
  	      clonedSelf.children = [];
  	      this.children.forEach(function(child) {
  	        var clonedChild;
  	        clonedChild = child.clone();
  	        clonedChild.parent = clonedSelf;
  	        return clonedSelf.children.push(clonedChild);
  	      });
  	      return clonedSelf;
  	    };
  
  	    XMLElement.prototype.attribute = function(name, value) {
  	      var attName, attValue;
  	      if (name != null) {
  	        name = getValue(name);
  	      }
  	      if (isObject(name)) {
  	        for (attName in name) {
  	          if (!hasProp.call(name, attName)) continue;
  	          attValue = name[attName];
  	          this.attribute(attName, attValue);
  	        }
  	      } else {
  	        if (isFunction(value)) {
  	          value = value.apply();
  	        }
  	        if (this.options.keepNullAttributes && (value == null)) {
  	          this.attribs[name] = new XMLAttribute(this, name, "");
  	        } else if (value != null) {
  	          this.attribs[name] = new XMLAttribute(this, name, value);
  	        }
  	      }
  	      return this;
  	    };
  
  	    XMLElement.prototype.removeAttribute = function(name) {
  	      var attName, j, len;
  	      if (name == null) {
  	        throw new Error("Missing attribute name. " + this.debugInfo());
  	      }
  	      name = getValue(name);
  	      if (Array.isArray(name)) {
  	        for (j = 0, len = name.length; j < len; j++) {
  	          attName = name[j];
  	          delete this.attribs[attName];
  	        }
  	      } else {
  	        delete this.attribs[name];
  	      }
  	      return this;
  	    };
  
  	    XMLElement.prototype.toString = function(options) {
  	      return this.options.writer.element(this, this.options.writer.filterOptions(options));
  	    };
  
  	    XMLElement.prototype.att = function(name, value) {
  	      return this.attribute(name, value);
  	    };
  
  	    XMLElement.prototype.a = function(name, value) {
  	      return this.attribute(name, value);
  	    };
  
  	    XMLElement.prototype.getAttribute = function(name) {
  	      if (this.attribs.hasOwnProperty(name)) {
  	        return this.attribs[name].value;
  	      } else {
  	        return null;
  	      }
  	    };
  
  	    XMLElement.prototype.setAttribute = function(name, value) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.getAttributeNode = function(name) {
  	      if (this.attribs.hasOwnProperty(name)) {
  	        return this.attribs[name];
  	      } else {
  	        return null;
  	      }
  	    };
  
  	    XMLElement.prototype.setAttributeNode = function(newAttr) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.removeAttributeNode = function(oldAttr) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.getElementsByTagName = function(name) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.getAttributeNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.setAttributeNS = function(namespaceURI, qualifiedName, value) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.removeAttributeNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.getAttributeNodeNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.setAttributeNodeNS = function(newAttr) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.hasAttribute = function(name) {
  	      return this.attribs.hasOwnProperty(name);
  	    };
  
  	    XMLElement.prototype.hasAttributeNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.setIdAttribute = function(name, isId) {
  	      if (this.attribs.hasOwnProperty(name)) {
  	        return this.attribs[name].isId;
  	      } else {
  	        return isId;
  	      }
  	    };
  
  	    XMLElement.prototype.setIdAttributeNS = function(namespaceURI, localName, isId) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.setIdAttributeNode = function(idAttr, isId) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.getElementsByTagName = function(tagname) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.getElementsByTagNameNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.getElementsByClassName = function(classNames) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLElement.prototype.isEqualNode = function(node) {
  	      var i, j, ref1;
  	      if (!XMLElement.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
  	        return false;
  	      }
  	      if (node.namespaceURI !== this.namespaceURI) {
  	        return false;
  	      }
  	      if (node.prefix !== this.prefix) {
  	        return false;
  	      }
  	      if (node.localName !== this.localName) {
  	        return false;
  	      }
  	      if (node.attribs.length !== this.attribs.length) {
  	        return false;
  	      }
  	      for (i = j = 0, ref1 = this.attribs.length - 1; 0 <= ref1 ? j <= ref1 : j >= ref1; i = 0 <= ref1 ? ++j : --j) {
  	        if (!this.attribs[i].isEqualNode(node.attribs[i])) {
  	          return false;
  	        }
  	      }
  	      return true;
  	    };
  
  	    return XMLElement;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 13 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  module.exports = {
  	    Element: 1,
  	    Attribute: 2,
  	    Text: 3,
  	    CData: 4,
  	    EntityReference: 5,
  	    EntityDeclaration: 6,
  	    ProcessingInstruction: 7,
  	    Comment: 8,
  	    Document: 9,
  	    DocType: 10,
  	    DocumentFragment: 11,
  	    NotationDeclaration: 12,
  	    Declaration: 201,
  	    Raw: 202,
  	    AttributeDeclaration: 203,
  	    ElementDeclaration: 204,
  	    Dummy: 205
  	  };
  
  	}).call(this);
  
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLAttribute, XMLNode;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLNode = __webpack_require__(11);
  
  	  module.exports = XMLAttribute = (function() {
  	    function XMLAttribute(parent, name, value) {
  	      this.parent = parent;
  	      if (this.parent) {
  	        this.options = this.parent.options;
  	        this.stringify = this.parent.stringify;
  	      }
  	      if (name == null) {
  	        throw new Error("Missing attribute name. " + this.debugInfo(name));
  	      }
  	      this.name = this.stringify.name(name);
  	      this.value = this.stringify.attValue(value);
  	      this.type = NodeType.Attribute;
  	      this.isId = false;
  	      this.schemaTypeInfo = null;
  	    }
  
  	    Object.defineProperty(XMLAttribute.prototype, 'nodeType', {
  	      get: function() {
  	        return this.type;
  	      }
  	    });
  
  	    Object.defineProperty(XMLAttribute.prototype, 'ownerElement', {
  	      get: function() {
  	        return this.parent;
  	      }
  	    });
  
  	    Object.defineProperty(XMLAttribute.prototype, 'textContent', {
  	      get: function() {
  	        return this.value;
  	      },
  	      set: function(value) {
  	        return this.value = value || '';
  	      }
  	    });
  
  	    Object.defineProperty(XMLAttribute.prototype, 'namespaceURI', {
  	      get: function() {
  	        return '';
  	      }
  	    });
  
  	    Object.defineProperty(XMLAttribute.prototype, 'prefix', {
  	      get: function() {
  	        return '';
  	      }
  	    });
  
  	    Object.defineProperty(XMLAttribute.prototype, 'localName', {
  	      get: function() {
  	        return this.name;
  	      }
  	    });
  
  	    Object.defineProperty(XMLAttribute.prototype, 'specified', {
  	      get: function() {
  	        return true;
  	      }
  	    });
  
  	    XMLAttribute.prototype.clone = function() {
  	      return Object.create(this);
  	    };
  
  	    XMLAttribute.prototype.toString = function(options) {
  	      return this.options.writer.attribute(this, this.options.writer.filterOptions(options));
  	    };
  
  	    XMLAttribute.prototype.debugInfo = function(name) {
  	      name = name || this.name;
  	      if (name == null) {
  	        return "parent: <" + this.parent.name + ">";
  	      } else {
  	        return "attribute: {" + name + "}, parent: <" + this.parent.name + ">";
  	      }
  	    };
  
  	    XMLAttribute.prototype.isEqualNode = function(node) {
  	      if (node.namespaceURI !== this.namespaceURI) {
  	        return false;
  	      }
  	      if (node.prefix !== this.prefix) {
  	        return false;
  	      }
  	      if (node.localName !== this.localName) {
  	        return false;
  	      }
  	      if (node.value !== this.value) {
  	        return false;
  	      }
  	      return true;
  	    };
  
  	    return XMLAttribute;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 15 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLNamedNodeMap;
  
  	  module.exports = XMLNamedNodeMap = (function() {
  	    function XMLNamedNodeMap(nodes) {
  	      this.nodes = nodes;
  	    }
  
  	    Object.defineProperty(XMLNamedNodeMap.prototype, 'length', {
  	      get: function() {
  	        return Object.keys(this.nodes).length || 0;
  	      }
  	    });
  
  	    XMLNamedNodeMap.prototype.clone = function() {
  	      return this.nodes = null;
  	    };
  
  	    XMLNamedNodeMap.prototype.getNamedItem = function(name) {
  	      return this.nodes[name];
  	    };
  
  	    XMLNamedNodeMap.prototype.setNamedItem = function(node) {
  	      var oldNode;
  	      oldNode = this.nodes[node.nodeName];
  	      this.nodes[node.nodeName] = node;
  	      return oldNode || null;
  	    };
  
  	    XMLNamedNodeMap.prototype.removeNamedItem = function(name) {
  	      var oldNode;
  	      oldNode = this.nodes[name];
  	      delete this.nodes[name];
  	      return oldNode || null;
  	    };
  
  	    XMLNamedNodeMap.prototype.item = function(index) {
  	      return this.nodes[Object.keys(this.nodes)[index]] || null;
  	    };
  
  	    XMLNamedNodeMap.prototype.getNamedItemNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented.");
  	    };
  
  	    XMLNamedNodeMap.prototype.setNamedItemNS = function(node) {
  	      throw new Error("This DOM method is not implemented.");
  	    };
  
  	    XMLNamedNodeMap.prototype.removeNamedItemNS = function(namespaceURI, localName) {
  	      throw new Error("This DOM method is not implemented.");
  	    };
  
  	    return XMLNamedNodeMap;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLCData, XMLCharacterData,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLCharacterData = __webpack_require__(17);
  
  	  module.exports = XMLCData = (function(superClass) {
  	    extend(XMLCData, superClass);
  
  	    function XMLCData(parent, text) {
  	      XMLCData.__super__.constructor.call(this, parent);
  	      if (text == null) {
  	        throw new Error("Missing CDATA text. " + this.debugInfo());
  	      }
  	      this.name = "#cdata-section";
  	      this.type = NodeType.CData;
  	      this.value = this.stringify.cdata(text);
  	    }
  
  	    XMLCData.prototype.clone = function() {
  	      return Object.create(this);
  	    };
  
  	    XMLCData.prototype.toString = function(options) {
  	      return this.options.writer.cdata(this, this.options.writer.filterOptions(options));
  	    };
  
  	    return XMLCData;
  
  	  })(XMLCharacterData);
  
  	}).call(this);
  
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLCharacterData, XMLNode,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  XMLNode = __webpack_require__(11);
  
  	  module.exports = XMLCharacterData = (function(superClass) {
  	    extend(XMLCharacterData, superClass);
  
  	    function XMLCharacterData(parent) {
  	      XMLCharacterData.__super__.constructor.call(this, parent);
  	      this.value = '';
  	    }
  
  	    Object.defineProperty(XMLCharacterData.prototype, 'data', {
  	      get: function() {
  	        return this.value;
  	      },
  	      set: function(value) {
  	        return this.value = value || '';
  	      }
  	    });
  
  	    Object.defineProperty(XMLCharacterData.prototype, 'length', {
  	      get: function() {
  	        return this.value.length;
  	      }
  	    });
  
  	    Object.defineProperty(XMLCharacterData.prototype, 'textContent', {
  	      get: function() {
  	        return this.value;
  	      },
  	      set: function(value) {
  	        return this.value = value || '';
  	      }
  	    });
  
  	    XMLCharacterData.prototype.clone = function() {
  	      return Object.create(this);
  	    };
  
  	    XMLCharacterData.prototype.substringData = function(offset, count) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLCharacterData.prototype.appendData = function(arg) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLCharacterData.prototype.insertData = function(offset, arg) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLCharacterData.prototype.deleteData = function(offset, count) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLCharacterData.prototype.replaceData = function(offset, count, arg) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLCharacterData.prototype.isEqualNode = function(node) {
  	      if (!XMLCharacterData.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
  	        return false;
  	      }
  	      if (node.data !== this.data) {
  	        return false;
  	      }
  	      return true;
  	    };
  
  	    return XMLCharacterData;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 18 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLCharacterData, XMLComment,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLCharacterData = __webpack_require__(17);
  
  	  module.exports = XMLComment = (function(superClass) {
  	    extend(XMLComment, superClass);
  
  	    function XMLComment(parent, text) {
  	      XMLComment.__super__.constructor.call(this, parent);
  	      if (text == null) {
  	        throw new Error("Missing comment text. " + this.debugInfo());
  	      }
  	      this.name = "#comment";
  	      this.type = NodeType.Comment;
  	      this.value = this.stringify.comment(text);
  	    }
  
  	    XMLComment.prototype.clone = function() {
  	      return Object.create(this);
  	    };
  
  	    XMLComment.prototype.toString = function(options) {
  	      return this.options.writer.comment(this, this.options.writer.filterOptions(options));
  	    };
  
  	    return XMLComment;
  
  	  })(XMLCharacterData);
  
  	}).call(this);
  
  
  /***/ }),
  /* 19 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLDeclaration, XMLNode, isObject,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  isObject = __webpack_require__(5).isObject;
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  module.exports = XMLDeclaration = (function(superClass) {
  	    extend(XMLDeclaration, superClass);
  
  	    function XMLDeclaration(parent, version, encoding, standalone) {
  	      var ref;
  	      XMLDeclaration.__super__.constructor.call(this, parent);
  	      if (isObject(version)) {
  	        ref = version, version = ref.version, encoding = ref.encoding, standalone = ref.standalone;
  	      }
  	      if (!version) {
  	        version = '1.0';
  	      }
  	      this.type = NodeType.Declaration;
  	      this.version = this.stringify.xmlVersion(version);
  	      if (encoding != null) {
  	        this.encoding = this.stringify.xmlEncoding(encoding);
  	      }
  	      if (standalone != null) {
  	        this.standalone = this.stringify.xmlStandalone(standalone);
  	      }
  	    }
  
  	    XMLDeclaration.prototype.toString = function(options) {
  	      return this.options.writer.declaration(this, this.options.writer.filterOptions(options));
  	    };
  
  	    return XMLDeclaration;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 20 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, XMLNamedNodeMap, XMLNode, isObject,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  isObject = __webpack_require__(5).isObject;
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLDTDAttList = __webpack_require__(21);
  
  	  XMLDTDEntity = __webpack_require__(22);
  
  	  XMLDTDElement = __webpack_require__(23);
  
  	  XMLDTDNotation = __webpack_require__(24);
  
  	  XMLNamedNodeMap = __webpack_require__(15);
  
  	  module.exports = XMLDocType = (function(superClass) {
  	    extend(XMLDocType, superClass);
  
  	    function XMLDocType(parent, pubID, sysID) {
  	      var child, i, len, ref, ref1, ref2;
  	      XMLDocType.__super__.constructor.call(this, parent);
  	      this.type = NodeType.DocType;
  	      if (parent.children) {
  	        ref = parent.children;
  	        for (i = 0, len = ref.length; i < len; i++) {
  	          child = ref[i];
  	          if (child.type === NodeType.Element) {
  	            this.name = child.name;
  	            break;
  	          }
  	        }
  	      }
  	      this.documentObject = parent;
  	      if (isObject(pubID)) {
  	        ref1 = pubID, pubID = ref1.pubID, sysID = ref1.sysID;
  	      }
  	      if (sysID == null) {
  	        ref2 = [pubID, sysID], sysID = ref2[0], pubID = ref2[1];
  	      }
  	      if (pubID != null) {
  	        this.pubID = this.stringify.dtdPubID(pubID);
  	      }
  	      if (sysID != null) {
  	        this.sysID = this.stringify.dtdSysID(sysID);
  	      }
  	    }
  
  	    Object.defineProperty(XMLDocType.prototype, 'entities', {
  	      get: function() {
  	        var child, i, len, nodes, ref;
  	        nodes = {};
  	        ref = this.children;
  	        for (i = 0, len = ref.length; i < len; i++) {
  	          child = ref[i];
  	          if ((child.type === NodeType.EntityDeclaration) && !child.pe) {
  	            nodes[child.name] = child;
  	          }
  	        }
  	        return new XMLNamedNodeMap(nodes);
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocType.prototype, 'notations', {
  	      get: function() {
  	        var child, i, len, nodes, ref;
  	        nodes = {};
  	        ref = this.children;
  	        for (i = 0, len = ref.length; i < len; i++) {
  	          child = ref[i];
  	          if (child.type === NodeType.NotationDeclaration) {
  	            nodes[child.name] = child;
  	          }
  	        }
  	        return new XMLNamedNodeMap(nodes);
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocType.prototype, 'publicId', {
  	      get: function() {
  	        return this.pubID;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocType.prototype, 'systemId', {
  	      get: function() {
  	        return this.sysID;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDocType.prototype, 'internalSubset', {
  	      get: function() {
  	        throw new Error("This DOM method is not implemented." + this.debugInfo());
  	      }
  	    });
  
  	    XMLDocType.prototype.element = function(name, value) {
  	      var child;
  	      child = new XMLDTDElement(this, name, value);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLDocType.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
  	      var child;
  	      child = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLDocType.prototype.entity = function(name, value) {
  	      var child;
  	      child = new XMLDTDEntity(this, false, name, value);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLDocType.prototype.pEntity = function(name, value) {
  	      var child;
  	      child = new XMLDTDEntity(this, true, name, value);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLDocType.prototype.notation = function(name, value) {
  	      var child;
  	      child = new XMLDTDNotation(this, name, value);
  	      this.children.push(child);
  	      return this;
  	    };
  
  	    XMLDocType.prototype.toString = function(options) {
  	      return this.options.writer.docType(this, this.options.writer.filterOptions(options));
  	    };
  
  	    XMLDocType.prototype.ele = function(name, value) {
  	      return this.element(name, value);
  	    };
  
  	    XMLDocType.prototype.att = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
  	      return this.attList(elementName, attributeName, attributeType, defaultValueType, defaultValue);
  	    };
  
  	    XMLDocType.prototype.ent = function(name, value) {
  	      return this.entity(name, value);
  	    };
  
  	    XMLDocType.prototype.pent = function(name, value) {
  	      return this.pEntity(name, value);
  	    };
  
  	    XMLDocType.prototype.not = function(name, value) {
  	      return this.notation(name, value);
  	    };
  
  	    XMLDocType.prototype.up = function() {
  	      return this.root() || this.documentObject;
  	    };
  
  	    XMLDocType.prototype.isEqualNode = function(node) {
  	      if (!XMLDocType.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
  	        return false;
  	      }
  	      if (node.name !== this.name) {
  	        return false;
  	      }
  	      if (node.publicId !== this.publicId) {
  	        return false;
  	      }
  	      if (node.systemId !== this.systemId) {
  	        return false;
  	      }
  	      return true;
  	    };
  
  	    return XMLDocType;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 21 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLDTDAttList, XMLNode,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  module.exports = XMLDTDAttList = (function(superClass) {
  	    extend(XMLDTDAttList, superClass);
  
  	    function XMLDTDAttList(parent, elementName, attributeName, attributeType, defaultValueType, defaultValue) {
  	      XMLDTDAttList.__super__.constructor.call(this, parent);
  	      if (elementName == null) {
  	        throw new Error("Missing DTD element name. " + this.debugInfo());
  	      }
  	      if (attributeName == null) {
  	        throw new Error("Missing DTD attribute name. " + this.debugInfo(elementName));
  	      }
  	      if (!attributeType) {
  	        throw new Error("Missing DTD attribute type. " + this.debugInfo(elementName));
  	      }
  	      if (!defaultValueType) {
  	        throw new Error("Missing DTD attribute default. " + this.debugInfo(elementName));
  	      }
  	      if (defaultValueType.indexOf('#') !== 0) {
  	        defaultValueType = '#' + defaultValueType;
  	      }
  	      if (!defaultValueType.match(/^(#REQUIRED|#IMPLIED|#FIXED|#DEFAULT)$/)) {
  	        throw new Error("Invalid default value type; expected: #REQUIRED, #IMPLIED, #FIXED or #DEFAULT. " + this.debugInfo(elementName));
  	      }
  	      if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
  	        throw new Error("Default value only applies to #FIXED or #DEFAULT. " + this.debugInfo(elementName));
  	      }
  	      this.elementName = this.stringify.name(elementName);
  	      this.type = NodeType.AttributeDeclaration;
  	      this.attributeName = this.stringify.name(attributeName);
  	      this.attributeType = this.stringify.dtdAttType(attributeType);
  	      if (defaultValue) {
  	        this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
  	      }
  	      this.defaultValueType = defaultValueType;
  	    }
  
  	    XMLDTDAttList.prototype.toString = function(options) {
  	      return this.options.writer.dtdAttList(this, this.options.writer.filterOptions(options));
  	    };
  
  	    return XMLDTDAttList;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 22 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLDTDEntity, XMLNode, isObject,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  isObject = __webpack_require__(5).isObject;
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  module.exports = XMLDTDEntity = (function(superClass) {
  	    extend(XMLDTDEntity, superClass);
  
  	    function XMLDTDEntity(parent, pe, name, value) {
  	      XMLDTDEntity.__super__.constructor.call(this, parent);
  	      if (name == null) {
  	        throw new Error("Missing DTD entity name. " + this.debugInfo(name));
  	      }
  	      if (value == null) {
  	        throw new Error("Missing DTD entity value. " + this.debugInfo(name));
  	      }
  	      this.pe = !!pe;
  	      this.name = this.stringify.name(name);
  	      this.type = NodeType.EntityDeclaration;
  	      if (!isObject(value)) {
  	        this.value = this.stringify.dtdEntityValue(value);
  	        this.internal = true;
  	      } else {
  	        if (!value.pubID && !value.sysID) {
  	          throw new Error("Public and/or system identifiers are required for an external entity. " + this.debugInfo(name));
  	        }
  	        if (value.pubID && !value.sysID) {
  	          throw new Error("System identifier is required for a public external entity. " + this.debugInfo(name));
  	        }
  	        this.internal = false;
  	        if (value.pubID != null) {
  	          this.pubID = this.stringify.dtdPubID(value.pubID);
  	        }
  	        if (value.sysID != null) {
  	          this.sysID = this.stringify.dtdSysID(value.sysID);
  	        }
  	        if (value.nData != null) {
  	          this.nData = this.stringify.dtdNData(value.nData);
  	        }
  	        if (this.pe && this.nData) {
  	          throw new Error("Notation declaration is not allowed in a parameter entity. " + this.debugInfo(name));
  	        }
  	      }
  	    }
  
  	    Object.defineProperty(XMLDTDEntity.prototype, 'publicId', {
  	      get: function() {
  	        return this.pubID;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDTDEntity.prototype, 'systemId', {
  	      get: function() {
  	        return this.sysID;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDTDEntity.prototype, 'notationName', {
  	      get: function() {
  	        return this.nData || null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDTDEntity.prototype, 'inputEncoding', {
  	      get: function() {
  	        return null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDTDEntity.prototype, 'xmlEncoding', {
  	      get: function() {
  	        return null;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDTDEntity.prototype, 'xmlVersion', {
  	      get: function() {
  	        return null;
  	      }
  	    });
  
  	    XMLDTDEntity.prototype.toString = function(options) {
  	      return this.options.writer.dtdEntity(this, this.options.writer.filterOptions(options));
  	    };
  
  	    return XMLDTDEntity;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 23 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLDTDElement, XMLNode,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  module.exports = XMLDTDElement = (function(superClass) {
  	    extend(XMLDTDElement, superClass);
  
  	    function XMLDTDElement(parent, name, value) {
  	      XMLDTDElement.__super__.constructor.call(this, parent);
  	      if (name == null) {
  	        throw new Error("Missing DTD element name. " + this.debugInfo());
  	      }
  	      if (!value) {
  	        value = '(#PCDATA)';
  	      }
  	      if (Array.isArray(value)) {
  	        value = '(' + value.join(',') + ')';
  	      }
  	      this.name = this.stringify.name(name);
  	      this.type = NodeType.ElementDeclaration;
  	      this.value = this.stringify.dtdElementValue(value);
  	    }
  
  	    XMLDTDElement.prototype.toString = function(options) {
  	      return this.options.writer.dtdElement(this, this.options.writer.filterOptions(options));
  	    };
  
  	    return XMLDTDElement;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 24 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLDTDNotation, XMLNode,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  module.exports = XMLDTDNotation = (function(superClass) {
  	    extend(XMLDTDNotation, superClass);
  
  	    function XMLDTDNotation(parent, name, value) {
  	      XMLDTDNotation.__super__.constructor.call(this, parent);
  	      if (name == null) {
  	        throw new Error("Missing DTD notation name. " + this.debugInfo(name));
  	      }
  	      if (!value.pubID && !value.sysID) {
  	        throw new Error("Public or system identifiers are required for an external entity. " + this.debugInfo(name));
  	      }
  	      this.name = this.stringify.name(name);
  	      this.type = NodeType.NotationDeclaration;
  	      if (value.pubID != null) {
  	        this.pubID = this.stringify.dtdPubID(value.pubID);
  	      }
  	      if (value.sysID != null) {
  	        this.sysID = this.stringify.dtdSysID(value.sysID);
  	      }
  	    }
  
  	    Object.defineProperty(XMLDTDNotation.prototype, 'publicId', {
  	      get: function() {
  	        return this.pubID;
  	      }
  	    });
  
  	    Object.defineProperty(XMLDTDNotation.prototype, 'systemId', {
  	      get: function() {
  	        return this.sysID;
  	      }
  	    });
  
  	    XMLDTDNotation.prototype.toString = function(options) {
  	      return this.options.writer.dtdNotation(this, this.options.writer.filterOptions(options));
  	    };
  
  	    return XMLDTDNotation;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 25 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLNode, XMLRaw,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLNode = __webpack_require__(11);
  
  	  module.exports = XMLRaw = (function(superClass) {
  	    extend(XMLRaw, superClass);
  
  	    function XMLRaw(parent, text) {
  	      XMLRaw.__super__.constructor.call(this, parent);
  	      if (text == null) {
  	        throw new Error("Missing raw text. " + this.debugInfo());
  	      }
  	      this.type = NodeType.Raw;
  	      this.value = this.stringify.raw(text);
  	    }
  
  	    XMLRaw.prototype.clone = function() {
  	      return Object.create(this);
  	    };
  
  	    XMLRaw.prototype.toString = function(options) {
  	      return this.options.writer.raw(this, this.options.writer.filterOptions(options));
  	    };
  
  	    return XMLRaw;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 26 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLCharacterData, XMLText,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLCharacterData = __webpack_require__(17);
  
  	  module.exports = XMLText = (function(superClass) {
  	    extend(XMLText, superClass);
  
  	    function XMLText(parent, text) {
  	      XMLText.__super__.constructor.call(this, parent);
  	      if (text == null) {
  	        throw new Error("Missing element text. " + this.debugInfo());
  	      }
  	      this.name = "#text";
  	      this.type = NodeType.Text;
  	      this.value = this.stringify.text(text);
  	    }
  
  	    Object.defineProperty(XMLText.prototype, 'isElementContentWhitespace', {
  	      get: function() {
  	        throw new Error("This DOM method is not implemented." + this.debugInfo());
  	      }
  	    });
  
  	    Object.defineProperty(XMLText.prototype, 'wholeText', {
  	      get: function() {
  	        var next, prev, str;
  	        str = '';
  	        prev = this.previousSibling;
  	        while (prev) {
  	          str = prev.data + str;
  	          prev = prev.previousSibling;
  	        }
  	        str += this.data;
  	        next = this.nextSibling;
  	        while (next) {
  	          str = str + next.data;
  	          next = next.nextSibling;
  	        }
  	        return str;
  	      }
  	    });
  
  	    XMLText.prototype.clone = function() {
  	      return Object.create(this);
  	    };
  
  	    XMLText.prototype.toString = function(options) {
  	      return this.options.writer.text(this, this.options.writer.filterOptions(options));
  	    };
  
  	    XMLText.prototype.splitText = function(offset) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    XMLText.prototype.replaceWholeText = function(content) {
  	      throw new Error("This DOM method is not implemented." + this.debugInfo());
  	    };
  
  	    return XMLText;
  
  	  })(XMLCharacterData);
  
  	}).call(this);
  
  
  /***/ }),
  /* 27 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLCharacterData, XMLProcessingInstruction,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLCharacterData = __webpack_require__(17);
  
  	  module.exports = XMLProcessingInstruction = (function(superClass) {
  	    extend(XMLProcessingInstruction, superClass);
  
  	    function XMLProcessingInstruction(parent, target, value) {
  	      XMLProcessingInstruction.__super__.constructor.call(this, parent);
  	      if (target == null) {
  	        throw new Error("Missing instruction target. " + this.debugInfo());
  	      }
  	      this.type = NodeType.ProcessingInstruction;
  	      this.target = this.stringify.insTarget(target);
  	      this.name = this.target;
  	      if (value) {
  	        this.value = this.stringify.insValue(value);
  	      }
  	    }
  
  	    XMLProcessingInstruction.prototype.clone = function() {
  	      return Object.create(this);
  	    };
  
  	    XMLProcessingInstruction.prototype.toString = function(options) {
  	      return this.options.writer.processingInstruction(this, this.options.writer.filterOptions(options));
  	    };
  
  	    XMLProcessingInstruction.prototype.isEqualNode = function(node) {
  	      if (!XMLProcessingInstruction.__super__.isEqualNode.apply(this, arguments).isEqualNode(node)) {
  	        return false;
  	      }
  	      if (node.target !== this.target) {
  	        return false;
  	      }
  	      return true;
  	    };
  
  	    return XMLProcessingInstruction;
  
  	  })(XMLCharacterData);
  
  	}).call(this);
  
  
  /***/ }),
  /* 28 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, XMLDummy, XMLNode,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  XMLNode = __webpack_require__(11);
  
  	  NodeType = __webpack_require__(13);
  
  	  module.exports = XMLDummy = (function(superClass) {
  	    extend(XMLDummy, superClass);
  
  	    function XMLDummy(parent) {
  	      XMLDummy.__super__.constructor.call(this, parent);
  	      this.type = NodeType.Dummy;
  	    }
  
  	    XMLDummy.prototype.clone = function() {
  	      return Object.create(this);
  	    };
  
  	    XMLDummy.prototype.toString = function(options) {
  	      return '';
  	    };
  
  	    return XMLDummy;
  
  	  })(XMLNode);
  
  	}).call(this);
  
  
  /***/ }),
  /* 29 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLNodeList;
  
  	  module.exports = XMLNodeList = (function() {
  	    function XMLNodeList(nodes) {
  	      this.nodes = nodes;
  	    }
  
  	    Object.defineProperty(XMLNodeList.prototype, 'length', {
  	      get: function() {
  	        return this.nodes.length || 0;
  	      }
  	    });
  
  	    XMLNodeList.prototype.clone = function() {
  	      return this.nodes = null;
  	    };
  
  	    XMLNodeList.prototype.item = function(index) {
  	      return this.nodes[index] || null;
  	    };
  
  	    return XMLNodeList;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 30 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  module.exports = {
  	    Disconnected: 1,
  	    Preceding: 2,
  	    Following: 4,
  	    Contains: 8,
  	    ContainedBy: 16,
  	    ImplementationSpecific: 32
  	  };
  
  	}).call(this);
  
  
  /***/ }),
  /* 31 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLStringifier,
  	    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
  	    hasProp = {}.hasOwnProperty;
  
  	  module.exports = XMLStringifier = (function() {
  	    function XMLStringifier(options) {
  	      this.assertLegalName = bind(this.assertLegalName, this);
  	      this.assertLegalChar = bind(this.assertLegalChar, this);
  	      var key, ref, value;
  	      options || (options = {});
  	      this.options = options;
  	      if (!this.options.version) {
  	        this.options.version = '1.0';
  	      }
  	      ref = options.stringify || {};
  	      for (key in ref) {
  	        if (!hasProp.call(ref, key)) continue;
  	        value = ref[key];
  	        this[key] = value;
  	      }
  	    }
  
  	    XMLStringifier.prototype.name = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalName('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.text = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar(this.textEscape('' + val || ''));
  	    };
  
  	    XMLStringifier.prototype.cdata = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      val = '' + val || '';
  	      val = val.replace(']]>', ']]]]><![CDATA[>');
  	      return this.assertLegalChar(val);
  	    };
  
  	    XMLStringifier.prototype.comment = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      val = '' + val || '';
  	      if (val.match(/--/)) {
  	        throw new Error("Comment text cannot contain double-hypen: " + val);
  	      }
  	      return this.assertLegalChar(val);
  	    };
  
  	    XMLStringifier.prototype.raw = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return '' + val || '';
  	    };
  
  	    XMLStringifier.prototype.attValue = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar(this.attEscape(val = '' + val || ''));
  	    };
  
  	    XMLStringifier.prototype.insTarget = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.insValue = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      val = '' + val || '';
  	      if (val.match(/\?>/)) {
  	        throw new Error("Invalid processing instruction value: " + val);
  	      }
  	      return this.assertLegalChar(val);
  	    };
  
  	    XMLStringifier.prototype.xmlVersion = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      val = '' + val || '';
  	      if (!val.match(/1\.[0-9]+/)) {
  	        throw new Error("Invalid version number: " + val);
  	      }
  	      return val;
  	    };
  
  	    XMLStringifier.prototype.xmlEncoding = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      val = '' + val || '';
  	      if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) {
  	        throw new Error("Invalid encoding: " + val);
  	      }
  	      return this.assertLegalChar(val);
  	    };
  
  	    XMLStringifier.prototype.xmlStandalone = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      if (val) {
  	        return "yes";
  	      } else {
  	        return "no";
  	      }
  	    };
  
  	    XMLStringifier.prototype.dtdPubID = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.dtdSysID = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.dtdElementValue = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.dtdAttType = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.dtdAttDefault = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.dtdEntityValue = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.dtdNData = function(val) {
  	      if (this.options.noValidation) {
  	        return val;
  	      }
  	      return this.assertLegalChar('' + val || '');
  	    };
  
  	    XMLStringifier.prototype.convertAttKey = '@';
  
  	    XMLStringifier.prototype.convertPIKey = '?';
  
  	    XMLStringifier.prototype.convertTextKey = '#text';
  
  	    XMLStringifier.prototype.convertCDataKey = '#cdata';
  
  	    XMLStringifier.prototype.convertCommentKey = '#comment';
  
  	    XMLStringifier.prototype.convertRawKey = '#raw';
  
  	    XMLStringifier.prototype.assertLegalChar = function(str) {
  	      var regex, res;
  	      if (this.options.noValidation) {
  	        return str;
  	      }
  	      regex = '';
  	      if (this.options.version === '1.0') {
  	        regex = /[\0-\x08\x0B\f\x0E-\x1F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
  	        if (res = str.match(regex)) {
  	          throw new Error("Invalid character in string: " + str + " at index " + res.index);
  	        }
  	      } else if (this.options.version === '1.1') {
  	        regex = /[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
  	        if (res = str.match(regex)) {
  	          throw new Error("Invalid character in string: " + str + " at index " + res.index);
  	        }
  	      }
  	      return str;
  	    };
  
  	    XMLStringifier.prototype.assertLegalName = function(str) {
  	      var regex;
  	      if (this.options.noValidation) {
  	        return str;
  	      }
  	      this.assertLegalChar(str);
  	      regex = /^([:A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])([\x2D\.0-:A-Z_a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*$/;
  	      if (!str.match(regex)) {
  	        throw new Error("Invalid character in name");
  	      }
  	      return str;
  	    };
  
  	    XMLStringifier.prototype.textEscape = function(str) {
  	      var ampregex;
  	      if (this.options.noValidation) {
  	        return str;
  	      }
  	      ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
  	      return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/\r/g, '&#xD;');
  	    };
  
  	    XMLStringifier.prototype.attEscape = function(str) {
  	      var ampregex;
  	      if (this.options.noValidation) {
  	        return str;
  	      }
  	      ampregex = this.options.noDoubleEncoding ? /(?!&\S+;)&/g : /&/g;
  	      return str.replace(ampregex, '&amp;').replace(/</g, '&lt;').replace(/"/g, '&quot;').replace(/\t/g, '&#x9;').replace(/\n/g, '&#xA;').replace(/\r/g, '&#xD;');
  	    };
  
  	    return XMLStringifier;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 32 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var XMLStringWriter, XMLWriterBase,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  XMLWriterBase = __webpack_require__(33);
  
  	  module.exports = XMLStringWriter = (function(superClass) {
  	    extend(XMLStringWriter, superClass);
  
  	    function XMLStringWriter(options) {
  	      XMLStringWriter.__super__.constructor.call(this, options);
  	    }
  
  	    XMLStringWriter.prototype.document = function(doc, options) {
  	      var child, i, len, r, ref;
  	      options = this.filterOptions(options);
  	      r = '';
  	      ref = doc.children;
  	      for (i = 0, len = ref.length; i < len; i++) {
  	        child = ref[i];
  	        r += this.writeChildNode(child, options, 0);
  	      }
  	      if (options.pretty && r.slice(-options.newline.length) === options.newline) {
  	        r = r.slice(0, -options.newline.length);
  	      }
  	      return r;
  	    };
  
  	    return XMLStringWriter;
  
  	  })(XMLWriterBase);
  
  	}).call(this);
  
  
  /***/ }),
  /* 33 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, WriterState, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDummy, XMLElement, XMLProcessingInstruction, XMLRaw, XMLText, XMLWriterBase, assign,
  	    hasProp = {}.hasOwnProperty;
  
  	  assign = __webpack_require__(5).assign;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLDeclaration = __webpack_require__(19);
  
  	  XMLDocType = __webpack_require__(20);
  
  	  XMLCData = __webpack_require__(16);
  
  	  XMLComment = __webpack_require__(18);
  
  	  XMLElement = __webpack_require__(12);
  
  	  XMLRaw = __webpack_require__(25);
  
  	  XMLText = __webpack_require__(26);
  
  	  XMLProcessingInstruction = __webpack_require__(27);
  
  	  XMLDummy = __webpack_require__(28);
  
  	  XMLDTDAttList = __webpack_require__(21);
  
  	  XMLDTDElement = __webpack_require__(23);
  
  	  XMLDTDEntity = __webpack_require__(22);
  
  	  XMLDTDNotation = __webpack_require__(24);
  
  	  WriterState = __webpack_require__(34);
  
  	  module.exports = XMLWriterBase = (function() {
  	    function XMLWriterBase(options) {
  	      var key, ref, value;
  	      options || (options = {});
  	      this.options = options;
  	      ref = options.writer || {};
  	      for (key in ref) {
  	        if (!hasProp.call(ref, key)) continue;
  	        value = ref[key];
  	        this["_" + key] = this[key];
  	        this[key] = value;
  	      }
  	    }
  
  	    XMLWriterBase.prototype.filterOptions = function(options) {
  	      var filteredOptions, ref, ref1, ref2, ref3, ref4, ref5, ref6;
  	      options || (options = {});
  	      options = assign({}, this.options, options);
  	      filteredOptions = {
  	        writer: this
  	      };
  	      filteredOptions.pretty = options.pretty || false;
  	      filteredOptions.allowEmpty = options.allowEmpty || false;
  	      filteredOptions.indent = (ref = options.indent) != null ? ref : '  ';
  	      filteredOptions.newline = (ref1 = options.newline) != null ? ref1 : '\n';
  	      filteredOptions.offset = (ref2 = options.offset) != null ? ref2 : 0;
  	      filteredOptions.dontPrettyTextNodes = (ref3 = (ref4 = options.dontPrettyTextNodes) != null ? ref4 : options.dontprettytextnodes) != null ? ref3 : 0;
  	      filteredOptions.spaceBeforeSlash = (ref5 = (ref6 = options.spaceBeforeSlash) != null ? ref6 : options.spacebeforeslash) != null ? ref5 : '';
  	      if (filteredOptions.spaceBeforeSlash === true) {
  	        filteredOptions.spaceBeforeSlash = ' ';
  	      }
  	      filteredOptions.suppressPrettyCount = 0;
  	      filteredOptions.user = {};
  	      filteredOptions.state = WriterState.None;
  	      return filteredOptions;
  	    };
  
  	    XMLWriterBase.prototype.indent = function(node, options, level) {
  	      var indentLevel;
  	      if (!options.pretty || options.suppressPrettyCount) {
  	        return '';
  	      } else if (options.pretty) {
  	        indentLevel = (level || 0) + options.offset + 1;
  	        if (indentLevel > 0) {
  	          return new Array(indentLevel).join(options.indent);
  	        }
  	      }
  	      return '';
  	    };
  
  	    XMLWriterBase.prototype.endline = function(node, options, level) {
  	      if (!options.pretty || options.suppressPrettyCount) {
  	        return '';
  	      } else {
  	        return options.newline;
  	      }
  	    };
  
  	    XMLWriterBase.prototype.attribute = function(att, options, level) {
  	      var r;
  	      this.openAttribute(att, options, level);
  	      r = ' ' + att.name + '="' + att.value + '"';
  	      this.closeAttribute(att, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.cdata = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level) + '<![CDATA[';
  	      options.state = WriterState.InsideTag;
  	      r += node.value;
  	      options.state = WriterState.CloseTag;
  	      r += ']]>' + this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.comment = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level) + '<!-- ';
  	      options.state = WriterState.InsideTag;
  	      r += node.value;
  	      options.state = WriterState.CloseTag;
  	      r += ' -->' + this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.declaration = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level) + '<?xml';
  	      options.state = WriterState.InsideTag;
  	      r += ' version="' + node.version + '"';
  	      if (node.encoding != null) {
  	        r += ' encoding="' + node.encoding + '"';
  	      }
  	      if (node.standalone != null) {
  	        r += ' standalone="' + node.standalone + '"';
  	      }
  	      options.state = WriterState.CloseTag;
  	      r += options.spaceBeforeSlash + '?>';
  	      r += this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.docType = function(node, options, level) {
  	      var child, i, len, r, ref;
  	      level || (level = 0);
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level);
  	      r += '<!DOCTYPE ' + node.root().name;
  	      if (node.pubID && node.sysID) {
  	        r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
  	      } else if (node.sysID) {
  	        r += ' SYSTEM "' + node.sysID + '"';
  	      }
  	      if (node.children.length > 0) {
  	        r += ' [';
  	        r += this.endline(node, options, level);
  	        options.state = WriterState.InsideTag;
  	        ref = node.children;
  	        for (i = 0, len = ref.length; i < len; i++) {
  	          child = ref[i];
  	          r += this.writeChildNode(child, options, level + 1);
  	        }
  	        options.state = WriterState.CloseTag;
  	        r += ']';
  	      }
  	      options.state = WriterState.CloseTag;
  	      r += options.spaceBeforeSlash + '>';
  	      r += this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.element = function(node, options, level) {
  	      var att, child, childNodeCount, firstChildNode, i, j, len, len1, name, prettySuppressed, r, ref, ref1, ref2;
  	      level || (level = 0);
  	      prettySuppressed = false;
  	      r = '';
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r += this.indent(node, options, level) + '<' + node.name;
  	      ref = node.attribs;
  	      for (name in ref) {
  	        if (!hasProp.call(ref, name)) continue;
  	        att = ref[name];
  	        r += this.attribute(att, options, level);
  	      }
  	      childNodeCount = node.children.length;
  	      firstChildNode = childNodeCount === 0 ? null : node.children[0];
  	      if (childNodeCount === 0 || node.children.every(function(e) {
  	        return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === '';
  	      })) {
  	        if (options.allowEmpty) {
  	          r += '>';
  	          options.state = WriterState.CloseTag;
  	          r += '</' + node.name + '>' + this.endline(node, options, level);
  	        } else {
  	          options.state = WriterState.CloseTag;
  	          r += options.spaceBeforeSlash + '/>' + this.endline(node, options, level);
  	        }
  	      } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) {
  	        r += '>';
  	        options.state = WriterState.InsideTag;
  	        options.suppressPrettyCount++;
  	        prettySuppressed = true;
  	        r += this.writeChildNode(firstChildNode, options, level + 1);
  	        options.suppressPrettyCount--;
  	        prettySuppressed = false;
  	        options.state = WriterState.CloseTag;
  	        r += '</' + node.name + '>' + this.endline(node, options, level);
  	      } else {
  	        if (options.dontPrettyTextNodes) {
  	          ref1 = node.children;
  	          for (i = 0, len = ref1.length; i < len; i++) {
  	            child = ref1[i];
  	            if ((child.type === NodeType.Text || child.type === NodeType.Raw) && (child.value != null)) {
  	              options.suppressPrettyCount++;
  	              prettySuppressed = true;
  	              break;
  	            }
  	          }
  	        }
  	        r += '>' + this.endline(node, options, level);
  	        options.state = WriterState.InsideTag;
  	        ref2 = node.children;
  	        for (j = 0, len1 = ref2.length; j < len1; j++) {
  	          child = ref2[j];
  	          r += this.writeChildNode(child, options, level + 1);
  	        }
  	        options.state = WriterState.CloseTag;
  	        r += this.indent(node, options, level) + '</' + node.name + '>';
  	        if (prettySuppressed) {
  	          options.suppressPrettyCount--;
  	        }
  	        r += this.endline(node, options, level);
  	        options.state = WriterState.None;
  	      }
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.writeChildNode = function(node, options, level) {
  	      switch (node.type) {
  	        case NodeType.CData:
  	          return this.cdata(node, options, level);
  	        case NodeType.Comment:
  	          return this.comment(node, options, level);
  	        case NodeType.Element:
  	          return this.element(node, options, level);
  	        case NodeType.Raw:
  	          return this.raw(node, options, level);
  	        case NodeType.Text:
  	          return this.text(node, options, level);
  	        case NodeType.ProcessingInstruction:
  	          return this.processingInstruction(node, options, level);
  	        case NodeType.Dummy:
  	          return '';
  	        case NodeType.Declaration:
  	          return this.declaration(node, options, level);
  	        case NodeType.DocType:
  	          return this.docType(node, options, level);
  	        case NodeType.AttributeDeclaration:
  	          return this.dtdAttList(node, options, level);
  	        case NodeType.ElementDeclaration:
  	          return this.dtdElement(node, options, level);
  	        case NodeType.EntityDeclaration:
  	          return this.dtdEntity(node, options, level);
  	        case NodeType.NotationDeclaration:
  	          return this.dtdNotation(node, options, level);
  	        default:
  	          throw new Error("Unknown XML node type: " + node.constructor.name);
  	      }
  	    };
  
  	    XMLWriterBase.prototype.processingInstruction = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level) + '<?';
  	      options.state = WriterState.InsideTag;
  	      r += node.target;
  	      if (node.value) {
  	        r += ' ' + node.value;
  	      }
  	      options.state = WriterState.CloseTag;
  	      r += options.spaceBeforeSlash + '?>';
  	      r += this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.raw = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level);
  	      options.state = WriterState.InsideTag;
  	      r += node.value;
  	      options.state = WriterState.CloseTag;
  	      r += this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.text = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level);
  	      options.state = WriterState.InsideTag;
  	      r += node.value;
  	      options.state = WriterState.CloseTag;
  	      r += this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.dtdAttList = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level) + '<!ATTLIST';
  	      options.state = WriterState.InsideTag;
  	      r += ' ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType;
  	      if (node.defaultValueType !== '#DEFAULT') {
  	        r += ' ' + node.defaultValueType;
  	      }
  	      if (node.defaultValue) {
  	        r += ' "' + node.defaultValue + '"';
  	      }
  	      options.state = WriterState.CloseTag;
  	      r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.dtdElement = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level) + '<!ELEMENT';
  	      options.state = WriterState.InsideTag;
  	      r += ' ' + node.name + ' ' + node.value;
  	      options.state = WriterState.CloseTag;
  	      r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.dtdEntity = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level) + '<!ENTITY';
  	      options.state = WriterState.InsideTag;
  	      if (node.pe) {
  	        r += ' %';
  	      }
  	      r += ' ' + node.name;
  	      if (node.value) {
  	        r += ' "' + node.value + '"';
  	      } else {
  	        if (node.pubID && node.sysID) {
  	          r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
  	        } else if (node.sysID) {
  	          r += ' SYSTEM "' + node.sysID + '"';
  	        }
  	        if (node.nData) {
  	          r += ' NDATA ' + node.nData;
  	        }
  	      }
  	      options.state = WriterState.CloseTag;
  	      r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.dtdNotation = function(node, options, level) {
  	      var r;
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      r = this.indent(node, options, level) + '<!NOTATION';
  	      options.state = WriterState.InsideTag;
  	      r += ' ' + node.name;
  	      if (node.pubID && node.sysID) {
  	        r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
  	      } else if (node.pubID) {
  	        r += ' PUBLIC "' + node.pubID + '"';
  	      } else if (node.sysID) {
  	        r += ' SYSTEM "' + node.sysID + '"';
  	      }
  	      options.state = WriterState.CloseTag;
  	      r += options.spaceBeforeSlash + '>' + this.endline(node, options, level);
  	      options.state = WriterState.None;
  	      this.closeNode(node, options, level);
  	      return r;
  	    };
  
  	    XMLWriterBase.prototype.openNode = function(node, options, level) {};
  
  	    XMLWriterBase.prototype.closeNode = function(node, options, level) {};
  
  	    XMLWriterBase.prototype.openAttribute = function(att, options, level) {};
  
  	    XMLWriterBase.prototype.closeAttribute = function(att, options, level) {};
  
  	    return XMLWriterBase;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 34 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  module.exports = {
  	    None: 0,
  	    OpenTag: 1,
  	    InsideTag: 2,
  	    CloseTag: 3
  	  };
  
  	}).call(this);
  
  
  /***/ }),
  /* 35 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, WriterState, XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocument, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, getValue, isFunction, isObject, isPlainObject, ref,
  	    hasProp = {}.hasOwnProperty;
  
  	  ref = __webpack_require__(5), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject, getValue = ref.getValue;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLDocument = __webpack_require__(7);
  
  	  XMLElement = __webpack_require__(12);
  
  	  XMLCData = __webpack_require__(16);
  
  	  XMLComment = __webpack_require__(18);
  
  	  XMLRaw = __webpack_require__(25);
  
  	  XMLText = __webpack_require__(26);
  
  	  XMLProcessingInstruction = __webpack_require__(27);
  
  	  XMLDeclaration = __webpack_require__(19);
  
  	  XMLDocType = __webpack_require__(20);
  
  	  XMLDTDAttList = __webpack_require__(21);
  
  	  XMLDTDEntity = __webpack_require__(22);
  
  	  XMLDTDElement = __webpack_require__(23);
  
  	  XMLDTDNotation = __webpack_require__(24);
  
  	  XMLAttribute = __webpack_require__(14);
  
  	  XMLStringifier = __webpack_require__(31);
  
  	  XMLStringWriter = __webpack_require__(32);
  
  	  WriterState = __webpack_require__(34);
  
  	  module.exports = XMLDocumentCB = (function() {
  	    function XMLDocumentCB(options, onData, onEnd) {
  	      var writerOptions;
  	      this.name = "?xml";
  	      this.type = NodeType.Document;
  	      options || (options = {});
  	      writerOptions = {};
  	      if (!options.writer) {
  	        options.writer = new XMLStringWriter();
  	      } else if (isPlainObject(options.writer)) {
  	        writerOptions = options.writer;
  	        options.writer = new XMLStringWriter();
  	      }
  	      this.options = options;
  	      this.writer = options.writer;
  	      this.writerOptions = this.writer.filterOptions(writerOptions);
  	      this.stringify = new XMLStringifier(options);
  	      this.onDataCallback = onData || function() {};
  	      this.onEndCallback = onEnd || function() {};
  	      this.currentNode = null;
  	      this.currentLevel = -1;
  	      this.openTags = {};
  	      this.documentStarted = false;
  	      this.documentCompleted = false;
  	      this.root = null;
  	    }
  
  	    XMLDocumentCB.prototype.createChildNode = function(node) {
  	      var att, attName, attributes, child, i, len, ref1, ref2;
  	      switch (node.type) {
  	        case NodeType.CData:
  	          this.cdata(node.value);
  	          break;
  	        case NodeType.Comment:
  	          this.comment(node.value);
  	          break;
  	        case NodeType.Element:
  	          attributes = {};
  	          ref1 = node.attribs;
  	          for (attName in ref1) {
  	            if (!hasProp.call(ref1, attName)) continue;
  	            att = ref1[attName];
  	            attributes[attName] = att.value;
  	          }
  	          this.node(node.name, attributes);
  	          break;
  	        case NodeType.Dummy:
  	          this.dummy();
  	          break;
  	        case NodeType.Raw:
  	          this.raw(node.value);
  	          break;
  	        case NodeType.Text:
  	          this.text(node.value);
  	          break;
  	        case NodeType.ProcessingInstruction:
  	          this.instruction(node.target, node.value);
  	          break;
  	        default:
  	          throw new Error("This XML node type is not supported in a JS object: " + node.constructor.name);
  	      }
  	      ref2 = node.children;
  	      for (i = 0, len = ref2.length; i < len; i++) {
  	        child = ref2[i];
  	        this.createChildNode(child);
  	        if (child.type === NodeType.Element) {
  	          this.up();
  	        }
  	      }
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.dummy = function() {
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.node = function(name, attributes, text) {
  	      var ref1;
  	      if (name == null) {
  	        throw new Error("Missing node name.");
  	      }
  	      if (this.root && this.currentLevel === -1) {
  	        throw new Error("Document can only have one root node. " + this.debugInfo(name));
  	      }
  	      this.openCurrent();
  	      name = getValue(name);
  	      if (attributes == null) {
  	        attributes = {};
  	      }
  	      attributes = getValue(attributes);
  	      if (!isObject(attributes)) {
  	        ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];
  	      }
  	      this.currentNode = new XMLElement(this, name, attributes);
  	      this.currentNode.children = false;
  	      this.currentLevel++;
  	      this.openTags[this.currentLevel] = this.currentNode;
  	      if (text != null) {
  	        this.text(text);
  	      }
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.element = function(name, attributes, text) {
  	      var child, i, len, oldValidationFlag, ref1, root;
  	      if (this.currentNode && this.currentNode.type === NodeType.DocType) {
  	        this.dtdElement.apply(this, arguments);
  	      } else {
  	        if (Array.isArray(name) || isObject(name) || isFunction(name)) {
  	          oldValidationFlag = this.options.noValidation;
  	          this.options.noValidation = true;
  	          root = new XMLDocument(this.options).element('TEMP_ROOT');
  	          root.element(name);
  	          this.options.noValidation = oldValidationFlag;
  	          ref1 = root.children;
  	          for (i = 0, len = ref1.length; i < len; i++) {
  	            child = ref1[i];
  	            this.createChildNode(child);
  	            if (child.type === NodeType.Element) {
  	              this.up();
  	            }
  	          }
  	        } else {
  	          this.node(name, attributes, text);
  	        }
  	      }
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.attribute = function(name, value) {
  	      var attName, attValue;
  	      if (!this.currentNode || this.currentNode.children) {
  	        throw new Error("att() can only be used immediately after an ele() call in callback mode. " + this.debugInfo(name));
  	      }
  	      if (name != null) {
  	        name = getValue(name);
  	      }
  	      if (isObject(name)) {
  	        for (attName in name) {
  	          if (!hasProp.call(name, attName)) continue;
  	          attValue = name[attName];
  	          this.attribute(attName, attValue);
  	        }
  	      } else {
  	        if (isFunction(value)) {
  	          value = value.apply();
  	        }
  	        if (this.options.keepNullAttributes && (value == null)) {
  	          this.currentNode.attribs[name] = new XMLAttribute(this, name, "");
  	        } else if (value != null) {
  	          this.currentNode.attribs[name] = new XMLAttribute(this, name, value);
  	        }
  	      }
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.text = function(value) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLText(this, value);
  	      this.onData(this.writer.text(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.cdata = function(value) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLCData(this, value);
  	      this.onData(this.writer.cdata(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.comment = function(value) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLComment(this, value);
  	      this.onData(this.writer.comment(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.raw = function(value) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLRaw(this, value);
  	      this.onData(this.writer.raw(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.instruction = function(target, value) {
  	      var i, insTarget, insValue, len, node;
  	      this.openCurrent();
  	      if (target != null) {
  	        target = getValue(target);
  	      }
  	      if (value != null) {
  	        value = getValue(value);
  	      }
  	      if (Array.isArray(target)) {
  	        for (i = 0, len = target.length; i < len; i++) {
  	          insTarget = target[i];
  	          this.instruction(insTarget);
  	        }
  	      } else if (isObject(target)) {
  	        for (insTarget in target) {
  	          if (!hasProp.call(target, insTarget)) continue;
  	          insValue = target[insTarget];
  	          this.instruction(insTarget, insValue);
  	        }
  	      } else {
  	        if (isFunction(value)) {
  	          value = value.apply();
  	        }
  	        node = new XMLProcessingInstruction(this, target, value);
  	        this.onData(this.writer.processingInstruction(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      }
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.declaration = function(version, encoding, standalone) {
  	      var node;
  	      this.openCurrent();
  	      if (this.documentStarted) {
  	        throw new Error("declaration() must be the first node.");
  	      }
  	      node = new XMLDeclaration(this, version, encoding, standalone);
  	      this.onData(this.writer.declaration(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.doctype = function(root, pubID, sysID) {
  	      this.openCurrent();
  	      if (root == null) {
  	        throw new Error("Missing root node name.");
  	      }
  	      if (this.root) {
  	        throw new Error("dtd() must come before the root node.");
  	      }
  	      this.currentNode = new XMLDocType(this, pubID, sysID);
  	      this.currentNode.rootNodeName = root;
  	      this.currentNode.children = false;
  	      this.currentLevel++;
  	      this.openTags[this.currentLevel] = this.currentNode;
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.dtdElement = function(name, value) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLDTDElement(this, name, value);
  	      this.onData(this.writer.dtdElement(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.attList = function(elementName, attributeName, attributeType, defaultValueType, defaultValue) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLDTDAttList(this, elementName, attributeName, attributeType, defaultValueType, defaultValue);
  	      this.onData(this.writer.dtdAttList(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.entity = function(name, value) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLDTDEntity(this, false, name, value);
  	      this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.pEntity = function(name, value) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLDTDEntity(this, true, name, value);
  	      this.onData(this.writer.dtdEntity(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.notation = function(name, value) {
  	      var node;
  	      this.openCurrent();
  	      node = new XMLDTDNotation(this, name, value);
  	      this.onData(this.writer.dtdNotation(node, this.writerOptions, this.currentLevel + 1), this.currentLevel + 1);
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.up = function() {
  	      if (this.currentLevel < 0) {
  	        throw new Error("The document node has no parent.");
  	      }
  	      if (this.currentNode) {
  	        if (this.currentNode.children) {
  	          this.closeNode(this.currentNode);
  	        } else {
  	          this.openNode(this.currentNode);
  	        }
  	        this.currentNode = null;
  	      } else {
  	        this.closeNode(this.openTags[this.currentLevel]);
  	      }
  	      delete this.openTags[this.currentLevel];
  	      this.currentLevel--;
  	      return this;
  	    };
  
  	    XMLDocumentCB.prototype.end = function() {
  	      while (this.currentLevel >= 0) {
  	        this.up();
  	      }
  	      return this.onEnd();
  	    };
  
  	    XMLDocumentCB.prototype.openCurrent = function() {
  	      if (this.currentNode) {
  	        this.currentNode.children = true;
  	        return this.openNode(this.currentNode);
  	      }
  	    };
  
  	    XMLDocumentCB.prototype.openNode = function(node) {
  	      var att, chunk, name, ref1;
  	      if (!node.isOpen) {
  	        if (!this.root && this.currentLevel === 0 && node.type === NodeType.Element) {
  	          this.root = node;
  	        }
  	        chunk = '';
  	        if (node.type === NodeType.Element) {
  	          this.writerOptions.state = WriterState.OpenTag;
  	          chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<' + node.name;
  	          ref1 = node.attribs;
  	          for (name in ref1) {
  	            if (!hasProp.call(ref1, name)) continue;
  	            att = ref1[name];
  	            chunk += this.writer.attribute(att, this.writerOptions, this.currentLevel);
  	          }
  	          chunk += (node.children ? '>' : '/>') + this.writer.endline(node, this.writerOptions, this.currentLevel);
  	          this.writerOptions.state = WriterState.InsideTag;
  	        } else {
  	          this.writerOptions.state = WriterState.OpenTag;
  	          chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '<!DOCTYPE ' + node.rootNodeName;
  	          if (node.pubID && node.sysID) {
  	            chunk += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
  	          } else if (node.sysID) {
  	            chunk += ' SYSTEM "' + node.sysID + '"';
  	          }
  	          if (node.children) {
  	            chunk += ' [';
  	            this.writerOptions.state = WriterState.InsideTag;
  	          } else {
  	            this.writerOptions.state = WriterState.CloseTag;
  	            chunk += '>';
  	          }
  	          chunk += this.writer.endline(node, this.writerOptions, this.currentLevel);
  	        }
  	        this.onData(chunk, this.currentLevel);
  	        return node.isOpen = true;
  	      }
  	    };
  
  	    XMLDocumentCB.prototype.closeNode = function(node) {
  	      var chunk;
  	      if (!node.isClosed) {
  	        chunk = '';
  	        this.writerOptions.state = WriterState.CloseTag;
  	        if (node.type === NodeType.Element) {
  	          chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + '</' + node.name + '>' + this.writer.endline(node, this.writerOptions, this.currentLevel);
  	        } else {
  	          chunk = this.writer.indent(node, this.writerOptions, this.currentLevel) + ']>' + this.writer.endline(node, this.writerOptions, this.currentLevel);
  	        }
  	        this.writerOptions.state = WriterState.None;
  	        this.onData(chunk, this.currentLevel);
  	        return node.isClosed = true;
  	      }
  	    };
  
  	    XMLDocumentCB.prototype.onData = function(chunk, level) {
  	      this.documentStarted = true;
  	      return this.onDataCallback(chunk, level + 1);
  	    };
  
  	    XMLDocumentCB.prototype.onEnd = function() {
  	      this.documentCompleted = true;
  	      return this.onEndCallback();
  	    };
  
  	    XMLDocumentCB.prototype.debugInfo = function(name) {
  	      if (name == null) {
  	        return "";
  	      } else {
  	        return "node: <" + name + ">";
  	      }
  	    };
  
  	    XMLDocumentCB.prototype.ele = function() {
  	      return this.element.apply(this, arguments);
  	    };
  
  	    XMLDocumentCB.prototype.nod = function(name, attributes, text) {
  	      return this.node(name, attributes, text);
  	    };
  
  	    XMLDocumentCB.prototype.txt = function(value) {
  	      return this.text(value);
  	    };
  
  	    XMLDocumentCB.prototype.dat = function(value) {
  	      return this.cdata(value);
  	    };
  
  	    XMLDocumentCB.prototype.com = function(value) {
  	      return this.comment(value);
  	    };
  
  	    XMLDocumentCB.prototype.ins = function(target, value) {
  	      return this.instruction(target, value);
  	    };
  
  	    XMLDocumentCB.prototype.dec = function(version, encoding, standalone) {
  	      return this.declaration(version, encoding, standalone);
  	    };
  
  	    XMLDocumentCB.prototype.dtd = function(root, pubID, sysID) {
  	      return this.doctype(root, pubID, sysID);
  	    };
  
  	    XMLDocumentCB.prototype.e = function(name, attributes, text) {
  	      return this.element(name, attributes, text);
  	    };
  
  	    XMLDocumentCB.prototype.n = function(name, attributes, text) {
  	      return this.node(name, attributes, text);
  	    };
  
  	    XMLDocumentCB.prototype.t = function(value) {
  	      return this.text(value);
  	    };
  
  	    XMLDocumentCB.prototype.d = function(value) {
  	      return this.cdata(value);
  	    };
  
  	    XMLDocumentCB.prototype.c = function(value) {
  	      return this.comment(value);
  	    };
  
  	    XMLDocumentCB.prototype.r = function(value) {
  	      return this.raw(value);
  	    };
  
  	    XMLDocumentCB.prototype.i = function(target, value) {
  	      return this.instruction(target, value);
  	    };
  
  	    XMLDocumentCB.prototype.att = function() {
  	      if (this.currentNode && this.currentNode.type === NodeType.DocType) {
  	        return this.attList.apply(this, arguments);
  	      } else {
  	        return this.attribute.apply(this, arguments);
  	      }
  	    };
  
  	    XMLDocumentCB.prototype.a = function() {
  	      if (this.currentNode && this.currentNode.type === NodeType.DocType) {
  	        return this.attList.apply(this, arguments);
  	      } else {
  	        return this.attribute.apply(this, arguments);
  	      }
  	    };
  
  	    XMLDocumentCB.prototype.ent = function(name, value) {
  	      return this.entity(name, value);
  	    };
  
  	    XMLDocumentCB.prototype.pent = function(name, value) {
  	      return this.pEntity(name, value);
  	    };
  
  	    XMLDocumentCB.prototype.not = function(name, value) {
  	      return this.notation(name, value);
  	    };
  
  	    return XMLDocumentCB;
  
  	  })();
  
  	}).call(this);
  
  
  /***/ }),
  /* 36 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  var NodeType, WriterState, XMLStreamWriter, XMLWriterBase,
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  NodeType = __webpack_require__(13);
  
  	  XMLWriterBase = __webpack_require__(33);
  
  	  WriterState = __webpack_require__(34);
  
  	  module.exports = XMLStreamWriter = (function(superClass) {
  	    extend(XMLStreamWriter, superClass);
  
  	    function XMLStreamWriter(stream, options) {
  	      this.stream = stream;
  	      XMLStreamWriter.__super__.constructor.call(this, options);
  	    }
  
  	    XMLStreamWriter.prototype.endline = function(node, options, level) {
  	      if (node.isLastRootNode && options.state === WriterState.CloseTag) {
  	        return '';
  	      } else {
  	        return XMLStreamWriter.__super__.endline.call(this, node, options, level);
  	      }
  	    };
  
  	    XMLStreamWriter.prototype.document = function(doc, options) {
  	      var child, i, j, k, len, len1, ref, ref1, results;
  	      ref = doc.children;
  	      for (i = j = 0, len = ref.length; j < len; i = ++j) {
  	        child = ref[i];
  	        child.isLastRootNode = i === doc.children.length - 1;
  	      }
  	      options = this.filterOptions(options);
  	      ref1 = doc.children;
  	      results = [];
  	      for (k = 0, len1 = ref1.length; k < len1; k++) {
  	        child = ref1[k];
  	        results.push(this.writeChildNode(child, options, 0));
  	      }
  	      return results;
  	    };
  
  	    XMLStreamWriter.prototype.attribute = function(att, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.attribute.call(this, att, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.cdata = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.cdata.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.comment = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.comment.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.declaration = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.declaration.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.docType = function(node, options, level) {
  	      var child, j, len, ref;
  	      level || (level = 0);
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      this.stream.write(this.indent(node, options, level));
  	      this.stream.write('<!DOCTYPE ' + node.root().name);
  	      if (node.pubID && node.sysID) {
  	        this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
  	      } else if (node.sysID) {
  	        this.stream.write(' SYSTEM "' + node.sysID + '"');
  	      }
  	      if (node.children.length > 0) {
  	        this.stream.write(' [');
  	        this.stream.write(this.endline(node, options, level));
  	        options.state = WriterState.InsideTag;
  	        ref = node.children;
  	        for (j = 0, len = ref.length; j < len; j++) {
  	          child = ref[j];
  	          this.writeChildNode(child, options, level + 1);
  	        }
  	        options.state = WriterState.CloseTag;
  	        this.stream.write(']');
  	      }
  	      options.state = WriterState.CloseTag;
  	      this.stream.write(options.spaceBeforeSlash + '>');
  	      this.stream.write(this.endline(node, options, level));
  	      options.state = WriterState.None;
  	      return this.closeNode(node, options, level);
  	    };
  
  	    XMLStreamWriter.prototype.element = function(node, options, level) {
  	      var att, child, childNodeCount, firstChildNode, j, len, name, prettySuppressed, ref, ref1;
  	      level || (level = 0);
  	      this.openNode(node, options, level);
  	      options.state = WriterState.OpenTag;
  	      this.stream.write(this.indent(node, options, level) + '<' + node.name);
  	      ref = node.attribs;
  	      for (name in ref) {
  	        if (!hasProp.call(ref, name)) continue;
  	        att = ref[name];
  	        this.attribute(att, options, level);
  	      }
  	      childNodeCount = node.children.length;
  	      firstChildNode = childNodeCount === 0 ? null : node.children[0];
  	      if (childNodeCount === 0 || node.children.every(function(e) {
  	        return (e.type === NodeType.Text || e.type === NodeType.Raw) && e.value === '';
  	      })) {
  	        if (options.allowEmpty) {
  	          this.stream.write('>');
  	          options.state = WriterState.CloseTag;
  	          this.stream.write('</' + node.name + '>');
  	        } else {
  	          options.state = WriterState.CloseTag;
  	          this.stream.write(options.spaceBeforeSlash + '/>');
  	        }
  	      } else if (options.pretty && childNodeCount === 1 && (firstChildNode.type === NodeType.Text || firstChildNode.type === NodeType.Raw) && (firstChildNode.value != null)) {
  	        this.stream.write('>');
  	        options.state = WriterState.InsideTag;
  	        options.suppressPrettyCount++;
  	        prettySuppressed = true;
  	        this.writeChildNode(firstChildNode, options, level + 1);
  	        options.suppressPrettyCount--;
  	        prettySuppressed = false;
  	        options.state = WriterState.CloseTag;
  	        this.stream.write('</' + node.name + '>');
  	      } else {
  	        this.stream.write('>' + this.endline(node, options, level));
  	        options.state = WriterState.InsideTag;
  	        ref1 = node.children;
  	        for (j = 0, len = ref1.length; j < len; j++) {
  	          child = ref1[j];
  	          this.writeChildNode(child, options, level + 1);
  	        }
  	        options.state = WriterState.CloseTag;
  	        this.stream.write(this.indent(node, options, level) + '</' + node.name + '>');
  	      }
  	      this.stream.write(this.endline(node, options, level));
  	      options.state = WriterState.None;
  	      return this.closeNode(node, options, level);
  	    };
  
  	    XMLStreamWriter.prototype.processingInstruction = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.processingInstruction.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.raw = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.raw.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.text = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.text.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.dtdAttList = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.dtdAttList.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.dtdElement = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.dtdElement.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.dtdEntity = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.dtdEntity.call(this, node, options, level));
  	    };
  
  	    XMLStreamWriter.prototype.dtdNotation = function(node, options, level) {
  	      return this.stream.write(XMLStreamWriter.__super__.dtdNotation.call(this, node, options, level));
  	    };
  
  	    return XMLStreamWriter;
  
  	  })(XMLWriterBase);
  
  	}).call(this);
  
  
  /***/ }),
  /* 37 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  "use strict";
  	  var bom, defaults, events, isEmpty, processItem, processors, promisify, sax, setImmediate,
  	    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
  	    extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
  	    hasProp = {}.hasOwnProperty;
  
  	  sax = __webpack_require__(38);
  
  	  events = __webpack_require__(44);
  
  	  bom = __webpack_require__(70);
  
  	  processors = __webpack_require__(71);
  
  	  setImmediate = __webpack_require__(59).setImmediate;
  
  	  defaults = __webpack_require__(2).defaults;
  
  	  promisify = __webpack_require__(72);
  
  	  isEmpty = function(thing) {
  	    return typeof thing === "object" && (thing != null) && Object.keys(thing).length === 0;
  	  };
  
  	  processItem = function(processors, item, key) {
  	    var i, len, process;
  	    for (i = 0, len = processors.length; i < len; i++) {
  	      process = processors[i];
  	      item = process(item, key);
  	    }
  	    return item;
  	  };
  
  	  exports.Parser = (function(superClass) {
  	    extend(Parser, superClass);
  
  	    function Parser(opts) {
  	      this.parseStringPromise = bind(this.parseStringPromise, this);
  	      this.parseString = bind(this.parseString, this);
  	      this.reset = bind(this.reset, this);
  	      this.assignOrPush = bind(this.assignOrPush, this);
  	      this.processAsync = bind(this.processAsync, this);
  	      var key, ref, value;
  	      if (!(this instanceof exports.Parser)) {
  	        return new exports.Parser(opts);
  	      }
  	      this.options = {};
  	      ref = defaults["0.2"];
  	      for (key in ref) {
  	        if (!hasProp.call(ref, key)) continue;
  	        value = ref[key];
  	        this.options[key] = value;
  	      }
  	      for (key in opts) {
  	        if (!hasProp.call(opts, key)) continue;
  	        value = opts[key];
  	        this.options[key] = value;
  	      }
  	      if (this.options.xmlns) {
  	        this.options.xmlnskey = this.options.attrkey + "ns";
  	      }
  	      if (this.options.normalizeTags) {
  	        if (!this.options.tagNameProcessors) {
  	          this.options.tagNameProcessors = [];
  	        }
  	        this.options.tagNameProcessors.unshift(processors.normalize);
  	      }
  	      this.reset();
  	    }
  
  	    Parser.prototype.processAsync = function() {
  	      var chunk, err;
  	      try {
  	        if (this.remaining.length <= this.options.chunkSize) {
  	          chunk = this.remaining;
  	          this.remaining = '';
  	          this.saxParser = this.saxParser.write(chunk);
  	          return this.saxParser.close();
  	        } else {
  	          chunk = this.remaining.substr(0, this.options.chunkSize);
  	          this.remaining = this.remaining.substr(this.options.chunkSize, this.remaining.length);
  	          this.saxParser = this.saxParser.write(chunk);
  	          return setImmediate(this.processAsync);
  	        }
  	      } catch (error1) {
  	        err = error1;
  	        if (!this.saxParser.errThrown) {
  	          this.saxParser.errThrown = true;
  	          return this.emit(err);
  	        }
  	      }
  	    };
  
  	    Parser.prototype.assignOrPush = function(obj, key, newValue) {
  	      if (!(key in obj)) {
  	        if (!this.options.explicitArray) {
  	          return obj[key] = newValue;
  	        } else {
  	          return obj[key] = [newValue];
  	        }
  	      } else {
  	        if (!(obj[key] instanceof Array)) {
  	          obj[key] = [obj[key]];
  	        }
  	        return obj[key].push(newValue);
  	      }
  	    };
  
  	    Parser.prototype.reset = function() {
  	      var attrkey, charkey, ontext, stack;
  	      this.removeAllListeners();
  	      this.saxParser = sax.parser(this.options.strict, {
  	        trim: false,
  	        normalize: false,
  	        xmlns: this.options.xmlns
  	      });
  	      this.saxParser.errThrown = false;
  	      this.saxParser.onerror = (function(_this) {
  	        return function(error) {
  	          _this.saxParser.resume();
  	          if (!_this.saxParser.errThrown) {
  	            _this.saxParser.errThrown = true;
  	            return _this.emit("error", error);
  	          }
  	        };
  	      })(this);
  	      this.saxParser.onend = (function(_this) {
  	        return function() {
  	          if (!_this.saxParser.ended) {
  	            _this.saxParser.ended = true;
  	            return _this.emit("end", _this.resultObject);
  	          }
  	        };
  	      })(this);
  	      this.saxParser.ended = false;
  	      this.EXPLICIT_CHARKEY = this.options.explicitCharkey;
  	      this.resultObject = null;
  	      stack = [];
  	      attrkey = this.options.attrkey;
  	      charkey = this.options.charkey;
  	      this.saxParser.onopentag = (function(_this) {
  	        return function(node) {
  	          var key, newValue, obj, processedKey, ref;
  	          obj = {};
  	          obj[charkey] = "";
  	          if (!_this.options.ignoreAttrs) {
  	            ref = node.attributes;
  	            for (key in ref) {
  	              if (!hasProp.call(ref, key)) continue;
  	              if (!(attrkey in obj) && !_this.options.mergeAttrs) {
  	                obj[attrkey] = {};
  	              }
  	              newValue = _this.options.attrValueProcessors ? processItem(_this.options.attrValueProcessors, node.attributes[key], key) : node.attributes[key];
  	              processedKey = _this.options.attrNameProcessors ? processItem(_this.options.attrNameProcessors, key) : key;
  	              if (_this.options.mergeAttrs) {
  	                _this.assignOrPush(obj, processedKey, newValue);
  	              } else {
  	                obj[attrkey][processedKey] = newValue;
  	              }
  	            }
  	          }
  	          obj["#name"] = _this.options.tagNameProcessors ? processItem(_this.options.tagNameProcessors, node.name) : node.name;
  	          if (_this.options.xmlns) {
  	            obj[_this.options.xmlnskey] = {
  	              uri: node.uri,
  	              local: node.local
  	            };
  	          }
  	          return stack.push(obj);
  	        };
  	      })(this);
  	      this.saxParser.onclosetag = (function(_this) {
  	        return function() {
  	          var cdata, emptyStr, key, node, nodeName, obj, objClone, old, s, xpath;
  	          obj = stack.pop();
  	          nodeName = obj["#name"];
  	          if (!_this.options.explicitChildren || !_this.options.preserveChildrenOrder) {
  	            delete obj["#name"];
  	          }
  	          if (obj.cdata === true) {
  	            cdata = obj.cdata;
  	            delete obj.cdata;
  	          }
  	          s = stack[stack.length - 1];
  	          if (obj[charkey].match(/^\s*$/) && !cdata) {
  	            emptyStr = obj[charkey];
  	            delete obj[charkey];
  	          } else {
  	            if (_this.options.trim) {
  	              obj[charkey] = obj[charkey].trim();
  	            }
  	            if (_this.options.normalize) {
  	              obj[charkey] = obj[charkey].replace(/\s{2,}/g, " ").trim();
  	            }
  	            obj[charkey] = _this.options.valueProcessors ? processItem(_this.options.valueProcessors, obj[charkey], nodeName) : obj[charkey];
  	            if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
  	              obj = obj[charkey];
  	            }
  	          }
  	          if (isEmpty(obj)) {
  	            obj = _this.options.emptyTag !== '' ? _this.options.emptyTag : emptyStr;
  	          }
  	          if (_this.options.validator != null) {
  	            xpath = "/" + ((function() {
  	              var i, len, results;
  	              results = [];
  	              for (i = 0, len = stack.length; i < len; i++) {
  	                node = stack[i];
  	                results.push(node["#name"]);
  	              }
  	              return results;
  	            })()).concat(nodeName).join("/");
  	            (function() {
  	              var err;
  	              try {
  	                return obj = _this.options.validator(xpath, s && s[nodeName], obj);
  	              } catch (error1) {
  	                err = error1;
  	                return _this.emit("error", err);
  	              }
  	            })();
  	          }
  	          if (_this.options.explicitChildren && !_this.options.mergeAttrs && typeof obj === 'object') {
  	            if (!_this.options.preserveChildrenOrder) {
  	              node = {};
  	              if (_this.options.attrkey in obj) {
  	                node[_this.options.attrkey] = obj[_this.options.attrkey];
  	                delete obj[_this.options.attrkey];
  	              }
  	              if (!_this.options.charsAsChildren && _this.options.charkey in obj) {
  	                node[_this.options.charkey] = obj[_this.options.charkey];
  	                delete obj[_this.options.charkey];
  	              }
  	              if (Object.getOwnPropertyNames(obj).length > 0) {
  	                node[_this.options.childkey] = obj;
  	              }
  	              obj = node;
  	            } else if (s) {
  	              s[_this.options.childkey] = s[_this.options.childkey] || [];
  	              objClone = {};
  	              for (key in obj) {
  	                if (!hasProp.call(obj, key)) continue;
  	                objClone[key] = obj[key];
  	              }
  	              s[_this.options.childkey].push(objClone);
  	              delete obj["#name"];
  	              if (Object.keys(obj).length === 1 && charkey in obj && !_this.EXPLICIT_CHARKEY) {
  	                obj = obj[charkey];
  	              }
  	            }
  	          }
  	          if (stack.length > 0) {
  	            return _this.assignOrPush(s, nodeName, obj);
  	          } else {
  	            if (_this.options.explicitRoot) {
  	              old = obj;
  	              obj = {};
  	              obj[nodeName] = old;
  	            }
  	            _this.resultObject = obj;
  	            _this.saxParser.ended = true;
  	            return _this.emit("end", _this.resultObject);
  	          }
  	        };
  	      })(this);
  	      ontext = (function(_this) {
  	        return function(text) {
  	          var charChild, s;
  	          s = stack[stack.length - 1];
  	          if (s) {
  	            s[charkey] += text;
  	            if (_this.options.explicitChildren && _this.options.preserveChildrenOrder && _this.options.charsAsChildren && (_this.options.includeWhiteChars || text.replace(/\\n/g, '').trim() !== '')) {
  	              s[_this.options.childkey] = s[_this.options.childkey] || [];
  	              charChild = {
  	                '#name': '__text__'
  	              };
  	              charChild[charkey] = text;
  	              if (_this.options.normalize) {
  	                charChild[charkey] = charChild[charkey].replace(/\s{2,}/g, " ").trim();
  	              }
  	              s[_this.options.childkey].push(charChild);
  	            }
  	            return s;
  	          }
  	        };
  	      })(this);
  	      this.saxParser.ontext = ontext;
  	      return this.saxParser.oncdata = (function(_this) {
  	        return function(text) {
  	          var s;
  	          s = ontext(text);
  	          if (s) {
  	            return s.cdata = true;
  	          }
  	        };
  	      })(this);
  	    };
  
  	    Parser.prototype.parseString = function(str, cb) {
  	      var err;
  	      if ((cb != null) && typeof cb === "function") {
  	        this.on("end", function(result) {
  	          this.reset();
  	          return cb(null, result);
  	        });
  	        this.on("error", function(err) {
  	          this.reset();
  	          return cb(err);
  	        });
  	      }
  	      try {
  	        str = str.toString();
  	        if (str.trim() === '') {
  	          this.emit("end", null);
  	          return true;
  	        }
  	        str = bom.stripBOM(str);
  	        if (this.options.async) {
  	          this.remaining = str;
  	          setImmediate(this.processAsync);
  	          return this.saxParser;
  	        }
  	        return this.saxParser.write(str).close();
  	      } catch (error1) {
  	        err = error1;
  	        if (!(this.saxParser.errThrown || this.saxParser.ended)) {
  	          this.emit('error', err);
  	          return this.saxParser.errThrown = true;
  	        } else if (this.saxParser.ended) {
  	          throw err;
  	        }
  	      }
  	    };
  
  	    Parser.prototype.parseStringPromise = function(str) {
  	      return promisify(this.parseString)(str);
  	    };
  
  	    return Parser;
  
  	  })(events);
  
  	  exports.parseString = function(str, a, b) {
  	    var cb, options, parser;
  	    if (b != null) {
  	      if (typeof b === 'function') {
  	        cb = b;
  	      }
  	      if (typeof a === 'object') {
  	        options = a;
  	      }
  	    } else {
  	      if (typeof a === 'function') {
  	        cb = a;
  	      }
  	      options = {};
  	    }
  	    parser = new exports.Parser(options);
  	    return parser.parseString(str, cb);
  	  };
  
  	  exports.parseStringPromise = function(str, a) {
  	    var options, parser;
  	    if (typeof a === 'object') {
  	      options = a;
  	    }
  	    parser = new exports.Parser(options);
  	    return parser.parseStringPromise(str);
  	  };
  
  	}).call(this);
  
  
  /***/ }),
  /* 38 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(Buffer) {;(function (sax) { // wrapper for non-node envs
  	  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }
  	  sax.SAXParser = SAXParser
  	  sax.SAXStream = SAXStream
  	  sax.createStream = createStream
  
  	  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.
  	  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),
  	  // since that's the earliest that a buffer overrun could occur.  This way, checks are
  	  // as rare as required, but as often as necessary to ensure never crossing this bound.
  	  // Furthermore, buffers are only tested at most once per write(), so passing a very
  	  // large string into write() might have undesirable effects, but this is manageable by
  	  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme
  	  // edge case, result in creating at most one complete copy of the string passed in.
  	  // Set to Infinity to have unlimited buffers.
  	  sax.MAX_BUFFER_LENGTH = 64 * 1024
  
  	  var buffers = [
  	    'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',
  	    'procInstName', 'procInstBody', 'entity', 'attribName',
  	    'attribValue', 'cdata', 'script'
  	  ]
  
  	  sax.EVENTS = [
  	    'text',
  	    'processinginstruction',
  	    'sgmldeclaration',
  	    'doctype',
  	    'comment',
  	    'opentagstart',
  	    'attribute',
  	    'opentag',
  	    'closetag',
  	    'opencdata',
  	    'cdata',
  	    'closecdata',
  	    'error',
  	    'end',
  	    'ready',
  	    'script',
  	    'opennamespace',
  	    'closenamespace'
  	  ]
  
  	  function SAXParser (strict, opt) {
  	    if (!(this instanceof SAXParser)) {
  	      return new SAXParser(strict, opt)
  	    }
  
  	    var parser = this
  	    clearBuffers(parser)
  	    parser.q = parser.c = ''
  	    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH
  	    parser.opt = opt || {}
  	    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags
  	    parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase'
  	    parser.tags = []
  	    parser.closed = parser.closedRoot = parser.sawRoot = false
  	    parser.tag = parser.error = null
  	    parser.strict = !!strict
  	    parser.noscript = !!(strict || parser.opt.noscript)
  	    parser.state = S.BEGIN
  	    parser.strictEntities = parser.opt.strictEntities
  	    parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)
  	    parser.attribList = []
  
  	    // namespaces form a prototype chain.
  	    // it always points at the current tag,
  	    // which protos to its parent tag.
  	    if (parser.opt.xmlns) {
  	      parser.ns = Object.create(rootNS)
  	    }
  
  	    // mostly just for error reporting
  	    parser.trackPosition = parser.opt.position !== false
  	    if (parser.trackPosition) {
  	      parser.position = parser.line = parser.column = 0
  	    }
  	    emit(parser, 'onready')
  	  }
  
  	  if (!Object.create) {
  	    Object.create = function (o) {
  	      function F () {}
  	      F.prototype = o
  	      var newf = new F()
  	      return newf
  	    }
  	  }
  
  	  if (!Object.keys) {
  	    Object.keys = function (o) {
  	      var a = []
  	      for (var i in o) if (o.hasOwnProperty(i)) a.push(i)
  	      return a
  	    }
  	  }
  
  	  function checkBufferLength (parser) {
  	    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)
  	    var maxActual = 0
  	    for (var i = 0, l = buffers.length; i < l; i++) {
  	      var len = parser[buffers[i]].length
  	      if (len > maxAllowed) {
  	        // Text/cdata nodes can get big, and since they're buffered,
  	        // we can get here under normal conditions.
  	        // Avoid issues by emitting the text node now,
  	        // so at least it won't get any bigger.
  	        switch (buffers[i]) {
  	          case 'textNode':
  	            closeText(parser)
  	            break
  
  	          case 'cdata':
  	            emitNode(parser, 'oncdata', parser.cdata)
  	            parser.cdata = ''
  	            break
  
  	          case 'script':
  	            emitNode(parser, 'onscript', parser.script)
  	            parser.script = ''
  	            break
  
  	          default:
  	            error(parser, 'Max buffer length exceeded: ' + buffers[i])
  	        }
  	      }
  	      maxActual = Math.max(maxActual, len)
  	    }
  	    // schedule the next check for the earliest possible buffer overrun.
  	    var m = sax.MAX_BUFFER_LENGTH - maxActual
  	    parser.bufferCheckPosition = m + parser.position
  	  }
  
  	  function clearBuffers (parser) {
  	    for (var i = 0, l = buffers.length; i < l; i++) {
  	      parser[buffers[i]] = ''
  	    }
  	  }
  
  	  function flushBuffers (parser) {
  	    closeText(parser)
  	    if (parser.cdata !== '') {
  	      emitNode(parser, 'oncdata', parser.cdata)
  	      parser.cdata = ''
  	    }
  	    if (parser.script !== '') {
  	      emitNode(parser, 'onscript', parser.script)
  	      parser.script = ''
  	    }
  	  }
  
  	  SAXParser.prototype = {
  	    end: function () { end(this) },
  	    write: write,
  	    resume: function () { this.error = null; return this },
  	    close: function () { return this.write(null) },
  	    flush: function () { flushBuffers(this) }
  	  }
  
  	  var Stream
  	  try {
  	    Stream = __webpack_require__(43).Stream
  	  } catch (ex) {
  	    Stream = function () {}
  	  }
  
  	  var streamWraps = sax.EVENTS.filter(function (ev) {
  	    return ev !== 'error' && ev !== 'end'
  	  })
  
  	  function createStream (strict, opt) {
  	    return new SAXStream(strict, opt)
  	  }
  
  	  function SAXStream (strict, opt) {
  	    if (!(this instanceof SAXStream)) {
  	      return new SAXStream(strict, opt)
  	    }
  
  	    Stream.apply(this)
  
  	    this._parser = new SAXParser(strict, opt)
  	    this.writable = true
  	    this.readable = true
  
  	    var me = this
  
  	    this._parser.onend = function () {
  	      me.emit('end')
  	    }
  
  	    this._parser.onerror = function (er) {
  	      me.emit('error', er)
  
  	      // if didn't throw, then means error was handled.
  	      // go ahead and clear error, so we can write again.
  	      me._parser.error = null
  	    }
  
  	    this._decoder = null
  
  	    streamWraps.forEach(function (ev) {
  	      Object.defineProperty(me, 'on' + ev, {
  	        get: function () {
  	          return me._parser['on' + ev]
  	        },
  	        set: function (h) {
  	          if (!h) {
  	            me.removeAllListeners(ev)
  	            me._parser['on' + ev] = h
  	            return h
  	          }
  	          me.on(ev, h)
  	        },
  	        enumerable: true,
  	        configurable: false
  	      })
  	    })
  	  }
  
  	  SAXStream.prototype = Object.create(Stream.prototype, {
  	    constructor: {
  	      value: SAXStream
  	    }
  	  })
  
  	  SAXStream.prototype.write = function (data) {
  	    if (typeof Buffer === 'function' &&
  	      typeof Buffer.isBuffer === 'function' &&
  	      Buffer.isBuffer(data)) {
  	      if (!this._decoder) {
  	        var SD = __webpack_require__(69).StringDecoder
  	        this._decoder = new SD('utf8')
  	      }
  	      data = this._decoder.write(data)
  	    }
  
  	    this._parser.write(data.toString())
  	    this.emit('data', data)
  	    return true
  	  }
  
  	  SAXStream.prototype.end = function (chunk) {
  	    if (chunk && chunk.length) {
  	      this.write(chunk)
  	    }
  	    this._parser.end()
  	    return true
  	  }
  
  	  SAXStream.prototype.on = function (ev, handler) {
  	    var me = this
  	    if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {
  	      me._parser['on' + ev] = function () {
  	        var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)
  	        args.splice(0, 0, ev)
  	        me.emit.apply(me, args)
  	      }
  	    }
  
  	    return Stream.prototype.on.call(me, ev, handler)
  	  }
  
  	  // this really needs to be replaced with character classes.
  	  // XML allows all manner of ridiculous numbers and digits.
  	  var CDATA = '[CDATA['
  	  var DOCTYPE = 'DOCTYPE'
  	  var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'
  	  var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'
  	  var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }
  
  	  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar
  	  // This implementation works on strings, a single character at a time
  	  // as such, it cannot ever support astral-plane characters (10000-EFFFF)
  	  // without a significant breaking change to either this  parser, or the
  	  // JavaScript language.  Implementation of an emoji-capable xml parser
  	  // is left as an exercise for the reader.
  	  var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
  
  	  var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/
  
  	  var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/
  	  var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/
  
  	  function isWhitespace (c) {
  	    return c === ' ' || c === '\n' || c === '\r' || c === '\t'
  	  }
  
  	  function isQuote (c) {
  	    return c === '"' || c === '\''
  	  }
  
  	  function isAttribEnd (c) {
  	    return c === '>' || isWhitespace(c)
  	  }
  
  	  function isMatch (regex, c) {
  	    return regex.test(c)
  	  }
  
  	  function notMatch (regex, c) {
  	    return !isMatch(regex, c)
  	  }
  
  	  var S = 0
  	  sax.STATE = {
  	    BEGIN: S++, // leading byte order mark or whitespace
  	    BEGIN_WHITESPACE: S++, // leading whitespace
  	    TEXT: S++, // general stuff
  	    TEXT_ENTITY: S++, // &amp and such.
  	    OPEN_WAKA: S++, // <
  	    SGML_DECL: S++, // <!BLARG
  	    SGML_DECL_QUOTED: S++, // <!BLARG foo "bar
  	    DOCTYPE: S++, // <!DOCTYPE
  	    DOCTYPE_QUOTED: S++, // <!DOCTYPE "//blah
  	    DOCTYPE_DTD: S++, // <!DOCTYPE "//blah" [ ...
  	    DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE "//blah" [ "foo
  	    COMMENT_STARTING: S++, // <!-
  	    COMMENT: S++, // <!--
  	    COMMENT_ENDING: S++, // <!-- blah -
  	    COMMENT_ENDED: S++, // <!-- blah --
  	    CDATA: S++, // <![CDATA[ something
  	    CDATA_ENDING: S++, // ]
  	    CDATA_ENDING_2: S++, // ]]
  	    PROC_INST: S++, // <?hi
  	    PROC_INST_BODY: S++, // <?hi there
  	    PROC_INST_ENDING: S++, // <?hi "there" ?
  	    OPEN_TAG: S++, // <strong
  	    OPEN_TAG_SLASH: S++, // <strong /
  	    ATTRIB: S++, // <a
  	    ATTRIB_NAME: S++, // <a foo
  	    ATTRIB_NAME_SAW_WHITE: S++, // <a foo _
  	    ATTRIB_VALUE: S++, // <a foo=
  	    ATTRIB_VALUE_QUOTED: S++, // <a foo="bar
  	    ATTRIB_VALUE_CLOSED: S++, // <a foo="bar"
  	    ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar
  	    ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar="&quot;"
  	    ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot
  	    CLOSE_TAG: S++, // </a
  	    CLOSE_TAG_SAW_WHITE: S++, // </a   >
  	    SCRIPT: S++, // <script> ...
  	    SCRIPT_ENDING: S++ // <script> ... <
  	  }
  
  	  sax.XML_ENTITIES = {
  	    'amp': '&',
  	    'gt': '>',
  	    'lt': '<',
  	    'quot': '"',
  	    'apos': "'"
  	  }
  
  	  sax.ENTITIES = {
  	    'amp': '&',
  	    'gt': '>',
  	    'lt': '<',
  	    'quot': '"',
  	    'apos': "'",
  	    'AElig': 198,
  	    'Aacute': 193,
  	    'Acirc': 194,
  	    'Agrave': 192,
  	    'Aring': 197,
  	    'Atilde': 195,
  	    'Auml': 196,
  	    'Ccedil': 199,
  	    'ETH': 208,
  	    'Eacute': 201,
  	    'Ecirc': 202,
  	    'Egrave': 200,
  	    'Euml': 203,
  	    'Iacute': 205,
  	    'Icirc': 206,
  	    'Igrave': 204,
  	    'Iuml': 207,
  	    'Ntilde': 209,
  	    'Oacute': 211,
  	    'Ocirc': 212,
  	    'Ograve': 210,
  	    'Oslash': 216,
  	    'Otilde': 213,
  	    'Ouml': 214,
  	    'THORN': 222,
  	    'Uacute': 218,
  	    'Ucirc': 219,
  	    'Ugrave': 217,
  	    'Uuml': 220,
  	    'Yacute': 221,
  	    'aacute': 225,
  	    'acirc': 226,
  	    'aelig': 230,
  	    'agrave': 224,
  	    'aring': 229,
  	    'atilde': 227,
  	    'auml': 228,
  	    'ccedil': 231,
  	    'eacute': 233,
  	    'ecirc': 234,
  	    'egrave': 232,
  	    'eth': 240,
  	    'euml': 235,
  	    'iacute': 237,
  	    'icirc': 238,
  	    'igrave': 236,
  	    'iuml': 239,
  	    'ntilde': 241,
  	    'oacute': 243,
  	    'ocirc': 244,
  	    'ograve': 242,
  	    'oslash': 248,
  	    'otilde': 245,
  	    'ouml': 246,
  	    'szlig': 223,
  	    'thorn': 254,
  	    'uacute': 250,
  	    'ucirc': 251,
  	    'ugrave': 249,
  	    'uuml': 252,
  	    'yacute': 253,
  	    'yuml': 255,
  	    'copy': 169,
  	    'reg': 174,
  	    'nbsp': 160,
  	    'iexcl': 161,
  	    'cent': 162,
  	    'pound': 163,
  	    'curren': 164,
  	    'yen': 165,
  	    'brvbar': 166,
  	    'sect': 167,
  	    'uml': 168,
  	    'ordf': 170,
  	    'laquo': 171,
  	    'not': 172,
  	    'shy': 173,
  	    'macr': 175,
  	    'deg': 176,
  	    'plusmn': 177,
  	    'sup1': 185,
  	    'sup2': 178,
  	    'sup3': 179,
  	    'acute': 180,
  	    'micro': 181,
  	    'para': 182,
  	    'middot': 183,
  	    'cedil': 184,
  	    'ordm': 186,
  	    'raquo': 187,
  	    'frac14': 188,
  	    'frac12': 189,
  	    'frac34': 190,
  	    'iquest': 191,
  	    'times': 215,
  	    'divide': 247,
  	    'OElig': 338,
  	    'oelig': 339,
  	    'Scaron': 352,
  	    'scaron': 353,
  	    'Yuml': 376,
  	    'fnof': 402,
  	    'circ': 710,
  	    'tilde': 732,
  	    'Alpha': 913,
  	    'Beta': 914,
  	    'Gamma': 915,
  	    'Delta': 916,
  	    'Epsilon': 917,
  	    'Zeta': 918,
  	    'Eta': 919,
  	    'Theta': 920,
  	    'Iota': 921,
  	    'Kappa': 922,
  	    'Lambda': 923,
  	    'Mu': 924,
  	    'Nu': 925,
  	    'Xi': 926,
  	    'Omicron': 927,
  	    'Pi': 928,
  	    'Rho': 929,
  	    'Sigma': 931,
  	    'Tau': 932,
  	    'Upsilon': 933,
  	    'Phi': 934,
  	    'Chi': 935,
  	    'Psi': 936,
  	    'Omega': 937,
  	    'alpha': 945,
  	    'beta': 946,
  	    'gamma': 947,
  	    'delta': 948,
  	    'epsilon': 949,
  	    'zeta': 950,
  	    'eta': 951,
  	    'theta': 952,
  	    'iota': 953,
  	    'kappa': 954,
  	    'lambda': 955,
  	    'mu': 956,
  	    'nu': 957,
  	    'xi': 958,
  	    'omicron': 959,
  	    'pi': 960,
  	    'rho': 961,
  	    'sigmaf': 962,
  	    'sigma': 963,
  	    'tau': 964,
  	    'upsilon': 965,
  	    'phi': 966,
  	    'chi': 967,
  	    'psi': 968,
  	    'omega': 969,
  	    'thetasym': 977,
  	    'upsih': 978,
  	    'piv': 982,
  	    'ensp': 8194,
  	    'emsp': 8195,
  	    'thinsp': 8201,
  	    'zwnj': 8204,
  	    'zwj': 8205,
  	    'lrm': 8206,
  	    'rlm': 8207,
  	    'ndash': 8211,
  	    'mdash': 8212,
  	    'lsquo': 8216,
  	    'rsquo': 8217,
  	    'sbquo': 8218,
  	    'ldquo': 8220,
  	    'rdquo': 8221,
  	    'bdquo': 8222,
  	    'dagger': 8224,
  	    'Dagger': 8225,
  	    'bull': 8226,
  	    'hellip': 8230,
  	    'permil': 8240,
  	    'prime': 8242,
  	    'Prime': 8243,
  	    'lsaquo': 8249,
  	    'rsaquo': 8250,
  	    'oline': 8254,
  	    'frasl': 8260,
  	    'euro': 8364,
  	    'image': 8465,
  	    'weierp': 8472,
  	    'real': 8476,
  	    'trade': 8482,
  	    'alefsym': 8501,
  	    'larr': 8592,
  	    'uarr': 8593,
  	    'rarr': 8594,
  	    'darr': 8595,
  	    'harr': 8596,
  	    'crarr': 8629,
  	    'lArr': 8656,
  	    'uArr': 8657,
  	    'rArr': 8658,
  	    'dArr': 8659,
  	    'hArr': 8660,
  	    'forall': 8704,
  	    'part': 8706,
  	    'exist': 8707,
  	    'empty': 8709,
  	    'nabla': 8711,
  	    'isin': 8712,
  	    'notin': 8713,
  	    'ni': 8715,
  	    'prod': 8719,
  	    'sum': 8721,
  	    'minus': 8722,
  	    'lowast': 8727,
  	    'radic': 8730,
  	    'prop': 8733,
  	    'infin': 8734,
  	    'ang': 8736,
  	    'and': 8743,
  	    'or': 8744,
  	    'cap': 8745,
  	    'cup': 8746,
  	    'int': 8747,
  	    'there4': 8756,
  	    'sim': 8764,
  	    'cong': 8773,
  	    'asymp': 8776,
  	    'ne': 8800,
  	    'equiv': 8801,
  	    'le': 8804,
  	    'ge': 8805,
  	    'sub': 8834,
  	    'sup': 8835,
  	    'nsub': 8836,
  	    'sube': 8838,
  	    'supe': 8839,
  	    'oplus': 8853,
  	    'otimes': 8855,
  	    'perp': 8869,
  	    'sdot': 8901,
  	    'lceil': 8968,
  	    'rceil': 8969,
  	    'lfloor': 8970,
  	    'rfloor': 8971,
  	    'lang': 9001,
  	    'rang': 9002,
  	    'loz': 9674,
  	    'spades': 9824,
  	    'clubs': 9827,
  	    'hearts': 9829,
  	    'diams': 9830
  	  }
  
  	  Object.keys(sax.ENTITIES).forEach(function (key) {
  	    var e = sax.ENTITIES[key]
  	    var s = typeof e === 'number' ? String.fromCharCode(e) : e
  	    sax.ENTITIES[key] = s
  	  })
  
  	  for (var s in sax.STATE) {
  	    sax.STATE[sax.STATE[s]] = s
  	  }
  
  	  // shorthand
  	  S = sax.STATE
  
  	  function emit (parser, event, data) {
  	    parser[event] && parser[event](data)
  	  }
  
  	  function emitNode (parser, nodeType, data) {
  	    if (parser.textNode) closeText(parser)
  	    emit(parser, nodeType, data)
  	  }
  
  	  function closeText (parser) {
  	    parser.textNode = textopts(parser.opt, parser.textNode)
  	    if (parser.textNode) emit(parser, 'ontext', parser.textNode)
  	    parser.textNode = ''
  	  }
  
  	  function textopts (opt, text) {
  	    if (opt.trim) text = text.trim()
  	    if (opt.normalize) text = text.replace(/\s+/g, ' ')
  	    return text
  	  }
  
  	  function error (parser, er) {
  	    closeText(parser)
  	    if (parser.trackPosition) {
  	      er += '\nLine: ' + parser.line +
  	        '\nColumn: ' + parser.column +
  	        '\nChar: ' + parser.c
  	    }
  	    er = new Error(er)
  	    parser.error = er
  	    emit(parser, 'onerror', er)
  	    return parser
  	  }
  
  	  function end (parser) {
  	    if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag')
  	    if ((parser.state !== S.BEGIN) &&
  	      (parser.state !== S.BEGIN_WHITESPACE) &&
  	      (parser.state !== S.TEXT)) {
  	      error(parser, 'Unexpected end')
  	    }
  	    closeText(parser)
  	    parser.c = ''
  	    parser.closed = true
  	    emit(parser, 'onend')
  	    SAXParser.call(parser, parser.strict, parser.opt)
  	    return parser
  	  }
  
  	  function strictFail (parser, message) {
  	    if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {
  	      throw new Error('bad call to strictFail')
  	    }
  	    if (parser.strict) {
  	      error(parser, message)
  	    }
  	  }
  
  	  function newTag (parser) {
  	    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
  	    var parent = parser.tags[parser.tags.length - 1] || parser
  	    var tag = parser.tag = { name: parser.tagName, attributes: {} }
  
  	    // will be overridden if tag contails an xmlns="foo" or xmlns:foo="bar"
  	    if (parser.opt.xmlns) {
  	      tag.ns = parent.ns
  	    }
  	    parser.attribList.length = 0
  	    emitNode(parser, 'onopentagstart', tag)
  	  }
  
  	  function qname (name, attribute) {
  	    var i = name.indexOf(':')
  	    var qualName = i < 0 ? [ '', name ] : name.split(':')
  	    var prefix = qualName[0]
  	    var local = qualName[1]
  
  	    // <x "xmlns"="http://foo">
  	    if (attribute && name === 'xmlns') {
  	      prefix = 'xmlns'
  	      local = ''
  	    }
  
  	    return { prefix: prefix, local: local }
  	  }
  
  	  function attrib (parser) {
  	    if (!parser.strict) {
  	      parser.attribName = parser.attribName[parser.looseCase]()
  	    }
  
  	    if (parser.attribList.indexOf(parser.attribName) !== -1 ||
  	      parser.tag.attributes.hasOwnProperty(parser.attribName)) {
  	      parser.attribName = parser.attribValue = ''
  	      return
  	    }
  
  	    if (parser.opt.xmlns) {
  	      var qn = qname(parser.attribName, true)
  	      var prefix = qn.prefix
  	      var local = qn.local
  
  	      if (prefix === 'xmlns') {
  	        // namespace binding attribute. push the binding into scope
  	        if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {
  	          strictFail(parser,
  	            'xml: prefix must be bound to ' + XML_NAMESPACE + '\n' +
  	            'Actual: ' + parser.attribValue)
  	        } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {
  	          strictFail(parser,
  	            'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\n' +
  	            'Actual: ' + parser.attribValue)
  	        } else {
  	          var tag = parser.tag
  	          var parent = parser.tags[parser.tags.length - 1] || parser
  	          if (tag.ns === parent.ns) {
  	            tag.ns = Object.create(parent.ns)
  	          }
  	          tag.ns[local] = parser.attribValue
  	        }
  	      }
  
  	      // defer onattribute events until all attributes have been seen
  	      // so any new bindings can take effect. preserve attribute order
  	      // so deferred events can be emitted in document order
  	      parser.attribList.push([parser.attribName, parser.attribValue])
  	    } else {
  	      // in non-xmlns mode, we can emit the event right away
  	      parser.tag.attributes[parser.attribName] = parser.attribValue
  	      emitNode(parser, 'onattribute', {
  	        name: parser.attribName,
  	        value: parser.attribValue
  	      })
  	    }
  
  	    parser.attribName = parser.attribValue = ''
  	  }
  
  	  function openTag (parser, selfClosing) {
  	    if (parser.opt.xmlns) {
  	      // emit namespace binding events
  	      var tag = parser.tag
  
  	      // add namespace info to tag
  	      var qn = qname(parser.tagName)
  	      tag.prefix = qn.prefix
  	      tag.local = qn.local
  	      tag.uri = tag.ns[qn.prefix] || ''
  
  	      if (tag.prefix && !tag.uri) {
  	        strictFail(parser, 'Unbound namespace prefix: ' +
  	          JSON.stringify(parser.tagName))
  	        tag.uri = qn.prefix
  	      }
  
  	      var parent = parser.tags[parser.tags.length - 1] || parser
  	      if (tag.ns && parent.ns !== tag.ns) {
  	        Object.keys(tag.ns).forEach(function (p) {
  	          emitNode(parser, 'onopennamespace', {
  	            prefix: p,
  	            uri: tag.ns[p]
  	          })
  	        })
  	      }
  
  	      // handle deferred onattribute events
  	      // Note: do not apply default ns to attributes:
  	      //   http://www.w3.org/TR/REC-xml-names/#defaulting
  	      for (var i = 0, l = parser.attribList.length; i < l; i++) {
  	        var nv = parser.attribList[i]
  	        var name = nv[0]
  	        var value = nv[1]
  	        var qualName = qname(name, true)
  	        var prefix = qualName.prefix
  	        var local = qualName.local
  	        var uri = prefix === '' ? '' : (tag.ns[prefix] || '')
  	        var a = {
  	          name: name,
  	          value: value,
  	          prefix: prefix,
  	          local: local,
  	          uri: uri
  	        }
  
  	        // if there's any attributes with an undefined namespace,
  	        // then fail on them now.
  	        if (prefix && prefix !== 'xmlns' && !uri) {
  	          strictFail(parser, 'Unbound namespace prefix: ' +
  	            JSON.stringify(prefix))
  	          a.uri = prefix
  	        }
  	        parser.tag.attributes[name] = a
  	        emitNode(parser, 'onattribute', a)
  	      }
  	      parser.attribList.length = 0
  	    }
  
  	    parser.tag.isSelfClosing = !!selfClosing
  
  	    // process the tag
  	    parser.sawRoot = true
  	    parser.tags.push(parser.tag)
  	    emitNode(parser, 'onopentag', parser.tag)
  	    if (!selfClosing) {
  	      // special case for <script> in non-strict mode.
  	      if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {
  	        parser.state = S.SCRIPT
  	      } else {
  	        parser.state = S.TEXT
  	      }
  	      parser.tag = null
  	      parser.tagName = ''
  	    }
  	    parser.attribName = parser.attribValue = ''
  	    parser.attribList.length = 0
  	  }
  
  	  function closeTag (parser) {
  	    if (!parser.tagName) {
  	      strictFail(parser, 'Weird empty close tag.')
  	      parser.textNode += '</>'
  	      parser.state = S.TEXT
  	      return
  	    }
  
  	    if (parser.script) {
  	      if (parser.tagName !== 'script') {
  	        parser.script += '</' + parser.tagName + '>'
  	        parser.tagName = ''
  	        parser.state = S.SCRIPT
  	        return
  	      }
  	      emitNode(parser, 'onscript', parser.script)
  	      parser.script = ''
  	    }
  
  	    // first make sure that the closing tag actually exists.
  	    // <a><b></c></b></a> will close everything, otherwise.
  	    var t = parser.tags.length
  	    var tagName = parser.tagName
  	    if (!parser.strict) {
  	      tagName = tagName[parser.looseCase]()
  	    }
  	    var closeTo = tagName
  	    while (t--) {
  	      var close = parser.tags[t]
  	      if (close.name !== closeTo) {
  	        // fail the first time in strict mode
  	        strictFail(parser, 'Unexpected close tag')
  	      } else {
  	        break
  	      }
  	    }
  
  	    // didn't find it.  we already failed for strict, so just abort.
  	    if (t < 0) {
  	      strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)
  	      parser.textNode += '</' + parser.tagName + '>'
  	      parser.state = S.TEXT
  	      return
  	    }
  	    parser.tagName = tagName
  	    var s = parser.tags.length
  	    while (s-- > t) {
  	      var tag = parser.tag = parser.tags.pop()
  	      parser.tagName = parser.tag.name
  	      emitNode(parser, 'onclosetag', parser.tagName)
  
  	      var x = {}
  	      for (var i in tag.ns) {
  	        x[i] = tag.ns[i]
  	      }
  
  	      var parent = parser.tags[parser.tags.length - 1] || parser
  	      if (parser.opt.xmlns && tag.ns !== parent.ns) {
  	        // remove namespace bindings introduced by tag
  	        Object.keys(tag.ns).forEach(function (p) {
  	          var n = tag.ns[p]
  	          emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })
  	        })
  	      }
  	    }
  	    if (t === 0) parser.closedRoot = true
  	    parser.tagName = parser.attribValue = parser.attribName = ''
  	    parser.attribList.length = 0
  	    parser.state = S.TEXT
  	  }
  
  	  function parseEntity (parser) {
  	    var entity = parser.entity
  	    var entityLC = entity.toLowerCase()
  	    var num
  	    var numStr = ''
  
  	    if (parser.ENTITIES[entity]) {
  	      return parser.ENTITIES[entity]
  	    }
  	    if (parser.ENTITIES[entityLC]) {
  	      return parser.ENTITIES[entityLC]
  	    }
  	    entity = entityLC
  	    if (entity.charAt(0) === '#') {
  	      if (entity.charAt(1) === 'x') {
  	        entity = entity.slice(2)
  	        num = parseInt(entity, 16)
  	        numStr = num.toString(16)
  	      } else {
  	        entity = entity.slice(1)
  	        num = parseInt(entity, 10)
  	        numStr = num.toString(10)
  	      }
  	    }
  	    entity = entity.replace(/^0+/, '')
  	    if (isNaN(num) || numStr.toLowerCase() !== entity) {
  	      strictFail(parser, 'Invalid character entity')
  	      return '&' + parser.entity + ';'
  	    }
  
  	    return String.fromCodePoint(num)
  	  }
  
  	  function beginWhiteSpace (parser, c) {
  	    if (c === '<') {
  	      parser.state = S.OPEN_WAKA
  	      parser.startTagPosition = parser.position
  	    } else if (!isWhitespace(c)) {
  	      // have to process this as a text node.
  	      // weird, but happens.
  	      strictFail(parser, 'Non-whitespace before first tag.')
  	      parser.textNode = c
  	      parser.state = S.TEXT
  	    }
  	  }
  
  	  function charAt (chunk, i) {
  	    var result = ''
  	    if (i < chunk.length) {
  	      result = chunk.charAt(i)
  	    }
  	    return result
  	  }
  
  	  function write (chunk) {
  	    var parser = this
  	    if (this.error) {
  	      throw this.error
  	    }
  	    if (parser.closed) {
  	      return error(parser,
  	        'Cannot write after close. Assign an onready handler.')
  	    }
  	    if (chunk === null) {
  	      return end(parser)
  	    }
  	    if (typeof chunk === 'object') {
  	      chunk = chunk.toString()
  	    }
  	    var i = 0
  	    var c = ''
  	    while (true) {
  	      c = charAt(chunk, i++)
  	      parser.c = c
  
  	      if (!c) {
  	        break
  	      }
  
  	      if (parser.trackPosition) {
  	        parser.position++
  	        if (c === '\n') {
  	          parser.line++
  	          parser.column = 0
  	        } else {
  	          parser.column++
  	        }
  	      }
  
  	      switch (parser.state) {
  	        case S.BEGIN:
  	          parser.state = S.BEGIN_WHITESPACE
  	          if (c === '\uFEFF') {
  	            continue
  	          }
  	          beginWhiteSpace(parser, c)
  	          continue
  
  	        case S.BEGIN_WHITESPACE:
  	          beginWhiteSpace(parser, c)
  	          continue
  
  	        case S.TEXT:
  	          if (parser.sawRoot && !parser.closedRoot) {
  	            var starti = i - 1
  	            while (c && c !== '<' && c !== '&') {
  	              c = charAt(chunk, i++)
  	              if (c && parser.trackPosition) {
  	                parser.position++
  	                if (c === '\n') {
  	                  parser.line++
  	                  parser.column = 0
  	                } else {
  	                  parser.column++
  	                }
  	              }
  	            }
  	            parser.textNode += chunk.substring(starti, i - 1)
  	          }
  	          if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
  	            parser.state = S.OPEN_WAKA
  	            parser.startTagPosition = parser.position
  	          } else {
  	            if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
  	              strictFail(parser, 'Text data outside of root node.')
  	            }
  	            if (c === '&') {
  	              parser.state = S.TEXT_ENTITY
  	            } else {
  	              parser.textNode += c
  	            }
  	          }
  	          continue
  
  	        case S.SCRIPT:
  	          // only non-strict
  	          if (c === '<') {
  	            parser.state = S.SCRIPT_ENDING
  	          } else {
  	            parser.script += c
  	          }
  	          continue
  
  	        case S.SCRIPT_ENDING:
  	          if (c === '/') {
  	            parser.state = S.CLOSE_TAG
  	          } else {
  	            parser.script += '<' + c
  	            parser.state = S.SCRIPT
  	          }
  	          continue
  
  	        case S.OPEN_WAKA:
  	          // either a /, ?, !, or text is coming next.
  	          if (c === '!') {
  	            parser.state = S.SGML_DECL
  	            parser.sgmlDecl = ''
  	          } else if (isWhitespace(c)) {
  	            // wait for it...
  	          } else if (isMatch(nameStart, c)) {
  	            parser.state = S.OPEN_TAG
  	            parser.tagName = c
  	          } else if (c === '/') {
  	            parser.state = S.CLOSE_TAG
  	            parser.tagName = ''
  	          } else if (c === '?') {
  	            parser.state = S.PROC_INST
  	            parser.procInstName = parser.procInstBody = ''
  	          } else {
  	            strictFail(parser, 'Unencoded <')
  	            // if there was some whitespace, then add that in.
  	            if (parser.startTagPosition + 1 < parser.position) {
  	              var pad = parser.position - parser.startTagPosition
  	              c = new Array(pad).join(' ') + c
  	            }
  	            parser.textNode += '<' + c
  	            parser.state = S.TEXT
  	          }
  	          continue
  
  	        case S.SGML_DECL:
  	          if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
  	            emitNode(parser, 'onopencdata')
  	            parser.state = S.CDATA
  	            parser.sgmlDecl = ''
  	            parser.cdata = ''
  	          } else if (parser.sgmlDecl + c === '--') {
  	            parser.state = S.COMMENT
  	            parser.comment = ''
  	            parser.sgmlDecl = ''
  	          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
  	            parser.state = S.DOCTYPE
  	            if (parser.doctype || parser.sawRoot) {
  	              strictFail(parser,
  	                'Inappropriately located doctype declaration')
  	            }
  	            parser.doctype = ''
  	            parser.sgmlDecl = ''
  	          } else if (c === '>') {
  	            emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)
  	            parser.sgmlDecl = ''
  	            parser.state = S.TEXT
  	          } else if (isQuote(c)) {
  	            parser.state = S.SGML_DECL_QUOTED
  	            parser.sgmlDecl += c
  	          } else {
  	            parser.sgmlDecl += c
  	          }
  	          continue
  
  	        case S.SGML_DECL_QUOTED:
  	          if (c === parser.q) {
  	            parser.state = S.SGML_DECL
  	            parser.q = ''
  	          }
  	          parser.sgmlDecl += c
  	          continue
  
  	        case S.DOCTYPE:
  	          if (c === '>') {
  	            parser.state = S.TEXT
  	            emitNode(parser, 'ondoctype', parser.doctype)
  	            parser.doctype = true // just remember that we saw it.
  	          } else {
  	            parser.doctype += c
  	            if (c === '[') {
  	              parser.state = S.DOCTYPE_DTD
  	            } else if (isQuote(c)) {
  	              parser.state = S.DOCTYPE_QUOTED
  	              parser.q = c
  	            }
  	          }
  	          continue
  
  	        case S.DOCTYPE_QUOTED:
  	          parser.doctype += c
  	          if (c === parser.q) {
  	            parser.q = ''
  	            parser.state = S.DOCTYPE
  	          }
  	          continue
  
  	        case S.DOCTYPE_DTD:
  	          parser.doctype += c
  	          if (c === ']') {
  	            parser.state = S.DOCTYPE
  	          } else if (isQuote(c)) {
  	            parser.state = S.DOCTYPE_DTD_QUOTED
  	            parser.q = c
  	          }
  	          continue
  
  	        case S.DOCTYPE_DTD_QUOTED:
  	          parser.doctype += c
  	          if (c === parser.q) {
  	            parser.state = S.DOCTYPE_DTD
  	            parser.q = ''
  	          }
  	          continue
  
  	        case S.COMMENT:
  	          if (c === '-') {
  	            parser.state = S.COMMENT_ENDING
  	          } else {
  	            parser.comment += c
  	          }
  	          continue
  
  	        case S.COMMENT_ENDING:
  	          if (c === '-') {
  	            parser.state = S.COMMENT_ENDED
  	            parser.comment = textopts(parser.opt, parser.comment)
  	            if (parser.comment) {
  	              emitNode(parser, 'oncomment', parser.comment)
  	            }
  	            parser.comment = ''
  	          } else {
  	            parser.comment += '-' + c
  	            parser.state = S.COMMENT
  	          }
  	          continue
  
  	        case S.COMMENT_ENDED:
  	          if (c !== '>') {
  	            strictFail(parser, 'Malformed comment')
  	            // allow <!-- blah -- bloo --> in non-strict mode,
  	            // which is a comment of " blah -- bloo "
  	            parser.comment += '--' + c
  	            parser.state = S.COMMENT
  	          } else {
  	            parser.state = S.TEXT
  	          }
  	          continue
  
  	        case S.CDATA:
  	          if (c === ']') {
  	            parser.state = S.CDATA_ENDING
  	          } else {
  	            parser.cdata += c
  	          }
  	          continue
  
  	        case S.CDATA_ENDING:
  	          if (c === ']') {
  	            parser.state = S.CDATA_ENDING_2
  	          } else {
  	            parser.cdata += ']' + c
  	            parser.state = S.CDATA
  	          }
  	          continue
  
  	        case S.CDATA_ENDING_2:
  	          if (c === '>') {
  	            if (parser.cdata) {
  	              emitNode(parser, 'oncdata', parser.cdata)
  	            }
  	            emitNode(parser, 'onclosecdata')
  	            parser.cdata = ''
  	            parser.state = S.TEXT
  	          } else if (c === ']') {
  	            parser.cdata += ']'
  	          } else {
  	            parser.cdata += ']]' + c
  	            parser.state = S.CDATA
  	          }
  	          continue
  
  	        case S.PROC_INST:
  	          if (c === '?') {
  	            parser.state = S.PROC_INST_ENDING
  	          } else if (isWhitespace(c)) {
  	            parser.state = S.PROC_INST_BODY
  	          } else {
  	            parser.procInstName += c
  	          }
  	          continue
  
  	        case S.PROC_INST_BODY:
  	          if (!parser.procInstBody && isWhitespace(c)) {
  	            continue
  	          } else if (c === '?') {
  	            parser.state = S.PROC_INST_ENDING
  	          } else {
  	            parser.procInstBody += c
  	          }
  	          continue
  
  	        case S.PROC_INST_ENDING:
  	          if (c === '>') {
  	            emitNode(parser, 'onprocessinginstruction', {
  	              name: parser.procInstName,
  	              body: parser.procInstBody
  	            })
  	            parser.procInstName = parser.procInstBody = ''
  	            parser.state = S.TEXT
  	          } else {
  	            parser.procInstBody += '?' + c
  	            parser.state = S.PROC_INST_BODY
  	          }
  	          continue
  
  	        case S.OPEN_TAG:
  	          if (isMatch(nameBody, c)) {
  	            parser.tagName += c
  	          } else {
  	            newTag(parser)
  	            if (c === '>') {
  	              openTag(parser)
  	            } else if (c === '/') {
  	              parser.state = S.OPEN_TAG_SLASH
  	            } else {
  	              if (!isWhitespace(c)) {
  	                strictFail(parser, 'Invalid character in tag name')
  	              }
  	              parser.state = S.ATTRIB
  	            }
  	          }
  	          continue
  
  	        case S.OPEN_TAG_SLASH:
  	          if (c === '>') {
  	            openTag(parser, true)
  	            closeTag(parser)
  	          } else {
  	            strictFail(parser, 'Forward-slash in opening tag not followed by >')
  	            parser.state = S.ATTRIB
  	          }
  	          continue
  
  	        case S.ATTRIB:
  	          // haven't read the attribute name yet.
  	          if (isWhitespace(c)) {
  	            continue
  	          } else if (c === '>') {
  	            openTag(parser)
  	          } else if (c === '/') {
  	            parser.state = S.OPEN_TAG_SLASH
  	          } else if (isMatch(nameStart, c)) {
  	            parser.attribName = c
  	            parser.attribValue = ''
  	            parser.state = S.ATTRIB_NAME
  	          } else {
  	            strictFail(parser, 'Invalid attribute name')
  	          }
  	          continue
  
  	        case S.ATTRIB_NAME:
  	          if (c === '=') {
  	            parser.state = S.ATTRIB_VALUE
  	          } else if (c === '>') {
  	            strictFail(parser, 'Attribute without value')
  	            parser.attribValue = parser.attribName
  	            attrib(parser)
  	            openTag(parser)
  	          } else if (isWhitespace(c)) {
  	            parser.state = S.ATTRIB_NAME_SAW_WHITE
  	          } else if (isMatch(nameBody, c)) {
  	            parser.attribName += c
  	          } else {
  	            strictFail(parser, 'Invalid attribute name')
  	          }
  	          continue
  
  	        case S.ATTRIB_NAME_SAW_WHITE:
  	          if (c === '=') {
  	            parser.state = S.ATTRIB_VALUE
  	          } else if (isWhitespace(c)) {
  	            continue
  	          } else {
  	            strictFail(parser, 'Attribute without value')
  	            parser.tag.attributes[parser.attribName] = ''
  	            parser.attribValue = ''
  	            emitNode(parser, 'onattribute', {
  	              name: parser.attribName,
  	              value: ''
  	            })
  	            parser.attribName = ''
  	            if (c === '>') {
  	              openTag(parser)
  	            } else if (isMatch(nameStart, c)) {
  	              parser.attribName = c
  	              parser.state = S.ATTRIB_NAME
  	            } else {
  	              strictFail(parser, 'Invalid attribute name')
  	              parser.state = S.ATTRIB
  	            }
  	          }
  	          continue
  
  	        case S.ATTRIB_VALUE:
  	          if (isWhitespace(c)) {
  	            continue
  	          } else if (isQuote(c)) {
  	            parser.q = c
  	            parser.state = S.ATTRIB_VALUE_QUOTED
  	          } else {
  	            strictFail(parser, 'Unquoted attribute value')
  	            parser.state = S.ATTRIB_VALUE_UNQUOTED
  	            parser.attribValue = c
  	          }
  	          continue
  
  	        case S.ATTRIB_VALUE_QUOTED:
  	          if (c !== parser.q) {
  	            if (c === '&') {
  	              parser.state = S.ATTRIB_VALUE_ENTITY_Q
  	            } else {
  	              parser.attribValue += c
  	            }
  	            continue
  	          }
  	          attrib(parser)
  	          parser.q = ''
  	          parser.state = S.ATTRIB_VALUE_CLOSED
  	          continue
  
  	        case S.ATTRIB_VALUE_CLOSED:
  	          if (isWhitespace(c)) {
  	            parser.state = S.ATTRIB
  	          } else if (c === '>') {
  	            openTag(parser)
  	          } else if (c === '/') {
  	            parser.state = S.OPEN_TAG_SLASH
  	          } else if (isMatch(nameStart, c)) {
  	            strictFail(parser, 'No whitespace between attributes')
  	            parser.attribName = c
  	            parser.attribValue = ''
  	            parser.state = S.ATTRIB_NAME
  	          } else {
  	            strictFail(parser, 'Invalid attribute name')
  	          }
  	          continue
  
  	        case S.ATTRIB_VALUE_UNQUOTED:
  	          if (!isAttribEnd(c)) {
  	            if (c === '&') {
  	              parser.state = S.ATTRIB_VALUE_ENTITY_U
  	            } else {
  	              parser.attribValue += c
  	            }
  	            continue
  	          }
  	          attrib(parser)
  	          if (c === '>') {
  	            openTag(parser)
  	          } else {
  	            parser.state = S.ATTRIB
  	          }
  	          continue
  
  	        case S.CLOSE_TAG:
  	          if (!parser.tagName) {
  	            if (isWhitespace(c)) {
  	              continue
  	            } else if (notMatch(nameStart, c)) {
  	              if (parser.script) {
  	                parser.script += '</' + c
  	                parser.state = S.SCRIPT
  	              } else {
  	                strictFail(parser, 'Invalid tagname in closing tag.')
  	              }
  	            } else {
  	              parser.tagName = c
  	            }
  	          } else if (c === '>') {
  	            closeTag(parser)
  	          } else if (isMatch(nameBody, c)) {
  	            parser.tagName += c
  	          } else if (parser.script) {
  	            parser.script += '</' + parser.tagName
  	            parser.tagName = ''
  	            parser.state = S.SCRIPT
  	          } else {
  	            if (!isWhitespace(c)) {
  	              strictFail(parser, 'Invalid tagname in closing tag')
  	            }
  	            parser.state = S.CLOSE_TAG_SAW_WHITE
  	          }
  	          continue
  
  	        case S.CLOSE_TAG_SAW_WHITE:
  	          if (isWhitespace(c)) {
  	            continue
  	          }
  	          if (c === '>') {
  	            closeTag(parser)
  	          } else {
  	            strictFail(parser, 'Invalid characters in closing tag')
  	          }
  	          continue
  
  	        case S.TEXT_ENTITY:
  	        case S.ATTRIB_VALUE_ENTITY_Q:
  	        case S.ATTRIB_VALUE_ENTITY_U:
  	          var returnState
  	          var buffer
  	          switch (parser.state) {
  	            case S.TEXT_ENTITY:
  	              returnState = S.TEXT
  	              buffer = 'textNode'
  	              break
  
  	            case S.ATTRIB_VALUE_ENTITY_Q:
  	              returnState = S.ATTRIB_VALUE_QUOTED
  	              buffer = 'attribValue'
  	              break
  
  	            case S.ATTRIB_VALUE_ENTITY_U:
  	              returnState = S.ATTRIB_VALUE_UNQUOTED
  	              buffer = 'attribValue'
  	              break
  	          }
  
  	          if (c === ';') {
  	            parser[buffer] += parseEntity(parser)
  	            parser.entity = ''
  	            parser.state = returnState
  	          } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
  	            parser.entity += c
  	          } else {
  	            strictFail(parser, 'Invalid character in entity name')
  	            parser[buffer] += '&' + parser.entity + c
  	            parser.entity = ''
  	            parser.state = returnState
  	          }
  
  	          continue
  
  	        default:
  	          throw new Error(parser, 'Unknown state: ' + parser.state)
  	      }
  	    } // while
  
  	    if (parser.position >= parser.bufferCheckPosition) {
  	      checkBufferLength(parser)
  	    }
  	    return parser
  	  }
  
  	  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
  	  /* istanbul ignore next */
  	  if (!String.fromCodePoint) {
  	    (function () {
  	      var stringFromCharCode = String.fromCharCode
  	      var floor = Math.floor
  	      var fromCodePoint = function () {
  	        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
  	      }
  	      /* istanbul ignore next */
  	      if (Object.defineProperty) {
  	        Object.defineProperty(String, 'fromCodePoint', {
  	          value: fromCodePoint,
  	          configurable: true,
  	          writable: true
  	        })
  	      } else {
  	        String.fromCodePoint = fromCodePoint
  	      }
  	    }())
  	  }
  	})( false ? this.sax = {} : exports)
  
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(39).Buffer))
  
  /***/ }),
  /* 39 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {/*!
  	 * The buffer module from node.js, for the browser.
  	 *
  	 * @author   Feross Aboukhadijeh <http://feross.org>
  	 * @license  MIT
  	 */
  	/* eslint-disable no-proto */
  
  	'use strict'
  
  	var base64 = __webpack_require__(40)
  	var ieee754 = __webpack_require__(41)
  	var isArray = __webpack_require__(42)
  
  	exports.Buffer = Buffer
  	exports.SlowBuffer = SlowBuffer
  	exports.INSPECT_MAX_BYTES = 50
  
  	/**
  	 * 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+.
  	 *
  	 * Due to various browser bugs, sometimes the Object implementation will be used even
  	 * when the browser supports typed arrays.
  	 *
  	 * Note:
  	 *
  	 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
  	 *     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
  	 * get the Object implementation, which is slower but behaves correctly.
  	 */
  	Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
  	  ? global.TYPED_ARRAY_SUPPORT
  	  : typedArraySupport()
  
  	/*
  	 * Export kMaxLength after typed array support is determined.
  	 */
  	exports.kMaxLength = kMaxLength()
  
  	function typedArraySupport () {
  	  try {
  	    var arr = new Uint8Array(1)
  	    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
  	    return arr.foo() === 42 && // typed array instances can be augmented
  	        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
  	        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
  	  } catch (e) {
  	    return false
  	  }
  	}
  
  	function kMaxLength () {
  	  return Buffer.TYPED_ARRAY_SUPPORT
  	    ? 0x7fffffff
  	    : 0x3fffffff
  	}
  
  	function createBuffer (that, length) {
  	  if (kMaxLength() < length) {
  	    throw new RangeError('Invalid typed array length')
  	  }
  	  if (Buffer.TYPED_ARRAY_SUPPORT) {
  	    // Return an augmented `Uint8Array` instance, for best performance
  	    that = new Uint8Array(length)
  	    that.__proto__ = Buffer.prototype
  	  } else {
  	    // Fallback: Return an object instance of the Buffer class
  	    if (that === null) {
  	      that = new Buffer(length)
  	    }
  	    that.length = length
  	  }
  
  	  return that
  	}
  
  	/**
  	 * The Buffer constructor returns instances of `Uint8Array` that have their
  	 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
  	 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
  	 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
  	 * returns a single octet.
  	 *
  	 * The `Uint8Array` prototype remains unmodified.
  	 */
  
  	function Buffer (arg, encodingOrOffset, length) {
  	  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
  	    return new Buffer(arg, encodingOrOffset, length)
  	  }
  
  	  // Common case.
  	  if (typeof arg === 'number') {
  	    if (typeof encodingOrOffset === 'string') {
  	      throw new Error(
  	        'If encoding is specified then the first argument must be a string'
  	      )
  	    }
  	    return allocUnsafe(this, arg)
  	  }
  	  return from(this, arg, encodingOrOffset, length)
  	}
  
  	Buffer.poolSize = 8192 // not used by this implementation
  
  	// TODO: Legacy, not needed anymore. Remove in next major version.
  	Buffer._augment = function (arr) {
  	  arr.__proto__ = Buffer.prototype
  	  return arr
  	}
  
  	function from (that, value, encodingOrOffset, length) {
  	  if (typeof value === 'number') {
  	    throw new TypeError('"value" argument must not be a number')
  	  }
  
  	  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
  	    return fromArrayBuffer(that, value, encodingOrOffset, length)
  	  }
  
  	  if (typeof value === 'string') {
  	    return fromString(that, value, encodingOrOffset)
  	  }
  
  	  return fromObject(that, value)
  	}
  
  	/**
  	 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
  	 * if value is a number.
  	 * Buffer.from(str[, encoding])
  	 * Buffer.from(array)
  	 * Buffer.from(buffer)
  	 * Buffer.from(arrayBuffer[, byteOffset[, length]])
  	 **/
  	Buffer.from = function (value, encodingOrOffset, length) {
  	  return from(null, value, encodingOrOffset, length)
  	}
  
  	if (Buffer.TYPED_ARRAY_SUPPORT) {
  	  Buffer.prototype.__proto__ = Uint8Array.prototype
  	  Buffer.__proto__ = Uint8Array
  	  if (typeof Symbol !== 'undefined' && Symbol.species &&
  	      Buffer[Symbol.species] === Buffer) {
  	    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
  	    Object.defineProperty(Buffer, Symbol.species, {
  	      value: null,
  	      configurable: true
  	    })
  	  }
  	}
  
  	function assertSize (size) {
  	  if (typeof size !== 'number') {
  	    throw new TypeError('"size" argument must be a number')
  	  } else if (size < 0) {
  	    throw new RangeError('"size" argument must not be negative')
  	  }
  	}
  
  	function alloc (that, size, fill, encoding) {
  	  assertSize(size)
  	  if (size <= 0) {
  	    return createBuffer(that, size)
  	  }
  	  if (fill !== undefined) {
  	    // Only pay attention to encoding if it's a string. This
  	    // prevents accidentally sending in a number that would
  	    // be interpretted as a start offset.
  	    return typeof encoding === 'string'
  	      ? createBuffer(that, size).fill(fill, encoding)
  	      : createBuffer(that, size).fill(fill)
  	  }
  	  return createBuffer(that, size)
  	}
  
  	/**
  	 * Creates a new filled Buffer instance.
  	 * alloc(size[, fill[, encoding]])
  	 **/
  	Buffer.alloc = function (size, fill, encoding) {
  	  return alloc(null, size, fill, encoding)
  	}
  
  	function allocUnsafe (that, size) {
  	  assertSize(size)
  	  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
  	  if (!Buffer.TYPED_ARRAY_SUPPORT) {
  	    for (var i = 0; i < size; ++i) {
  	      that[i] = 0
  	    }
  	  }
  	  return that
  	}
  
  	/**
  	 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
  	 * */
  	Buffer.allocUnsafe = function (size) {
  	  return allocUnsafe(null, size)
  	}
  	/**
  	 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
  	 */
  	Buffer.allocUnsafeSlow = function (size) {
  	  return allocUnsafe(null, size)
  	}
  
  	function fromString (that, string, encoding) {
  	  if (typeof encoding !== 'string' || encoding === '') {
  	    encoding = 'utf8'
  	  }
  
  	  if (!Buffer.isEncoding(encoding)) {
  	    throw new TypeError('"encoding" must be a valid string encoding')
  	  }
  
  	  var length = byteLength(string, encoding) | 0
  	  that = createBuffer(that, length)
  
  	  var actual = that.write(string, encoding)
  
  	  if (actual !== length) {
  	    // Writing a hex string, for example, that contains invalid characters will
  	    // cause everything after the first invalid character to be ignored. (e.g.
  	    // 'abxxcd' will be treated as 'ab')
  	    that = that.slice(0, actual)
  	  }
  
  	  return that
  	}
  
  	function fromArrayLike (that, array) {
  	  var length = array.length < 0 ? 0 : checked(array.length) | 0
  	  that = createBuffer(that, length)
  	  for (var i = 0; i < length; i += 1) {
  	    that[i] = array[i] & 255
  	  }
  	  return that
  	}
  
  	function fromArrayBuffer (that, array, byteOffset, length) {
  	  array.byteLength // this throws if `array` is not a valid ArrayBuffer
  
  	  if (byteOffset < 0 || array.byteLength < byteOffset) {
  	    throw new RangeError('\'offset\' is out of bounds')
  	  }
  
  	  if (array.byteLength < byteOffset + (length || 0)) {
  	    throw new RangeError('\'length\' is out of bounds')
  	  }
  
  	  if (byteOffset === undefined && length === undefined) {
  	    array = new Uint8Array(array)
  	  } else if (length === undefined) {
  	    array = new Uint8Array(array, byteOffset)
  	  } else {
  	    array = new Uint8Array(array, byteOffset, length)
  	  }
  
  	  if (Buffer.TYPED_ARRAY_SUPPORT) {
  	    // Return an augmented `Uint8Array` instance, for best performance
  	    that = array
  	    that.__proto__ = Buffer.prototype
  	  } else {
  	    // Fallback: Return an object instance of the Buffer class
  	    that = fromArrayLike(that, array)
  	  }
  	  return that
  	}
  
  	function fromObject (that, obj) {
  	  if (Buffer.isBuffer(obj)) {
  	    var len = checked(obj.length) | 0
  	    that = createBuffer(that, len)
  
  	    if (that.length === 0) {
  	      return that
  	    }
  
  	    obj.copy(that, 0, 0, len)
  	    return that
  	  }
  
  	  if (obj) {
  	    if ((typeof ArrayBuffer !== 'undefined' &&
  	        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
  	      if (typeof obj.length !== 'number' || isnan(obj.length)) {
  	        return createBuffer(that, 0)
  	      }
  	      return fromArrayLike(that, obj)
  	    }
  
  	    if (obj.type === 'Buffer' && isArray(obj.data)) {
  	      return fromArrayLike(that, obj.data)
  	    }
  	  }
  
  	  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
  	}
  
  	function checked (length) {
  	  // Note: cannot use `length < kMaxLength()` here because that fails when
  	  // length is NaN (which is otherwise coerced to zero.)
  	  if (length >= kMaxLength()) {
  	    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
  	                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
  	  }
  	  return length | 0
  	}
  
  	function SlowBuffer (length) {
  	  if (+length != length) { // eslint-disable-line eqeqeq
  	    length = 0
  	  }
  	  return Buffer.alloc(+length)
  	}
  
  	Buffer.isBuffer = function isBuffer (b) {
  	  return !!(b != null && b._isBuffer)
  	}
  
  	Buffer.compare = function compare (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; ++i) {
  	    if (a[i] !== b[i]) {
  	      x = a[i]
  	      y = b[i]
  	      break
  	    }
  	  }
  
  	  if (x < y) return -1
  	  if (y < x) return 1
  	  return 0
  	}
  
  	Buffer.isEncoding = function isEncoding (encoding) {
  	  switch (String(encoding).toLowerCase()) {
  	    case 'hex':
  	    case 'utf8':
  	    case 'utf-8':
  	    case 'ascii':
  	    case 'latin1':
  	    case 'binary':
  	    case 'base64':
  	    case 'ucs2':
  	    case 'ucs-2':
  	    case 'utf16le':
  	    case 'utf-16le':
  	      return true
  	    default:
  	      return false
  	  }
  	}
  
  	Buffer.concat = function concat (list, length) {
  	  if (!isArray(list)) {
  	    throw new TypeError('"list" argument must be an Array of Buffers')
  	  }
  
  	  if (list.length === 0) {
  	    return Buffer.alloc(0)
  	  }
  
  	  var i
  	  if (length === undefined) {
  	    length = 0
  	    for (i = 0; i < list.length; ++i) {
  	      length += list[i].length
  	    }
  	  }
  
  	  var buffer = Buffer.allocUnsafe(length)
  	  var pos = 0
  	  for (i = 0; i < list.length; ++i) {
  	    var buf = list[i]
  	    if (!Buffer.isBuffer(buf)) {
  	      throw new TypeError('"list" argument must be an Array of Buffers')
  	    }
  	    buf.copy(buffer, pos)
  	    pos += buf.length
  	  }
  	  return buffer
  	}
  
  	function byteLength (string, encoding) {
  	  if (Buffer.isBuffer(string)) {
  	    return string.length
  	  }
  	  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
  	      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
  	    return string.byteLength
  	  }
  	  if (typeof string !== 'string') {
  	    string = '' + string
  	  }
  
  	  var len = string.length
  	  if (len === 0) return 0
  
  	  // Use a for loop to avoid recursion
  	  var loweredCase = false
  	  for (;;) {
  	    switch (encoding) {
  	      case 'ascii':
  	      case 'latin1':
  	      case 'binary':
  	        return len
  	      case 'utf8':
  	      case 'utf-8':
  	      case undefined:
  	        return utf8ToBytes(string).length
  	      case 'ucs2':
  	      case 'ucs-2':
  	      case 'utf16le':
  	      case 'utf-16le':
  	        return len * 2
  	      case 'hex':
  	        return len >>> 1
  	      case 'base64':
  	        return base64ToBytes(string).length
  	      default:
  	        if (loweredCase) return utf8ToBytes(string).length // assume utf8
  	        encoding = ('' + encoding).toLowerCase()
  	        loweredCase = true
  	    }
  	  }
  	}
  	Buffer.byteLength = byteLength
  
  	function slowToString (encoding, start, end) {
  	  var loweredCase = false
  
  	  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
  	  // property of a typed array.
  
  	  // This behaves neither like String nor Uint8Array in that we set start/end
  	  // to their upper/lower bounds if the value passed is out of range.
  	  // undefined is handled specially as per ECMA-262 6th Edition,
  	  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
  	  if (start === undefined || start < 0) {
  	    start = 0
  	  }
  	  // Return early if start > this.length. Done here to prevent potential uint32
  	  // coercion fail below.
  	  if (start > this.length) {
  	    return ''
  	  }
  
  	  if (end === undefined || end > this.length) {
  	    end = this.length
  	  }
  
  	  if (end <= 0) {
  	    return ''
  	  }
  
  	  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
  	  end >>>= 0
  	  start >>>= 0
  
  	  if (end <= start) {
  	    return ''
  	  }
  
  	  if (!encoding) encoding = 'utf8'
  
  	  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 'latin1':
  	      case 'binary':
  	        return latin1Slice(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
  	    }
  	  }
  	}
  
  	// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
  	// Buffer instances.
  	Buffer.prototype._isBuffer = true
  
  	function swap (b, n, m) {
  	  var i = b[n]
  	  b[n] = b[m]
  	  b[m] = i
  	}
  
  	Buffer.prototype.swap16 = function swap16 () {
  	  var len = this.length
  	  if (len % 2 !== 0) {
  	    throw new RangeError('Buffer size must be a multiple of 16-bits')
  	  }
  	  for (var i = 0; i < len; i += 2) {
  	    swap(this, i, i + 1)
  	  }
  	  return this
  	}
  
  	Buffer.prototype.swap32 = function swap32 () {
  	  var len = this.length
  	  if (len % 4 !== 0) {
  	    throw new RangeError('Buffer size must be a multiple of 32-bits')
  	  }
  	  for (var i = 0; i < len; i += 4) {
  	    swap(this, i, i + 3)
  	    swap(this, i + 1, i + 2)
  	  }
  	  return this
  	}
  
  	Buffer.prototype.swap64 = function swap64 () {
  	  var len = this.length
  	  if (len % 8 !== 0) {
  	    throw new RangeError('Buffer size must be a multiple of 64-bits')
  	  }
  	  for (var i = 0; i < len; i += 8) {
  	    swap(this, i, i + 7)
  	    swap(this, i + 1, i + 6)
  	    swap(this, i + 2, i + 5)
  	    swap(this, i + 3, i + 4)
  	  }
  	  return this
  	}
  
  	Buffer.prototype.toString = function toString () {
  	  var length = this.length | 0
  	  if (length === 0) return ''
  	  if (arguments.length === 0) return utf8Slice(this, 0, length)
  	  return slowToString.apply(this, arguments)
  	}
  
  	Buffer.prototype.equals = function equals (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 inspect () {
  	  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 compare (target, start, end, thisStart, thisEnd) {
  	  if (!Buffer.isBuffer(target)) {
  	    throw new TypeError('Argument must be a Buffer')
  	  }
  
  	  if (start === undefined) {
  	    start = 0
  	  }
  	  if (end === undefined) {
  	    end = target ? target.length : 0
  	  }
  	  if (thisStart === undefined) {
  	    thisStart = 0
  	  }
  	  if (thisEnd === undefined) {
  	    thisEnd = this.length
  	  }
  
  	  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
  	    throw new RangeError('out of range index')
  	  }
  
  	  if (thisStart >= thisEnd && start >= end) {
  	    return 0
  	  }
  	  if (thisStart >= thisEnd) {
  	    return -1
  	  }
  	  if (start >= end) {
  	    return 1
  	  }
  
  	  start >>>= 0
  	  end >>>= 0
  	  thisStart >>>= 0
  	  thisEnd >>>= 0
  
  	  if (this === target) return 0
  
  	  var x = thisEnd - thisStart
  	  var y = end - start
  	  var len = Math.min(x, y)
  
  	  var thisCopy = this.slice(thisStart, thisEnd)
  	  var targetCopy = target.slice(start, end)
  
  	  for (var i = 0; i < len; ++i) {
  	    if (thisCopy[i] !== targetCopy[i]) {
  	      x = thisCopy[i]
  	      y = targetCopy[i]
  	      break
  	    }
  	  }
  
  	  if (x < y) return -1
  	  if (y < x) return 1
  	  return 0
  	}
  
  	// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
  	// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
  	//
  	// Arguments:
  	// - buffer - a Buffer to search
  	// - val - a string, Buffer, or number
  	// - byteOffset - an index into `buffer`; will be clamped to an int32
  	// - encoding - an optional encoding, relevant is val is a string
  	// - dir - true for indexOf, false for lastIndexOf
  	function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
  	  // Empty buffer means no match
  	  if (buffer.length === 0) return -1
  
  	  // Normalize byteOffset
  	  if (typeof byteOffset === 'string') {
  	    encoding = byteOffset
  	    byteOffset = 0
  	  } else if (byteOffset > 0x7fffffff) {
  	    byteOffset = 0x7fffffff
  	  } else if (byteOffset < -0x80000000) {
  	    byteOffset = -0x80000000
  	  }
  	  byteOffset = +byteOffset  // Coerce to Number.
  	  if (isNaN(byteOffset)) {
  	    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
  	    byteOffset = dir ? 0 : (buffer.length - 1)
  	  }
  
  	  // Normalize byteOffset: negative offsets start from the end of the buffer
  	  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
  	  if (byteOffset >= buffer.length) {
  	    if (dir) return -1
  	    else byteOffset = buffer.length - 1
  	  } else if (byteOffset < 0) {
  	    if (dir) byteOffset = 0
  	    else return -1
  	  }
  
  	  // Normalize val
  	  if (typeof val === 'string') {
  	    val = Buffer.from(val, encoding)
  	  }
  
  	  // Finally, search either indexOf (if dir is true) or lastIndexOf
  	  if (Buffer.isBuffer(val)) {
  	    // Special case: looking for empty string/buffer always fails
  	    if (val.length === 0) {
  	      return -1
  	    }
  	    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
  	  } else if (typeof val === 'number') {
  	    val = val & 0xFF // Search for a byte value [0-255]
  	    if (Buffer.TYPED_ARRAY_SUPPORT &&
  	        typeof Uint8Array.prototype.indexOf === 'function') {
  	      if (dir) {
  	        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
  	      } else {
  	        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
  	      }
  	    }
  	    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
  	  }
  
  	  throw new TypeError('val must be string, number or Buffer')
  	}
  
  	function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
  	  var indexSize = 1
  	  var arrLength = arr.length
  	  var valLength = val.length
  
  	  if (encoding !== undefined) {
  	    encoding = String(encoding).toLowerCase()
  	    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
  	        encoding === 'utf16le' || encoding === 'utf-16le') {
  	      if (arr.length < 2 || val.length < 2) {
  	        return -1
  	      }
  	      indexSize = 2
  	      arrLength /= 2
  	      valLength /= 2
  	      byteOffset /= 2
  	    }
  	  }
  
  	  function read (buf, i) {
  	    if (indexSize === 1) {
  	      return buf[i]
  	    } else {
  	      return buf.readUInt16BE(i * indexSize)
  	    }
  	  }
  
  	  var i
  	  if (dir) {
  	    var foundIndex = -1
  	    for (i = byteOffset; i < arrLength; i++) {
  	      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
  	        if (foundIndex === -1) foundIndex = i
  	        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
  	      } else {
  	        if (foundIndex !== -1) i -= i - foundIndex
  	        foundIndex = -1
  	      }
  	    }
  	  } else {
  	    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
  	    for (i = byteOffset; i >= 0; i--) {
  	      var found = true
  	      for (var j = 0; j < valLength; j++) {
  	        if (read(arr, i + j) !== read(val, j)) {
  	          found = false
  	          break
  	        }
  	      }
  	      if (found) return i
  	    }
  	  }
  
  	  return -1
  	}
  
  	Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  	  return this.indexOf(val, byteOffset, encoding) !== -1
  	}
  
  	Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
  	  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
  	}
  
  	Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
  	  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
  	}
  
  	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 TypeError('Invalid hex string')
  
  	  if (length > strLen / 2) {
  	    length = strLen / 2
  	  }
  	  for (var i = 0; i < length; ++i) {
  	    var parsed = parseInt(string.substr(i * 2, 2), 16)
  	    if (isNaN(parsed)) return i
  	    buf[offset + i] = parsed
  	  }
  	  return i
  	}
  
  	function utf8Write (buf, string, offset, length) {
  	  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
  	}
  
  	function asciiWrite (buf, string, offset, length) {
  	  return blitBuffer(asciiToBytes(string), buf, offset, length)
  	}
  
  	function latin1Write (buf, string, offset, length) {
  	  return asciiWrite(buf, string, offset, length)
  	}
  
  	function base64Write (buf, string, offset, length) {
  	  return blitBuffer(base64ToBytes(string), buf, offset, length)
  	}
  
  	function ucs2Write (buf, string, offset, length) {
  	  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
  	}
  
  	Buffer.prototype.write = function write (string, offset, length, encoding) {
  	  // Buffer#write(string)
  	  if (offset === undefined) {
  	    encoding = 'utf8'
  	    length = this.length
  	    offset = 0
  	  // Buffer#write(string, encoding)
  	  } else if (length === undefined && typeof offset === 'string') {
  	    encoding = offset
  	    length = this.length
  	    offset = 0
  	  // Buffer#write(string, offset[, length][, encoding])
  	  } else if (isFinite(offset)) {
  	    offset = offset | 0
  	    if (isFinite(length)) {
  	      length = length | 0
  	      if (encoding === undefined) encoding = 'utf8'
  	    } else {
  	      encoding = length
  	      length = undefined
  	    }
  	  // legacy write(string, encoding, offset, length) - remove in v0.13
  	  } else {
  	    throw new Error(
  	      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
  	    )
  	  }
  
  	  var remaining = this.length - offset
  	  if (length === undefined || length > remaining) length = remaining
  
  	  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
  	    throw new RangeError('Attempt to write outside buffer bounds')
  	  }
  
  	  if (!encoding) encoding = 'utf8'
  
  	  var loweredCase = false
  	  for (;;) {
  	    switch (encoding) {
  	      case 'hex':
  	        return hexWrite(this, string, offset, length)
  
  	      case 'utf8':
  	      case 'utf-8':
  	        return utf8Write(this, string, offset, length)
  
  	      case 'ascii':
  	        return asciiWrite(this, string, offset, length)
  
  	      case 'latin1':
  	      case 'binary':
  	        return latin1Write(this, string, offset, length)
  
  	      case 'base64':
  	        // Warning: maxLength not taken into account in base64Write
  	        return base64Write(this, string, offset, length)
  
  	      case 'ucs2':
  	      case 'ucs-2':
  	      case 'utf16le':
  	      case 'utf-16le':
  	        return ucs2Write(this, string, offset, length)
  
  	      default:
  	        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
  	        encoding = ('' + encoding).toLowerCase()
  	        loweredCase = true
  	    }
  	  }
  	}
  
  	Buffer.prototype.toJSON = function toJSON () {
  	  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) {
  	  end = Math.min(buf.length, end)
  	  var res = []
  
  	  var i = start
  	  while (i < end) {
  	    var firstByte = buf[i]
  	    var codePoint = null
  	    var bytesPerSequence = (firstByte > 0xEF) ? 4
  	      : (firstByte > 0xDF) ? 3
  	      : (firstByte > 0xBF) ? 2
  	      : 1
  
  	    if (i + bytesPerSequence <= end) {
  	      var secondByte, thirdByte, fourthByte, tempCodePoint
  
  	      switch (bytesPerSequence) {
  	        case 1:
  	          if (firstByte < 0x80) {
  	            codePoint = firstByte
  	          }
  	          break
  	        case 2:
  	          secondByte = buf[i + 1]
  	          if ((secondByte & 0xC0) === 0x80) {
  	            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
  	            if (tempCodePoint > 0x7F) {
  	              codePoint = tempCodePoint
  	            }
  	          }
  	          break
  	        case 3:
  	          secondByte = buf[i + 1]
  	          thirdByte = buf[i + 2]
  	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
  	            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
  	            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
  	              codePoint = tempCodePoint
  	            }
  	          }
  	          break
  	        case 4:
  	          secondByte = buf[i + 1]
  	          thirdByte = buf[i + 2]
  	          fourthByte = buf[i + 3]
  	          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
  	            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
  	            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
  	              codePoint = tempCodePoint
  	            }
  	          }
  	      }
  	    }
  
  	    if (codePoint === null) {
  	      // we did not generate a valid codePoint so insert a
  	      // replacement char (U+FFFD) and advance only 1 byte
  	      codePoint = 0xFFFD
  	      bytesPerSequence = 1
  	    } else if (codePoint > 0xFFFF) {
  	      // encode to utf16 (surrogate pair dance)
  	      codePoint -= 0x10000
  	      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
  	      codePoint = 0xDC00 | codePoint & 0x3FF
  	    }
  
  	    res.push(codePoint)
  	    i += bytesPerSequence
  	  }
  
  	  return decodeCodePointsArray(res)
  	}
  
  	// Based on http://stackoverflow.com/a/22747272/680742, the browser with
  	// the lowest limit is Chrome, with 0x10000 args.
  	// We go 1 magnitude less, for safety
  	var MAX_ARGUMENTS_LENGTH = 0x1000
  
  	function decodeCodePointsArray (codePoints) {
  	  var len = codePoints.length
  	  if (len <= MAX_ARGUMENTS_LENGTH) {
  	    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
  	  }
  
  	  // Decode in chunks to avoid "call stack size exceeded".
  	  var res = ''
  	  var i = 0
  	  while (i < len) {
  	    res += String.fromCharCode.apply(
  	      String,
  	      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
  	    )
  	  }
  	  return res
  	}
  
  	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 latin1Slice (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 slice (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 = this.subarray(start, end)
  	    newBuf.__proto__ = Buffer.prototype
  	  } else {
  	    var sliceLen = end - start
  	    newBuf = new Buffer(sliceLen, undefined)
  	    for (var i = 0; i < sliceLen; ++i) {
  	      newBuf[i] = this[i + start]
  	    }
  	  }
  
  	  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 readUIntLE (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 readUIntBE (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 readUInt8 (offset, noAssert) {
  	  if (!noAssert) checkOffset(offset, 1, this.length)
  	  return this[offset]
  	}
  
  	Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
  	  if (!noAssert) checkOffset(offset, 2, this.length)
  	  return this[offset] | (this[offset + 1] << 8)
  	}
  
  	Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
  	  if (!noAssert) checkOffset(offset, 2, this.length)
  	  return (this[offset] << 8) | this[offset + 1]
  	}
  
  	Buffer.prototype.readUInt32LE = function readUInt32LE (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 readUInt32BE (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 readIntLE (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 readIntBE (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 readInt8 (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 readInt16LE (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 readInt16BE (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 readInt32LE (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 readInt32BE (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 readFloatLE (offset, noAssert) {
  	  if (!noAssert) checkOffset(offset, 4, this.length)
  	  return ieee754.read(this, offset, true, 23, 4)
  	}
  
  	Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
  	  if (!noAssert) checkOffset(offset, 4, this.length)
  	  return ieee754.read(this, offset, false, 23, 4)
  	}
  
  	Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
  	  if (!noAssert) checkOffset(offset, 8, this.length)
  	  return ieee754.read(this, offset, true, 52, 8)
  	}
  
  	Buffer.prototype.readDoubleBE = function readDoubleBE (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" argument must be a Buffer instance')
  	  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
  	  if (offset + ext > buf.length) throw new RangeError('Index out of range')
  	}
  
  	Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
  	  value = +value
  	  offset = offset | 0
  	  byteLength = byteLength | 0
  	  if (!noAssert) {
  	    var maxBytes = Math.pow(2, 8 * byteLength) - 1
  	    checkInt(this, value, offset, byteLength, maxBytes, 0)
  	  }
  
  	  var mul = 1
  	  var i = 0
  	  this[offset] = value & 0xFF
  	  while (++i < byteLength && (mul *= 0x100)) {
  	    this[offset + i] = (value / mul) & 0xFF
  	  }
  
  	  return offset + byteLength
  	}
  
  	Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
  	  value = +value
  	  offset = offset | 0
  	  byteLength = byteLength | 0
  	  if (!noAssert) {
  	    var maxBytes = Math.pow(2, 8 * byteLength) - 1
  	    checkInt(this, value, offset, byteLength, maxBytes, 0)
  	  }
  
  	  var i = byteLength - 1
  	  var mul = 1
  	  this[offset + i] = value & 0xFF
  	  while (--i >= 0 && (mul *= 0x100)) {
  	    this[offset + i] = (value / mul) & 0xFF
  	  }
  
  	  return offset + byteLength
  	}
  
  	Buffer.prototype.writeUInt8 = function writeUInt8 (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 & 0xff)
  	  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 writeUInt16LE (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 & 0xff)
  	    this[offset + 1] = (value >>> 8)
  	  } else {
  	    objectWriteUInt16(this, value, offset, true)
  	  }
  	  return offset + 2
  	}
  
  	Buffer.prototype.writeUInt16BE = function writeUInt16BE (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 & 0xff)
  	  } 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 writeUInt32LE (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 & 0xff)
  	  } else {
  	    objectWriteUInt32(this, value, offset, true)
  	  }
  	  return offset + 4
  	}
  
  	Buffer.prototype.writeUInt32BE = function writeUInt32BE (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 & 0xff)
  	  } else {
  	    objectWriteUInt32(this, value, offset, false)
  	  }
  	  return offset + 4
  	}
  
  	Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
  	  value = +value
  	  offset = offset | 0
  	  if (!noAssert) {
  	    var limit = Math.pow(2, 8 * byteLength - 1)
  
  	    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  	  }
  
  	  var i = 0
  	  var mul = 1
  	  var sub = 0
  	  this[offset] = value & 0xFF
  	  while (++i < byteLength && (mul *= 0x100)) {
  	    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
  	      sub = 1
  	    }
  	    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  	  }
  
  	  return offset + byteLength
  	}
  
  	Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
  	  value = +value
  	  offset = offset | 0
  	  if (!noAssert) {
  	    var limit = Math.pow(2, 8 * byteLength - 1)
  
  	    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  	  }
  
  	  var i = byteLength - 1
  	  var mul = 1
  	  var sub = 0
  	  this[offset + i] = value & 0xFF
  	  while (--i >= 0 && (mul *= 0x100)) {
  	    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
  	      sub = 1
  	    }
  	    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  	  }
  
  	  return offset + byteLength
  	}
  
  	Buffer.prototype.writeInt8 = function writeInt8 (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 & 0xff)
  	  return offset + 1
  	}
  
  	Buffer.prototype.writeInt16LE = function writeInt16LE (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 & 0xff)
  	    this[offset + 1] = (value >>> 8)
  	  } else {
  	    objectWriteUInt16(this, value, offset, true)
  	  }
  	  return offset + 2
  	}
  
  	Buffer.prototype.writeInt16BE = function writeInt16BE (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 & 0xff)
  	  } else {
  	    objectWriteUInt16(this, value, offset, false)
  	  }
  	  return offset + 2
  	}
  
  	Buffer.prototype.writeInt32LE = function writeInt32LE (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 & 0xff)
  	    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 writeInt32BE (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 & 0xff)
  	  } else {
  	    objectWriteUInt32(this, value, offset, false)
  	  }
  	  return offset + 4
  	}
  
  	function checkIEEE754 (buf, value, offset, ext, max, min) {
  	  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 writeFloatLE (value, offset, noAssert) {
  	  return writeFloat(this, value, offset, true, noAssert)
  	}
  
  	Buffer.prototype.writeFloatBE = function writeFloatBE (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 writeDoubleLE (value, offset, noAssert) {
  	  return writeDouble(this, value, offset, true, noAssert)
  	}
  
  	Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
  	  return writeDouble(this, value, offset, false, noAssert)
  	}
  
  	// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
  	Buffer.prototype.copy = function copy (target, targetStart, start, end) {
  	  if (!start) start = 0
  	  if (!end && end !== 0) end = this.length
  	  if (targetStart >= target.length) targetStart = target.length
  	  if (!targetStart) targetStart = 0
  	  if (end > 0 && end < start) end = start
  
  	  // Copy 0 bytes; we're done
  	  if (end === start) return 0
  	  if (target.length === 0 || this.length === 0) return 0
  
  	  // Fatal error conditions
  	  if (targetStart < 0) {
  	    throw new RangeError('targetStart out of bounds')
  	  }
  	  if (start < 0 || start >= this.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 - targetStart < end - start) {
  	    end = target.length - targetStart + start
  	  }
  
  	  var len = end - start
  	  var i
  
  	  if (this === target && start < targetStart && targetStart < end) {
  	    // descending copy from end
  	    for (i = len - 1; i >= 0; --i) {
  	      target[i + targetStart] = this[i + start]
  	    }
  	  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
  	    // ascending copy from start
  	    for (i = 0; i < len; ++i) {
  	      target[i + targetStart] = this[i + start]
  	    }
  	  } else {
  	    Uint8Array.prototype.set.call(
  	      target,
  	      this.subarray(start, start + len),
  	      targetStart
  	    )
  	  }
  
  	  return len
  	}
  
  	// Usage:
  	//    buffer.fill(number[, offset[, end]])
  	//    buffer.fill(buffer[, offset[, end]])
  	//    buffer.fill(string[, offset[, end]][, encoding])
  	Buffer.prototype.fill = function fill (val, start, end, encoding) {
  	  // Handle string cases:
  	  if (typeof val === 'string') {
  	    if (typeof start === 'string') {
  	      encoding = start
  	      start = 0
  	      end = this.length
  	    } else if (typeof end === 'string') {
  	      encoding = end
  	      end = this.length
  	    }
  	    if (val.length === 1) {
  	      var code = val.charCodeAt(0)
  	      if (code < 256) {
  	        val = code
  	      }
  	    }
  	    if (encoding !== undefined && typeof encoding !== 'string') {
  	      throw new TypeError('encoding must be a string')
  	    }
  	    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
  	      throw new TypeError('Unknown encoding: ' + encoding)
  	    }
  	  } else if (typeof val === 'number') {
  	    val = val & 255
  	  }
  
  	  // Invalid ranges are not set to a default, so can range check early.
  	  if (start < 0 || this.length < start || this.length < end) {
  	    throw new RangeError('Out of range index')
  	  }
  
  	  if (end <= start) {
  	    return this
  	  }
  
  	  start = start >>> 0
  	  end = end === undefined ? this.length : end >>> 0
  
  	  if (!val) val = 0
  
  	  var i
  	  if (typeof val === 'number') {
  	    for (i = start; i < end; ++i) {
  	      this[i] = val
  	    }
  	  } else {
  	    var bytes = Buffer.isBuffer(val)
  	      ? val
  	      : utf8ToBytes(new Buffer(val, encoding).toString())
  	    var len = bytes.length
  	    for (i = 0; i < end - start; ++i) {
  	      this[i + start] = bytes[i % len]
  	    }
  	  }
  
  	  return this
  	}
  
  	// HELPER FUNCTIONS
  	// ================
  
  	var INVALID_BASE64_RE = /[^+\/0-9A-Za-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 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 = []
  
  	  for (var i = 0; i < length; ++i) {
  	    codePoint = string.charCodeAt(i)
  
  	    // is surrogate component
  	    if (codePoint > 0xD7FF && codePoint < 0xE000) {
  	      // last char was a lead
  	      if (!leadSurrogate) {
  	        // 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
  	        }
  
  	        // valid lead
  	        leadSurrogate = codePoint
  
  	        continue
  	      }
  
  	      // 2 leads in a row
  	      if (codePoint < 0xDC00) {
  	        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
  	        leadSurrogate = codePoint
  	        continue
  	      }
  
  	      // valid surrogate pair
  	      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
  	    } 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 < 0x110000) {
  	      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 isnan (val) {
  	  return val !== val // eslint-disable-line no-self-compare
  	}
  
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ }),
  /* 40 */
  /***/ (function(module, exports) {
  
  	'use strict'
  
  	exports.byteLength = byteLength
  	exports.toByteArray = toByteArray
  	exports.fromByteArray = fromByteArray
  
  	var lookup = []
  	var revLookup = []
  	var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
  
  	var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
  	for (var i = 0, len = code.length; i < len; ++i) {
  	  lookup[i] = code[i]
  	  revLookup[code.charCodeAt(i)] = i
  	}
  
  	// Support decoding URL-safe base64 strings, as Node.js does.
  	// See: https://en.wikipedia.org/wiki/Base64#URL_applications
  	revLookup['-'.charCodeAt(0)] = 62
  	revLookup['_'.charCodeAt(0)] = 63
  
  	function getLens (b64) {
  	  var len = b64.length
  
  	  if (len % 4 > 0) {
  	    throw new Error('Invalid string. Length must be a multiple of 4')
  	  }
  
  	  // Trim off extra bytes after placeholder bytes are found
  	  // See: https://github.com/beatgammit/base64-js/issues/42
  	  var validLen = b64.indexOf('=')
  	  if (validLen === -1) validLen = len
  
  	  var placeHoldersLen = validLen === len
  	    ? 0
  	    : 4 - (validLen % 4)
  
  	  return [validLen, placeHoldersLen]
  	}
  
  	// base64 is 4/3 + up to two characters of the original data
  	function byteLength (b64) {
  	  var lens = getLens(b64)
  	  var validLen = lens[0]
  	  var placeHoldersLen = lens[1]
  	  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
  	}
  
  	function _byteLength (b64, validLen, placeHoldersLen) {
  	  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
  	}
  
  	function toByteArray (b64) {
  	  var tmp
  	  var lens = getLens(b64)
  	  var validLen = lens[0]
  	  var placeHoldersLen = lens[1]
  
  	  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
  
  	  var curByte = 0
  
  	  // if there are placeholders, only get up to the last complete 4 chars
  	  var len = placeHoldersLen > 0
  	    ? validLen - 4
  	    : validLen
  
  	  var i
  	  for (i = 0; i < len; i += 4) {
  	    tmp =
  	      (revLookup[b64.charCodeAt(i)] << 18) |
  	      (revLookup[b64.charCodeAt(i + 1)] << 12) |
  	      (revLookup[b64.charCodeAt(i + 2)] << 6) |
  	      revLookup[b64.charCodeAt(i + 3)]
  	    arr[curByte++] = (tmp >> 16) & 0xFF
  	    arr[curByte++] = (tmp >> 8) & 0xFF
  	    arr[curByte++] = tmp & 0xFF
  	  }
  
  	  if (placeHoldersLen === 2) {
  	    tmp =
  	      (revLookup[b64.charCodeAt(i)] << 2) |
  	      (revLookup[b64.charCodeAt(i + 1)] >> 4)
  	    arr[curByte++] = tmp & 0xFF
  	  }
  
  	  if (placeHoldersLen === 1) {
  	    tmp =
  	      (revLookup[b64.charCodeAt(i)] << 10) |
  	      (revLookup[b64.charCodeAt(i + 1)] << 4) |
  	      (revLookup[b64.charCodeAt(i + 2)] >> 2)
  	    arr[curByte++] = (tmp >> 8) & 0xFF
  	    arr[curByte++] = tmp & 0xFF
  	  }
  
  	  return arr
  	}
  
  	function tripletToBase64 (num) {
  	  return lookup[num >> 18 & 0x3F] +
  	    lookup[num >> 12 & 0x3F] +
  	    lookup[num >> 6 & 0x3F] +
  	    lookup[num & 0x3F]
  	}
  
  	function encodeChunk (uint8, start, end) {
  	  var tmp
  	  var output = []
  	  for (var i = start; i < end; i += 3) {
  	    tmp =
  	      ((uint8[i] << 16) & 0xFF0000) +
  	      ((uint8[i + 1] << 8) & 0xFF00) +
  	      (uint8[i + 2] & 0xFF)
  	    output.push(tripletToBase64(tmp))
  	  }
  	  return output.join('')
  	}
  
  	function fromByteArray (uint8) {
  	  var tmp
  	  var len = uint8.length
  	  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
  	  var parts = []
  	  var maxChunkLength = 16383 // must be multiple of 3
  
  	  // go through the array every three bytes, we'll deal with trailing stuff later
  	  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
  	    parts.push(encodeChunk(
  	      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
  	    ))
  	  }
  
  	  // pad the end with zeros, but make sure to not forget the extra bytes
  	  if (extraBytes === 1) {
  	    tmp = uint8[len - 1]
  	    parts.push(
  	      lookup[tmp >> 2] +
  	      lookup[(tmp << 4) & 0x3F] +
  	      '=='
  	    )
  	  } else if (extraBytes === 2) {
  	    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
  	    parts.push(
  	      lookup[tmp >> 10] +
  	      lookup[(tmp >> 4) & 0x3F] +
  	      lookup[(tmp << 2) & 0x3F] +
  	      '='
  	    )
  	  }
  
  	  return parts.join('')
  	}
  
  
  /***/ }),
  /* 41 */
  /***/ (function(module, exports) {
  
  	exports.read = function (buffer, offset, isLE, mLen, nBytes) {
  	  var e, m
  	  var eLen = (nBytes * 8) - mLen - 1
  	  var eMax = (1 << eLen) - 1
  	  var eBias = eMax >> 1
  	  var nBits = -7
  	  var i = isLE ? (nBytes - 1) : 0
  	  var d = isLE ? -1 : 1
  	  var 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
  	  var eLen = (nBytes * 8) - mLen - 1
  	  var eMax = (1 << eLen) - 1
  	  var eBias = eMax >> 1
  	  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
  	  var i = isLE ? 0 : (nBytes - 1)
  	  var d = isLE ? 1 : -1
  	  var 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
  	}
  
  
  /***/ }),
  /* 42 */
  /***/ (function(module, exports) {
  
  	var toString = {}.toString;
  
  	module.exports = Array.isArray || function (arr) {
  	  return toString.call(arr) == '[object Array]';
  	};
  
  
  /***/ }),
  /* 43 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// 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 = __webpack_require__(44).EventEmitter;
  	var inherits = __webpack_require__(45);
  
  	inherits(Stream, EE);
  	Stream.Readable = __webpack_require__(46);
  	Stream.Writable = __webpack_require__(65);
  	Stream.Duplex = __webpack_require__(66);
  	Stream.Transform = __webpack_require__(67);
  	Stream.PassThrough = __webpack_require__(68);
  
  	// 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;
  	};
  
  
  /***/ }),
  /* 44 */
  /***/ (function(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
  	      } else {
  	        // At least give some kind of context to the user
  	        var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
  	        err.context = er;
  	        throw err;
  	      }
  	    }
  	  }
  
  	  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:
  	        args = Array.prototype.slice.call(arguments, 1);
  	        handler.apply(this, args);
  	    }
  	  } else if (isObject(handler)) {
  	    args = Array.prototype.slice.call(arguments, 1);
  	    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) {
  	    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 if (listeners) {
  	    // 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.prototype.listenerCount = function(type) {
  	  if (this._events) {
  	    var evlistener = this._events[type];
  
  	    if (isFunction(evlistener))
  	      return 1;
  	    else if (evlistener)
  	      return evlistener.length;
  	  }
  	  return 0;
  	};
  
  	EventEmitter.listenerCount = function(emitter, type) {
  	  return emitter.listenerCount(type);
  	};
  
  	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;
  	}
  
  
  /***/ }),
  /* 45 */
  /***/ (function(module, exports) {
  
  	if (typeof Object.create === 'function') {
  	  // implementation from standard node.js 'util' module
  	  module.exports = function inherits(ctor, superCtor) {
  	    if (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) {
  	    if (superCtor) {
  	      ctor.super_ = superCtor
  	      var TempCtor = function () {}
  	      TempCtor.prototype = superCtor.prototype
  	      ctor.prototype = new TempCtor()
  	      ctor.prototype.constructor = ctor
  	    }
  	  }
  	}
  
  
  /***/ }),
  /* 46 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	exports = module.exports = __webpack_require__(47);
  	exports.Stream = exports;
  	exports.Readable = exports;
  	exports.Writable = __webpack_require__(58);
  	exports.Duplex = __webpack_require__(57);
  	exports.Transform = __webpack_require__(63);
  	exports.PassThrough = __webpack_require__(64);
  
  
  /***/ }),
  /* 47 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global, 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.
  
  	'use strict';
  
  	/*<replacement>*/
  
  	var pna = __webpack_require__(49);
  	/*</replacement>*/
  
  	module.exports = Readable;
  
  	/*<replacement>*/
  	var isArray = __webpack_require__(42);
  	/*</replacement>*/
  
  	/*<replacement>*/
  	var Duplex;
  	/*</replacement>*/
  
  	Readable.ReadableState = ReadableState;
  
  	/*<replacement>*/
  	var EE = __webpack_require__(44).EventEmitter;
  
  	var EElistenerCount = function (emitter, type) {
  	  return emitter.listeners(type).length;
  	};
  	/*</replacement>*/
  
  	/*<replacement>*/
  	var Stream = __webpack_require__(50);
  	/*</replacement>*/
  
  	/*<replacement>*/
  
  	var Buffer = __webpack_require__(51).Buffer;
  	var OurUint8Array = global.Uint8Array || function () {};
  	function _uint8ArrayToBuffer(chunk) {
  	  return Buffer.from(chunk);
  	}
  	function _isUint8Array(obj) {
  	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
  	}
  
  	/*</replacement>*/
  
  	/*<replacement>*/
  	var util = __webpack_require__(52);
  	util.inherits = __webpack_require__(45);
  	/*</replacement>*/
  
  	/*<replacement>*/
  	var debugUtil = __webpack_require__(53);
  	var debug = void 0;
  	if (debugUtil && debugUtil.debuglog) {
  	  debug = debugUtil.debuglog('stream');
  	} else {
  	  debug = function () {};
  	}
  	/*</replacement>*/
  
  	var BufferList = __webpack_require__(54);
  	var destroyImpl = __webpack_require__(56);
  	var StringDecoder;
  
  	util.inherits(Readable, Stream);
  
  	var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
  
  	function prependListener(emitter, event, fn) {
  	  // Sadly this is not cacheable as some libraries bundle their own
  	  // event emitter implementation with them.
  	  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
  
  	  // This is a hack to make sure that our error handler is attached before any
  	  // userland ones.  NEVER DO THIS. This is here only because this code needs
  	  // to continue to work with older versions of Node.js that do not include
  	  // the prependListener() method. The goal is to eventually remove this hack.
  	  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
  	}
  
  	function ReadableState(options, stream) {
  	  Duplex = Duplex || __webpack_require__(57);
  
  	  options = options || {};
  
  	  // Duplex streams are both readable and writable, but share
  	  // the same options object.
  	  // However, some cases require setting options to different
  	  // values for the readable and the writable sides of the duplex stream.
  	  // These options can be provided separately as readableXXX and writableXXX.
  	  var isDuplex = stream instanceof Duplex;
  
  	  // 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;
  
  	  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
  
  	  // 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;
  	  var readableHwm = options.readableHighWaterMark;
  	  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  
  	  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
  
  	  // cast to ints.
  	  this.highWaterMark = Math.floor(this.highWaterMark);
  
  	  // A linked list is used to store data chunks instead of an array because the
  	  // linked list can remove elements from the beginning faster than
  	  // array.shift()
  	  this.buffer = new BufferList();
  	  this.length = 0;
  	  this.pipes = null;
  	  this.pipesCount = 0;
  	  this.flowing = null;
  	  this.ended = false;
  	  this.endEmitted = false;
  	  this.reading = false;
  
  	  // a flag to be able to tell if the event 'readable'/'data' is emitted
  	  // immediately, or on a later tick.  We set this to true at first, because
  	  // any actions that shouldn't happen until "later" should generally also
  	  // not happen before the first read 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;
  	  this.resumeScheduled = false;
  
  	  // has it been destroyed
  	  this.destroyed = false;
  
  	  // 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';
  
  	  // 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 = __webpack_require__(62).StringDecoder;
  	    this.decoder = new StringDecoder(options.encoding);
  	    this.encoding = options.encoding;
  	  }
  	}
  
  	function Readable(options) {
  	  Duplex = Duplex || __webpack_require__(57);
  
  	  if (!(this instanceof Readable)) return new Readable(options);
  
  	  this._readableState = new ReadableState(options, this);
  
  	  // legacy
  	  this.readable = true;
  
  	  if (options) {
  	    if (typeof options.read === 'function') this._read = options.read;
  
  	    if (typeof options.destroy === 'function') this._destroy = options.destroy;
  	  }
  
  	  Stream.call(this);
  	}
  
  	Object.defineProperty(Readable.prototype, 'destroyed', {
  	  get: function () {
  	    if (this._readableState === undefined) {
  	      return false;
  	    }
  	    return this._readableState.destroyed;
  	  },
  	  set: function (value) {
  	    // we ignore the value if the stream
  	    // has not been initialized yet
  	    if (!this._readableState) {
  	      return;
  	    }
  
  	    // backward compatibility, the user is explicitly
  	    // managing destroyed
  	    this._readableState.destroyed = value;
  	  }
  	});
  
  	Readable.prototype.destroy = destroyImpl.destroy;
  	Readable.prototype._undestroy = destroyImpl.undestroy;
  	Readable.prototype._destroy = function (err, cb) {
  	  this.push(null);
  	  cb(err);
  	};
  
  	// 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;
  	  var skipChunkCheck;
  
  	  if (!state.objectMode) {
  	    if (typeof chunk === 'string') {
  	      encoding = encoding || state.defaultEncoding;
  	      if (encoding !== state.encoding) {
  	        chunk = Buffer.from(chunk, encoding);
  	        encoding = '';
  	      }
  	      skipChunkCheck = true;
  	    }
  	  } else {
  	    skipChunkCheck = true;
  	  }
  
  	  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
  	};
  
  	// Unshift should *always* be something directly out of read()
  	Readable.prototype.unshift = function (chunk) {
  	  return readableAddChunk(this, chunk, null, true, false);
  	};
  
  	function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
  	  var state = stream._readableState;
  	  if (chunk === null) {
  	    state.reading = false;
  	    onEofChunk(stream, state);
  	  } else {
  	    var er;
  	    if (!skipChunkCheck) er = chunkInvalid(state, chunk);
  	    if (er) {
  	      stream.emit('error', er);
  	    } else if (state.objectMode || chunk && chunk.length > 0) {
  	      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
  	        chunk = _uint8ArrayToBuffer(chunk);
  	      }
  
  	      if (addToFront) {
  	        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
  	      } else if (state.ended) {
  	        stream.emit('error', new Error('stream.push() after EOF'));
  	      } else {
  	        state.reading = false;
  	        if (state.decoder && !encoding) {
  	          chunk = state.decoder.write(chunk);
  	          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
  	        } else {
  	          addChunk(stream, state, chunk, false);
  	        }
  	      }
  	    } else if (!addToFront) {
  	      state.reading = false;
  	    }
  	  }
  
  	  return needMoreData(state);
  	}
  
  	function addChunk(stream, state, chunk, addToFront) {
  	  if (state.flowing && state.length === 0 && !state.sync) {
  	    stream.emit('data', chunk);
  	    stream.read(0);
  	  } else {
  	    // update the buffer info.
  	    state.length += state.objectMode ? 1 : chunk.length;
  	    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
  
  	    if (state.needReadable) emitReadable(stream);
  	  }
  	  maybeReadMore(stream, state);
  	}
  
  	function chunkInvalid(state, chunk) {
  	  var er;
  	  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
  	    er = new TypeError('Invalid non-string/buffer chunk');
  	  }
  	  return er;
  	}
  
  	// 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);
  	}
  
  	Readable.prototype.isPaused = function () {
  	  return this._readableState.flowing === false;
  	};
  
  	// backwards compatibility.
  	Readable.prototype.setEncoding = function (enc) {
  	  if (!StringDecoder) StringDecoder = __webpack_require__(62).StringDecoder;
  	  this._readableState.decoder = new StringDecoder(enc);
  	  this._readableState.encoding = enc;
  	  return this;
  	};
  
  	// Don't raise the hwm > 8MB
  	var MAX_HWM = 0x800000;
  	function computeNewHighWaterMark(n) {
  	  if (n >= MAX_HWM) {
  	    n = MAX_HWM;
  	  } else {
  	    // Get the next highest power of 2 to prevent increasing hwm excessively in
  	    // tiny amounts
  	    n--;
  	    n |= n >>> 1;
  	    n |= n >>> 2;
  	    n |= n >>> 4;
  	    n |= n >>> 8;
  	    n |= n >>> 16;
  	    n++;
  	  }
  	  return n;
  	}
  
  	// This function is designed to be inlinable, so please take care when making
  	// changes to the function body.
  	function howMuchToRead(n, state) {
  	  if (n <= 0 || state.length === 0 && state.ended) return 0;
  	  if (state.objectMode) return 1;
  	  if (n !== n) {
  	    // Only flow one buffer at a time
  	    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
  	  }
  	  // If we're asking for more than the current hwm, then raise the hwm.
  	  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
  	  if (n <= state.length) return n;
  	  // Don't have enough
  	  if (!state.ended) {
  	    state.needReadable = true;
  	    return 0;
  	  }
  	  return state.length;
  	}
  
  	// you can override either this method, or the async _read(n) below.
  	Readable.prototype.read = function (n) {
  	  debug('read', n);
  	  n = parseInt(n, 10);
  	  var state = this._readableState;
  	  var nOrig = n;
  
  	  if (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)) {
  	    debug('read: emitReadable', state.length, state.ended);
  	    if (state.length === 0 && state.ended) endReadable(this);else 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) {
  	    if (state.length === 0) endReadable(this);
  	    return null;
  	  }
  
  	  // 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;
  	  debug('need readable', doRead);
  
  	  // if we currently have less than the highWaterMark, then also read some
  	  if (state.length === 0 || state.length - n < state.highWaterMark) {
  	    doRead = true;
  	    debug('length less than watermark', doRead);
  	  }
  
  	  // 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;
  	    debug('reading or ended', doRead);
  	  } else if (doRead) {
  	    debug('do read');
  	    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 pushed data synchronously, then `reading` will be false,
  	    // and we need to re-evaluate how much data we can return to the user.
  	    if (!state.reading) n = howMuchToRead(nOrig, state);
  	  }
  
  	  var ret;
  	  if (n > 0) ret = fromList(n, state);else ret = null;
  
  	  if (ret === null) {
  	    state.needReadable = true;
  	    n = 0;
  	  } else {
  	    state.length -= n;
  	  }
  
  	  if (state.length === 0) {
  	    // If we have nothing in the buffer, then we want to know
  	    // as soon as we *do* get something into the buffer.
  	    if (!state.ended) state.needReadable = true;
  
  	    // If we tried to read() past the EOF, then emit end on the next tick.
  	    if (nOrig !== n && state.ended) endReadable(this);
  	  }
  
  	  if (ret !== null) this.emit('data', ret);
  
  	  return ret;
  	};
  
  	function onEofChunk(stream, state) {
  	  if (state.ended) return;
  	  if (state.decoder) {
  	    var chunk = state.decoder.end();
  	    if (chunk && chunk.length) {
  	      state.buffer.push(chunk);
  	      state.length += state.objectMode ? 1 : chunk.length;
  	    }
  	  }
  	  state.ended = true;
  
  	  // emit 'readable' now to make sure it gets picked up.
  	  emitReadable(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) {
  	    debug('emitReadable', state.flowing);
  	    state.emittedReadable = true;
  	    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
  	  }
  	}
  
  	function emitReadable_(stream) {
  	  debug('emit readable');
  	  stream.emit('readable');
  	  flow(stream);
  	}
  
  	// 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;
  	    pna.nextTick(maybeReadMore_, stream, state);
  	  }
  	}
  
  	function maybeReadMore_(stream, state) {
  	  var len = state.length;
  	  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
  	    debug('maybeReadMore read 0');
  	    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('_read() is 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;
  	  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
  
  	  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
  
  	  var endFn = doEnd ? onend : unpipe;
  	  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
  
  	  dest.on('unpipe', onunpipe);
  	  function onunpipe(readable, unpipeInfo) {
  	    debug('onunpipe');
  	    if (readable === src) {
  	      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
  	        unpipeInfo.hasUnpiped = true;
  	        cleanup();
  	      }
  	    }
  	  }
  
  	  function onend() {
  	    debug('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);
  
  	  var cleanedUp = false;
  	  function cleanup() {
  	    debug('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', unpipe);
  	    src.removeListener('data', ondata);
  
  	    cleanedUp = true;
  
  	    // 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 (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
  	  }
  
  	  // If the user pushes more data while we're writing to dest then we'll end up
  	  // in ondata again. However, we only want to increase awaitDrain once because
  	  // dest will only emit one 'drain' event for the multiple writes.
  	  // => Introduce a guard on increasing awaitDrain.
  	  var increasedAwaitDrain = false;
  	  src.on('data', ondata);
  	  function ondata(chunk) {
  	    debug('ondata');
  	    increasedAwaitDrain = false;
  	    var ret = dest.write(chunk);
  	    if (false === ret && !increasedAwaitDrain) {
  	      // If the user unpiped during `dest.write()`, it is possible
  	      // to get stuck in a permanently paused state if that write
  	      // also returned false.
  	      // => Check whether `dest` is still a piping destination.
  	      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
  	        debug('false write response, pause', src._readableState.awaitDrain);
  	        src._readableState.awaitDrain++;
  	        increasedAwaitDrain = true;
  	      }
  	      src.pause();
  	    }
  	  }
  
  	  // if the dest has an error, then stop piping into it.
  	  // however, don't suppress the throwing behavior for this.
  	  function onerror(er) {
  	    debug('onerror', er);
  	    unpipe();
  	    dest.removeListener('error', onerror);
  	    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
  	  }
  
  	  // Make sure our error handler is attached before userland ones.
  	  prependListener(dest, 'error', onerror);
  
  	  // Both close and finish should trigger unpipe, but only once.
  	  function onclose() {
  	    dest.removeListener('finish', onfinish);
  	    unpipe();
  	  }
  	  dest.once('close', onclose);
  	  function onfinish() {
  	    debug('onfinish');
  	    dest.removeListener('close', onclose);
  	    unpipe();
  	  }
  	  dest.once('finish', onfinish);
  
  	  function unpipe() {
  	    debug('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) {
  	    debug('pipe resume');
  	    src.resume();
  	  }
  
  	  return dest;
  	};
  
  	function pipeOnDrain(src) {
  	  return function () {
  	    var state = src._readableState;
  	    debug('pipeOnDrain', state.awaitDrain);
  	    if (state.awaitDrain) state.awaitDrain--;
  	    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
  	      state.flowing = true;
  	      flow(src);
  	    }
  	  };
  	}
  
  	Readable.prototype.unpipe = function (dest) {
  	  var state = this._readableState;
  	  var unpipeInfo = { hasUnpiped: false };
  
  	  // 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;
  	    state.flowing = false;
  	    if (dest) dest.emit('unpipe', this, unpipeInfo);
  	    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;
  	    state.flowing = false;
  
  	    for (var i = 0; i < len; i++) {
  	      dests[i].emit('unpipe', this, unpipeInfo);
  	    }return this;
  	  }
  
  	  // try to find the right one.
  	  var index = indexOf(state.pipes, dest);
  	  if (index === -1) return this;
  
  	  state.pipes.splice(index, 1);
  	  state.pipesCount -= 1;
  	  if (state.pipesCount === 1) state.pipes = state.pipes[0];
  
  	  dest.emit('unpipe', this, unpipeInfo);
  
  	  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') {
  	    // Start flowing on next tick if stream isn't explicitly paused
  	    if (this._readableState.flowing !== false) this.resume();
  	  } else if (ev === 'readable') {
  	    var state = this._readableState;
  	    if (!state.endEmitted && !state.readableListening) {
  	      state.readableListening = state.needReadable = true;
  	      state.emittedReadable = false;
  	      if (!state.reading) {
  	        pna.nextTick(nReadingNextTick, this);
  	      } else if (state.length) {
  	        emitReadable(this);
  	      }
  	    }
  	  }
  
  	  return res;
  	};
  	Readable.prototype.addListener = Readable.prototype.on;
  
  	function nReadingNextTick(self) {
  	  debug('readable nexttick read 0');
  	  self.read(0);
  	}
  
  	// 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 () {
  	  var state = this._readableState;
  	  if (!state.flowing) {
  	    debug('resume');
  	    state.flowing = true;
  	    resume(this, state);
  	  }
  	  return this;
  	};
  
  	function resume(stream, state) {
  	  if (!state.resumeScheduled) {
  	    state.resumeScheduled = true;
  	    pna.nextTick(resume_, stream, state);
  	  }
  	}
  
  	function resume_(stream, state) {
  	  if (!state.reading) {
  	    debug('resume read 0');
  	    stream.read(0);
  	  }
  
  	  state.resumeScheduled = false;
  	  state.awaitDrain = 0;
  	  stream.emit('resume');
  	  flow(stream);
  	  if (state.flowing && !state.reading) stream.read(0);
  	}
  
  	Readable.prototype.pause = function () {
  	  debug('call pause flowing=%j', this._readableState.flowing);
  	  if (false !== this._readableState.flowing) {
  	    debug('pause');
  	    this._readableState.flowing = false;
  	    this.emit('pause');
  	  }
  	  return this;
  	};
  
  	function flow(stream) {
  	  var state = stream._readableState;
  	  debug('flow', state.flowing);
  	  while (state.flowing && stream.read() !== null) {}
  	}
  
  	// 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 _this = this;
  
  	  var state = this._readableState;
  	  var paused = false;
  
  	  stream.on('end', function () {
  	    debug('wrapped end');
  	    if (state.decoder && !state.ended) {
  	      var chunk = state.decoder.end();
  	      if (chunk && chunk.length) _this.push(chunk);
  	    }
  
  	    _this.push(null);
  	  });
  
  	  stream.on('data', function (chunk) {
  	    debug('wrapped data');
  	    if (state.decoder) chunk = state.decoder.write(chunk);
  
  	    // don't skip over falsy values in objectMode
  	    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
  
  	    var ret = _this.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 (this[i] === undefined && typeof stream[i] === 'function') {
  	      this[i] = function (method) {
  	        return function () {
  	          return stream[method].apply(stream, arguments);
  	        };
  	      }(i);
  	    }
  	  }
  
  	  // proxy certain important events.
  	  for (var n = 0; n < kProxyEvents.length; n++) {
  	    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
  	  }
  
  	  // when we try to consume some more bytes, simply unpause the
  	  // underlying stream.
  	  this._read = function (n) {
  	    debug('wrapped _read', n);
  	    if (paused) {
  	      paused = false;
  	      stream.resume();
  	    }
  	  };
  
  	  return this;
  	};
  
  	Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
  	  // making it explicit this property is not enumerable
  	  // because otherwise some prototype manipulation in
  	  // userland will fail
  	  enumerable: false,
  	  get: function () {
  	    return this._readableState.highWaterMark;
  	  }
  	});
  
  	// 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.
  	// This function is designed to be inlinable, so please take care when making
  	// changes to the function body.
  	function fromList(n, state) {
  	  // nothing buffered
  	  if (state.length === 0) return null;
  
  	  var ret;
  	  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
  	    // read it all, truncate the list
  	    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
  	    state.buffer.clear();
  	  } else {
  	    // read part of list
  	    ret = fromListPartial(n, state.buffer, state.decoder);
  	  }
  
  	  return ret;
  	}
  
  	// Extracts only enough buffered data to satisfy the amount requested.
  	// This function is designed to be inlinable, so please take care when making
  	// changes to the function body.
  	function fromListPartial(n, list, hasStrings) {
  	  var ret;
  	  if (n < list.head.data.length) {
  	    // slice is the same for buffers and strings
  	    ret = list.head.data.slice(0, n);
  	    list.head.data = list.head.data.slice(n);
  	  } else if (n === list.head.data.length) {
  	    // first chunk is a perfect match
  	    ret = list.shift();
  	  } else {
  	    // result spans more than one buffer
  	    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
  	  }
  	  return ret;
  	}
  
  	// Copies a specified amount of characters from the list of buffered data
  	// chunks.
  	// This function is designed to be inlinable, so please take care when making
  	// changes to the function body.
  	function copyFromBufferString(n, list) {
  	  var p = list.head;
  	  var c = 1;
  	  var ret = p.data;
  	  n -= ret.length;
  	  while (p = p.next) {
  	    var str = p.data;
  	    var nb = n > str.length ? str.length : n;
  	    if (nb === str.length) ret += str;else ret += str.slice(0, n);
  	    n -= nb;
  	    if (n === 0) {
  	      if (nb === str.length) {
  	        ++c;
  	        if (p.next) list.head = p.next;else list.head = list.tail = null;
  	      } else {
  	        list.head = p;
  	        p.data = str.slice(nb);
  	      }
  	      break;
  	    }
  	    ++c;
  	  }
  	  list.length -= c;
  	  return ret;
  	}
  
  	// Copies a specified amount of bytes from the list of buffered data chunks.
  	// This function is designed to be inlinable, so please take care when making
  	// changes to the function body.
  	function copyFromBuffer(n, list) {
  	  var ret = Buffer.allocUnsafe(n);
  	  var p = list.head;
  	  var c = 1;
  	  p.data.copy(ret);
  	  n -= p.data.length;
  	  while (p = p.next) {
  	    var buf = p.data;
  	    var nb = n > buf.length ? buf.length : n;
  	    buf.copy(ret, ret.length - n, 0, nb);
  	    n -= nb;
  	    if (n === 0) {
  	      if (nb === buf.length) {
  	        ++c;
  	        if (p.next) list.head = p.next;else list.head = list.tail = null;
  	      } else {
  	        list.head = p;
  	        p.data = buf.slice(nb);
  	      }
  	      break;
  	    }
  	    ++c;
  	  }
  	  list.length -= c;
  	  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.ended = true;
  	    pna.nextTick(endReadableNT, state, stream);
  	  }
  	}
  
  	function endReadableNT(state, stream) {
  	  // 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 indexOf(xs, x) {
  	  for (var i = 0, l = xs.length; i < l; i++) {
  	    if (xs[i] === x) return i;
  	  }
  	  return -1;
  	}
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(48)))
  
  /***/ }),
  /* 48 */
  /***/ (function(module, exports) {
  
  	// shim for using process in browser
  	var process = module.exports = {};
  
  	// cached from whatever global is present so that test runners that stub it
  	// don't break things.  But we need to wrap it in a try catch in case it is
  	// wrapped in strict mode code which doesn't define any globals.  It's inside a
  	// function because try/catches deoptimize in certain engines.
  
  	var cachedSetTimeout;
  	var cachedClearTimeout;
  
  	function defaultSetTimout() {
  	    throw new Error('setTimeout has not been defined');
  	}
  	function defaultClearTimeout () {
  	    throw new Error('clearTimeout has not been defined');
  	}
  	(function () {
  	    try {
  	        if (typeof setTimeout === 'function') {
  	            cachedSetTimeout = setTimeout;
  	        } else {
  	            cachedSetTimeout = defaultSetTimout;
  	        }
  	    } catch (e) {
  	        cachedSetTimeout = defaultSetTimout;
  	    }
  	    try {
  	        if (typeof clearTimeout === 'function') {
  	            cachedClearTimeout = clearTimeout;
  	        } else {
  	            cachedClearTimeout = defaultClearTimeout;
  	        }
  	    } catch (e) {
  	        cachedClearTimeout = defaultClearTimeout;
  	    }
  	} ())
  	function runTimeout(fun) {
  	    if (cachedSetTimeout === setTimeout) {
  	        //normal enviroments in sane situations
  	        return setTimeout(fun, 0);
  	    }
  	    // if setTimeout wasn't available but was latter defined
  	    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
  	        cachedSetTimeout = setTimeout;
  	        return setTimeout(fun, 0);
  	    }
  	    try {
  	        // when when somebody has screwed with setTimeout but no I.E. maddness
  	        return cachedSetTimeout(fun, 0);
  	    } catch(e){
  	        try {
  	            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
  	            return cachedSetTimeout.call(null, fun, 0);
  	        } catch(e){
  	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
  	            return cachedSetTimeout.call(this, fun, 0);
  	        }
  	    }
  
  
  	}
  	function runClearTimeout(marker) {
  	    if (cachedClearTimeout === clearTimeout) {
  	        //normal enviroments in sane situations
  	        return clearTimeout(marker);
  	    }
  	    // if clearTimeout wasn't available but was latter defined
  	    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
  	        cachedClearTimeout = clearTimeout;
  	        return clearTimeout(marker);
  	    }
  	    try {
  	        // when when somebody has screwed with setTimeout but no I.E. maddness
  	        return cachedClearTimeout(marker);
  	    } catch (e){
  	        try {
  	            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
  	            return cachedClearTimeout.call(null, marker);
  	        } catch (e){
  	            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
  	            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
  	            return cachedClearTimeout.call(this, marker);
  	        }
  	    }
  
  
  
  	}
  	var queue = [];
  	var draining = false;
  	var currentQueue;
  	var queueIndex = -1;
  
  	function cleanUpNextTick() {
  	    if (!draining || !currentQueue) {
  	        return;
  	    }
  	    draining = false;
  	    if (currentQueue.length) {
  	        queue = currentQueue.concat(queue);
  	    } else {
  	        queueIndex = -1;
  	    }
  	    if (queue.length) {
  	        drainQueue();
  	    }
  	}
  
  	function drainQueue() {
  	    if (draining) {
  	        return;
  	    }
  	    var timeout = runTimeout(cleanUpNextTick);
  	    draining = true;
  
  	    var len = queue.length;
  	    while(len) {
  	        currentQueue = queue;
  	        queue = [];
  	        while (++queueIndex < len) {
  	            if (currentQueue) {
  	                currentQueue[queueIndex].run();
  	            }
  	        }
  	        queueIndex = -1;
  	        len = queue.length;
  	    }
  	    currentQueue = null;
  	    draining = false;
  	    runClearTimeout(timeout);
  	}
  
  	process.nextTick = function (fun) {
  	    var args = new Array(arguments.length - 1);
  	    if (arguments.length > 1) {
  	        for (var i = 1; i < arguments.length; i++) {
  	            args[i - 1] = arguments[i];
  	        }
  	    }
  	    queue.push(new Item(fun, args));
  	    if (queue.length === 1 && !draining) {
  	        runTimeout(drainQueue);
  	    }
  	};
  
  	// v8 likes predictible objects
  	function Item(fun, array) {
  	    this.fun = fun;
  	    this.array = array;
  	}
  	Item.prototype.run = function () {
  	    this.fun.apply(null, this.array);
  	};
  	process.title = 'browser';
  	process.browser = true;
  	process.env = {};
  	process.argv = [];
  	process.version = ''; // empty string to avoid regexp issues
  	process.versions = {};
  
  	function noop() {}
  
  	process.on = noop;
  	process.addListener = noop;
  	process.once = noop;
  	process.off = noop;
  	process.removeListener = noop;
  	process.removeAllListeners = noop;
  	process.emit = noop;
  	process.prependListener = noop;
  	process.prependOnceListener = noop;
  
  	process.listeners = function (name) { return [] }
  
  	process.binding = function (name) {
  	    throw new Error('process.binding is not supported');
  	};
  
  	process.cwd = function () { return '/' };
  	process.chdir = function (dir) {
  	    throw new Error('process.chdir is not supported');
  	};
  	process.umask = function() { return 0; };
  
  
  /***/ }),
  /* 49 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  
  	if (typeof process === 'undefined' ||
  	    !process.version ||
  	    process.version.indexOf('v0.') === 0 ||
  	    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
  	  module.exports = { nextTick: nextTick };
  	} else {
  	  module.exports = process
  	}
  
  	function nextTick(fn, arg1, arg2, arg3) {
  	  if (typeof fn !== 'function') {
  	    throw new TypeError('"callback" argument must be a function');
  	  }
  	  var len = arguments.length;
  	  var args, i;
  	  switch (len) {
  	  case 0:
  	  case 1:
  	    return process.nextTick(fn);
  	  case 2:
  	    return process.nextTick(function afterTickOne() {
  	      fn.call(null, arg1);
  	    });
  	  case 3:
  	    return process.nextTick(function afterTickTwo() {
  	      fn.call(null, arg1, arg2);
  	    });
  	  case 4:
  	    return process.nextTick(function afterTickThree() {
  	      fn.call(null, arg1, arg2, arg3);
  	    });
  	  default:
  	    args = new Array(len - 1);
  	    i = 0;
  	    while (i < args.length) {
  	      args[i++] = arguments[i];
  	    }
  	    return process.nextTick(function afterTick() {
  	      fn.apply(null, args);
  	    });
  	  }
  	}
  
  
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(48)))
  
  /***/ }),
  /* 50 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(44).EventEmitter;
  
  
  /***/ }),
  /* 51 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* eslint-disable node/no-deprecated-api */
  	var buffer = __webpack_require__(39)
  	var Buffer = buffer.Buffer
  
  	// alternative to using Object.keys for old browsers
  	function copyProps (src, dst) {
  	  for (var key in src) {
  	    dst[key] = src[key]
  	  }
  	}
  	if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
  	  module.exports = buffer
  	} else {
  	  // Copy properties from require('buffer')
  	  copyProps(buffer, exports)
  	  exports.Buffer = SafeBuffer
  	}
  
  	function SafeBuffer (arg, encodingOrOffset, length) {
  	  return Buffer(arg, encodingOrOffset, length)
  	}
  
  	// Copy static methods from Buffer
  	copyProps(Buffer, SafeBuffer)
  
  	SafeBuffer.from = function (arg, encodingOrOffset, length) {
  	  if (typeof arg === 'number') {
  	    throw new TypeError('Argument must not be a number')
  	  }
  	  return Buffer(arg, encodingOrOffset, length)
  	}
  
  	SafeBuffer.alloc = function (size, fill, encoding) {
  	  if (typeof size !== 'number') {
  	    throw new TypeError('Argument must be a number')
  	  }
  	  var buf = Buffer(size)
  	  if (fill !== undefined) {
  	    if (typeof encoding === 'string') {
  	      buf.fill(fill, encoding)
  	    } else {
  	      buf.fill(fill)
  	    }
  	  } else {
  	    buf.fill(0)
  	  }
  	  return buf
  	}
  
  	SafeBuffer.allocUnsafe = function (size) {
  	  if (typeof size !== 'number') {
  	    throw new TypeError('Argument must be a number')
  	  }
  	  return Buffer(size)
  	}
  
  	SafeBuffer.allocUnsafeSlow = function (size) {
  	  if (typeof size !== 'number') {
  	    throw new TypeError('Argument must be a number')
  	  }
  	  return buffer.SlowBuffer(size)
  	}
  
  
  /***/ }),
  /* 52 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(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(arg) {
  	  if (Array.isArray) {
  	    return Array.isArray(arg);
  	  }
  	  return objectToString(arg) === '[object Array]';
  	}
  	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 objectToString(re) === '[object RegExp]';
  	}
  	exports.isRegExp = isRegExp;
  
  	function isObject(arg) {
  	  return typeof arg === 'object' && arg !== null;
  	}
  	exports.isObject = isObject;
  
  	function isDate(d) {
  	  return objectToString(d) === '[object Date]';
  	}
  	exports.isDate = isDate;
  
  	function isError(e) {
  	  return (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 = Buffer.isBuffer;
  
  	function objectToString(o) {
  	  return Object.prototype.toString.call(o);
  	}
  
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(39).Buffer))
  
  /***/ }),
  /* 53 */
  /***/ (function(module, exports) {
  
  	/* (ignored) */
  
  /***/ }),
  /* 54 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  	var Buffer = __webpack_require__(51).Buffer;
  	var util = __webpack_require__(55);
  
  	function copyBuffer(src, target, offset) {
  	  src.copy(target, offset);
  	}
  
  	module.exports = function () {
  	  function BufferList() {
  	    _classCallCheck(this, BufferList);
  
  	    this.head = null;
  	    this.tail = null;
  	    this.length = 0;
  	  }
  
  	  BufferList.prototype.push = function push(v) {
  	    var entry = { data: v, next: null };
  	    if (this.length > 0) this.tail.next = entry;else this.head = entry;
  	    this.tail = entry;
  	    ++this.length;
  	  };
  
  	  BufferList.prototype.unshift = function unshift(v) {
  	    var entry = { data: v, next: this.head };
  	    if (this.length === 0) this.tail = entry;
  	    this.head = entry;
  	    ++this.length;
  	  };
  
  	  BufferList.prototype.shift = function shift() {
  	    if (this.length === 0) return;
  	    var ret = this.head.data;
  	    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
  	    --this.length;
  	    return ret;
  	  };
  
  	  BufferList.prototype.clear = function clear() {
  	    this.head = this.tail = null;
  	    this.length = 0;
  	  };
  
  	  BufferList.prototype.join = function join(s) {
  	    if (this.length === 0) return '';
  	    var p = this.head;
  	    var ret = '' + p.data;
  	    while (p = p.next) {
  	      ret += s + p.data;
  	    }return ret;
  	  };
  
  	  BufferList.prototype.concat = function concat(n) {
  	    if (this.length === 0) return Buffer.alloc(0);
  	    if (this.length === 1) return this.head.data;
  	    var ret = Buffer.allocUnsafe(n >>> 0);
  	    var p = this.head;
  	    var i = 0;
  	    while (p) {
  	      copyBuffer(p.data, ret, i);
  	      i += p.data.length;
  	      p = p.next;
  	    }
  	    return ret;
  	  };
  
  	  return BufferList;
  	}();
  
  	if (util && util.inspect && util.inspect.custom) {
  	  module.exports.prototype[util.inspect.custom] = function () {
  	    var obj = util.inspect({ length: this.length });
  	    return this.constructor.name + ' ' + obj;
  	  };
  	}
  
  /***/ }),
  /* 55 */
  /***/ (function(module, exports) {
  
  	/* (ignored) */
  
  /***/ }),
  /* 56 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	/*<replacement>*/
  
  	var pna = __webpack_require__(49);
  	/*</replacement>*/
  
  	// undocumented cb() API, needed for core, not for public API
  	function destroy(err, cb) {
  	  var _this = this;
  
  	  var readableDestroyed = this._readableState && this._readableState.destroyed;
  	  var writableDestroyed = this._writableState && this._writableState.destroyed;
  
  	  if (readableDestroyed || writableDestroyed) {
  	    if (cb) {
  	      cb(err);
  	    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
  	      pna.nextTick(emitErrorNT, this, err);
  	    }
  	    return this;
  	  }
  
  	  // we set destroyed to true before firing error callbacks in order
  	  // to make it re-entrance safe in case destroy() is called within callbacks
  
  	  if (this._readableState) {
  	    this._readableState.destroyed = true;
  	  }
  
  	  // if this is a duplex stream mark the writable part as destroyed as well
  	  if (this._writableState) {
  	    this._writableState.destroyed = true;
  	  }
  
  	  this._destroy(err || null, function (err) {
  	    if (!cb && err) {
  	      pna.nextTick(emitErrorNT, _this, err);
  	      if (_this._writableState) {
  	        _this._writableState.errorEmitted = true;
  	      }
  	    } else if (cb) {
  	      cb(err);
  	    }
  	  });
  
  	  return this;
  	}
  
  	function undestroy() {
  	  if (this._readableState) {
  	    this._readableState.destroyed = false;
  	    this._readableState.reading = false;
  	    this._readableState.ended = false;
  	    this._readableState.endEmitted = false;
  	  }
  
  	  if (this._writableState) {
  	    this._writableState.destroyed = false;
  	    this._writableState.ended = false;
  	    this._writableState.ending = false;
  	    this._writableState.finished = false;
  	    this._writableState.errorEmitted = false;
  	  }
  	}
  
  	function emitErrorNT(self, err) {
  	  self.emit('error', err);
  	}
  
  	module.exports = {
  	  destroy: destroy,
  	  undestroy: undestroy
  	};
  
  /***/ }),
  /* 57 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// 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.
  
  	'use strict';
  
  	/*<replacement>*/
  
  	var pna = __webpack_require__(49);
  	/*</replacement>*/
  
  	/*<replacement>*/
  	var objectKeys = Object.keys || function (obj) {
  	  var keys = [];
  	  for (var key in obj) {
  	    keys.push(key);
  	  }return keys;
  	};
  	/*</replacement>*/
  
  	module.exports = Duplex;
  
  	/*<replacement>*/
  	var util = __webpack_require__(52);
  	util.inherits = __webpack_require__(45);
  	/*</replacement>*/
  
  	var Readable = __webpack_require__(47);
  	var Writable = __webpack_require__(58);
  
  	util.inherits(Duplex, Readable);
  
  	{
  	  // avoid scope creep, the keys array can then be collected
  	  var keys = objectKeys(Writable.prototype);
  	  for (var v = 0; v < keys.length; v++) {
  	    var method = keys[v];
  	    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);
  	}
  
  	Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
  	  // making it explicit this property is not enumerable
  	  // because otherwise some prototype manipulation in
  	  // userland will fail
  	  enumerable: false,
  	  get: function () {
  	    return this._writableState.highWaterMark;
  	  }
  	});
  
  	// 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.
  	  pna.nextTick(onEndNT, this);
  	}
  
  	function onEndNT(self) {
  	  self.end();
  	}
  
  	Object.defineProperty(Duplex.prototype, 'destroyed', {
  	  get: function () {
  	    if (this._readableState === undefined || this._writableState === undefined) {
  	      return false;
  	    }
  	    return this._readableState.destroyed && this._writableState.destroyed;
  	  },
  	  set: function (value) {
  	    // we ignore the value if the stream
  	    // has not been initialized yet
  	    if (this._readableState === undefined || this._writableState === undefined) {
  	      return;
  	    }
  
  	    // backward compatibility, the user is explicitly
  	    // managing destroyed
  	    this._readableState.destroyed = value;
  	    this._writableState.destroyed = value;
  	  }
  	});
  
  	Duplex.prototype._destroy = function (err, cb) {
  	  this.push(null);
  	  this.end();
  
  	  pna.nextTick(cb, err);
  	};
  
  /***/ }),
  /* 58 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(process, setImmediate, 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.
  
  	// A bit simpler than readable streams.
  	// Implement an async ._write(chunk, encoding, cb), and it'll handle all
  	// the drain event emission and buffering.
  
  	'use strict';
  
  	/*<replacement>*/
  
  	var pna = __webpack_require__(49);
  	/*</replacement>*/
  
  	module.exports = Writable;
  
  	/* <replacement> */
  	function WriteReq(chunk, encoding, cb) {
  	  this.chunk = chunk;
  	  this.encoding = encoding;
  	  this.callback = cb;
  	  this.next = null;
  	}
  
  	// It seems a linked list but it is not
  	// there will be only 2 of these for each stream
  	function CorkedRequest(state) {
  	  var _this = this;
  
  	  this.next = null;
  	  this.entry = null;
  	  this.finish = function () {
  	    onCorkedFinish(_this, state);
  	  };
  	}
  	/* </replacement> */
  
  	/*<replacement>*/
  	var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
  	/*</replacement>*/
  
  	/*<replacement>*/
  	var Duplex;
  	/*</replacement>*/
  
  	Writable.WritableState = WritableState;
  
  	/*<replacement>*/
  	var util = __webpack_require__(52);
  	util.inherits = __webpack_require__(45);
  	/*</replacement>*/
  
  	/*<replacement>*/
  	var internalUtil = {
  	  deprecate: __webpack_require__(61)
  	};
  	/*</replacement>*/
  
  	/*<replacement>*/
  	var Stream = __webpack_require__(50);
  	/*</replacement>*/
  
  	/*<replacement>*/
  
  	var Buffer = __webpack_require__(51).Buffer;
  	var OurUint8Array = global.Uint8Array || function () {};
  	function _uint8ArrayToBuffer(chunk) {
  	  return Buffer.from(chunk);
  	}
  	function _isUint8Array(obj) {
  	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
  	}
  
  	/*</replacement>*/
  
  	var destroyImpl = __webpack_require__(56);
  
  	util.inherits(Writable, Stream);
  
  	function nop() {}
  
  	function WritableState(options, stream) {
  	  Duplex = Duplex || __webpack_require__(57);
  
  	  options = options || {};
  
  	  // Duplex streams are both readable and writable, but share
  	  // the same options object.
  	  // However, some cases require setting options to different
  	  // values for the readable and the writable sides of the duplex stream.
  	  // These options can be provided separately as readableXXX and writableXXX.
  	  var isDuplex = stream instanceof Duplex;
  
  	  // object stream flag to indicate whether or not this stream
  	  // contains buffers or objects.
  	  this.objectMode = !!options.objectMode;
  
  	  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
  
  	  // 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;
  	  var writableHwm = options.writableHighWaterMark;
  	  var defaultHwm = this.objectMode ? 16 : 16 * 1024;
  
  	  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
  
  	  // cast to ints.
  	  this.highWaterMark = Math.floor(this.highWaterMark);
  
  	  // if _final has been called
  	  this.finalCalled = false;
  
  	  // drain event flag.
  	  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;
  
  	  // has it been destroyed
  	  this.destroyed = 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;
  
  	  // when true all writes will be buffered until .uncork() call
  	  this.corked = 0;
  
  	  // 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, because 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.bufferedRequest = null;
  	  this.lastBufferedRequest = null;
  
  	  // number of pending user-supplied write callbacks
  	  // this must be 0 before 'finish' can be emitted
  	  this.pendingcb = 0;
  
  	  // emit prefinish if the only thing we're waiting for is _write cbs
  	  // This is relevant for synchronous Transform streams
  	  this.prefinished = false;
  
  	  // True if the error was already emitted and should not be thrown again
  	  this.errorEmitted = false;
  
  	  // count buffered requests
  	  this.bufferedRequestCount = 0;
  
  	  // allocate the first CorkedRequest, there is always
  	  // one allocated and free to use, and we maintain at most two
  	  this.corkedRequestsFree = new CorkedRequest(this);
  	}
  
  	WritableState.prototype.getBuffer = function getBuffer() {
  	  var current = this.bufferedRequest;
  	  var out = [];
  	  while (current) {
  	    out.push(current);
  	    current = current.next;
  	  }
  	  return out;
  	};
  
  	(function () {
  	  try {
  	    Object.defineProperty(WritableState.prototype, 'buffer', {
  	      get: internalUtil.deprecate(function () {
  	        return this.getBuffer();
  	      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
  	    });
  	  } catch (_) {}
  	})();
  
  	// Test _writableState for inheritance to account for Duplex streams,
  	// whose prototype chain only points to Readable.
  	var realHasInstance;
  	if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
  	  realHasInstance = Function.prototype[Symbol.hasInstance];
  	  Object.defineProperty(Writable, Symbol.hasInstance, {
  	    value: function (object) {
  	      if (realHasInstance.call(this, object)) return true;
  	      if (this !== Writable) return false;
  
  	      return object && object._writableState instanceof WritableState;
  	    }
  	  });
  	} else {
  	  realHasInstance = function (object) {
  	    return object instanceof this;
  	  };
  	}
  
  	function Writable(options) {
  	  Duplex = Duplex || __webpack_require__(57);
  
  	  // Writable ctor is applied to Duplexes, too.
  	  // `realHasInstance` is necessary because using plain `instanceof`
  	  // would return false, as no `_writableState` property is attached.
  
  	  // Trying to use the custom `instanceof` for Writable here will also break the
  	  // Node.js LazyTransform implementation, which has a non-trivial getter for
  	  // `_writableState` that would lead to infinite recursion.
  	  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
  	    return new Writable(options);
  	  }
  
  	  this._writableState = new WritableState(options, this);
  
  	  // legacy.
  	  this.writable = true;
  
  	  if (options) {
  	    if (typeof options.write === 'function') this._write = options.write;
  
  	    if (typeof options.writev === 'function') this._writev = options.writev;
  
  	    if (typeof options.destroy === 'function') this._destroy = options.destroy;
  
  	    if (typeof options.final === 'function') this._final = options.final;
  	  }
  
  	  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, cb) {
  	  var er = new Error('write after end');
  	  // TODO: defer error events consistently everywhere, not just the cb
  	  stream.emit('error', er);
  	  pna.nextTick(cb, er);
  	}
  
  	// Checks that a user-supplied chunk is valid, especially for the particular
  	// mode the stream is in. Currently this means that `null` is never accepted
  	// and undefined/non-string values are only allowed in object mode.
  	function validChunk(stream, state, chunk, cb) {
  	  var valid = true;
  	  var er = false;
  
  	  if (chunk === null) {
  	    er = new TypeError('May not write null values to stream');
  	  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
  	    er = new TypeError('Invalid non-string/buffer chunk');
  	  }
  	  if (er) {
  	    stream.emit('error', er);
  	    pna.nextTick(cb, er);
  	    valid = false;
  	  }
  	  return valid;
  	}
  
  	Writable.prototype.write = function (chunk, encoding, cb) {
  	  var state = this._writableState;
  	  var ret = false;
  	  var isBuf = !state.objectMode && _isUint8Array(chunk);
  
  	  if (isBuf && !Buffer.isBuffer(chunk)) {
  	    chunk = _uint8ArrayToBuffer(chunk);
  	  }
  
  	  if (typeof encoding === 'function') {
  	    cb = encoding;
  	    encoding = null;
  	  }
  
  	  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
  
  	  if (typeof cb !== 'function') cb = nop;
  
  	  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
  	    state.pendingcb++;
  	    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
  	  }
  
  	  return ret;
  	};
  
  	Writable.prototype.cork = function () {
  	  var state = this._writableState;
  
  	  state.corked++;
  	};
  
  	Writable.prototype.uncork = function () {
  	  var state = this._writableState;
  
  	  if (state.corked) {
  	    state.corked--;
  
  	    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
  	  }
  	};
  
  	Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
  	  // node::ParseEncoding() requires lower case.
  	  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
  	  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
  	  this._writableState.defaultEncoding = encoding;
  	  return this;
  	};
  
  	function decodeChunk(state, chunk, encoding) {
  	  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
  	    chunk = Buffer.from(chunk, encoding);
  	  }
  	  return chunk;
  	}
  
  	Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
  	  // making it explicit this property is not enumerable
  	  // because otherwise some prototype manipulation in
  	  // userland will fail
  	  enumerable: false,
  	  get: function () {
  	    return this._writableState.highWaterMark;
  	  }
  	});
  
  	// 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, isBuf, chunk, encoding, cb) {
  	  if (!isBuf) {
  	    var newChunk = decodeChunk(state, chunk, encoding);
  	    if (chunk !== newChunk) {
  	      isBuf = true;
  	      encoding = 'buffer';
  	      chunk = newChunk;
  	    }
  	  }
  	  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.corked) {
  	    var last = state.lastBufferedRequest;
  	    state.lastBufferedRequest = {
  	      chunk: chunk,
  	      encoding: encoding,
  	      isBuf: isBuf,
  	      callback: cb,
  	      next: null
  	    };
  	    if (last) {
  	      last.next = state.lastBufferedRequest;
  	    } else {
  	      state.bufferedRequest = state.lastBufferedRequest;
  	    }
  	    state.bufferedRequestCount += 1;
  	  } else {
  	    doWrite(stream, state, false, len, chunk, encoding, cb);
  	  }
  
  	  return ret;
  	}
  
  	function doWrite(stream, state, writev, len, chunk, encoding, cb) {
  	  state.writelen = len;
  	  state.writecb = cb;
  	  state.writing = true;
  	  state.sync = true;
  	  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
  	  state.sync = false;
  	}
  
  	function onwriteError(stream, state, sync, er, cb) {
  	  --state.pendingcb;
  
  	  if (sync) {
  	    // defer the callback if we are being called synchronously
  	    // to avoid piling up things on the stack
  	    pna.nextTick(cb, er);
  	    // this can emit finish, and it will always happen
  	    // after error
  	    pna.nextTick(finishMaybe, stream, state);
  	    stream._writableState.errorEmitted = true;
  	    stream.emit('error', er);
  	  } else {
  	    // the caller expect this to happen before if
  	    // it is async
  	    cb(er);
  	    stream._writableState.errorEmitted = true;
  	    stream.emit('error', er);
  	    // this can emit finish, but finish must
  	    // always follow error
  	    finishMaybe(stream, state);
  	  }
  	}
  
  	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(state);
  
  	    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
  	      clearBuffer(stream, state);
  	    }
  
  	    if (sync) {
  	      /*<replacement>*/
  	      asyncWrite(afterWrite, stream, state, finished, cb);
  	      /*</replacement>*/
  	    } else {
  	      afterWrite(stream, state, finished, cb);
  	    }
  	  }
  	}
  
  	function afterWrite(stream, state, finished, cb) {
  	  if (!finished) onwriteDrain(stream, state);
  	  state.pendingcb--;
  	  cb();
  	  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;
  	  var entry = state.bufferedRequest;
  
  	  if (stream._writev && entry && entry.next) {
  	    // Fast case, write everything using _writev()
  	    var l = state.bufferedRequestCount;
  	    var buffer = new Array(l);
  	    var holder = state.corkedRequestsFree;
  	    holder.entry = entry;
  
  	    var count = 0;
  	    var allBuffers = true;
  	    while (entry) {
  	      buffer[count] = entry;
  	      if (!entry.isBuf) allBuffers = false;
  	      entry = entry.next;
  	      count += 1;
  	    }
  	    buffer.allBuffers = allBuffers;
  
  	    doWrite(stream, state, true, state.length, buffer, '', holder.finish);
  
  	    // doWrite is almost always async, defer these to save a bit of time
  	    // as the hot path ends with doWrite
  	    state.pendingcb++;
  	    state.lastBufferedRequest = null;
  	    if (holder.next) {
  	      state.corkedRequestsFree = holder.next;
  	      holder.next = null;
  	    } else {
  	      state.corkedRequestsFree = new CorkedRequest(state);
  	    }
  	    state.bufferedRequestCount = 0;
  	  } else {
  	    // Slow case, write chunks one-by-one
  	    while (entry) {
  	      var chunk = entry.chunk;
  	      var encoding = entry.encoding;
  	      var cb = entry.callback;
  	      var len = state.objectMode ? 1 : chunk.length;
  
  	      doWrite(stream, state, false, len, chunk, encoding, cb);
  	      entry = entry.next;
  	      state.bufferedRequestCount--;
  	      // 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) {
  	        break;
  	      }
  	    }
  
  	    if (entry === null) state.lastBufferedRequest = null;
  	  }
  
  	  state.bufferedRequest = entry;
  	  state.bufferProcessing = false;
  	}
  
  	Writable.prototype._write = function (chunk, encoding, cb) {
  	  cb(new Error('_write() is not implemented'));
  	};
  
  	Writable.prototype._writev = null;
  
  	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 (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
  
  	  // .end() fully uncorks
  	  if (state.corked) {
  	    state.corked = 1;
  	    this.uncork();
  	  }
  
  	  // ignore unnecessary end() calls.
  	  if (!state.ending && !state.finished) endWritable(this, state, cb);
  	};
  
  	function needFinish(state) {
  	  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
  	}
  	function callFinal(stream, state) {
  	  stream._final(function (err) {
  	    state.pendingcb--;
  	    if (err) {
  	      stream.emit('error', err);
  	    }
  	    state.prefinished = true;
  	    stream.emit('prefinish');
  	    finishMaybe(stream, state);
  	  });
  	}
  	function prefinish(stream, state) {
  	  if (!state.prefinished && !state.finalCalled) {
  	    if (typeof stream._final === 'function') {
  	      state.pendingcb++;
  	      state.finalCalled = true;
  	      pna.nextTick(callFinal, stream, state);
  	    } else {
  	      state.prefinished = true;
  	      stream.emit('prefinish');
  	    }
  	  }
  	}
  
  	function finishMaybe(stream, state) {
  	  var need = needFinish(state);
  	  if (need) {
  	    prefinish(stream, state);
  	    if (state.pendingcb === 0) {
  	      state.finished = true;
  	      stream.emit('finish');
  	    }
  	  }
  	  return need;
  	}
  
  	function endWritable(stream, state, cb) {
  	  state.ending = true;
  	  finishMaybe(stream, state);
  	  if (cb) {
  	    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
  	  }
  	  state.ended = true;
  	  stream.writable = false;
  	}
  
  	function onCorkedFinish(corkReq, state, err) {
  	  var entry = corkReq.entry;
  	  corkReq.entry = null;
  	  while (entry) {
  	    var cb = entry.callback;
  	    state.pendingcb--;
  	    cb(err);
  	    entry = entry.next;
  	  }
  	  if (state.corkedRequestsFree) {
  	    state.corkedRequestsFree.next = corkReq;
  	  } else {
  	    state.corkedRequestsFree = corkReq;
  	  }
  	}
  
  	Object.defineProperty(Writable.prototype, 'destroyed', {
  	  get: function () {
  	    if (this._writableState === undefined) {
  	      return false;
  	    }
  	    return this._writableState.destroyed;
  	  },
  	  set: function (value) {
  	    // we ignore the value if the stream
  	    // has not been initialized yet
  	    if (!this._writableState) {
  	      return;
  	    }
  
  	    // backward compatibility, the user is explicitly
  	    // managing destroyed
  	    this._writableState.destroyed = value;
  	  }
  	});
  
  	Writable.prototype.destroy = destroyImpl.destroy;
  	Writable.prototype._undestroy = destroyImpl.undestroy;
  	Writable.prototype._destroy = function (err, cb) {
  	  this.end();
  	  cb(err);
  	};
  	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(48), __webpack_require__(59).setImmediate, (function() { return this; }())))
  
  /***/ }),
  /* 59 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) ||
  	            (typeof self !== "undefined" && self) ||
  	            window;
  	var apply = Function.prototype.apply;
  
  	// DOM APIs, for completeness
  
  	exports.setTimeout = function() {
  	  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
  	};
  	exports.setInterval = function() {
  	  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
  	};
  	exports.clearTimeout =
  	exports.clearInterval = function(timeout) {
  	  if (timeout) {
  	    timeout.close();
  	  }
  	};
  
  	function Timeout(id, clearFn) {
  	  this._id = id;
  	  this._clearFn = clearFn;
  	}
  	Timeout.prototype.unref = Timeout.prototype.ref = function() {};
  	Timeout.prototype.close = function() {
  	  this._clearFn.call(scope, this._id);
  	};
  
  	// Does not start the time, just sets up the members needed.
  	exports.enroll = function(item, msecs) {
  	  clearTimeout(item._idleTimeoutId);
  	  item._idleTimeout = msecs;
  	};
  
  	exports.unenroll = function(item) {
  	  clearTimeout(item._idleTimeoutId);
  	  item._idleTimeout = -1;
  	};
  
  	exports._unrefActive = exports.active = function(item) {
  	  clearTimeout(item._idleTimeoutId);
  
  	  var msecs = item._idleTimeout;
  	  if (msecs >= 0) {
  	    item._idleTimeoutId = setTimeout(function onTimeout() {
  	      if (item._onTimeout)
  	        item._onTimeout();
  	    }, msecs);
  	  }
  	};
  
  	// setimmediate attaches itself to the global object
  	__webpack_require__(60);
  	// On some exotic environments, it's not clear which object `setimmediate` was
  	// able to install onto.  Search each possibility in the same order as the
  	// `setimmediate` library.
  	exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) ||
  	                       (typeof global !== "undefined" && global.setImmediate) ||
  	                       (this && this.setImmediate);
  	exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) ||
  	                         (typeof global !== "undefined" && global.clearImmediate) ||
  	                         (this && this.clearImmediate);
  
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ }),
  /* 60 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
  	    "use strict";
  
  	    if (global.setImmediate) {
  	        return;
  	    }
  
  	    var nextHandle = 1; // Spec says greater than zero
  	    var tasksByHandle = {};
  	    var currentlyRunningATask = false;
  	    var doc = global.document;
  	    var registerImmediate;
  
  	    function setImmediate(callback) {
  	      // Callback can either be a function or a string
  	      if (typeof callback !== "function") {
  	        callback = new Function("" + callback);
  	      }
  	      // Copy function arguments
  	      var args = new Array(arguments.length - 1);
  	      for (var i = 0; i < args.length; i++) {
  	          args[i] = arguments[i + 1];
  	      }
  	      // Store and register the task
  	      var task = { callback: callback, args: args };
  	      tasksByHandle[nextHandle] = task;
  	      registerImmediate(nextHandle);
  	      return nextHandle++;
  	    }
  
  	    function clearImmediate(handle) {
  	        delete tasksByHandle[handle];
  	    }
  
  	    function run(task) {
  	        var callback = task.callback;
  	        var args = task.args;
  	        switch (args.length) {
  	        case 0:
  	            callback();
  	            break;
  	        case 1:
  	            callback(args[0]);
  	            break;
  	        case 2:
  	            callback(args[0], args[1]);
  	            break;
  	        case 3:
  	            callback(args[0], args[1], args[2]);
  	            break;
  	        default:
  	            callback.apply(undefined, args);
  	            break;
  	        }
  	    }
  
  	    function runIfPresent(handle) {
  	        // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
  	        // So if we're currently running a task, we'll need to delay this invocation.
  	        if (currentlyRunningATask) {
  	            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
  	            // "too much recursion" error.
  	            setTimeout(runIfPresent, 0, handle);
  	        } else {
  	            var task = tasksByHandle[handle];
  	            if (task) {
  	                currentlyRunningATask = true;
  	                try {
  	                    run(task);
  	                } finally {
  	                    clearImmediate(handle);
  	                    currentlyRunningATask = false;
  	                }
  	            }
  	        }
  	    }
  
  	    function installNextTickImplementation() {
  	        registerImmediate = function(handle) {
  	            process.nextTick(function () { runIfPresent(handle); });
  	        };
  	    }
  
  	    function canUsePostMessage() {
  	        // The test against `importScripts` prevents this implementation from being installed inside a web worker,
  	        // where `global.postMessage` means something completely different and can't be used for this purpose.
  	        if (global.postMessage && !global.importScripts) {
  	            var postMessageIsAsynchronous = true;
  	            var oldOnMessage = global.onmessage;
  	            global.onmessage = function() {
  	                postMessageIsAsynchronous = false;
  	            };
  	            global.postMessage("", "*");
  	            global.onmessage = oldOnMessage;
  	            return postMessageIsAsynchronous;
  	        }
  	    }
  
  	    function installPostMessageImplementation() {
  	        // Installs an event handler on `global` for the `message` event: see
  	        // * https://developer.mozilla.org/en/DOM/window.postMessage
  	        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
  
  	        var messagePrefix = "setImmediate$" + Math.random() + "$";
  	        var onGlobalMessage = function(event) {
  	            if (event.source === global &&
  	                typeof event.data === "string" &&
  	                event.data.indexOf(messagePrefix) === 0) {
  	                runIfPresent(+event.data.slice(messagePrefix.length));
  	            }
  	        };
  
  	        if (global.addEventListener) {
  	            global.addEventListener("message", onGlobalMessage, false);
  	        } else {
  	            global.attachEvent("onmessage", onGlobalMessage);
  	        }
  
  	        registerImmediate = function(handle) {
  	            global.postMessage(messagePrefix + handle, "*");
  	        };
  	    }
  
  	    function installMessageChannelImplementation() {
  	        var channel = new MessageChannel();
  	        channel.port1.onmessage = function(event) {
  	            var handle = event.data;
  	            runIfPresent(handle);
  	        };
  
  	        registerImmediate = function(handle) {
  	            channel.port2.postMessage(handle);
  	        };
  	    }
  
  	    function installReadyStateChangeImplementation() {
  	        var html = doc.documentElement;
  	        registerImmediate = function(handle) {
  	            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
  	            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
  	            var script = doc.createElement("script");
  	            script.onreadystatechange = function () {
  	                runIfPresent(handle);
  	                script.onreadystatechange = null;
  	                html.removeChild(script);
  	                script = null;
  	            };
  	            html.appendChild(script);
  	        };
  	    }
  
  	    function installSetTimeoutImplementation() {
  	        registerImmediate = function(handle) {
  	            setTimeout(runIfPresent, 0, handle);
  	        };
  	    }
  
  	    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
  	    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
  	    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
  
  	    // Don't get fooled by e.g. browserify environments.
  	    if ({}.toString.call(global.process) === "[object process]") {
  	        // For Node.js before 0.9
  	        installNextTickImplementation();
  
  	    } else if (canUsePostMessage()) {
  	        // For non-IE10 modern browsers
  	        installPostMessageImplementation();
  
  	    } else if (global.MessageChannel) {
  	        // For web workers, where supported
  	        installMessageChannelImplementation();
  
  	    } else if (doc && "onreadystatechange" in doc.createElement("script")) {
  	        // For IE 6–8
  	        installReadyStateChangeImplementation();
  
  	    } else {
  	        // For older browsers
  	        installSetTimeoutImplementation();
  	    }
  
  	    attachTo.setImmediate = setImmediate;
  	    attachTo.clearImmediate = clearImmediate;
  	}(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));
  
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(48)))
  
  /***/ }),
  /* 61 */
  /***/ (function(module, exports) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {
  	/**
  	 * Module exports.
  	 */
  
  	module.exports = deprecate;
  
  	/**
  	 * Mark that a method should not be used.
  	 * Returns a modified function which warns once by default.
  	 *
  	 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
  	 *
  	 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
  	 * will throw an Error when invoked.
  	 *
  	 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
  	 * will invoke `console.trace()` instead of `console.error()`.
  	 *
  	 * @param {Function} fn - the function to deprecate
  	 * @param {String} msg - the string to print to the console when `fn` is invoked
  	 * @returns {Function} a new "deprecated" version of `fn`
  	 * @api public
  	 */
  
  	function deprecate (fn, msg) {
  	  if (config('noDeprecation')) {
  	    return fn;
  	  }
  
  	  var warned = false;
  	  function deprecated() {
  	    if (!warned) {
  	      if (config('throwDeprecation')) {
  	        throw new Error(msg);
  	      } else if (config('traceDeprecation')) {
  	        console.trace(msg);
  	      } else {
  	        console.warn(msg);
  	      }
  	      warned = true;
  	    }
  	    return fn.apply(this, arguments);
  	  }
  
  	  return deprecated;
  	}
  
  	/**
  	 * Checks `localStorage` for boolean values for the given `name`.
  	 *
  	 * @param {String} name
  	 * @returns {Boolean}
  	 * @api private
  	 */
  
  	function config (name) {
  	  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
  	  try {
  	    if (!global.localStorage) return false;
  	  } catch (_) {
  	    return false;
  	  }
  	  var val = global.localStorage[name];
  	  if (null == val) return false;
  	  return String(val).toLowerCase() === 'true';
  	}
  
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ }),
  /* 62 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// 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.
  
  	'use strict';
  
  	/*<replacement>*/
  
  	var Buffer = __webpack_require__(51).Buffer;
  	/*</replacement>*/
  
  	var isEncoding = Buffer.isEncoding || function (encoding) {
  	  encoding = '' + 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 _normalizeEncoding(enc) {
  	  if (!enc) return 'utf8';
  	  var retried;
  	  while (true) {
  	    switch (enc) {
  	      case 'utf8':
  	      case 'utf-8':
  	        return 'utf8';
  	      case 'ucs2':
  	      case 'ucs-2':
  	      case 'utf16le':
  	      case 'utf-16le':
  	        return 'utf16le';
  	      case 'latin1':
  	      case 'binary':
  	        return 'latin1';
  	      case 'base64':
  	      case 'ascii':
  	      case 'hex':
  	        return enc;
  	      default:
  	        if (retried) return; // undefined
  	        enc = ('' + enc).toLowerCase();
  	        retried = true;
  	    }
  	  }
  	};
  
  	// Do not cache `Buffer.isEncoding` when checking encoding names as some
  	// modules monkey-patch it to support additional encodings
  	function normalizeEncoding(enc) {
  	  var nenc = _normalizeEncoding(enc);
  	  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
  	  return nenc || enc;
  	}
  
  	// StringDecoder provides an interface for efficiently splitting a series of
  	// buffers into a series of JS strings without breaking apart multi-byte
  	// characters.
  	exports.StringDecoder = StringDecoder;
  	function StringDecoder(encoding) {
  	  this.encoding = normalizeEncoding(encoding);
  	  var nb;
  	  switch (this.encoding) {
  	    case 'utf16le':
  	      this.text = utf16Text;
  	      this.end = utf16End;
  	      nb = 4;
  	      break;
  	    case 'utf8':
  	      this.fillLast = utf8FillLast;
  	      nb = 4;
  	      break;
  	    case 'base64':
  	      this.text = base64Text;
  	      this.end = base64End;
  	      nb = 3;
  	      break;
  	    default:
  	      this.write = simpleWrite;
  	      this.end = simpleEnd;
  	      return;
  	  }
  	  this.lastNeed = 0;
  	  this.lastTotal = 0;
  	  this.lastChar = Buffer.allocUnsafe(nb);
  	}
  
  	StringDecoder.prototype.write = function (buf) {
  	  if (buf.length === 0) return '';
  	  var r;
  	  var i;
  	  if (this.lastNeed) {
  	    r = this.fillLast(buf);
  	    if (r === undefined) return '';
  	    i = this.lastNeed;
  	    this.lastNeed = 0;
  	  } else {
  	    i = 0;
  	  }
  	  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
  	  return r || '';
  	};
  
  	StringDecoder.prototype.end = utf8End;
  
  	// Returns only complete characters in a Buffer
  	StringDecoder.prototype.text = utf8Text;
  
  	// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
  	StringDecoder.prototype.fillLast = function (buf) {
  	  if (this.lastNeed <= buf.length) {
  	    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
  	    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
  	  }
  	  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
  	  this.lastNeed -= buf.length;
  	};
  
  	// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
  	// continuation byte. If an invalid byte is detected, -2 is returned.
  	function utf8CheckByte(byte) {
  	  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
  	  return byte >> 6 === 0x02 ? -1 : -2;
  	}
  
  	// Checks at most 3 bytes at the end of a Buffer in order to detect an
  	// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
  	// needed to complete the UTF-8 character (if applicable) are returned.
  	function utf8CheckIncomplete(self, buf, i) {
  	  var j = buf.length - 1;
  	  if (j < i) return 0;
  	  var nb = utf8CheckByte(buf[j]);
  	  if (nb >= 0) {
  	    if (nb > 0) self.lastNeed = nb - 1;
  	    return nb;
  	  }
  	  if (--j < i || nb === -2) return 0;
  	  nb = utf8CheckByte(buf[j]);
  	  if (nb >= 0) {
  	    if (nb > 0) self.lastNeed = nb - 2;
  	    return nb;
  	  }
  	  if (--j < i || nb === -2) return 0;
  	  nb = utf8CheckByte(buf[j]);
  	  if (nb >= 0) {
  	    if (nb > 0) {
  	      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
  	    }
  	    return nb;
  	  }
  	  return 0;
  	}
  
  	// Validates as many continuation bytes for a multi-byte UTF-8 character as
  	// needed or are available. If we see a non-continuation byte where we expect
  	// one, we "replace" the validated continuation bytes we've seen so far with
  	// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
  	// behavior. The continuation byte check is included three times in the case
  	// where all of the continuation bytes for a character exist in the same buffer.
  	// It is also done this way as a slight performance increase instead of using a
  	// loop.
  	function utf8CheckExtraBytes(self, buf, p) {
  	  if ((buf[0] & 0xC0) !== 0x80) {
  	    self.lastNeed = 0;
  	    return '\ufffd';
  	  }
  	  if (self.lastNeed > 1 && buf.length > 1) {
  	    if ((buf[1] & 0xC0) !== 0x80) {
  	      self.lastNeed = 1;
  	      return '\ufffd';
  	    }
  	    if (self.lastNeed > 2 && buf.length > 2) {
  	      if ((buf[2] & 0xC0) !== 0x80) {
  	        self.lastNeed = 2;
  	        return '\ufffd';
  	      }
  	    }
  	  }
  	}
  
  	// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
  	function utf8FillLast(buf) {
  	  var p = this.lastTotal - this.lastNeed;
  	  var r = utf8CheckExtraBytes(this, buf, p);
  	  if (r !== undefined) return r;
  	  if (this.lastNeed <= buf.length) {
  	    buf.copy(this.lastChar, p, 0, this.lastNeed);
  	    return this.lastChar.toString(this.encoding, 0, this.lastTotal);
  	  }
  	  buf.copy(this.lastChar, p, 0, buf.length);
  	  this.lastNeed -= buf.length;
  	}
  
  	// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
  	// partial character, the character's bytes are buffered until the required
  	// number of bytes are available.
  	function utf8Text(buf, i) {
  	  var total = utf8CheckIncomplete(this, buf, i);
  	  if (!this.lastNeed) return buf.toString('utf8', i);
  	  this.lastTotal = total;
  	  var end = buf.length - (total - this.lastNeed);
  	  buf.copy(this.lastChar, 0, end);
  	  return buf.toString('utf8', i, end);
  	}
  
  	// For UTF-8, a replacement character is added when ending on a partial
  	// character.
  	function utf8End(buf) {
  	  var r = buf && buf.length ? this.write(buf) : '';
  	  if (this.lastNeed) return r + '\ufffd';
  	  return r;
  	}
  
  	// UTF-16LE typically needs two bytes per character, but even if we have an even
  	// number of bytes available, we need to check if we end on a leading/high
  	// surrogate. In that case, we need to wait for the next two bytes in order to
  	// decode the last character properly.
  	function utf16Text(buf, i) {
  	  if ((buf.length - i) % 2 === 0) {
  	    var r = buf.toString('utf16le', i);
  	    if (r) {
  	      var c = r.charCodeAt(r.length - 1);
  	      if (c >= 0xD800 && c <= 0xDBFF) {
  	        this.lastNeed = 2;
  	        this.lastTotal = 4;
  	        this.lastChar[0] = buf[buf.length - 2];
  	        this.lastChar[1] = buf[buf.length - 1];
  	        return r.slice(0, -1);
  	      }
  	    }
  	    return r;
  	  }
  	  this.lastNeed = 1;
  	  this.lastTotal = 2;
  	  this.lastChar[0] = buf[buf.length - 1];
  	  return buf.toString('utf16le', i, buf.length - 1);
  	}
  
  	// For UTF-16LE we do not explicitly append special replacement characters if we
  	// end on a partial character, we simply let v8 handle that.
  	function utf16End(buf) {
  	  var r = buf && buf.length ? this.write(buf) : '';
  	  if (this.lastNeed) {
  	    var end = this.lastTotal - this.lastNeed;
  	    return r + this.lastChar.toString('utf16le', 0, end);
  	  }
  	  return r;
  	}
  
  	function base64Text(buf, i) {
  	  var n = (buf.length - i) % 3;
  	  if (n === 0) return buf.toString('base64', i);
  	  this.lastNeed = 3 - n;
  	  this.lastTotal = 3;
  	  if (n === 1) {
  	    this.lastChar[0] = buf[buf.length - 1];
  	  } else {
  	    this.lastChar[0] = buf[buf.length - 2];
  	    this.lastChar[1] = buf[buf.length - 1];
  	  }
  	  return buf.toString('base64', i, buf.length - n);
  	}
  
  	function base64End(buf) {
  	  var r = buf && buf.length ? this.write(buf) : '';
  	  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
  	  return r;
  	}
  
  	// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
  	function simpleWrite(buf) {
  	  return buf.toString(this.encoding);
  	}
  
  	function simpleEnd(buf) {
  	  return buf && buf.length ? this.write(buf) : '';
  	}
  
  /***/ }),
  /* 63 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// 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.
  
  	'use strict';
  
  	module.exports = Transform;
  
  	var Duplex = __webpack_require__(57);
  
  	/*<replacement>*/
  	var util = __webpack_require__(52);
  	util.inherits = __webpack_require__(45);
  	/*</replacement>*/
  
  	util.inherits(Transform, Duplex);
  
  	function afterTransform(er, data) {
  	  var ts = this._transformState;
  	  ts.transforming = false;
  
  	  var cb = ts.writecb;
  
  	  if (!cb) {
  	    return this.emit('error', new Error('write callback called multiple times'));
  	  }
  
  	  ts.writechunk = null;
  	  ts.writecb = null;
  
  	  if (data != null) // single equals check for both `null` and `undefined`
  	    this.push(data);
  
  	  cb(er);
  
  	  var rs = this._readableState;
  	  rs.reading = false;
  	  if (rs.needReadable || rs.length < rs.highWaterMark) {
  	    this._read(rs.highWaterMark);
  	  }
  	}
  
  	function Transform(options) {
  	  if (!(this instanceof Transform)) return new Transform(options);
  
  	  Duplex.call(this, options);
  
  	  this._transformState = {
  	    afterTransform: afterTransform.bind(this),
  	    needTransform: false,
  	    transforming: false,
  	    writecb: null,
  	    writechunk: null,
  	    writeencoding: null
  	  };
  
  	  // 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;
  
  	  if (options) {
  	    if (typeof options.transform === 'function') this._transform = options.transform;
  
  	    if (typeof options.flush === 'function') this._flush = options.flush;
  	  }
  
  	  // When the writable side finishes, then flush out anything remaining.
  	  this.on('prefinish', prefinish);
  	}
  
  	function prefinish() {
  	  var _this = this;
  
  	  if (typeof this._flush === 'function') {
  	    this._flush(function (er, data) {
  	      done(_this, er, data);
  	    });
  	  } else {
  	    done(this, null, null);
  	  }
  	}
  
  	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('_transform() is 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;
  	  }
  	};
  
  	Transform.prototype._destroy = function (err, cb) {
  	  var _this2 = this;
  
  	  Duplex.prototype._destroy.call(this, err, function (err2) {
  	    cb(err2);
  	    _this2.emit('close');
  	  });
  	};
  
  	function done(stream, er, data) {
  	  if (er) return stream.emit('error', er);
  
  	  if (data != null) // single equals check for both `null` and `undefined`
  	    stream.push(data);
  
  	  // if there's nothing in the write buffer, then that means
  	  // that nothing more will ever be provided
  	  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
  
  	  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
  
  	  return stream.push(null);
  	}
  
  /***/ }),
  /* 64 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// 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.
  
  	'use strict';
  
  	module.exports = PassThrough;
  
  	var Transform = __webpack_require__(63);
  
  	/*<replacement>*/
  	var util = __webpack_require__(52);
  	util.inherits = __webpack_require__(45);
  	/*</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);
  	};
  
  /***/ }),
  /* 65 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(58);
  
  
  /***/ }),
  /* 66 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(57);
  
  
  /***/ }),
  /* 67 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(46).Transform
  
  
  /***/ }),
  /* 68 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	module.exports = __webpack_require__(46).PassThrough
  
  
  /***/ }),
  /* 69 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	// 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 = __webpack_require__(39).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;
  	}
  
  
  /***/ }),
  /* 70 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  "use strict";
  	  exports.stripBOM = function(str) {
  	    if (str[0] === '\uFEFF') {
  	      return str.substring(1);
  	    } else {
  	      return str;
  	    }
  	  };
  
  	}).call(this);
  
  
  /***/ }),
  /* 71 */
  /***/ (function(module, exports) {
  
  	// Generated by CoffeeScript 1.12.7
  	(function() {
  	  "use strict";
  	  var prefixMatch;
  
  	  prefixMatch = new RegExp(/(?!xmlns)^.*:/);
  
  	  exports.normalize = function(str) {
  	    return str.toLowerCase();
  	  };
  
  	  exports.firstCharLowerCase = function(str) {
  	    return str.charAt(0).toLowerCase() + str.slice(1);
  	  };
  
  	  exports.stripPrefix = function(str) {
  	    return str.replace(prefixMatch, '');
  	  };
  
  	  exports.parseNumbers = function(str) {
  	    if (!isNaN(str)) {
  	      str = str % 1 === 0 ? parseInt(str, 10) : parseFloat(str);
  	    }
  	    return str;
  	  };
  
  	  exports.parseBooleans = function(str) {
  	    if (/^(?:true|false)$/i.test(str)) {
  	      str = str.toLowerCase() === 'true';
  	    }
  	    return str;
  	  };
  
  	}).call(this);
  
  
  /***/ }),
  /* 72 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var define = __webpack_require__(73);
  	var util = __webpack_require__(77);
  
  	var implementation = __webpack_require__(80);
  	var getPolyfill = __webpack_require__(126);
  	var polyfill = getPolyfill();
  	var shim = __webpack_require__(127);
  
  	/* eslint-disable no-unused-vars */
  	var boundPromisify = function promisify(orig) {
  	/* eslint-enable no-unused-vars */
  		return polyfill.apply(util, arguments);
  	};
  	define(boundPromisify, {
  		custom: polyfill.custom,
  		customPromisifyArgs: polyfill.customPromisifyArgs,
  		getPolyfill: getPolyfill,
  		implementation: implementation,
  		shim: shim
  	});
  
  	module.exports = boundPromisify;
  
  
  /***/ }),
  /* 73 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var keys = __webpack_require__(74);
  	var hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
  
  	var toStr = Object.prototype.toString;
  	var concat = Array.prototype.concat;
  	var origDefineProperty = Object.defineProperty;
  
  	var isFunction = function (fn) {
  		return typeof fn === 'function' && toStr.call(fn) === '[object Function]';
  	};
  
  	var arePropertyDescriptorsSupported = function () {
  		var obj = {};
  		try {
  			origDefineProperty(obj, 'x', { enumerable: false, value: obj });
  			// eslint-disable-next-line no-unused-vars, no-restricted-syntax
  			for (var _ in obj) { // jscs:ignore disallowUnusedVariables
  				return false;
  			}
  			return obj.x === obj;
  		} catch (e) { /* this is IE 8. */
  			return false;
  		}
  	};
  	var supportsDescriptors = origDefineProperty && arePropertyDescriptorsSupported();
  
  	var defineProperty = function (object, name, value, predicate) {
  		if (name in object && (!isFunction(predicate) || !predicate())) {
  			return;
  		}
  		if (supportsDescriptors) {
  			origDefineProperty(object, name, {
  				configurable: true,
  				enumerable: false,
  				value: value,
  				writable: true
  			});
  		} else {
  			object[name] = value;
  		}
  	};
  
  	var defineProperties = function (object, map) {
  		var predicates = arguments.length > 2 ? arguments[2] : {};
  		var props = keys(map);
  		if (hasSymbols) {
  			props = concat.call(props, Object.getOwnPropertySymbols(map));
  		}
  		for (var i = 0; i < props.length; i += 1) {
  			defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
  		}
  	};
  
  	defineProperties.supportsDescriptors = !!supportsDescriptors;
  
  	module.exports = defineProperties;
  
  
  /***/ }),
  /* 74 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var slice = Array.prototype.slice;
  	var isArgs = __webpack_require__(75);
  
  	var origKeys = Object.keys;
  	var keysShim = origKeys ? function keys(o) { return origKeys(o); } : __webpack_require__(76);
  
  	var originalKeys = Object.keys;
  
  	keysShim.shim = function shimObjectKeys() {
  		if (Object.keys) {
  			var keysWorksWithArguments = (function () {
  				// Safari 5.0 bug
  				var args = Object.keys(arguments);
  				return args && args.length === arguments.length;
  			}(1, 2));
  			if (!keysWorksWithArguments) {
  				Object.keys = function keys(object) { // eslint-disable-line func-name-matching
  					if (isArgs(object)) {
  						return originalKeys(slice.call(object));
  					}
  					return originalKeys(object);
  				};
  			}
  		} else {
  			Object.keys = keysShim;
  		}
  		return Object.keys || keysShim;
  	};
  
  	module.exports = keysShim;
  
  
  /***/ }),
  /* 75 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	var toStr = Object.prototype.toString;
  
  	module.exports = function isArguments(value) {
  		var str = toStr.call(value);
  		var isArgs = str === '[object Arguments]';
  		if (!isArgs) {
  			isArgs = str !== '[object Array]' &&
  				value !== null &&
  				typeof value === 'object' &&
  				typeof value.length === 'number' &&
  				value.length >= 0 &&
  				toStr.call(value.callee) === '[object Function]';
  		}
  		return isArgs;
  	};
  
  
  /***/ }),
  /* 76 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var keysShim;
  	if (!Object.keys) {
  		// modified from https://github.com/es-shims/es5-shim
  		var has = Object.prototype.hasOwnProperty;
  		var toStr = Object.prototype.toString;
  		var isArgs = __webpack_require__(75); // eslint-disable-line global-require
  		var isEnumerable = Object.prototype.propertyIsEnumerable;
  		var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
  		var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
  		var dontEnums = [
  			'toString',
  			'toLocaleString',
  			'valueOf',
  			'hasOwnProperty',
  			'isPrototypeOf',
  			'propertyIsEnumerable',
  			'constructor'
  		];
  		var equalsConstructorPrototype = function (o) {
  			var ctor = o.constructor;
  			return ctor && ctor.prototype === o;
  		};
  		var excludedKeys = {
  			$applicationCache: true,
  			$console: true,
  			$external: true,
  			$frame: true,
  			$frameElement: true,
  			$frames: true,
  			$innerHeight: true,
  			$innerWidth: true,
  			$onmozfullscreenchange: true,
  			$onmozfullscreenerror: true,
  			$outerHeight: true,
  			$outerWidth: true,
  			$pageXOffset: true,
  			$pageYOffset: true,
  			$parent: true,
  			$scrollLeft: true,
  			$scrollTop: true,
  			$scrollX: true,
  			$scrollY: true,
  			$self: true,
  			$webkitIndexedDB: true,
  			$webkitStorageInfo: true,
  			$window: true
  		};
  		var hasAutomationEqualityBug = (function () {
  			/* global window */
  			if (typeof window === 'undefined') { return false; }
  			for (var k in window) {
  				try {
  					if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
  						try {
  							equalsConstructorPrototype(window[k]);
  						} catch (e) {
  							return true;
  						}
  					}
  				} catch (e) {
  					return true;
  				}
  			}
  			return false;
  		}());
  		var equalsConstructorPrototypeIfNotBuggy = function (o) {
  			/* global window */
  			if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
  				return equalsConstructorPrototype(o);
  			}
  			try {
  				return equalsConstructorPrototype(o);
  			} catch (e) {
  				return false;
  			}
  		};
  
  		keysShim = function keys(object) {
  			var isObject = object !== null && typeof object === 'object';
  			var isFunction = toStr.call(object) === '[object Function]';
  			var isArguments = isArgs(object);
  			var isString = isObject && toStr.call(object) === '[object String]';
  			var theKeys = [];
  
  			if (!isObject && !isFunction && !isArguments) {
  				throw new TypeError('Object.keys called on a non-object');
  			}
  
  			var skipProto = hasProtoEnumBug && isFunction;
  			if (isString && object.length > 0 && !has.call(object, 0)) {
  				for (var i = 0; i < object.length; ++i) {
  					theKeys.push(String(i));
  				}
  			}
  
  			if (isArguments && object.length > 0) {
  				for (var j = 0; j < object.length; ++j) {
  					theKeys.push(String(j));
  				}
  			} else {
  				for (var name in object) {
  					if (!(skipProto && name === 'prototype') && has.call(object, name)) {
  						theKeys.push(String(name));
  					}
  				}
  			}
  
  			if (hasDontEnumBug) {
  				var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
  
  				for (var k = 0; k < dontEnums.length; ++k) {
  					if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
  						theKeys.push(dontEnums[k]);
  					}
  				}
  			}
  			return theKeys;
  		};
  	}
  	module.exports = keysShim;
  
  
  /***/ }),
  /* 77 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global, 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.
  
  	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 = __webpack_require__(78);
  
  	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 = __webpack_require__(79);
  
  	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);
  	}
  
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(48)))
  
  /***/ }),
  /* 78 */
  /***/ (function(module, exports) {
  
  	module.exports = function isBuffer(arg) {
  	  return arg && typeof arg === 'object'
  	    && typeof arg.copy === 'function'
  	    && typeof arg.fill === 'function'
  	    && typeof arg.readUInt8 === 'function';
  	}
  
  /***/ }),
  /* 79 */
  /***/ (function(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
  	  }
  	}
  
  
  /***/ }),
  /* 80 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var isES5 = typeof Object.defineProperty === 'function'
  		&& typeof Object.defineProperties === 'function'
  		&& typeof Object.getPrototypeOf === 'function'
  		&& typeof Object.setPrototypeOf === 'function';
  
  	if (!isES5) {
  		throw new TypeError('util.promisify requires a true ES5 environment');
  	}
  
  	var getOwnPropertyDescriptors = __webpack_require__(81);
  
  	if (typeof Promise !== 'function') {
  		throw new TypeError('`Promise` must be globally available for util.promisify to work.');
  	}
  
  	var slice = Function.call.bind(Array.prototype.slice);
  	var concat = Function.call.bind(Array.prototype.concat);
  	var forEach = Function.call.bind(Array.prototype.forEach);
  
  	var hasSymbols = typeof Symbol === 'function' && typeof Symbol('') === 'symbol';
  
  	var kCustomPromisifiedSymbol = hasSymbols ? Symbol('util.promisify.custom') : null;
  	var kCustomPromisifyArgsSymbol = hasSymbols ? Symbol('customPromisifyArgs') : null;
  
  	module.exports = function promisify(orig) {
  		if (typeof orig !== 'function') {
  			var error = new TypeError('The "original" argument must be of type function');
  			error.name = 'TypeError [ERR_INVALID_ARG_TYPE]';
  			error.code = 'ERR_INVALID_ARG_TYPE';
  			throw error;
  		}
  
  		if (hasSymbols && orig[kCustomPromisifiedSymbol]) {
  			var customFunction = orig[kCustomPromisifiedSymbol];
  			if (typeof customFunction !== 'function') {
  				throw new TypeError('The [util.promisify.custom] property must be a function');
  			}
  			Object.defineProperty(customFunction, kCustomPromisifiedSymbol, {
  				configurable: true,
  				enumerable: false,
  				value: customFunction,
  				writable: false
  			});
  			return customFunction;
  		}
  
  		// Names to create an object from in case the callback receives multiple
  		// arguments, e.g. ['stdout', 'stderr'] for child_process.exec.
  		var argumentNames = orig[kCustomPromisifyArgsSymbol];
  
  		var promisified = function fn() {
  			var args = slice(arguments);
  			var self = this; // eslint-disable-line no-invalid-this
  			return new Promise(function (resolve, reject) {
  				orig.apply(self, concat(args, function (err) {
  					var values = arguments.length > 1 ? slice(arguments, 1) : [];
  					if (err) {
  						reject(err);
  					} else if (typeof argumentNames !== 'undefined' && values.length > 1) {
  						var obj = {};
  						forEach(argumentNames, function (name, index) {
  							obj[name] = values[index];
  						});
  						resolve(obj);
  					} else {
  						resolve(values[0]);
  					}
  				}));
  			});
  		};
  
  		Object.setPrototypeOf(promisified, Object.getPrototypeOf(orig));
  
  		Object.defineProperty(promisified, kCustomPromisifiedSymbol, {
  			configurable: true,
  			enumerable: false,
  			value: promisified,
  			writable: false
  		});
  		return Object.defineProperties(promisified, getOwnPropertyDescriptors(orig));
  	};
  
  	module.exports.custom = kCustomPromisifiedSymbol;
  	module.exports.customPromisifyArgs = kCustomPromisifyArgsSymbol;
  
  
  /***/ }),
  /* 81 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var define = __webpack_require__(73);
  
  	var implementation = __webpack_require__(82);
  	var getPolyfill = __webpack_require__(124);
  	var shim = __webpack_require__(125);
  
  	define(implementation, {
  		getPolyfill: getPolyfill,
  		implementation: implementation,
  		shim: shim
  	});
  
  	module.exports = implementation;
  
  
  /***/ }),
  /* 82 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var ES = __webpack_require__(83);
  
  	var defineProperty = Object.defineProperty;
  	var getDescriptor = Object.getOwnPropertyDescriptor;
  	var getOwnNames = Object.getOwnPropertyNames;
  	var getSymbols = Object.getOwnPropertySymbols;
  	var concat = Function.call.bind(Array.prototype.concat);
  	var reduce = Function.call.bind(Array.prototype.reduce);
  	var getAll = getSymbols ? function (obj) {
  		return concat(getOwnNames(obj), getSymbols(obj));
  	} : getOwnNames;
  
  	var isES5 = ES.IsCallable(getDescriptor) && ES.IsCallable(getOwnNames);
  
  	var safePut = function put(obj, prop, val) { // eslint-disable-line max-params
  		if (defineProperty && prop in obj) {
  			defineProperty(obj, prop, {
  				configurable: true,
  				enumerable: true,
  				value: val,
  				writable: true
  			});
  		} else {
  			obj[prop] = val;
  		}
  	};
  
  	module.exports = function getOwnPropertyDescriptors(value) {
  		ES.RequireObjectCoercible(value);
  		if (!isES5) {
  			throw new TypeError('getOwnPropertyDescriptors requires Object.getOwnPropertyDescriptor');
  		}
  
  		var O = ES.ToObject(value);
  		return reduce(getAll(O), function (acc, key) {
  			var descriptor = getDescriptor(O, key);
  			if (typeof descriptor !== 'undefined') {
  				safePut(acc, key, descriptor);
  			}
  			return acc;
  		}, {});
  	};
  
  
  /***/ }),
  /* 83 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	module.exports = __webpack_require__(84);
  
  
  /***/ }),
  /* 84 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var ES2015 = __webpack_require__(85);
  	var GetIntrinsic = __webpack_require__(99);
  	var assign = __webpack_require__(104);
  	var $setProto = __webpack_require__(118);
  
  	var callBound = __webpack_require__(112);
  	var getIteratorMethod = __webpack_require__(115);
  
  	var $TypeError = GetIntrinsic('%TypeError%');
  	var $arrayPush = callBound('Array.prototype.push');
  	var $getProto = __webpack_require__(123);
  
  	var ES2016 = assign(assign({}, ES2015), {
  		// https://www.ecma-international.org/ecma-262/7.0/#sec-samevaluenonnumber
  		SameValueNonNumber: function SameValueNonNumber(x, y) {
  			if (typeof x === 'number' || typeof x !== typeof y) {
  				throw new TypeError('SameValueNonNumber requires two non-number values of the same type.');
  			}
  			return this.SameValue(x, y);
  		},
  
  		// https://www.ecma-international.org/ecma-262/7.0/#sec-iterabletoarraylike
  		IterableToArrayLike: function IterableToArrayLike(items) {
  			var usingIterator = getIteratorMethod(this, items);
  			if (typeof usingIterator !== 'undefined') {
  				var iterator = this.GetIterator(items, usingIterator);
  				var values = [];
  				var next = true;
  				while (next) {
  					next = this.IteratorStep(iterator);
  					if (next) {
  						var nextValue = this.IteratorValue(next);
  						$arrayPush(values, nextValue);
  					}
  				}
  				return values;
  			}
  
  			return this.ToObject(items);
  		},
  
  		// https://ecma-international.org/ecma-262/7.0/#sec-ordinarygetprototypeof
  		OrdinaryGetPrototypeOf: function (O) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: O must be an Object');
  			}
  			if (!$getProto) {
  				throw new $TypeError('This environment does not support fetching prototypes.');
  			}
  			return $getProto(O);
  		},
  
  		// https://ecma-international.org/ecma-262/7.0/#sec-ordinarysetprototypeof
  		OrdinarySetPrototypeOf: function (O, V) {
  			if (this.Type(V) !== 'Object' && this.Type(V) !== 'Null') {
  				throw new $TypeError('Assertion failed: V must be Object or Null');
  			}
  			/*
  			var extensible = this.IsExtensible(O);
  			var current = this.OrdinaryGetPrototypeOf(O);
  			if (this.SameValue(V, current)) {
  				return true;
  			}
  			if (!extensible) {
  				return false;
  			}
  			*/
  			try {
  				$setProto(O, V);
  			} catch (e) {
  				return false;
  			}
  			return this.OrdinaryGetPrototypeOf(O) === V;
  			/*
  			var p = V;
  			var done = false;
  			while (!done) {
  				if (p === null) {
  					done = true;
  				} else if (this.SameValue(p, O)) {
  					return false;
  				} else {
  					if (wat) {
  						done = true;
  					} else {
  						p = p.[[Prototype]];
  					}
  				}
  			 }
  			 O.[[Prototype]] = V;
  			 return true;
  			 */
  		}
  	});
  
  	module.exports = ES2016;
  
  
  /***/ }),
  /* 85 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var has = __webpack_require__(86);
  	var toPrimitive = __webpack_require__(89);
  	var keys = __webpack_require__(74);
  	var inspect = __webpack_require__(97);
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var $TypeError = GetIntrinsic('%TypeError%');
  	var $RangeError = GetIntrinsic('%RangeError%');
  	var $SyntaxError = GetIntrinsic('%SyntaxError%');
  	var $Array = GetIntrinsic('%Array%');
  	var $ArrayPrototype = $Array.prototype;
  	var $String = GetIntrinsic('%String%');
  	var $Object = GetIntrinsic('%Object%');
  	var $Number = GetIntrinsic('%Number%');
  	var $Symbol = GetIntrinsic('%Symbol%', true);
  	var $RegExp = GetIntrinsic('%RegExp%');
  	var $Date = GetIntrinsic('%Date%');
  	var $Function = GetIntrinsic('%Function%');
  	var $preventExtensions = $Object.preventExtensions;
  
  	var hasSymbols = __webpack_require__(95)();
  
  	var assertRecord = __webpack_require__(100);
  	var $isNaN = __webpack_require__(101);
  	var $isFinite = __webpack_require__(102);
  	var MAX_ARRAY_LENGTH = Math.pow(2, 32) - 1;
  	var MAX_SAFE_INTEGER = __webpack_require__(103);
  
  	var assign = __webpack_require__(104);
  	var sign = __webpack_require__(105);
  	var mod = __webpack_require__(106);
  	var isPrimitive = __webpack_require__(107);
  	var forEach = __webpack_require__(108);
  	var every = __webpack_require__(109);
  	var isSamePropertyDescriptor = __webpack_require__(110);
  	var isPropertyDescriptor = __webpack_require__(111);
  	var parseInteger = parseInt;
  	var callBound = __webpack_require__(112);
  	var regexTester = __webpack_require__(114);
  	var getIteratorMethod = __webpack_require__(115);
  	var getSymbolDescription = __webpack_require__(116);
  
  	var $PromiseThen = callBound('Promise.prototype.then', true);
  	var arraySlice = callBound('Array.prototype.slice');
  	var strSlice = callBound('String.prototype.slice');
  	var $indexOf = callBound('Array.prototype.indexOf');
  	var $push = callBound('Array.prototype.push');
  
  	var isBinary = regexTester(/^0b[01]+$/i);
  	var isOctal = regexTester(/^0o[0-7]+$/i);
  	var isDigit = regexTester(/^[0-9]$/);
  	var regexExec = callBound('RegExp.prototype.exec');
  	var nonWS = ['\u0085', '\u200b', '\ufffe'].join('');
  	var nonWSregex = new $RegExp('[' + nonWS + ']', 'g');
  	var hasNonWS = regexTester(nonWSregex);
  	var isInvalidHexLiteral = regexTester(/^[-+]0x[0-9a-f]+$/i);
  	var $charCodeAt = callBound('String.prototype.charCodeAt');
  	var $isEnumerable = callBound('Object.prototype.propertyIsEnumerable');
  
  	var toStr = callBound('Object.prototype.toString');
  
  	var $NumberValueOf = callBound('Number.prototype.valueOf');
  	var $BooleanValueOf = callBound('Boolean.prototype.valueOf');
  	var $StringValueOf = callBound('String.prototype.valueOf');
  	var $DateValueOf = callBound('Date.prototype.valueOf');
  	var $SymbolToString = callBound('Symbol.prototype.toString', true);
  
  	var $floor = Math.floor;
  	var $abs = Math.abs;
  
  	var $ObjectCreate = $Object.create;
  	var $gOPD = $Object.getOwnPropertyDescriptor;
  	var $gOPN = $Object.getOwnPropertyNames;
  	var $gOPS = $Object.getOwnPropertySymbols;
  	var $isExtensible = $Object.isExtensible;
  	var $defineProperty = $Object.defineProperty;
  	var $setProto = __webpack_require__(118);
  
  	var DefineOwnProperty = function DefineOwnProperty(ES, O, P, desc) {
  		if (!$defineProperty) {
  			if (!ES.IsDataDescriptor(desc)) {
  				// ES3 does not support getters/setters
  				return false;
  			}
  			if (!desc['[[Configurable]]'] || !desc['[[Writable]]']) {
  				return false;
  			}
  
  			// fallback for ES3
  			if (P in O && $isEnumerable(O, P) !== !!desc['[[Enumerable]]']) {
  				// a non-enumerable existing property
  				return false;
  			}
  
  			// property does not exist at all, or exists but is enumerable
  			var V = desc['[[Value]]'];
  			O[P] = V; // will use [[Define]]
  			return ES.SameValue(O[P], V);
  		}
  		$defineProperty(O, P, ES.FromPropertyDescriptor(desc));
  		return true;
  	};
  
  	// whitespace from: https://es5.github.io/#x15.5.4.20
  	// implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
  	var ws = [
  		'\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003',
  		'\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028',
  		'\u2029\uFEFF'
  	].join('');
  	var trimRegex = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');
  	var $replace = callBound('String.prototype.replace');
  	var trim = function (value) {
  		return $replace(value, trimRegex, '');
  	};
  
  	var ES5 = __webpack_require__(119);
  
  	var hasRegExpMatcher = __webpack_require__(122);
  
  	// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-abstract-operations
  	var ES6 = assign(assign({}, ES5), {
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-call-f-v-args
  		Call: function Call(F, V) {
  			var args = arguments.length > 2 ? arguments[2] : [];
  			if (!this.IsCallable(F)) {
  				throw new $TypeError(inspect(F) + ' is not a function');
  			}
  			return F.apply(V, args);
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toprimitive
  		ToPrimitive: toPrimitive,
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toboolean
  		// ToBoolean: ES5.ToBoolean,
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-tonumber
  		ToNumber: function ToNumber(argument) {
  			var value = isPrimitive(argument) ? argument : toPrimitive(argument, $Number);
  			if (typeof value === 'symbol') {
  				throw new $TypeError('Cannot convert a Symbol value to a number');
  			}
  			if (typeof value === 'string') {
  				if (isBinary(value)) {
  					return this.ToNumber(parseInteger(strSlice(value, 2), 2));
  				} else if (isOctal(value)) {
  					return this.ToNumber(parseInteger(strSlice(value, 2), 8));
  				} else if (hasNonWS(value) || isInvalidHexLiteral(value)) {
  					return NaN;
  				} else {
  					var trimmed = trim(value);
  					if (trimmed !== value) {
  						return this.ToNumber(trimmed);
  					}
  				}
  			}
  			return $Number(value);
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tointeger
  		// ToInteger: ES5.ToNumber,
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint32
  		// ToInt32: ES5.ToInt32,
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint32
  		// ToUint32: ES5.ToUint32,
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint16
  		ToInt16: function ToInt16(argument) {
  			var int16bit = this.ToUint16(argument);
  			return int16bit >= 0x8000 ? int16bit - 0x10000 : int16bit;
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint16
  		// ToUint16: ES5.ToUint16,
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toint8
  		ToInt8: function ToInt8(argument) {
  			var int8bit = this.ToUint8(argument);
  			return int8bit >= 0x80 ? int8bit - 0x100 : int8bit;
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint8
  		ToUint8: function ToUint8(argument) {
  			var number = this.ToNumber(argument);
  			if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
  			var posInt = sign(number) * $floor($abs(number));
  			return mod(posInt, 0x100);
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-touint8clamp
  		ToUint8Clamp: function ToUint8Clamp(argument) {
  			var number = this.ToNumber(argument);
  			if ($isNaN(number) || number <= 0) { return 0; }
  			if (number >= 0xFF) { return 0xFF; }
  			var f = $floor(argument);
  			if (f + 0.5 < number) { return f + 1; }
  			if (number < f + 0.5) { return f; }
  			if (f % 2 !== 0) { return f + 1; }
  			return f;
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tostring
  		ToString: function ToString(argument) {
  			if (typeof argument === 'symbol') {
  				throw new $TypeError('Cannot convert a Symbol value to a string');
  			}
  			return $String(argument);
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-toobject
  		ToObject: function ToObject(value) {
  			this.RequireObjectCoercible(value);
  			return $Object(value);
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-topropertykey
  		ToPropertyKey: function ToPropertyKey(argument) {
  			var key = this.ToPrimitive(argument, $String);
  			return typeof key === 'symbol' ? key : this.ToString(key);
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
  		ToLength: function ToLength(argument) {
  			var len = this.ToInteger(argument);
  			if (len <= 0) { return 0; } // includes converting -0 to +0
  			if (len > MAX_SAFE_INTEGER) { return MAX_SAFE_INTEGER; }
  			return len;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-canonicalnumericindexstring
  		CanonicalNumericIndexString: function CanonicalNumericIndexString(argument) {
  			if (toStr(argument) !== '[object String]') {
  				throw new $TypeError('must be a string');
  			}
  			if (argument === '-0') { return -0; }
  			var n = this.ToNumber(argument);
  			if (this.SameValue(this.ToString(n), argument)) { return n; }
  			return void 0;
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-requireobjectcoercible
  		RequireObjectCoercible: ES5.CheckObjectCoercible,
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isarray
  		IsArray: $Array.isArray || function IsArray(argument) {
  			return toStr(argument) === '[object Array]';
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-iscallable
  		// IsCallable: ES5.IsCallable,
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor
  		IsConstructor: function IsConstructor(argument) {
  			return typeof argument === 'function' && !!argument.prototype; // unfortunately there's no way to truly check this without try/catch `new argument` or Proxy
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isextensible-o
  		IsExtensible: $preventExtensions
  			? function IsExtensible(obj) {
  				if (isPrimitive(obj)) {
  					return false;
  				}
  				return $isExtensible(obj);
  			}
  			: function isExtensible(obj) { return true; }, // eslint-disable-line no-unused-vars
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isinteger
  		IsInteger: function IsInteger(argument) {
  			if (typeof argument !== 'number' || $isNaN(argument) || !$isFinite(argument)) {
  				return false;
  			}
  			var abs = $abs(argument);
  			return $floor(abs) === abs;
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ispropertykey
  		IsPropertyKey: function IsPropertyKey(argument) {
  			return typeof argument === 'string' || typeof argument === 'symbol';
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-isregexp
  		IsRegExp: function IsRegExp(argument) {
  			if (!argument || typeof argument !== 'object') {
  				return false;
  			}
  			if (hasSymbols) {
  				var isRegExp = argument[$Symbol.match];
  				if (typeof isRegExp !== 'undefined') {
  					return ES5.ToBoolean(isRegExp);
  				}
  			}
  			return hasRegExpMatcher(argument);
  		},
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevalue
  		// SameValue: ES5.SameValue,
  
  		// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero
  		SameValueZero: function SameValueZero(x, y) {
  			return (x === y) || ($isNaN(x) && $isNaN(y));
  		},
  
  		/**
  		 * 7.3.2 GetV (V, P)
  		 * 1. Assert: IsPropertyKey(P) is true.
  		 * 2. Let O be ToObject(V).
  		 * 3. ReturnIfAbrupt(O).
  		 * 4. Return O.[[Get]](P, V).
  		 */
  		GetV: function GetV(V, P) {
  			// 7.3.2.1
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
  			}
  
  			// 7.3.2.2-3
  			var O = this.ToObject(V);
  
  			// 7.3.2.4
  			return O[P];
  		},
  
  		/**
  		 * 7.3.9 - https://ecma-international.org/ecma-262/6.0/#sec-getmethod
  		 * 1. Assert: IsPropertyKey(P) is true.
  		 * 2. Let func be GetV(O, P).
  		 * 3. ReturnIfAbrupt(func).
  		 * 4. If func is either undefined or null, return undefined.
  		 * 5. If IsCallable(func) is false, throw a TypeError exception.
  		 * 6. Return func.
  		 */
  		GetMethod: function GetMethod(O, P) {
  			// 7.3.9.1
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
  			}
  
  			// 7.3.9.2
  			var func = this.GetV(O, P);
  
  			// 7.3.9.4
  			if (func == null) {
  				return void 0;
  			}
  
  			// 7.3.9.5
  			if (!this.IsCallable(func)) {
  				throw new $TypeError(P + 'is not a function');
  			}
  
  			// 7.3.9.6
  			return func;
  		},
  
  		/**
  		 * 7.3.1 Get (O, P) - https://ecma-international.org/ecma-262/6.0/#sec-get-o-p
  		 * 1. Assert: Type(O) is Object.
  		 * 2. Assert: IsPropertyKey(P) is true.
  		 * 3. Return O.[[Get]](P, O).
  		 */
  		Get: function Get(O, P) {
  			// 7.3.1.1
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			// 7.3.1.2
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true, got ' + inspect(P));
  			}
  			// 7.3.1.3
  			return O[P];
  		},
  
  		Type: function Type(x) {
  			if (typeof x === 'symbol') {
  				return 'Symbol';
  			}
  			return ES5.Type(x);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-speciesconstructor
  		SpeciesConstructor: function SpeciesConstructor(O, defaultConstructor) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			var C = O.constructor;
  			if (typeof C === 'undefined') {
  				return defaultConstructor;
  			}
  			if (this.Type(C) !== 'Object') {
  				throw new $TypeError('O.constructor is not an Object');
  			}
  			var S = hasSymbols && $Symbol.species ? C[$Symbol.species] : void 0;
  			if (S == null) {
  				return defaultConstructor;
  			}
  			if (this.IsConstructor(S)) {
  				return S;
  			}
  			throw new $TypeError('no constructor found');
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-frompropertydescriptor
  		FromPropertyDescriptor: function FromPropertyDescriptor(Desc) {
  			if (typeof Desc === 'undefined') {
  				return Desc;
  			}
  
  			assertRecord(this, 'Property Descriptor', 'Desc', Desc);
  
  			var obj = {};
  			if ('[[Value]]' in Desc) {
  				obj.value = Desc['[[Value]]'];
  			}
  			if ('[[Writable]]' in Desc) {
  				obj.writable = Desc['[[Writable]]'];
  			}
  			if ('[[Get]]' in Desc) {
  				obj.get = Desc['[[Get]]'];
  			}
  			if ('[[Set]]' in Desc) {
  				obj.set = Desc['[[Set]]'];
  			}
  			if ('[[Enumerable]]' in Desc) {
  				obj.enumerable = Desc['[[Enumerable]]'];
  			}
  			if ('[[Configurable]]' in Desc) {
  				obj.configurable = Desc['[[Configurable]]'];
  			}
  			return obj;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-completepropertydescriptor
  		CompletePropertyDescriptor: function CompletePropertyDescriptor(Desc) {
  			assertRecord(this, 'Property Descriptor', 'Desc', Desc);
  
  			if (this.IsGenericDescriptor(Desc) || this.IsDataDescriptor(Desc)) {
  				if (!has(Desc, '[[Value]]')) {
  					Desc['[[Value]]'] = void 0;
  				}
  				if (!has(Desc, '[[Writable]]')) {
  					Desc['[[Writable]]'] = false;
  				}
  			} else {
  				if (!has(Desc, '[[Get]]')) {
  					Desc['[[Get]]'] = void 0;
  				}
  				if (!has(Desc, '[[Set]]')) {
  					Desc['[[Set]]'] = void 0;
  				}
  			}
  			if (!has(Desc, '[[Enumerable]]')) {
  				Desc['[[Enumerable]]'] = false;
  			}
  			if (!has(Desc, '[[Configurable]]')) {
  				Desc['[[Configurable]]'] = false;
  			}
  			return Desc;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-set-o-p-v-throw
  		Set: function Set(O, P, V, Throw) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('O must be an Object');
  			}
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('P must be a Property Key');
  			}
  			if (this.Type(Throw) !== 'Boolean') {
  				throw new $TypeError('Throw must be a Boolean');
  			}
  			if (Throw) {
  				O[P] = V;
  				return true;
  			} else {
  				try {
  					O[P] = V;
  				} catch (e) {
  					return false;
  				}
  			}
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-hasownproperty
  		HasOwnProperty: function HasOwnProperty(O, P) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('O must be an Object');
  			}
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('P must be a Property Key');
  			}
  			return has(O, P);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-hasproperty
  		HasProperty: function HasProperty(O, P) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('O must be an Object');
  			}
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('P must be a Property Key');
  			}
  			return P in O;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-isconcatspreadable
  		IsConcatSpreadable: function IsConcatSpreadable(O) {
  			if (this.Type(O) !== 'Object') {
  				return false;
  			}
  			if (hasSymbols && typeof $Symbol.isConcatSpreadable === 'symbol') {
  				var spreadable = this.Get(O, Symbol.isConcatSpreadable);
  				if (typeof spreadable !== 'undefined') {
  					return this.ToBoolean(spreadable);
  				}
  			}
  			return this.IsArray(O);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-invoke
  		Invoke: function Invoke(O, P) {
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('P must be a Property Key');
  			}
  			var argumentsList = arraySlice(arguments, 2);
  			var func = this.GetV(O, P);
  			return this.Call(func, O, argumentsList);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-getiterator
  		GetIterator: function GetIterator(obj, method) {
  			var actualMethod = method;
  			if (arguments.length < 2) {
  				actualMethod = getIteratorMethod(this, obj);
  			}
  			var iterator = this.Call(actualMethod, obj);
  			if (this.Type(iterator) !== 'Object') {
  				throw new $TypeError('iterator must return an object');
  			}
  
  			return iterator;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-iteratornext
  		IteratorNext: function IteratorNext(iterator, value) {
  			var result = this.Invoke(iterator, 'next', arguments.length < 2 ? [] : [value]);
  			if (this.Type(result) !== 'Object') {
  				throw new $TypeError('iterator next must return an object');
  			}
  			return result;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-iteratorcomplete
  		IteratorComplete: function IteratorComplete(iterResult) {
  			if (this.Type(iterResult) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(iterResult) is not Object');
  			}
  			return this.ToBoolean(this.Get(iterResult, 'done'));
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-iteratorvalue
  		IteratorValue: function IteratorValue(iterResult) {
  			if (this.Type(iterResult) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(iterResult) is not Object');
  			}
  			return this.Get(iterResult, 'value');
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-iteratorstep
  		IteratorStep: function IteratorStep(iterator) {
  			var result = this.IteratorNext(iterator);
  			var done = this.IteratorComplete(result);
  			return done === true ? false : result;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-iteratorclose
  		IteratorClose: function IteratorClose(iterator, completion) {
  			if (this.Type(iterator) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(iterator) is not Object');
  			}
  			if (!this.IsCallable(completion)) {
  				throw new $TypeError('Assertion failed: completion is not a thunk for a Completion Record');
  			}
  			var completionThunk = completion;
  
  			var iteratorReturn = this.GetMethod(iterator, 'return');
  
  			if (typeof iteratorReturn === 'undefined') {
  				return completionThunk();
  			}
  
  			var completionRecord;
  			try {
  				var innerResult = this.Call(iteratorReturn, iterator, []);
  			} catch (e) {
  				// if we hit here, then "e" is the innerResult completion that needs re-throwing
  
  				// if the completion is of type "throw", this will throw.
  				completionRecord = completionThunk();
  				completionThunk = null; // ensure it's not called twice.
  
  				// if not, then return the innerResult completion
  				throw e;
  			}
  			completionRecord = completionThunk(); // if innerResult worked, then throw if the completion does
  			completionThunk = null; // ensure it's not called twice.
  
  			if (this.Type(innerResult) !== 'Object') {
  				throw new $TypeError('iterator .return must return an object');
  			}
  
  			return completionRecord;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-createiterresultobject
  		CreateIterResultObject: function CreateIterResultObject(value, done) {
  			if (this.Type(done) !== 'Boolean') {
  				throw new $TypeError('Assertion failed: Type(done) is not Boolean');
  			}
  			return {
  				value: value,
  				done: done
  			};
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-regexpexec
  		RegExpExec: function RegExpExec(R, S) {
  			if (this.Type(R) !== 'Object') {
  				throw new $TypeError('R must be an Object');
  			}
  			if (this.Type(S) !== 'String') {
  				throw new $TypeError('S must be a String');
  			}
  			var exec = this.Get(R, 'exec');
  			if (this.IsCallable(exec)) {
  				var result = this.Call(exec, R, [S]);
  				if (result === null || this.Type(result) === 'Object') {
  					return result;
  				}
  				throw new $TypeError('"exec" method must return `null` or an Object');
  			}
  			return regexExec(R, S);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-arrayspeciescreate
  		ArraySpeciesCreate: function ArraySpeciesCreate(originalArray, length) {
  			if (!this.IsInteger(length) || length < 0) {
  				throw new $TypeError('Assertion failed: length must be an integer >= 0');
  			}
  			var len = length === 0 ? 0 : length;
  			var C;
  			var isArray = this.IsArray(originalArray);
  			if (isArray) {
  				C = this.Get(originalArray, 'constructor');
  				// TODO: figure out how to make a cross-realm normal Array, a same-realm Array
  				// if (this.IsConstructor(C)) {
  				// 	if C is another realm's Array, C = undefined
  				// 	Object.getPrototypeOf(Object.getPrototypeOf(Object.getPrototypeOf(Array))) === null ?
  				// }
  				if (this.Type(C) === 'Object' && hasSymbols && $Symbol.species) {
  					C = this.Get(C, $Symbol.species);
  					if (C === null) {
  						C = void 0;
  					}
  				}
  			}
  			if (typeof C === 'undefined') {
  				return $Array(len);
  			}
  			if (!this.IsConstructor(C)) {
  				throw new $TypeError('C must be a constructor');
  			}
  			return new C(len); // this.Construct(C, len);
  		},
  
  		CreateDataProperty: function CreateDataProperty(O, P, V) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
  			}
  			var oldDesc = $gOPD(O, P);
  			var extensible = oldDesc || this.IsExtensible(O);
  			var immutable = oldDesc && (!oldDesc.writable || !oldDesc.configurable);
  			if (immutable || !extensible) {
  				return false;
  			}
  			return DefineOwnProperty(this, O, P, {
  				'[[Configurable]]': true,
  				'[[Enumerable]]': true,
  				'[[Value]]': V,
  				'[[Writable]]': true
  			});
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-createdatapropertyorthrow
  		CreateDataPropertyOrThrow: function CreateDataPropertyOrThrow(O, P, V) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
  			}
  			var success = this.CreateDataProperty(O, P, V);
  			if (!success) {
  				throw new $TypeError('unable to create data property');
  			}
  			return success;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-objectcreate
  		ObjectCreate: function ObjectCreate(proto, internalSlotsList) {
  			if (proto !== null && this.Type(proto) !== 'Object') {
  				throw new $TypeError('Assertion failed: proto must be null or an object');
  			}
  			var slots = arguments.length < 2 ? [] : internalSlotsList;
  			if (slots.length > 0) {
  				throw new $SyntaxError('es-abstract does not yet support internal slots');
  			}
  
  			if (proto === null && !$ObjectCreate) {
  				throw new $SyntaxError('native Object.create support is required to create null objects');
  			}
  
  			return $ObjectCreate(proto);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-advancestringindex
  		AdvanceStringIndex: function AdvanceStringIndex(S, index, unicode) {
  			if (this.Type(S) !== 'String') {
  				throw new $TypeError('S must be a String');
  			}
  			if (!this.IsInteger(index) || index < 0 || index > MAX_SAFE_INTEGER) {
  				throw new $TypeError('Assertion failed: length must be an integer >= 0 and <= 2**53');
  			}
  			if (this.Type(unicode) !== 'Boolean') {
  				throw new $TypeError('Assertion failed: unicode must be a Boolean');
  			}
  			if (!unicode) {
  				return index + 1;
  			}
  			var length = S.length;
  			if ((index + 1) >= length) {
  				return index + 1;
  			}
  
  			var first = $charCodeAt(S, index);
  			if (first < 0xD800 || first > 0xDBFF) {
  				return index + 1;
  			}
  
  			var second = $charCodeAt(S, index + 1);
  			if (second < 0xDC00 || second > 0xDFFF) {
  				return index + 1;
  			}
  
  			return index + 2;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-createmethodproperty
  		CreateMethodProperty: function CreateMethodProperty(O, P, V) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
  			}
  
  			var newDesc = {
  				'[[Configurable]]': true,
  				'[[Enumerable]]': false,
  				'[[Value]]': V,
  				'[[Writable]]': true
  			};
  			return DefineOwnProperty(this, O, P, newDesc);
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-definepropertyorthrow
  		DefinePropertyOrThrow: function DefinePropertyOrThrow(O, P, desc) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
  			}
  
  			var Desc = isPropertyDescriptor(this, desc) ? desc : this.ToPropertyDescriptor(desc);
  			if (!isPropertyDescriptor(this, Desc)) {
  				throw new $TypeError('Assertion failed: Desc is not a valid Property Descriptor');
  			}
  
  			return DefineOwnProperty(this, O, P, Desc);
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-deletepropertyorthrow
  		DeletePropertyOrThrow: function DeletePropertyOrThrow(O, P) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: IsPropertyKey(P) is not true');
  			}
  
  			var success = delete O[P];
  			if (!success) {
  				throw new TypeError('Attempt to delete property failed.');
  			}
  			return success;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-enumerableownnames
  		EnumerableOwnNames: function EnumerableOwnNames(O) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  
  			return keys(O);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-number-prototype-object
  		thisNumberValue: function thisNumberValue(value) {
  			if (this.Type(value) === 'Number') {
  				return value;
  			}
  
  			return $NumberValueOf(value);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-boolean-prototype-object
  		thisBooleanValue: function thisBooleanValue(value) {
  			if (this.Type(value) === 'Boolean') {
  				return value;
  			}
  
  			return $BooleanValueOf(value);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-string-prototype-object
  		thisStringValue: function thisStringValue(value) {
  			if (this.Type(value) === 'String') {
  				return value;
  			}
  
  			return $StringValueOf(value);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-date-prototype-object
  		thisTimeValue: function thisTimeValue(value) {
  			return $DateValueOf(value);
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-setintegritylevel
  		SetIntegrityLevel: function SetIntegrityLevel(O, level) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			if (level !== 'sealed' && level !== 'frozen') {
  				throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`');
  			}
  			if (!$preventExtensions) {
  				throw new $SyntaxError('SetIntegrityLevel requires native `Object.preventExtensions` support');
  			}
  			var status = $preventExtensions(O);
  			if (!status) {
  				return false;
  			}
  			if (!$gOPN) {
  				throw new $SyntaxError('SetIntegrityLevel requires native `Object.getOwnPropertyNames` support');
  			}
  			var theKeys = $gOPN(O);
  			var ES = this;
  			if (level === 'sealed') {
  				forEach(theKeys, function (k) {
  					ES.DefinePropertyOrThrow(O, k, { configurable: false });
  				});
  			} else if (level === 'frozen') {
  				forEach(theKeys, function (k) {
  					var currentDesc = $gOPD(O, k);
  					if (typeof currentDesc !== 'undefined') {
  						var desc;
  						if (ES.IsAccessorDescriptor(ES.ToPropertyDescriptor(currentDesc))) {
  							desc = { configurable: false };
  						} else {
  							desc = { configurable: false, writable: false };
  						}
  						ES.DefinePropertyOrThrow(O, k, desc);
  					}
  				});
  			}
  			return true;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-testintegritylevel
  		TestIntegrityLevel: function TestIntegrityLevel(O, level) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			if (level !== 'sealed' && level !== 'frozen') {
  				throw new $TypeError('Assertion failed: `level` must be `"sealed"` or `"frozen"`');
  			}
  			var status = this.IsExtensible(O);
  			if (status) {
  				return false;
  			}
  			var theKeys = $gOPN(O);
  			var ES = this;
  			return theKeys.length === 0 || every(theKeys, function (k) {
  				var currentDesc = $gOPD(O, k);
  				if (typeof currentDesc !== 'undefined') {
  					if (currentDesc.configurable) {
  						return false;
  					}
  					if (level === 'frozen' && ES.IsDataDescriptor(ES.ToPropertyDescriptor(currentDesc)) && currentDesc.writable) {
  						return false;
  					}
  				}
  				return true;
  			});
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinaryhasinstance
  		OrdinaryHasInstance: function OrdinaryHasInstance(C, O) {
  			if (this.IsCallable(C) === false) {
  				return false;
  			}
  			if (this.Type(O) !== 'Object') {
  				return false;
  			}
  			var P = this.Get(C, 'prototype');
  			if (this.Type(P) !== 'Object') {
  				throw new $TypeError('OrdinaryHasInstance called on an object with an invalid prototype property.');
  			}
  			return O instanceof C;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinaryhasproperty
  		OrdinaryHasProperty: function OrdinaryHasProperty(O, P) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: P must be a Property Key');
  			}
  			return P in O;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-instanceofoperator
  		InstanceofOperator: function InstanceofOperator(O, C) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			var instOfHandler = hasSymbols && $Symbol.hasInstance ? this.GetMethod(C, $Symbol.hasInstance) : void 0;
  			if (typeof instOfHandler !== 'undefined') {
  				return this.ToBoolean(this.Call(instOfHandler, C, [O]));
  			}
  			if (!this.IsCallable(C)) {
  				throw new $TypeError('`C` is not Callable');
  			}
  			return this.OrdinaryHasInstance(C, O);
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-ispromise
  		IsPromise: function IsPromise(x) {
  			if (this.Type(x) !== 'Object') {
  				return false;
  			}
  			if (!$PromiseThen) { // Promises are not supported
  				return false;
  			}
  			try {
  				$PromiseThen(x); // throws if not a promise
  			} catch (e) {
  				return false;
  			}
  			return true;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-abstract-equality-comparison
  		'Abstract Equality Comparison': function AbstractEqualityComparison(x, y) {
  			var xType = this.Type(x);
  			var yType = this.Type(y);
  			if (xType === yType) {
  				return x === y; // ES6+ specified this shortcut anyways.
  			}
  			if (x == null && y == null) {
  				return true;
  			}
  			if (xType === 'Number' && yType === 'String') {
  				return this['Abstract Equality Comparison'](x, this.ToNumber(y));
  			}
  			if (xType === 'String' && yType === 'Number') {
  				return this['Abstract Equality Comparison'](this.ToNumber(x), y);
  			}
  			if (xType === 'Boolean') {
  				return this['Abstract Equality Comparison'](this.ToNumber(x), y);
  			}
  			if (yType === 'Boolean') {
  				return this['Abstract Equality Comparison'](x, this.ToNumber(y));
  			}
  			if ((xType === 'String' || xType === 'Number' || xType === 'Symbol') && yType === 'Object') {
  				return this['Abstract Equality Comparison'](x, this.ToPrimitive(y));
  			}
  			if (xType === 'Object' && (yType === 'String' || yType === 'Number' || yType === 'Symbol')) {
  				return this['Abstract Equality Comparison'](this.ToPrimitive(x), y);
  			}
  			return false;
  		},
  
  		// eslint-disable-next-line max-lines-per-function, max-statements, id-length, max-params
  		ValidateAndApplyPropertyDescriptor: function ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current) {
  			// this uses the ES2017+ logic, since it fixes a number of bugs in the ES2015 logic.
  			var oType = this.Type(O);
  			if (oType !== 'Undefined' && oType !== 'Object') {
  				throw new $TypeError('Assertion failed: O must be undefined or an Object');
  			}
  			if (this.Type(extensible) !== 'Boolean') {
  				throw new $TypeError('Assertion failed: extensible must be a Boolean');
  			}
  			if (!isPropertyDescriptor(this, Desc)) {
  				throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
  			}
  			if (this.Type(current) !== 'Undefined' && !isPropertyDescriptor(this, current)) {
  				throw new $TypeError('Assertion failed: current must be a Property Descriptor, or undefined');
  			}
  			if (oType !== 'Undefined' && !this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: if O is not undefined, P must be a Property Key');
  			}
  			if (this.Type(current) === 'Undefined') {
  				if (!extensible) {
  					return false;
  				}
  				if (this.IsGenericDescriptor(Desc) || this.IsDataDescriptor(Desc)) {
  					if (oType !== 'Undefined') {
  						DefineOwnProperty(this, O, P, {
  							'[[Configurable]]': Desc['[[Configurable]]'],
  							'[[Enumerable]]': Desc['[[Enumerable]]'],
  							'[[Value]]': Desc['[[Value]]'],
  							'[[Writable]]': Desc['[[Writable]]']
  						});
  					}
  				} else {
  					if (!this.IsAccessorDescriptor(Desc)) {
  						throw new $TypeError('Assertion failed: Desc is not an accessor descriptor');
  					}
  					if (oType !== 'Undefined') {
  						return DefineOwnProperty(this, O, P, Desc);
  					}
  				}
  				return true;
  			}
  			if (this.IsGenericDescriptor(Desc) && !('[[Configurable]]' in Desc) && !('[[Enumerable]]' in Desc)) {
  				return true;
  			}
  			if (isSamePropertyDescriptor(this, Desc, current)) {
  				return true; // removed by ES2017, but should still be correct
  			}
  			// "if every field in Desc is absent, return true" can't really match the assertion that it's a Property Descriptor
  			if (!current['[[Configurable]]']) {
  				if (Desc['[[Configurable]]']) {
  					return false;
  				}
  				if ('[[Enumerable]]' in Desc && !Desc['[[Enumerable]]'] === !!current['[[Enumerable]]']) {
  					return false;
  				}
  			}
  			if (this.IsGenericDescriptor(Desc)) {
  				// no further validation is required.
  			} else if (this.IsDataDescriptor(current) !== this.IsDataDescriptor(Desc)) {
  				if (!current['[[Configurable]]']) {
  					return false;
  				}
  				if (this.IsDataDescriptor(current)) {
  					if (oType !== 'Undefined') {
  						DefineOwnProperty(this, O, P, {
  							'[[Configurable]]': current['[[Configurable]]'],
  							'[[Enumerable]]': current['[[Enumerable]]'],
  							'[[Get]]': undefined
  						});
  					}
  				} else if (oType !== 'Undefined') {
  					DefineOwnProperty(this, O, P, {
  						'[[Configurable]]': current['[[Configurable]]'],
  						'[[Enumerable]]': current['[[Enumerable]]'],
  						'[[Value]]': undefined
  					});
  				}
  			} else if (this.IsDataDescriptor(current) && this.IsDataDescriptor(Desc)) {
  				if (!current['[[Configurable]]'] && !current['[[Writable]]']) {
  					if ('[[Writable]]' in Desc && Desc['[[Writable]]']) {
  						return false;
  					}
  					if ('[[Value]]' in Desc && !this.SameValue(Desc['[[Value]]'], current['[[Value]]'])) {
  						return false;
  					}
  					return true;
  				}
  			} else if (this.IsAccessorDescriptor(current) && this.IsAccessorDescriptor(Desc)) {
  				if (!current['[[Configurable]]']) {
  					if ('[[Set]]' in Desc && !this.SameValue(Desc['[[Set]]'], current['[[Set]]'])) {
  						return false;
  					}
  					if ('[[Get]]' in Desc && !this.SameValue(Desc['[[Get]]'], current['[[Get]]'])) {
  						return false;
  					}
  					return true;
  				}
  			} else {
  				throw new $TypeError('Assertion failed: current and Desc are not both data, both accessors, or one accessor and one data.');
  			}
  			if (oType !== 'Undefined') {
  				return DefineOwnProperty(this, O, P, Desc);
  			}
  			return true;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinarydefineownproperty
  		OrdinaryDefineOwnProperty: function OrdinaryDefineOwnProperty(O, P, Desc) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: O must be an Object');
  			}
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: P must be a Property Key');
  			}
  			if (!isPropertyDescriptor(this, Desc)) {
  				throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
  			}
  			var desc = $gOPD(O, P);
  			var current = desc && this.ToPropertyDescriptor(desc);
  			var extensible = this.IsExtensible(O);
  			return this.ValidateAndApplyPropertyDescriptor(O, P, extensible, Desc, current);
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-ordinarygetownproperty
  		OrdinaryGetOwnProperty: function OrdinaryGetOwnProperty(O, P) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: O must be an Object');
  			}
  			if (!this.IsPropertyKey(P)) {
  				throw new $TypeError('Assertion failed: P must be a Property Key');
  			}
  			if (!has(O, P)) {
  				return void 0;
  			}
  			if (!$gOPD) {
  				// ES3 fallback
  				var arrayLength = this.IsArray(O) && P === 'length';
  				var regexLastIndex = this.IsRegExp(O) && P === 'lastIndex';
  				return {
  					'[[Configurable]]': !(arrayLength || regexLastIndex),
  					'[[Enumerable]]': $isEnumerable(O, P),
  					'[[Value]]': O[P],
  					'[[Writable]]': true
  				};
  			}
  			return this.ToPropertyDescriptor($gOPD(O, P));
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-arraycreate
  		ArrayCreate: function ArrayCreate(length) {
  			if (!this.IsInteger(length) || length < 0) {
  				throw new $TypeError('Assertion failed: `length` must be an integer Number >= 0');
  			}
  			if (length > MAX_ARRAY_LENGTH) {
  				throw new $RangeError('length is greater than (2**32 - 1)');
  			}
  			var proto = arguments.length > 1 ? arguments[1] : $ArrayPrototype;
  			var A = []; // steps 5 - 7, and 9
  			if (proto !== $ArrayPrototype) { // step 8
  				if (!$setProto) {
  					throw new $SyntaxError('ArrayCreate: a `proto` argument that is not `Array.prototype` is not supported in an environment that does not support setting the [[Prototype]]');
  				}
  				$setProto(A, proto);
  			}
  			if (length !== 0) { // bypasses the need for step 2
  				A.length = length;
  			}
  			/* step 10, the above as a shortcut for the below
  			this.OrdinaryDefineOwnProperty(A, 'length', {
  				'[[Configurable]]': false,
  				'[[Enumerable]]': false,
  				'[[Value]]': length,
  				'[[Writable]]': true
  			});
  			*/
  			return A;
  		},
  
  		// eslint-disable-next-line max-statements, max-lines-per-function
  		ArraySetLength: function ArraySetLength(A, Desc) {
  			if (!this.IsArray(A)) {
  				throw new $TypeError('Assertion failed: A must be an Array');
  			}
  			if (!isPropertyDescriptor(this, Desc)) {
  				throw new $TypeError('Assertion failed: Desc must be a Property Descriptor');
  			}
  			if (!('[[Value]]' in Desc)) {
  				return this.OrdinaryDefineOwnProperty(A, 'length', Desc);
  			}
  			var newLenDesc = assign({}, Desc);
  			var newLen = this.ToUint32(Desc['[[Value]]']);
  			var numberLen = this.ToNumber(Desc['[[Value]]']);
  			if (newLen !== numberLen) {
  				throw new $RangeError('Invalid array length');
  			}
  			newLenDesc['[[Value]]'] = newLen;
  			var oldLenDesc = this.OrdinaryGetOwnProperty(A, 'length');
  			if (!this.IsDataDescriptor(oldLenDesc)) {
  				throw new $TypeError('Assertion failed: an array had a non-data descriptor on `length`');
  			}
  			var oldLen = oldLenDesc['[[Value]]'];
  			if (newLen >= oldLen) {
  				return this.OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
  			}
  			if (!oldLenDesc['[[Writable]]']) {
  				return false;
  			}
  			var newWritable;
  			if (!('[[Writable]]' in newLenDesc) || newLenDesc['[[Writable]]']) {
  				newWritable = true;
  			} else {
  				newWritable = false;
  				newLenDesc['[[Writable]]'] = true;
  			}
  			var succeeded = this.OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
  			if (!succeeded) {
  				return false;
  			}
  			while (newLen < oldLen) {
  				oldLen -= 1;
  				var deleteSucceeded = delete A[this.ToString(oldLen)];
  				if (!deleteSucceeded) {
  					newLenDesc['[[Value]]'] = oldLen + 1;
  					if (!newWritable) {
  						newLenDesc['[[Writable]]'] = false;
  						this.OrdinaryDefineOwnProperty(A, 'length', newLenDesc);
  						return false;
  					}
  				}
  			}
  			if (!newWritable) {
  				return this.OrdinaryDefineOwnProperty(A, 'length', { '[[Writable]]': false });
  			}
  			return true;
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-createhtml
  		CreateHTML: function CreateHTML(string, tag, attribute, value) {
  			if (this.Type(tag) !== 'String' || this.Type(attribute) !== 'String') {
  				throw new $TypeError('Assertion failed: `tag` and `attribute` must be strings');
  			}
  			var str = this.RequireObjectCoercible(string);
  			var S = this.ToString(str);
  			var p1 = '<' + tag;
  			if (attribute !== '') {
  				var V = this.ToString(value);
  				var escapedV = $replace(V, /\x22/g, '&quot;');
  				p1 += '\x20' + attribute + '\x3D\x22' + escapedV + '\x22';
  			}
  			return p1 + '>' + S + '</' + tag + '>';
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-getownpropertykeys
  		GetOwnPropertyKeys: function GetOwnPropertyKeys(O, Type) {
  			if (this.Type(O) !== 'Object') {
  				throw new $TypeError('Assertion failed: Type(O) is not Object');
  			}
  			if (Type === 'Symbol') {
  				return hasSymbols && $gOPS ? $gOPS(O) : [];
  			}
  			if (Type === 'String') {
  				if (!$gOPN) {
  					return keys(O);
  				}
  				return $gOPN(O);
  			}
  			throw new $TypeError('Assertion failed: `Type` must be `"String"` or `"Symbol"`');
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-symboldescriptivestring
  		SymbolDescriptiveString: function SymbolDescriptiveString(sym) {
  			if (this.Type(sym) !== 'Symbol') {
  				throw new $TypeError('Assertion failed: `sym` must be a Symbol');
  			}
  			return $SymbolToString(sym);
  		},
  
  		// https://www.ecma-international.org/ecma-262/6.0/#sec-getsubstitution
  		// eslint-disable-next-line max-statements, max-params, max-lines-per-function
  		GetSubstitution: function GetSubstitution(matched, str, position, captures, replacement) {
  			if (this.Type(matched) !== 'String') {
  				throw new $TypeError('Assertion failed: `matched` must be a String');
  			}
  			var matchLength = matched.length;
  
  			if (this.Type(str) !== 'String') {
  				throw new $TypeError('Assertion failed: `str` must be a String');
  			}
  			var stringLength = str.length;
  
  			if (!this.IsInteger(position) || position < 0 || position > stringLength) {
  				throw new $TypeError('Assertion failed: `position` must be a nonnegative integer, and less than or equal to the length of `string`, got ' + inspect(position));
  			}
  
  			var ES = this;
  			var isStringOrHole = function (capture, index, arr) { return ES.Type(capture) === 'String' || !(index in arr); };
  			if (!this.IsArray(captures) || !every(captures, isStringOrHole)) {
  				throw new $TypeError('Assertion failed: `captures` must be a List of Strings, got ' + inspect(captures));
  			}
  
  			if (this.Type(replacement) !== 'String') {
  				throw new $TypeError('Assertion failed: `replacement` must be a String');
  			}
  
  			var tailPos = position + matchLength;
  			var m = captures.length;
  
  			var result = '';
  			for (var i = 0; i < replacement.length; i += 1) {
  				// if this is a $, and it's not the end of the replacement
  				var current = replacement[i];
  				var isLast = (i + 1) >= replacement.length;
  				var nextIsLast = (i + 2) >= replacement.length;
  				if (current === '$' && !isLast) {
  					var next = replacement[i + 1];
  					if (next === '$') {
  						result += '$';
  						i += 1;
  					} else if (next === '&') {
  						result += matched;
  						i += 1;
  					} else if (next === '`') {
  						result += position === 0 ? '' : strSlice(str, 0, position - 1);
  						i += 1;
  					} else if (next === "'") {
  						result += tailPos >= stringLength ? '' : strSlice(str, tailPos);
  						i += 1;
  					} else {
  						var nextNext = nextIsLast ? null : replacement[i + 2];
  						if (isDigit(next) && next !== '0' && (nextIsLast || !isDigit(nextNext))) {
  							// $1 through $9, and not followed by a digit
  							var n = parseInteger(next, 10);
  							// if (n > m, impl-defined)
  							result += (n <= m && this.Type(captures[n - 1]) === 'Undefined') ? '' : captures[n - 1];
  							i += 1;
  						} else if (isDigit(next) && (nextIsLast || isDigit(nextNext))) {
  							// $00 through $99
  							var nn = next + nextNext;
  							var nnI = parseInteger(nn, 10) - 1;
  							// if nn === '00' or nn > m, impl-defined
  							result += (nn <= m && this.Type(captures[nnI]) === 'Undefined') ? '' : captures[nnI];
  							i += 2;
  						} else {
  							result += '$';
  						}
  					}
  				} else {
  					// the final $, or else not a $
  					result += replacement[i];
  				}
  			}
  			return result;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-todatestring
  		ToDateString: function ToDateString(tv) {
  			if (this.Type(tv) !== 'Number') {
  				throw new $TypeError('Assertion failed: `tv` must be a Number');
  			}
  			if ($isNaN(tv)) {
  				return 'Invalid Date';
  			}
  			return $Date(tv);
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-createlistfromarraylike
  		CreateListFromArrayLike: function CreateListFromArrayLike(obj) {
  			var elementTypes = arguments.length > 1
  				? arguments[1]
  				: ['Undefined', 'Null', 'Boolean', 'String', 'Symbol', 'Number', 'Object'];
  
  			if (this.Type(obj) !== 'Object') {
  				throw new $TypeError('Assertion failed: `obj` must be an Object');
  			}
  			if (!this.IsArray(elementTypes)) {
  				throw new $TypeError('Assertion failed: `elementTypes`, if provided, must be an array');
  			}
  			var len = this.ToLength(this.Get(obj, 'length'));
  			var list = [];
  			var index = 0;
  			while (index < len) {
  				var indexName = this.ToString(index);
  				var next = this.Get(obj, indexName);
  				var nextType = this.Type(next);
  				if ($indexOf(elementTypes, nextType) < 0) {
  					throw new $TypeError('item type ' + nextType + ' is not a valid elementType');
  				}
  				$push(list, next);
  				index += 1;
  			}
  			return list;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-getprototypefromconstructor
  		GetPrototypeFromConstructor: function GetPrototypeFromConstructor(constructor, intrinsicDefaultProto) {
  			var intrinsic = GetIntrinsic(intrinsicDefaultProto); // throws if not a valid intrinsic
  			if (!this.IsConstructor(constructor)) {
  				throw new $TypeError('Assertion failed: `constructor` must be a constructor');
  			}
  			var proto = this.Get(constructor, 'prototype');
  			if (this.Type(proto) !== 'Object') {
  				if (!(constructor instanceof $Function)) {
  					// ignore other realms, for now
  					throw new $TypeError('cross-realm constructors not currently supported');
  				}
  				proto = intrinsic;
  			}
  			return proto;
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-setfunctionname
  		SetFunctionName: function SetFunctionName(F, name) {
  			if (typeof F !== 'function') {
  				throw new $TypeError('Assertion failed: `F` must be a function');
  			}
  			if (!this.IsExtensible(F) || has(F, 'name')) {
  				throw new $TypeError('Assertion failed: `F` must be extensible, and must not have a `name` own property');
  			}
  			var nameType = this.Type(name);
  			if (nameType !== 'Symbol' && nameType !== 'String') {
  				throw new $TypeError('Assertion failed: `name` must be a Symbol or a String');
  			}
  			if (nameType === 'Symbol') {
  				var description = getSymbolDescription(name);
  				// eslint-disable-next-line no-param-reassign
  				name = typeof description === 'undefined' ? '' : '[' + description + ']';
  			}
  			if (arguments.length > 2) {
  				var prefix = arguments[2];
  				// eslint-disable-next-line no-param-reassign
  				name = prefix + ' ' + name;
  			}
  			return this.DefinePropertyOrThrow(F, 'name', {
  				'[[Value]]': name,
  				'[[Writable]]': false,
  				'[[Enumerable]]': false,
  				'[[Configurable]]': true
  			});
  		}
  	});
  
  	delete ES6.CheckObjectCoercible; // renamed in ES6 to RequireObjectCoercible
  
  	module.exports = ES6;
  
  
  /***/ }),
  /* 86 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var bind = __webpack_require__(87);
  
  	module.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);
  
  
  /***/ }),
  /* 87 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var implementation = __webpack_require__(88);
  
  	module.exports = Function.prototype.bind || implementation;
  
  
  /***/ }),
  /* 88 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	/* eslint no-invalid-this: 1 */
  
  	var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';
  	var slice = Array.prototype.slice;
  	var toStr = Object.prototype.toString;
  	var funcType = '[object Function]';
  
  	module.exports = function bind(that) {
  	    var target = this;
  	    if (typeof target !== 'function' || toStr.call(target) !== funcType) {
  	        throw new TypeError(ERROR_MESSAGE + target);
  	    }
  	    var args = slice.call(arguments, 1);
  
  	    var bound;
  	    var binder = function () {
  	        if (this instanceof bound) {
  	            var result = target.apply(
  	                this,
  	                args.concat(slice.call(arguments))
  	            );
  	            if (Object(result) === result) {
  	                return result;
  	            }
  	            return this;
  	        } else {
  	            return target.apply(
  	                that,
  	                args.concat(slice.call(arguments))
  	            );
  	        }
  	    };
  
  	    var boundLength = Math.max(0, target.length - args.length);
  	    var boundArgs = [];
  	    for (var i = 0; i < boundLength; i++) {
  	        boundArgs.push('$' + i);
  	    }
  
  	    bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);
  
  	    if (target.prototype) {
  	        var Empty = function Empty() {};
  	        Empty.prototype = target.prototype;
  	        bound.prototype = new Empty();
  	        Empty.prototype = null;
  	    }
  
  	    return bound;
  	};
  
  
  /***/ }),
  /* 89 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	module.exports = __webpack_require__(90);
  
  
  /***/ }),
  /* 90 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var hasSymbols = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol';
  
  	var isPrimitive = __webpack_require__(91);
  	var isCallable = __webpack_require__(92);
  	var isDate = __webpack_require__(93);
  	var isSymbol = __webpack_require__(94);
  
  	var ordinaryToPrimitive = function OrdinaryToPrimitive(O, hint) {
  		if (typeof O === 'undefined' || O === null) {
  			throw new TypeError('Cannot call method on ' + O);
  		}
  		if (typeof hint !== 'string' || (hint !== 'number' && hint !== 'string')) {
  			throw new TypeError('hint must be "string" or "number"');
  		}
  		var methodNames = hint === 'string' ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
  		var method, result, i;
  		for (i = 0; i < methodNames.length; ++i) {
  			method = O[methodNames[i]];
  			if (isCallable(method)) {
  				result = method.call(O);
  				if (isPrimitive(result)) {
  					return result;
  				}
  			}
  		}
  		throw new TypeError('No default value');
  	};
  
  	var GetMethod = function GetMethod(O, P) {
  		var func = O[P];
  		if (func !== null && typeof func !== 'undefined') {
  			if (!isCallable(func)) {
  				throw new TypeError(func + ' returned for property ' + P + ' of object ' + O + ' is not a function');
  			}
  			return func;
  		}
  		return void 0;
  	};
  
  	// http://www.ecma-international.org/ecma-262/6.0/#sec-toprimitive
  	module.exports = function ToPrimitive(input) {
  		if (isPrimitive(input)) {
  			return input;
  		}
  		var hint = 'default';
  		if (arguments.length > 1) {
  			if (arguments[1] === String) {
  				hint = 'string';
  			} else if (arguments[1] === Number) {
  				hint = 'number';
  			}
  		}
  
  		var exoticToPrim;
  		if (hasSymbols) {
  			if (Symbol.toPrimitive) {
  				exoticToPrim = GetMethod(input, Symbol.toPrimitive);
  			} else if (isSymbol(input)) {
  				exoticToPrim = Symbol.prototype.valueOf;
  			}
  		}
  		if (typeof exoticToPrim !== 'undefined') {
  			var result = exoticToPrim.call(input, hint);
  			if (isPrimitive(result)) {
  				return result;
  			}
  			throw new TypeError('unable to convert exotic object to primitive');
  		}
  		if (hint === 'default' && (isDate(input) || isSymbol(input))) {
  			hint = 'string';
  		}
  		return ordinaryToPrimitive(input, hint === 'default' ? 'number' : hint);
  	};
  
  
  /***/ }),
  /* 91 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	module.exports = function isPrimitive(value) {
  		return value === null || (typeof value !== 'function' && typeof value !== 'object');
  	};
  
  
  /***/ }),
  /* 92 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	var fnToStr = Function.prototype.toString;
  
  	var constructorRegex = /^\s*class\b/;
  	var isES6ClassFn = function isES6ClassFunction(value) {
  		try {
  			var fnStr = fnToStr.call(value);
  			return constructorRegex.test(fnStr);
  		} catch (e) {
  			return false; // not a function
  		}
  	};
  
  	var tryFunctionObject = function tryFunctionToStr(value) {
  		try {
  			if (isES6ClassFn(value)) { return false; }
  			fnToStr.call(value);
  			return true;
  		} catch (e) {
  			return false;
  		}
  	};
  	var toStr = Object.prototype.toString;
  	var fnClass = '[object Function]';
  	var genClass = '[object GeneratorFunction]';
  	var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
  
  	module.exports = function isCallable(value) {
  		if (!value) { return false; }
  		if (typeof value !== 'function' && typeof value !== 'object') { return false; }
  		if (typeof value === 'function' && !value.prototype) { return true; }
  		if (hasToStringTag) { return tryFunctionObject(value); }
  		if (isES6ClassFn(value)) { return false; }
  		var strClass = toStr.call(value);
  		return strClass === fnClass || strClass === genClass;
  	};
  
  
  /***/ }),
  /* 93 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	var getDay = Date.prototype.getDay;
  	var tryDateObject = function tryDateObject(value) {
  		try {
  			getDay.call(value);
  			return true;
  		} catch (e) {
  			return false;
  		}
  	};
  
  	var toStr = Object.prototype.toString;
  	var dateClass = '[object Date]';
  	var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
  
  	module.exports = function isDateObject(value) {
  		if (typeof value !== 'object' || value === null) { return false; }
  		return hasToStringTag ? tryDateObject(value) : toStr.call(value) === dateClass;
  	};
  
  
  /***/ }),
  /* 94 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var toStr = Object.prototype.toString;
  	var hasSymbols = __webpack_require__(95)();
  
  	if (hasSymbols) {
  		var symToStr = Symbol.prototype.toString;
  		var symStringRegex = /^Symbol\(.*\)$/;
  		var isSymbolObject = function isRealSymbolObject(value) {
  			if (typeof value.valueOf() !== 'symbol') {
  				return false;
  			}
  			return symStringRegex.test(symToStr.call(value));
  		};
  
  		module.exports = function isSymbol(value) {
  			if (typeof value === 'symbol') {
  				return true;
  			}
  			if (toStr.call(value) !== '[object Symbol]') {
  				return false;
  			}
  			try {
  				return isSymbolObject(value);
  			} catch (e) {
  				return false;
  			}
  		};
  	} else {
  
  		module.exports = function isSymbol(value) {
  			// this environment does not support Symbols.
  			return false && value;
  		};
  	}
  
  
  /***/ }),
  /* 95 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	/* WEBPACK VAR INJECTION */(function(global) {'use strict';
  
  	var origSymbol = global.Symbol;
  	var hasSymbolSham = __webpack_require__(96);
  
  	module.exports = function hasNativeSymbols() {
  		if (typeof origSymbol !== 'function') { return false; }
  		if (typeof Symbol !== 'function') { return false; }
  		if (typeof origSymbol('foo') !== 'symbol') { return false; }
  		if (typeof Symbol('bar') !== 'symbol') { return false; }
  
  		return hasSymbolSham();
  	};
  
  	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
  
  /***/ }),
  /* 96 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	/* eslint complexity: [2, 17], max-statements: [2, 33] */
  	module.exports = function hasSymbols() {
  		if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }
  		if (typeof Symbol.iterator === 'symbol') { return true; }
  
  		var obj = {};
  		var sym = Symbol('test');
  		var symObj = Object(sym);
  		if (typeof sym === 'string') { return false; }
  
  		if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }
  		if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }
  
  		// temp disabled per https://github.com/ljharb/object.assign/issues/17
  		// if (sym instanceof Symbol) { return false; }
  		// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4
  		// if (!(symObj instanceof Symbol)) { return false; }
  
  		// if (typeof Symbol.prototype.toString !== 'function') { return false; }
  		// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }
  
  		var symVal = 42;
  		obj[sym] = symVal;
  		for (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax
  		if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }
  
  		if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }
  
  		var syms = Object.getOwnPropertySymbols(obj);
  		if (syms.length !== 1 || syms[0] !== sym) { return false; }
  
  		if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }
  
  		if (typeof Object.getOwnPropertyDescriptor === 'function') {
  			var descriptor = Object.getOwnPropertyDescriptor(obj, sym);
  			if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }
  		}
  
  		return true;
  	};
  
  
  /***/ }),
  /* 97 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	var hasMap = typeof Map === 'function' && Map.prototype;
  	var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, 'size') : null;
  	var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === 'function' ? mapSizeDescriptor.get : null;
  	var mapForEach = hasMap && Map.prototype.forEach;
  	var hasSet = typeof Set === 'function' && Set.prototype;
  	var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, 'size') : null;
  	var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === 'function' ? setSizeDescriptor.get : null;
  	var setForEach = hasSet && Set.prototype.forEach;
  	var hasWeakMap = typeof WeakMap === 'function' && WeakMap.prototype;
  	var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
  	var hasWeakSet = typeof WeakSet === 'function' && WeakSet.prototype;
  	var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
  	var booleanValueOf = Boolean.prototype.valueOf;
  	var objectToString = Object.prototype.toString;
  	var match = String.prototype.match;
  	var bigIntValueOf = typeof BigInt === 'function' ? BigInt.prototype.valueOf : null;
  
  	var inspectCustom = __webpack_require__(98).custom;
  	var inspectSymbol = inspectCustom && isSymbol(inspectCustom) ? inspectCustom : null;
  
  	module.exports = function inspect_(obj, options, depth, seen) {
  	    var opts = options || {};
  
  	    if (has(opts, 'quoteStyle') && (opts.quoteStyle !== 'single' && opts.quoteStyle !== 'double')) {
  	        throw new TypeError('option "quoteStyle" must be "single" or "double"');
  	    }
  
  	    if (typeof obj === 'undefined') {
  	        return 'undefined';
  	    }
  	    if (obj === null) {
  	        return 'null';
  	    }
  	    if (typeof obj === 'boolean') {
  	        return obj ? 'true' : 'false';
  	    }
  
  	    if (typeof obj === 'string') {
  	        return inspectString(obj, opts);
  	    }
  	    if (typeof obj === 'number') {
  	        if (obj === 0) {
  	            return Infinity / obj > 0 ? '0' : '-0';
  	        }
  	        return String(obj);
  	    }
  	    if (typeof obj === 'bigint') { // eslint-disable-line valid-typeof
  	        return String(obj) + 'n';
  	    }
  
  	    var maxDepth = typeof opts.depth === 'undefined' ? 5 : opts.depth;
  	    if (typeof depth === 'undefined') { depth = 0; }
  	    if (depth >= maxDepth && maxDepth > 0 && typeof obj === 'object') {
  	        return '[Object]';
  	    }
  
  	    if (typeof seen === 'undefined') {
  	        seen = [];
  	    } else if (indexOf(seen, obj) >= 0) {
  	        return '[Circular]';
  	    }
  
  	    function inspect(value, from) {
  	        if (from) {
  	            seen = seen.slice();
  	            seen.push(from);
  	        }
  	        return inspect_(value, opts, depth + 1, seen);
  	    }
  
  	    if (typeof obj === 'function') {
  	        var name = nameOf(obj);
  	        return '[Function' + (name ? ': ' + name : '') + ']';
  	    }
  	    if (isSymbol(obj)) {
  	        var symString = Symbol.prototype.toString.call(obj);
  	        return typeof obj === 'object' ? markBoxed(symString) : symString;
  	    }
  	    if (isElement(obj)) {
  	        var s = '<' + String(obj.nodeName).toLowerCase();
  	        var attrs = obj.attributes || [];
  	        for (var i = 0; i < attrs.length; i++) {
  	            s += ' ' + attrs[i].name + '=' + wrapQuotes(quote(attrs[i].value), 'double', opts);
  	        }
  	        s += '>';
  	        if (obj.childNodes && obj.childNodes.length) { s += '...'; }
  	        s += '</' + String(obj.nodeName).toLowerCase() + '>';
  	        return s;
  	    }
  	    if (isArray(obj)) {
  	        if (obj.length === 0) { return '[]'; }
  	        return '[ ' + arrObjKeys(obj, inspect).join(', ') + ' ]';
  	    }
  	    if (isError(obj)) {
  	        var parts = arrObjKeys(obj, inspect);
  	        if (parts.length === 0) { return '[' + String(obj) + ']'; }
  	        return '{ [' + String(obj) + '] ' + parts.join(', ') + ' }';
  	    }
  	    if (typeof obj === 'object') {
  	        if (inspectSymbol && typeof obj[inspectSymbol] === 'function') {
  	            return obj[inspectSymbol]();
  	        } else if (typeof obj.inspect === 'function') {
  	            return obj.inspect();
  	        }
  	    }
  	    if (isMap(obj)) {
  	        var mapParts = [];
  	        mapForEach.call(obj, function (value, key) {
  	            mapParts.push(inspect(key, obj) + ' => ' + inspect(value, obj));
  	        });
  	        return collectionOf('Map', mapSize.call(obj), mapParts);
  	    }
  	    if (isSet(obj)) {
  	        var setParts = [];
  	        setForEach.call(obj, function (value) {
  	            setParts.push(inspect(value, obj));
  	        });
  	        return collectionOf('Set', setSize.call(obj), setParts);
  	    }
  	    if (isWeakMap(obj)) {
  	        return weakCollectionOf('WeakMap');
  	    }
  	    if (isWeakSet(obj)) {
  	        return weakCollectionOf('WeakSet');
  	    }
  	    if (isNumber(obj)) {
  	        return markBoxed(inspect(Number(obj)));
  	    }
  	    if (isBigInt(obj)) {
  	        return markBoxed(inspect(bigIntValueOf.call(obj)));
  	    }
  	    if (isBoolean(obj)) {
  	        return markBoxed(booleanValueOf.call(obj));
  	    }
  	    if (isString(obj)) {
  	        return markBoxed(inspect(String(obj)));
  	    }
  	    if (!isDate(obj) && !isRegExp(obj)) {
  	        var xs = arrObjKeys(obj, inspect);
  	        if (xs.length === 0) { return '{}'; }
  	        return '{ ' + xs.join(', ') + ' }';
  	    }
  	    return String(obj);
  	};
  
  	function wrapQuotes(s, defaultStyle, opts) {
  	    var quoteChar = (opts.quoteStyle || defaultStyle) === 'double' ? '"' : "'";
  	    return quoteChar + s + quoteChar;
  	}
  
  	function quote(s) {
  	    return String(s).replace(/"/g, '&quot;');
  	}
  
  	function isArray(obj) { return toStr(obj) === '[object Array]'; }
  	function isDate(obj) { return toStr(obj) === '[object Date]'; }
  	function isRegExp(obj) { return toStr(obj) === '[object RegExp]'; }
  	function isError(obj) { return toStr(obj) === '[object Error]'; }
  	function isSymbol(obj) { return toStr(obj) === '[object Symbol]'; }
  	function isString(obj) { return toStr(obj) === '[object String]'; }
  	function isNumber(obj) { return toStr(obj) === '[object Number]'; }
  	function isBigInt(obj) { return toStr(obj) === '[object BigInt]'; }
  	function isBoolean(obj) { return toStr(obj) === '[object Boolean]'; }
  
  	var hasOwn = Object.prototype.hasOwnProperty || function (key) { return key in this; };
  	function has(obj, key) {
  	    return hasOwn.call(obj, key);
  	}
  
  	function toStr(obj) {
  	    return objectToString.call(obj);
  	}
  
  	function nameOf(f) {
  	    if (f.name) { return f.name; }
  	    var m = match.call(f, /^function\s*([\w$]+)/);
  	    if (m) { return m[1]; }
  	    return null;
  	}
  
  	function indexOf(xs, x) {
  	    if (xs.indexOf) { return xs.indexOf(x); }
  	    for (var i = 0, l = xs.length; i < l; i++) {
  	        if (xs[i] === x) { return i; }
  	    }
  	    return -1;
  	}
  
  	function isMap(x) {
  	    if (!mapSize || !x || typeof x !== 'object') {
  	        return false;
  	    }
  	    try {
  	        mapSize.call(x);
  	        try {
  	            setSize.call(x);
  	        } catch (s) {
  	            return true;
  	        }
  	        return x instanceof Map; // core-js workaround, pre-v2.5.0
  	    } catch (e) {}
  	    return false;
  	}
  
  	function isWeakMap(x) {
  	    if (!weakMapHas || !x || typeof x !== 'object') {
  	        return false;
  	    }
  	    try {
  	        weakMapHas.call(x, weakMapHas);
  	        try {
  	            weakSetHas.call(x, weakSetHas);
  	        } catch (s) {
  	            return true;
  	        }
  	        return x instanceof WeakMap; // core-js workaround, pre-v2.5.0
  	    } catch (e) {}
  	    return false;
  	}
  
  	function isSet(x) {
  	    if (!setSize || !x || typeof x !== 'object') {
  	        return false;
  	    }
  	    try {
  	        setSize.call(x);
  	        try {
  	            mapSize.call(x);
  	        } catch (m) {
  	            return true;
  	        }
  	        return x instanceof Set; // core-js workaround, pre-v2.5.0
  	    } catch (e) {}
  	    return false;
  	}
  
  	function isWeakSet(x) {
  	    if (!weakSetHas || !x || typeof x !== 'object') {
  	        return false;
  	    }
  	    try {
  	        weakSetHas.call(x, weakSetHas);
  	        try {
  	            weakMapHas.call(x, weakMapHas);
  	        } catch (s) {
  	            return true;
  	        }
  	        return x instanceof WeakSet; // core-js workaround, pre-v2.5.0
  	    } catch (e) {}
  	    return false;
  	}
  
  	function isElement(x) {
  	    if (!x || typeof x !== 'object') { return false; }
  	    if (typeof HTMLElement !== 'undefined' && x instanceof HTMLElement) {
  	        return true;
  	    }
  	    return typeof x.nodeName === 'string' && typeof x.getAttribute === 'function';
  	}
  
  	function inspectString(str, opts) {
  	    // eslint-disable-next-line no-control-regex
  	    var s = str.replace(/(['\\])/g, '\\$1').replace(/[\x00-\x1f]/g, lowbyte);
  	    return wrapQuotes(s, 'single', opts);
  	}
  
  	function lowbyte(c) {
  	    var n = c.charCodeAt(0);
  	    var x = {
  	        8: 'b', 9: 't', 10: 'n', 12: 'f', 13: 'r'
  	    }[n];
  	    if (x) { return '\\' + x; }
  	    return '\\x' + (n < 0x10 ? '0' : '') + n.toString(16);
  	}
  
  	function markBoxed(str) {
  	    return 'Object(' + str + ')';
  	}
  
  	function weakCollectionOf(type) {
  	    return type + ' { ? }';
  	}
  
  	function collectionOf(type, size, entries) {
  	    return type + ' (' + size + ') {' + entries.join(', ') + '}';
  	}
  
  	function arrObjKeys(obj, inspect) {
  	    var isArr = isArray(obj);
  	    var xs = [];
  	    if (isArr) {
  	        xs.length = obj.length;
  	        for (var i = 0; i < obj.length; i++) {
  	            xs[i] = has(obj, i) ? inspect(obj[i], obj) : '';
  	        }
  	    }
  	    for (var key in obj) { // eslint-disable-line no-restricted-syntax
  	        if (!has(obj, key)) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
  	        if (isArr && String(Number(key)) === key && key < obj.length) { continue; } // eslint-disable-line no-restricted-syntax, no-continue
  	        if ((/[^\w$]/).test(key)) {
  	            xs.push(inspect(key, obj) + ': ' + inspect(obj[key], obj));
  	        } else {
  	            xs.push(key + ': ' + inspect(obj[key], obj));
  	        }
  	    }
  	    return xs;
  	}
  
  
  /***/ }),
  /* 98 */
  /***/ (function(module, exports) {
  
  	/* (ignored) */
  
  /***/ }),
  /* 99 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	/* globals
  		Atomics,
  		SharedArrayBuffer,
  	*/
  
  	var undefined; // eslint-disable-line no-shadow-restricted-names
  
  	var $TypeError = TypeError;
  
  	var ThrowTypeError = Object.getOwnPropertyDescriptor
  		? (function () { return Object.getOwnPropertyDescriptor(arguments, 'callee').get; }())
  		: function () { throw new $TypeError(); };
  
  	var hasSymbols = __webpack_require__(95)();
  
  	var getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto
  
  	var generator; // = function * () {};
  	var generatorFunction = generator ? getProto(generator) : undefined;
  	var asyncFn; // async function() {};
  	var asyncFunction = asyncFn ? asyncFn.constructor : undefined;
  	var asyncGen; // async function * () {};
  	var asyncGenFunction = asyncGen ? getProto(asyncGen) : undefined;
  	var asyncGenIterator = asyncGen ? asyncGen() : undefined;
  
  	var TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);
  
  	var INTRINSICS = {
  		'$ %Array%': Array,
  		'$ %ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,
  		'$ %ArrayBufferPrototype%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer.prototype,
  		'$ %ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,
  		'$ %ArrayPrototype%': Array.prototype,
  		'$ %ArrayProto_entries%': Array.prototype.entries,
  		'$ %ArrayProto_forEach%': Array.prototype.forEach,
  		'$ %ArrayProto_keys%': Array.prototype.keys,
  		'$ %ArrayProto_values%': Array.prototype.values,
  		'$ %AsyncFromSyncIteratorPrototype%': undefined,
  		'$ %AsyncFunction%': asyncFunction,
  		'$ %AsyncFunctionPrototype%': asyncFunction ? asyncFunction.prototype : undefined,
  		'$ %AsyncGenerator%': asyncGen ? getProto(asyncGenIterator) : undefined,
  		'$ %AsyncGeneratorFunction%': asyncGenFunction,
  		'$ %AsyncGeneratorPrototype%': asyncGenFunction ? asyncGenFunction.prototype : undefined,
  		'$ %AsyncIteratorPrototype%': asyncGenIterator && hasSymbols && Symbol.asyncIterator ? asyncGenIterator[Symbol.asyncIterator]() : undefined,
  		'$ %Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,
  		'$ %Boolean%': Boolean,
  		'$ %BooleanPrototype%': Boolean.prototype,
  		'$ %DataView%': typeof DataView === 'undefined' ? undefined : DataView,
  		'$ %DataViewPrototype%': typeof DataView === 'undefined' ? undefined : DataView.prototype,
  		'$ %Date%': Date,
  		'$ %DatePrototype%': Date.prototype,
  		'$ %decodeURI%': decodeURI,
  		'$ %decodeURIComponent%': decodeURIComponent,
  		'$ %encodeURI%': encodeURI,
  		'$ %encodeURIComponent%': encodeURIComponent,
  		'$ %Error%': Error,
  		'$ %ErrorPrototype%': Error.prototype,
  		'$ %eval%': eval, // eslint-disable-line no-eval
  		'$ %EvalError%': EvalError,
  		'$ %EvalErrorPrototype%': EvalError.prototype,
  		'$ %Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,
  		'$ %Float32ArrayPrototype%': typeof Float32Array === 'undefined' ? undefined : Float32Array.prototype,
  		'$ %Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,
  		'$ %Float64ArrayPrototype%': typeof Float64Array === 'undefined' ? undefined : Float64Array.prototype,
  		'$ %Function%': Function,
  		'$ %FunctionPrototype%': Function.prototype,
  		'$ %Generator%': generator ? getProto(generator()) : undefined,
  		'$ %GeneratorFunction%': generatorFunction,
  		'$ %GeneratorPrototype%': generatorFunction ? generatorFunction.prototype : undefined,
  		'$ %Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,
  		'$ %Int8ArrayPrototype%': typeof Int8Array === 'undefined' ? undefined : Int8Array.prototype,
  		'$ %Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,
  		'$ %Int16ArrayPrototype%': typeof Int16Array === 'undefined' ? undefined : Int8Array.prototype,
  		'$ %Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,
  		'$ %Int32ArrayPrototype%': typeof Int32Array === 'undefined' ? undefined : Int32Array.prototype,
  		'$ %isFinite%': isFinite,
  		'$ %isNaN%': isNaN,
  		'$ %IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,
  		'$ %JSON%': JSON,
  		'$ %JSONParse%': JSON.parse,
  		'$ %Map%': typeof Map === 'undefined' ? undefined : Map,
  		'$ %MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),
  		'$ %MapPrototype%': typeof Map === 'undefined' ? undefined : Map.prototype,
  		'$ %Math%': Math,
  		'$ %Number%': Number,
  		'$ %NumberPrototype%': Number.prototype,
  		'$ %Object%': Object,
  		'$ %ObjectPrototype%': Object.prototype,
  		'$ %ObjProto_toString%': Object.prototype.toString,
  		'$ %ObjProto_valueOf%': Object.prototype.valueOf,
  		'$ %parseFloat%': parseFloat,
  		'$ %parseInt%': parseInt,
  		'$ %Promise%': typeof Promise === 'undefined' ? undefined : Promise,
  		'$ %PromisePrototype%': typeof Promise === 'undefined' ? undefined : Promise.prototype,
  		'$ %PromiseProto_then%': typeof Promise === 'undefined' ? undefined : Promise.prototype.then,
  		'$ %Promise_all%': typeof Promise === 'undefined' ? undefined : Promise.all,
  		'$ %Promise_reject%': typeof Promise === 'undefined' ? undefined : Promise.reject,
  		'$ %Promise_resolve%': typeof Promise === 'undefined' ? undefined : Promise.resolve,
  		'$ %Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,
  		'$ %RangeError%': RangeError,
  		'$ %RangeErrorPrototype%': RangeError.prototype,
  		'$ %ReferenceError%': ReferenceError,
  		'$ %ReferenceErrorPrototype%': ReferenceError.prototype,
  		'$ %Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,
  		'$ %RegExp%': RegExp,
  		'$ %RegExpPrototype%': RegExp.prototype,
  		'$ %Set%': typeof Set === 'undefined' ? undefined : Set,
  		'$ %SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),
  		'$ %SetPrototype%': typeof Set === 'undefined' ? undefined : Set.prototype,
  		'$ %SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,
  		'$ %SharedArrayBufferPrototype%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer.prototype,
  		'$ %String%': String,
  		'$ %StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,
  		'$ %StringPrototype%': String.prototype,
  		'$ %Symbol%': hasSymbols ? Symbol : undefined,
  		'$ %SymbolPrototype%': hasSymbols ? Symbol.prototype : undefined,
  		'$ %SyntaxError%': SyntaxError,
  		'$ %SyntaxErrorPrototype%': SyntaxError.prototype,
  		'$ %ThrowTypeError%': ThrowTypeError,
  		'$ %TypedArray%': TypedArray,
  		'$ %TypedArrayPrototype%': TypedArray ? TypedArray.prototype : undefined,
  		'$ %TypeError%': $TypeError,
  		'$ %TypeErrorPrototype%': $TypeError.prototype,
  		'$ %Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,
  		'$ %Uint8ArrayPrototype%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array.prototype,
  		'$ %Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,
  		'$ %Uint8ClampedArrayPrototype%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray.prototype,
  		'$ %Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,
  		'$ %Uint16ArrayPrototype%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array.prototype,
  		'$ %Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,
  		'$ %Uint32ArrayPrototype%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array.prototype,
  		'$ %URIError%': URIError,
  		'$ %URIErrorPrototype%': URIError.prototype,
  		'$ %WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,
  		'$ %WeakMapPrototype%': typeof WeakMap === 'undefined' ? undefined : WeakMap.prototype,
  		'$ %WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet,
  		'$ %WeakSetPrototype%': typeof WeakSet === 'undefined' ? undefined : WeakSet.prototype
  	};
  
  	var bind = __webpack_require__(87);
  	var $replace = bind.call(Function.call, String.prototype.replace);
  
  	/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */
  	var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
  	var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */
  	var stringToPath = function stringToPath(string) {
  		var result = [];
  		$replace(string, rePropName, function (match, number, quote, subString) {
  			result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : (number || match);
  		});
  		return result;
  	};
  	/* end adaptation */
  
  	var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {
  		var key = '$ ' + name;
  		if (!(key in INTRINSICS)) {
  			throw new SyntaxError('intrinsic ' + name + ' does not exist!');
  		}
  
  		// istanbul ignore if // hopefully this is impossible to test :-)
  		if (typeof INTRINSICS[key] === 'undefined' && !allowMissing) {
  			throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');
  		}
  
  		return INTRINSICS[key];
  	};
  
  	module.exports = function GetIntrinsic(name, allowMissing) {
  		if (arguments.length > 1 && typeof allowMissing !== 'boolean') {
  			throw new TypeError('"allowMissing" argument must be a boolean');
  		}
  
  		var parts = stringToPath(name);
  
  		if (parts.length === 0) {
  			return getBaseIntrinsic(name, allowMissing);
  		}
  
  		var value = getBaseIntrinsic('%' + parts[0] + '%', allowMissing);
  		for (var i = 1; i < parts.length; i += 1) {
  			if (value != null) {
  				value = value[parts[i]];
  			}
  		}
  		return value;
  	};
  
  
  /***/ }),
  /* 100 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var $TypeError = GetIntrinsic('%TypeError%');
  	var $SyntaxError = GetIntrinsic('%SyntaxError%');
  
  	var has = __webpack_require__(86);
  
  	var predicates = {
  		// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type
  		'Property Descriptor': function isPropertyDescriptor(ES, Desc) {
  			if (ES.Type(Desc) !== 'Object') {
  				return false;
  			}
  			var allowed = {
  				'[[Configurable]]': true,
  				'[[Enumerable]]': true,
  				'[[Get]]': true,
  				'[[Set]]': true,
  				'[[Value]]': true,
  				'[[Writable]]': true
  			};
  
  			for (var key in Desc) { // eslint-disable-line
  				if (has(Desc, key) && !allowed[key]) {
  					return false;
  				}
  			}
  
  			var isData = has(Desc, '[[Value]]');
  			var IsAccessor = has(Desc, '[[Get]]') || has(Desc, '[[Set]]');
  			if (isData && IsAccessor) {
  				throw new $TypeError('Property Descriptors may not be both accessor and data descriptors');
  			}
  			return true;
  		}
  	};
  
  	module.exports = function assertRecord(ES, recordType, argumentName, value) {
  		var predicate = predicates[recordType];
  		if (typeof predicate !== 'function') {
  			throw new $SyntaxError('unknown record type: ' + recordType);
  		}
  		if (!predicate(ES, value)) {
  			throw new $TypeError(argumentName + ' must be a ' + recordType);
  		}
  	};
  
  
  /***/ }),
  /* 101 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	module.exports = Number.isNaN || function isNaN(a) {
  		return a !== a;
  	};
  
  
  /***/ }),
  /* 102 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	var $isNaN = Number.isNaN || function (a) { return a !== a; };
  
  	module.exports = Number.isFinite || function (x) { return typeof x === 'number' && !$isNaN(x) && x !== Infinity && x !== -Infinity; };
  
  
  /***/ }),
  /* 103 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var $Math = GetIntrinsic('%Math%');
  	var $Number = GetIntrinsic('%Number%');
  
  	module.exports = $Number.MAX_SAFE_INTEGER || $Math.pow(2, 53) - 1;
  
  
  /***/ }),
  /* 104 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var has = __webpack_require__(86);
  
  	var $assign = GetIntrinsic('%Object%').assign;
  
  	module.exports = function assign(target, source) {
  		if ($assign) {
  			return $assign(target, source);
  		}
  
  		// eslint-disable-next-line no-restricted-syntax
  		for (var key in source) {
  			if (has(source, key)) {
  				target[key] = source[key];
  			}
  		}
  		return target;
  	};
  
  
  /***/ }),
  /* 105 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	module.exports = function sign(number) {
  		return number >= 0 ? 1 : -1;
  	};
  
  
  /***/ }),
  /* 106 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	module.exports = function mod(number, modulo) {
  		var remain = number % modulo;
  		return Math.floor(remain >= 0 ? remain : remain + modulo);
  	};
  
  
  /***/ }),
  /* 107 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	module.exports = function isPrimitive(value) {
  		return value === null || (typeof value !== 'function' && typeof value !== 'object');
  	};
  
  
  /***/ }),
  /* 108 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	module.exports = function forEach(array, callback) {
  		for (var i = 0; i < array.length; i += 1) {
  			callback(array[i], i, array); // eslint-disable-line callback-return
  		}
  	};
  
  
  /***/ }),
  /* 109 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	module.exports = function every(array, predicate) {
  		for (var i = 0; i < array.length; i += 1) {
  			if (!predicate(array[i], i, array)) {
  				return false;
  			}
  		}
  		return true;
  	};
  
  
  /***/ }),
  /* 110 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var every = __webpack_require__(109);
  
  	module.exports = function isSamePropertyDescriptor(ES, D1, D2) {
  		var fields = [
  			'[[Configurable]]',
  			'[[Enumerable]]',
  			'[[Get]]',
  			'[[Set]]',
  			'[[Value]]',
  			'[[Writable]]'
  		];
  		return every(fields, function (field) {
  			if ((field in D1) !== (field in D2)) {
  				return false;
  			}
  			return ES.SameValue(D1[field], D2[field]);
  		});
  	};
  
  
  /***/ }),
  /* 111 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var has = __webpack_require__(86);
  	var $TypeError = GetIntrinsic('%TypeError%');
  
  	module.exports = function IsPropertyDescriptor(ES, Desc) {
  		if (ES.Type(Desc) !== 'Object') {
  			return false;
  		}
  		var allowed = {
  			'[[Configurable]]': true,
  			'[[Enumerable]]': true,
  			'[[Get]]': true,
  			'[[Set]]': true,
  			'[[Value]]': true,
  			'[[Writable]]': true
  		};
  
  	    for (var key in Desc) { // eslint-disable-line
  			if (has(Desc, key) && !allowed[key]) {
  				return false;
  			}
  		}
  
  		if (ES.IsDataDescriptor(Desc) && ES.IsAccessorDescriptor(Desc)) {
  			throw new $TypeError('Property Descriptors may not be both accessor and data descriptors');
  		}
  		return true;
  	};
  
  
  /***/ }),
  /* 112 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var callBind = __webpack_require__(113);
  
  	var $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));
  
  	module.exports = function callBoundIntrinsic(name, allowMissing) {
  		var intrinsic = GetIntrinsic(name, !!allowMissing);
  		if (typeof intrinsic === 'function' && $indexOf(name, '.prototype.')) {
  			return callBind(intrinsic);
  		}
  		return intrinsic;
  	};
  
  
  /***/ }),
  /* 113 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var bind = __webpack_require__(87);
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var $Function = GetIntrinsic('%Function%');
  	var $apply = $Function.apply;
  	var $call = $Function.call;
  
  	module.exports = function callBind() {
  		return bind.apply($call, arguments);
  	};
  
  	module.exports.apply = function applyBind() {
  		return bind.apply($apply, arguments);
  	};
  
  
  /***/ }),
  /* 114 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var $test = GetIntrinsic('RegExp.prototype.test');
  
  	var callBind = __webpack_require__(113);
  
  	module.exports = function regexTester(regex) {
  		return callBind($test, regex);
  	};
  
  
  /***/ }),
  /* 115 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var hasSymbols = __webpack_require__(95)();
  	var GetIntrinsic = __webpack_require__(99);
  	var callBound = __webpack_require__(112);
  
  	var $iterator = GetIntrinsic('%Symbol.iterator%', true);
  	var $arraySlice = callBound('Array.prototype.slice');
  	var $arrayJoin = callBound('Array.prototype.join');
  
  	module.exports = function getIteratorMethod(ES, iterable) {
  		var usingIterator;
  		if (hasSymbols) {
  			usingIterator = ES.GetMethod(iterable, $iterator);
  		} else if (ES.IsArray(iterable)) {
  			usingIterator = function () {
  				var i = -1;
  				var arr = this; // eslint-disable-line no-invalid-this
  				return {
  					next: function () {
  						i += 1;
  						return {
  							done: i >= arr.length,
  							value: arr[i]
  						};
  					}
  				};
  			};
  		} else if (ES.Type(iterable) === 'String') {
  			usingIterator = function () {
  				var i = 0;
  				return {
  					next: function () {
  						var nextIndex = ES.AdvanceStringIndex(iterable, i, true);
  						var value = $arrayJoin($arraySlice(iterable, i, nextIndex), '');
  						i = nextIndex;
  						return {
  							done: nextIndex > iterable.length,
  							value: value
  						};
  					}
  				};
  			};
  		}
  		return usingIterator;
  	};
  
  
  /***/ }),
  /* 116 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var callBound = __webpack_require__(112);
  
  	var $SyntaxError = GetIntrinsic('%SyntaxError%');
  	var symToStr = callBound('Symbol.prototype.toString', true);
  
  	var getInferredName = __webpack_require__(117);
  
  	module.exports = function getSymbolDescription(symbol) {
  		if (!symToStr) {
  			throw new $SyntaxError('Symbols are not supported in this environment');
  		}
  		var str = symToStr(symbol); // will throw if not a symbol
  
  		if (getInferredName) {
  			var name = getInferredName(symbol);
  			if (name === '') { return; }
  			// eslint-disable-next-line consistent-return
  			return name.slice(1, -1); // name.slice('['.length, -']'.length);
  		}
  
  		var desc = str.slice(7, -1); // str.slice('Symbol('.length, -')'.length);
  		if (desc) {
  			// eslint-disable-next-line consistent-return
  			return desc;
  		}
  	};
  
  
  /***/ }),
  /* 117 */
  /***/ (function(module, exports) {
  
  	'use strict';
  
  	var getInferredName;
  	try {
  		// eslint-disable-next-line no-new-func
  		getInferredName = Function('s', 'return { [s]() {} }[s].name;');
  	} catch (e) {}
  
  	var inferred = function () {};
  	module.exports = getInferredName && inferred.name === 'inferred' ? getInferredName : null;
  
  
  /***/ }),
  /* 118 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var originalSetProto = GetIntrinsic('%Object.setPrototypeOf%', true);
  	var $ArrayProto = GetIntrinsic('%Array.prototype%');
  
  	module.exports = originalSetProto || (
  		// eslint-disable-next-line no-proto, no-negated-condition
  		[].__proto__ !== $ArrayProto
  			? null
  			: function (O, proto) {
  				O.__proto__ = proto; // eslint-disable-line no-proto
  				return O;
  			}
  	);
  
  
  /***/ }),
  /* 119 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var $Object = GetIntrinsic('%Object%');
  	var $EvalError = GetIntrinsic('%EvalError%');
  	var $TypeError = GetIntrinsic('%TypeError%');
  	var $String = GetIntrinsic('%String%');
  	var $Date = GetIntrinsic('%Date%');
  	var $Number = GetIntrinsic('%Number%');
  	var $floor = GetIntrinsic('%Math.floor%');
  	var $DateUTC = GetIntrinsic('%Date.UTC%');
  	var $abs = GetIntrinsic('%Math.abs%');
  
  	var assertRecord = __webpack_require__(100);
  	var isPropertyDescriptor = __webpack_require__(111);
  	var $isNaN = __webpack_require__(101);
  	var $isFinite = __webpack_require__(102);
  	var sign = __webpack_require__(105);
  	var mod = __webpack_require__(106);
  	var isPrefixOf = __webpack_require__(120);
  	var callBound = __webpack_require__(112);
  
  	var IsCallable = __webpack_require__(92);
  	var toPrimitive = __webpack_require__(121);
  
  	var has = __webpack_require__(86);
  
  	var $getUTCFullYear = callBound('Date.prototype.getUTCFullYear');
  
  	var HoursPerDay = 24;
  	var MinutesPerHour = 60;
  	var SecondsPerMinute = 60;
  	var msPerSecond = 1e3;
  	var msPerMinute = msPerSecond * SecondsPerMinute;
  	var msPerHour = msPerMinute * MinutesPerHour;
  	var msPerDay = 86400000;
  
  	// https://es5.github.io/#x9
  	var ES5 = {
  		ToPrimitive: toPrimitive,
  
  		ToBoolean: function ToBoolean(value) {
  			return !!value;
  		},
  		ToNumber: function ToNumber(value) {
  			return +value; // eslint-disable-line no-implicit-coercion
  		},
  		ToInteger: function ToInteger(value) {
  			var number = this.ToNumber(value);
  			if ($isNaN(number)) { return 0; }
  			if (number === 0 || !$isFinite(number)) { return number; }
  			return sign(number) * Math.floor(Math.abs(number));
  		},
  		ToInt32: function ToInt32(x) {
  			return this.ToNumber(x) >> 0;
  		},
  		ToUint32: function ToUint32(x) {
  			return this.ToNumber(x) >>> 0;
  		},
  		ToUint16: function ToUint16(value) {
  			var number = this.ToNumber(value);
  			if ($isNaN(number) || number === 0 || !$isFinite(number)) { return 0; }
  			var posInt = sign(number) * Math.floor(Math.abs(number));
  			return mod(posInt, 0x10000);
  		},
  		ToString: function ToString(value) {
  			return $String(value);
  		},
  		ToObject: function ToObject(value) {
  			this.CheckObjectCoercible(value);
  			return $Object(value);
  		},
  		CheckObjectCoercible: function CheckObjectCoercible(value, optMessage) {
  			/* jshint eqnull:true */
  			if (value == null) {
  				throw new $TypeError(optMessage || 'Cannot call method on ' + value);
  			}
  			return value;
  		},
  		IsCallable: IsCallable,
  		SameValue: function SameValue(x, y) {
  			if (x === y) { // 0 === -0, but they are not identical.
  				if (x === 0) { return 1 / x === 1 / y; }
  				return true;
  			}
  			return $isNaN(x) && $isNaN(y);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-8
  		Type: function Type(x) {
  			if (x === null) {
  				return 'Null';
  			}
  			if (typeof x === 'undefined') {
  				return 'Undefined';
  			}
  			if (typeof x === 'function' || typeof x === 'object') {
  				return 'Object';
  			}
  			if (typeof x === 'number') {
  				return 'Number';
  			}
  			if (typeof x === 'boolean') {
  				return 'Boolean';
  			}
  			if (typeof x === 'string') {
  				return 'String';
  			}
  		},
  
  		// https://ecma-international.org/ecma-262/6.0/#sec-property-descriptor-specification-type
  		IsPropertyDescriptor: function IsPropertyDescriptor(Desc) {
  			return isPropertyDescriptor(this, Desc);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-8.10.1
  		IsAccessorDescriptor: function IsAccessorDescriptor(Desc) {
  			if (typeof Desc === 'undefined') {
  				return false;
  			}
  
  			assertRecord(this, 'Property Descriptor', 'Desc', Desc);
  
  			if (!has(Desc, '[[Get]]') && !has(Desc, '[[Set]]')) {
  				return false;
  			}
  
  			return true;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-8.10.2
  		IsDataDescriptor: function IsDataDescriptor(Desc) {
  			if (typeof Desc === 'undefined') {
  				return false;
  			}
  
  			assertRecord(this, 'Property Descriptor', 'Desc', Desc);
  
  			if (!has(Desc, '[[Value]]') && !has(Desc, '[[Writable]]')) {
  				return false;
  			}
  
  			return true;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-8.10.3
  		IsGenericDescriptor: function IsGenericDescriptor(Desc) {
  			if (typeof Desc === 'undefined') {
  				return false;
  			}
  
  			assertRecord(this, 'Property Descriptor', 'Desc', Desc);
  
  			if (!this.IsAccessorDescriptor(Desc) && !this.IsDataDescriptor(Desc)) {
  				return true;
  			}
  
  			return false;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-8.10.4
  		FromPropertyDescriptor: function FromPropertyDescriptor(Desc) {
  			if (typeof Desc === 'undefined') {
  				return Desc;
  			}
  
  			assertRecord(this, 'Property Descriptor', 'Desc', Desc);
  
  			if (this.IsDataDescriptor(Desc)) {
  				return {
  					value: Desc['[[Value]]'],
  					writable: !!Desc['[[Writable]]'],
  					enumerable: !!Desc['[[Enumerable]]'],
  					configurable: !!Desc['[[Configurable]]']
  				};
  			} else if (this.IsAccessorDescriptor(Desc)) {
  				return {
  					get: Desc['[[Get]]'],
  					set: Desc['[[Set]]'],
  					enumerable: !!Desc['[[Enumerable]]'],
  					configurable: !!Desc['[[Configurable]]']
  				};
  			} else {
  				throw new $TypeError('FromPropertyDescriptor must be called with a fully populated Property Descriptor');
  			}
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-8.10.5
  		ToPropertyDescriptor: function ToPropertyDescriptor(Obj) {
  			if (this.Type(Obj) !== 'Object') {
  				throw new $TypeError('ToPropertyDescriptor requires an object');
  			}
  
  			var desc = {};
  			if (has(Obj, 'enumerable')) {
  				desc['[[Enumerable]]'] = this.ToBoolean(Obj.enumerable);
  			}
  			if (has(Obj, 'configurable')) {
  				desc['[[Configurable]]'] = this.ToBoolean(Obj.configurable);
  			}
  			if (has(Obj, 'value')) {
  				desc['[[Value]]'] = Obj.value;
  			}
  			if (has(Obj, 'writable')) {
  				desc['[[Writable]]'] = this.ToBoolean(Obj.writable);
  			}
  			if (has(Obj, 'get')) {
  				var getter = Obj.get;
  				if (typeof getter !== 'undefined' && !this.IsCallable(getter)) {
  					throw new TypeError('getter must be a function');
  				}
  				desc['[[Get]]'] = getter;
  			}
  			if (has(Obj, 'set')) {
  				var setter = Obj.set;
  				if (typeof setter !== 'undefined' && !this.IsCallable(setter)) {
  					throw new $TypeError('setter must be a function');
  				}
  				desc['[[Set]]'] = setter;
  			}
  
  			if ((has(desc, '[[Get]]') || has(desc, '[[Set]]')) && (has(desc, '[[Value]]') || has(desc, '[[Writable]]'))) {
  				throw new $TypeError('Invalid property descriptor. Cannot both specify accessors and a value or writable attribute');
  			}
  			return desc;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-11.9.3
  		'Abstract Equality Comparison': function AbstractEqualityComparison(x, y) {
  			var xType = this.Type(x);
  			var yType = this.Type(y);
  			if (xType === yType) {
  				return x === y; // ES6+ specified this shortcut anyways.
  			}
  			if (x == null && y == null) {
  				return true;
  			}
  			if (xType === 'Number' && yType === 'String') {
  				return this['Abstract Equality Comparison'](x, this.ToNumber(y));
  			}
  			if (xType === 'String' && yType === 'Number') {
  				return this['Abstract Equality Comparison'](this.ToNumber(x), y);
  			}
  			if (xType === 'Boolean') {
  				return this['Abstract Equality Comparison'](this.ToNumber(x), y);
  			}
  			if (yType === 'Boolean') {
  				return this['Abstract Equality Comparison'](x, this.ToNumber(y));
  			}
  			if ((xType === 'String' || xType === 'Number') && yType === 'Object') {
  				return this['Abstract Equality Comparison'](x, this.ToPrimitive(y));
  			}
  			if (xType === 'Object' && (yType === 'String' || yType === 'Number')) {
  				return this['Abstract Equality Comparison'](this.ToPrimitive(x), y);
  			}
  			return false;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-11.9.6
  		'Strict Equality Comparison': function StrictEqualityComparison(x, y) {
  			var xType = this.Type(x);
  			var yType = this.Type(y);
  			if (xType !== yType) {
  				return false;
  			}
  			if (xType === 'Undefined' || xType === 'Null') {
  				return true;
  			}
  			return x === y; // shortcut for steps 4-7
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-11.8.5
  		// eslint-disable-next-line max-statements
  		'Abstract Relational Comparison': function AbstractRelationalComparison(x, y, LeftFirst) {
  			if (this.Type(LeftFirst) !== 'Boolean') {
  				throw new $TypeError('Assertion failed: LeftFirst argument must be a Boolean');
  			}
  			var px;
  			var py;
  			if (LeftFirst) {
  				px = this.ToPrimitive(x, $Number);
  				py = this.ToPrimitive(y, $Number);
  			} else {
  				py = this.ToPrimitive(y, $Number);
  				px = this.ToPrimitive(x, $Number);
  			}
  			var bothStrings = this.Type(px) === 'String' && this.Type(py) === 'String';
  			if (!bothStrings) {
  				var nx = this.ToNumber(px);
  				var ny = this.ToNumber(py);
  				if ($isNaN(nx) || $isNaN(ny)) {
  					return undefined;
  				}
  				if ($isFinite(nx) && $isFinite(ny) && nx === ny) {
  					return false;
  				}
  				if (nx === 0 && ny === 0) {
  					return false;
  				}
  				if (nx === Infinity) {
  					return false;
  				}
  				if (ny === Infinity) {
  					return true;
  				}
  				if (ny === -Infinity) {
  					return false;
  				}
  				if (nx === -Infinity) {
  					return true;
  				}
  				return nx < ny; // by now, these are both nonzero, finite, and not equal
  			}
  			if (isPrefixOf(py, px)) {
  				return false;
  			}
  			if (isPrefixOf(px, py)) {
  				return true;
  			}
  			return px < py; // both strings, neither a prefix of the other. shortcut for steps c-f
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10
  		msFromTime: function msFromTime(t) {
  			return mod(t, msPerSecond);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10
  		SecFromTime: function SecFromTime(t) {
  			return mod($floor(t / msPerSecond), SecondsPerMinute);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10
  		MinFromTime: function MinFromTime(t) {
  			return mod($floor(t / msPerMinute), MinutesPerHour);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.10
  		HourFromTime: function HourFromTime(t) {
  			return mod($floor(t / msPerHour), HoursPerDay);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.2
  		Day: function Day(t) {
  			return $floor(t / msPerDay);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.2
  		TimeWithinDay: function TimeWithinDay(t) {
  			return mod(t, msPerDay);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
  		DayFromYear: function DayFromYear(y) {
  			return (365 * (y - 1970)) + $floor((y - 1969) / 4) - $floor((y - 1901) / 100) + $floor((y - 1601) / 400);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
  		TimeFromYear: function TimeFromYear(y) {
  			return msPerDay * this.DayFromYear(y);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
  		YearFromTime: function YearFromTime(t) {
  			// largest y such that this.TimeFromYear(y) <= t
  			return $getUTCFullYear(new $Date(t));
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.6
  		WeekDay: function WeekDay(t) {
  			return mod(this.Day(t) + 4, 7);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
  		DaysInYear: function DaysInYear(y) {
  			if (mod(y, 4) !== 0) {
  				return 365;
  			}
  			if (mod(y, 100) !== 0) {
  				return 366;
  			}
  			if (mod(y, 400) !== 0) {
  				return 365;
  			}
  			return 366;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.3
  		InLeapYear: function InLeapYear(t) {
  			var days = this.DaysInYear(this.YearFromTime(t));
  			if (days === 365) {
  				return 0;
  			}
  			if (days === 366) {
  				return 1;
  			}
  			throw new $EvalError('Assertion failed: there are not 365 or 366 days in a year, got: ' + days);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.4
  		DayWithinYear: function DayWithinYear(t) {
  			return this.Day(t) - this.DayFromYear(this.YearFromTime(t));
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.4
  		MonthFromTime: function MonthFromTime(t) {
  			var day = this.DayWithinYear(t);
  			if (0 <= day && day < 31) {
  				return 0;
  			}
  			var leap = this.InLeapYear(t);
  			if (31 <= day && day < (59 + leap)) {
  				return 1;
  			}
  			if ((59 + leap) <= day && day < (90 + leap)) {
  				return 2;
  			}
  			if ((90 + leap) <= day && day < (120 + leap)) {
  				return 3;
  			}
  			if ((120 + leap) <= day && day < (151 + leap)) {
  				return 4;
  			}
  			if ((151 + leap) <= day && day < (181 + leap)) {
  				return 5;
  			}
  			if ((181 + leap) <= day && day < (212 + leap)) {
  				return 6;
  			}
  			if ((212 + leap) <= day && day < (243 + leap)) {
  				return 7;
  			}
  			if ((243 + leap) <= day && day < (273 + leap)) {
  				return 8;
  			}
  			if ((273 + leap) <= day && day < (304 + leap)) {
  				return 9;
  			}
  			if ((304 + leap) <= day && day < (334 + leap)) {
  				return 10;
  			}
  			if ((334 + leap) <= day && day < (365 + leap)) {
  				return 11;
  			}
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.5
  		DateFromTime: function DateFromTime(t) {
  			var m = this.MonthFromTime(t);
  			var d = this.DayWithinYear(t);
  			if (m === 0) {
  				return d + 1;
  			}
  			if (m === 1) {
  				return d - 30;
  			}
  			var leap = this.InLeapYear(t);
  			if (m === 2) {
  				return d - 58 - leap;
  			}
  			if (m === 3) {
  				return d - 89 - leap;
  			}
  			if (m === 4) {
  				return d - 119 - leap;
  			}
  			if (m === 5) {
  				return d - 150 - leap;
  			}
  			if (m === 6) {
  				return d - 180 - leap;
  			}
  			if (m === 7) {
  				return d - 211 - leap;
  			}
  			if (m === 8) {
  				return d - 242 - leap;
  			}
  			if (m === 9) {
  				return d - 272 - leap;
  			}
  			if (m === 10) {
  				return d - 303 - leap;
  			}
  			if (m === 11) {
  				return d - 333 - leap;
  			}
  			throw new $EvalError('Assertion failed: MonthFromTime returned an impossible value: ' + m);
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.12
  		MakeDay: function MakeDay(year, month, date) {
  			if (!$isFinite(year) || !$isFinite(month) || !$isFinite(date)) {
  				return NaN;
  			}
  			var y = this.ToInteger(year);
  			var m = this.ToInteger(month);
  			var dt = this.ToInteger(date);
  			var ym = y + $floor(m / 12);
  			var mn = mod(m, 12);
  			var t = $DateUTC(ym, mn, 1);
  			if (this.YearFromTime(t) !== ym || this.MonthFromTime(t) !== mn || this.DateFromTime(t) !== 1) {
  				return NaN;
  			}
  			return this.Day(t) + dt - 1;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.13
  		MakeDate: function MakeDate(day, time) {
  			if (!$isFinite(day) || !$isFinite(time)) {
  				return NaN;
  			}
  			return (day * msPerDay) + time;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.11
  		MakeTime: function MakeTime(hour, min, sec, ms) {
  			if (!$isFinite(hour) || !$isFinite(min) || !$isFinite(sec) || !$isFinite(ms)) {
  				return NaN;
  			}
  			var h = this.ToInteger(hour);
  			var m = this.ToInteger(min);
  			var s = this.ToInteger(sec);
  			var milli = this.ToInteger(ms);
  			var t = (h * msPerHour) + (m * msPerMinute) + (s * msPerSecond) + milli;
  			return t;
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-15.9.1.14
  		TimeClip: function TimeClip(time) {
  			if (!$isFinite(time) || $abs(time) > 8.64e15) {
  				return NaN;
  			}
  			return $Number(new $Date(this.ToNumber(time)));
  		},
  
  		// https://ecma-international.org/ecma-262/5.1/#sec-5.2
  		modulo: function modulo(x, y) {
  			return mod(x, y);
  		}
  	};
  
  	module.exports = ES5;
  
  
  /***/ }),
  /* 120 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var $strSlice = __webpack_require__(112)('String.prototype.slice');
  
  	module.exports = function isPrefixOf(prefix, string) {
  		if (prefix === string) {
  			return true;
  		}
  		if (prefix.length > string.length) {
  			return false;
  		}
  		return $strSlice(string, 0, prefix.length) === prefix;
  	};
  
  
  /***/ }),
  /* 121 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var toStr = Object.prototype.toString;
  
  	var isPrimitive = __webpack_require__(91);
  
  	var isCallable = __webpack_require__(92);
  
  	// http://ecma-international.org/ecma-262/5.1/#sec-8.12.8
  	var ES5internalSlots = {
  		'[[DefaultValue]]': function (O) {
  			var actualHint;
  			if (arguments.length > 1) {
  				actualHint = arguments[1];
  			} else {
  				actualHint = toStr.call(O) === '[object Date]' ? String : Number;
  			}
  
  			if (actualHint === String || actualHint === Number) {
  				var methods = actualHint === String ? ['toString', 'valueOf'] : ['valueOf', 'toString'];
  				var value, i;
  				for (i = 0; i < methods.length; ++i) {
  					if (isCallable(O[methods[i]])) {
  						value = O[methods[i]]();
  						if (isPrimitive(value)) {
  							return value;
  						}
  					}
  				}
  				throw new TypeError('No default value');
  			}
  			throw new TypeError('invalid [[DefaultValue]] hint supplied');
  		}
  	};
  
  	// http://ecma-international.org/ecma-262/5.1/#sec-9.1
  	module.exports = function ToPrimitive(input) {
  		if (isPrimitive(input)) {
  			return input;
  		}
  		if (arguments.length > 1) {
  			return ES5internalSlots['[[DefaultValue]]'](input, arguments[1]);
  		}
  		return ES5internalSlots['[[DefaultValue]]'](input);
  	};
  
  
  /***/ }),
  /* 122 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var has = __webpack_require__(86);
  	var regexExec = RegExp.prototype.exec;
  	var gOPD = Object.getOwnPropertyDescriptor;
  
  	var tryRegexExecCall = function tryRegexExec(value) {
  		try {
  			var lastIndex = value.lastIndex;
  			value.lastIndex = 0;
  
  			regexExec.call(value);
  			return true;
  		} catch (e) {
  			return false;
  		} finally {
  			value.lastIndex = lastIndex;
  		}
  	};
  	var toStr = Object.prototype.toString;
  	var regexClass = '[object RegExp]';
  	var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
  
  	module.exports = function isRegex(value) {
  		if (!value || typeof value !== 'object') {
  			return false;
  		}
  		if (!hasToStringTag) {
  			return toStr.call(value) === regexClass;
  		}
  
  		var descriptor = gOPD(value, 'lastIndex');
  		var hasLastIndexDataProperty = descriptor && has(descriptor, 'value');
  		if (!hasLastIndexDataProperty) {
  			return false;
  		}
  
  		return tryRegexExecCall(value);
  	};
  
  
  /***/ }),
  /* 123 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var GetIntrinsic = __webpack_require__(99);
  
  	var originalGetProto = GetIntrinsic('%Object.getPrototypeOf%', true);
  	var $ArrayProto = GetIntrinsic('%Array.prototype%');
  
  	module.exports = originalGetProto || (
  		// eslint-disable-next-line no-proto
  		[].__proto__ === $ArrayProto
  			? function (O) {
  				return O.__proto__; // eslint-disable-line no-proto
  			}
  			: null
  	);
  
  
  /***/ }),
  /* 124 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var implementation = __webpack_require__(82);
  
  	module.exports = function getPolyfill() {
  		return typeof Object.getOwnPropertyDescriptors === 'function' ? Object.getOwnPropertyDescriptors : implementation;
  	};
  
  
  /***/ }),
  /* 125 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var getPolyfill = __webpack_require__(124);
  	var define = __webpack_require__(73);
  
  	module.exports = function shimGetOwnPropertyDescriptors() {
  		var polyfill = getPolyfill();
  		define(
  			Object,
  			{ getOwnPropertyDescriptors: polyfill },
  			{ getOwnPropertyDescriptors: function () { return Object.getOwnPropertyDescriptors !== polyfill; } }
  		);
  		return polyfill;
  	};
  
  
  /***/ }),
  /* 126 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var util = __webpack_require__(77);
  	var implementation = __webpack_require__(80);
  
  	module.exports = function getPolyfill() {
  		if (typeof util.promisify === 'function') {
  			return util.promisify;
  		}
  		return implementation;
  	};
  
  
  /***/ }),
  /* 127 */
  /***/ (function(module, exports, __webpack_require__) {
  
  	'use strict';
  
  	var util = __webpack_require__(77);
  	var getPolyfill = __webpack_require__(126);
  
  	module.exports = function shimUtilPromisify() {
  		var polyfill = getPolyfill();
  		if (polyfill !== util.promisify) {
  			util.promisify = polyfill;
  			Object.defineProperty(util, 'promisify', { value: polyfill });
  		}
  		return polyfill;
  	};
  
  
  /***/ })
  /******/ ]);