{"version":3,"sources":["webpack:///./node_modules/xml-js/lib/xml2json.js","webpack:///./node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/readable-stream/writable-browser.js","webpack:///./node_modules/sax/lib/sax.js","webpack:///./node_modules/core-util-is/lib/util.js","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/xml-js/lib/json2xml.js","webpack:///./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./node_modules/xml-js/lib/xml2js.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/process-nextick-args/index.js","webpack:///./node_modules/xml-js/lib/options-helper.js","webpack:///./node_modules/xml-js/lib/array-helper.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/readable-stream/passthrough.js","webpack:///./node_modules/xml-js/lib/index.js","webpack:///./node_modules/xml-js/lib/js2xml.js","webpack:///./node_modules/readable-stream/transform.js","webpack:///./node_modules/stream-browserify/index.js","webpack:///./node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/events/events.js"],"names":["helper","xml2js","validateOptions","userOptions","options","copyOptions","ensureSpacesExists","module","exports","xml","js","json","parentKey","compact","addParent","JSON","stringify","k","v","spaces","replace","Transform","Duplex","util","Object","create","afterTransform","er","data","ts","this","_transformState","transforming","cb","writecb","emit","Error","writechunk","push","rs","_readableState","reading","needReadable","length","highWaterMark","_read","call","bind","needTransform","writeencoding","sync","transform","_transform","flush","_flush","on","prefinish","_this","done","stream","_writableState","inherits","prototype","chunk","encoding","_write","n","_destroy","err","_this2","err2","sax","parser","strict","opt","SAXParser","SAXStream","createStream","MAX_BUFFER_LENGTH","Stream","buffers","clearBuffers","q","c","bufferCheckPosition","lowercase","lowercasetags","looseCase","tags","closed","closedRoot","sawRoot","tag","error","noscript","state","S","BEGIN","strictEntities","ENTITIES","XML_ENTITIES","attribList","xmlns","ns","rootNS","trackPosition","position","line","column","checkBufferLength","maxAllowed","Math","max","maxActual","i","l","len","closeText","emitNode","cdata","script","m","flushBuffers","EVENTS","o","F","newf","keys","a","hasOwnProperty","end","write","resume","close","ex","streamWraps","filter","ev","apply","_parser","writable","readable","me","onend","onerror","_decoder","forEach","defineProperty","get","set","h","removeAllListeners","enumerable","configurable","constructor","value","Buffer","isBuffer","SD","StringDecoder","toString","handler","indexOf","args","arguments","Array","splice","CDATA","DOCTYPE","XML_NAMESPACE","XMLNS_NAMESPACE","nameStart","nameBody","entityStart","entityBody","isWhitespace","isQuote","isAttribEnd","isMatch","regex","test","notMatch","s","STATE","BEGIN_WHITESPACE","TEXT","TEXT_ENTITY","OPEN_WAKA","SGML_DECL","SGML_DECL_QUOTED","DOCTYPE_QUOTED","DOCTYPE_DTD","DOCTYPE_DTD_QUOTED","COMMENT_STARTING","COMMENT","COMMENT_ENDING","COMMENT_ENDED","CDATA_ENDING","CDATA_ENDING_2","PROC_INST","PROC_INST_BODY","PROC_INST_ENDING","OPEN_TAG","OPEN_TAG_SLASH","ATTRIB","ATTRIB_NAME","ATTRIB_NAME_SAW_WHITE","ATTRIB_VALUE","ATTRIB_VALUE_QUOTED","ATTRIB_VALUE_CLOSED","ATTRIB_VALUE_UNQUOTED","ATTRIB_VALUE_ENTITY_Q","ATTRIB_VALUE_ENTITY_U","CLOSE_TAG","CLOSE_TAG_SAW_WHITE","SCRIPT","SCRIPT_ENDING","key","e","String","fromCharCode","event","nodeType","textNode","textopts","text","trim","normalize","strictFail","message","newTag","tagName","parent","name","attributes","qname","attribute","qualName","split","prefix","local","attrib","attribName","attribValue","qn","openTag","selfClosing","uri","p","nv","isSelfClosing","toLowerCase","closeTag","t","closeTo","pop","x","parseEntity","num","entity","entityLC","numStr","charAt","slice","parseInt","isNaN","fromCodePoint","beginWhiteSpace","startTagPosition","result","starti","substring","sgmlDecl","procInstName","procInstBody","pad","join","toUpperCase","comment","doctype","body","returnState","buffer","stringFromCharCode","floor","highSurrogate","lowSurrogate","MAX_SIZE","codeUnits","index","codePoint","Number","isFinite","RangeError","isArray","arg","objectToString","isBoolean","isNull","isNullOrUndefined","isNumber","isString","isSymbol","isUndefined","isRegExp","re","isObject","isDate","d","isError","isFunction","isPrimitive","ctor","superCtor","super_","TempCtor","EventEmitter","pna","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","nextTick","emitErrorNT","undestroy","ended","endEmitted","ending","finished","self","parse","js2xml","_classCallCheck","instance","Constructor","TypeError","copyBuffer","src","target","offset","copy","BufferList","head","tail","entry","next","unshift","shift","ret","clear","concat","alloc","allocUnsafe","inspect","custom","obj","PassThrough","isEncoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","nb","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","buf","j","utf8CheckExtraBytes","r","undefined","utf8Text","total","utf8End","charCodeAt","currentElement","expat","pureJsParser","ensureFlagExists","ensureAlwaysArrayExists","ensureKeyExists","checkFnExists","nativeType","nValue","bValue","addField","type","alwaysArray","instructionFn","temp","instructionNameFn","elementsKey","element","typeKey","nameKey","instructionHasAttributes","attributesKey","instructionKey","manipulateAttributes","attributesFn","nativeTypeAttributes","attributeValueFn","attributeNameFn","onInstruction","instruction","match","attrsRegExp","exec","ignoreDeclaration","declarationKey","ignoreInstruction","onStartElement","elementNameFn","ignoreAttributes","alwaysChildren","onText","ignoreText","captureSpacesBetweenElements","sanitize","onComment","ignoreComment","onEndElement","parentElement","onCdata","ignoreCdata","onDoctype","ignoreDoctype","onError","note","Parser","onopentag","ontext","oncomment","onclosetag","oncdata","ondoctype","onprocessinginstruction","getError","copyProps","dst","SafeBuffer","encodingOrOffset","from","allocUnsafeSlow","size","fill","SlowBuffer","fn","arg1","arg2","arg3","process","version","item","Readable","ReadableState","EElistenerCount","emitter","listeners","OurUint8Array","global","Uint8Array","_uint8ArrayToBuffer","_isUint8Array","debugUtil","debug","debuglog","destroyImpl","kProxyEvents","prependListener","_events","isDuplex","objectMode","readableObjectMode","hwm","readableHwm","readableHighWaterMark","defaultHwm","pipes","pipesCount","flowing","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","read","readableAddChunk","addToFront","skipChunkCheck","onEofChunk","chunkInvalid","getPrototypeOf","addChunk","maybeReadMore","needMoreData","emitReadable","_undestroy","isPaused","setEncoding","MAX_HWM","computeNewHighWaterMark","howMuchToRead","emitReadable_","flow","maybeReadMore_","pipeOnDrain","nReadingNextTick","resume_","fromList","fromListPartial","list","hasStrings","copyFromBufferString","copyFromBuffer","str","endReadable","endReadableNT","xs","nOrig","doRead","pipe","dest","pipeOpts","doEnd","stdout","stderr","endFn","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","once","ondrain","cleanedUp","removeListener","onclose","onfinish","ondata","needDrain","increasedAwaitDrain","pause","dests","res","addListener","wrap","paused","method","_fromList","objectKeys","Writable","allowHalfOpen","onEndNT","xml2json","json2xml","currentElementName","writeIndentation","depth","firstLine","writeAttributes","attr","attrName","quote","noQuotesForNativeAttributes","indentAttributes","writeDeclaration","declaration","writeInstruction","instructionName","instructionValue","writeComment","commentFn","writeCdata","cdataFn","writeDoctype","doctypeFn","writeText","textFn","hasContent","elements","indentText","indentCdata","indentInstruction","writeElement","elementName","withClosingTag","fullTagEmptyElementFn","fullTagEmptyElement","writeElements","reduce","indent","commentKey","doctypeKey","cdataKey","textKey","hasContentCompact","anyContent","writeElementCompact","writeElementsCompact","nodes","EE","source","_isStdio","didOnEnd","listenerCount","CorkedRequest","finish","onCorkedFinish","asyncWrite","browser","setImmediate","WritableState","internalUtil","deprecate","realHasInstance","nop","writableObjectMode","writableHwm","writableHighWaterMark","finalCalled","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","bufferedRequestCount","corkedRequestsFree","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","last","callback","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","count","allBuffers","callFinal","need","endWritable","corkReq","getBuffer","current","out","_","Symbol","hasInstance","Function","object","cork","uncork","setDefaultEncoding","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","ProcessEmitWarning","warning","console","warn","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","init","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","events","existing","newListener","warned","w","onceWrapper","fired","wrapFn","_onceWrap","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","arr","spliceOne","Promise","resolve","reject","errorListener","resolver","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","flags","addEventListener","wrapListener","removeEventListener","setMaxListeners","getMaxListeners","doError","context","prependOnceListener","originalListener","off","rawListeners","eventNames"],"mappings":"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","file":"js/chunk-2f7317ab.0210cc7a.js","sourcesContent":["var helper = require('./options-helper');\r\nvar xml2js = require('./xml2js');\r\n\r\nfunction validateOptions (userOptions) {\r\n  var options = helper.copyOptions(userOptions);\r\n  helper.ensureSpacesExists(options);\r\n  return options;\r\n}\r\n\r\nmodule.exports = function(xml, userOptions) {\r\n  var options, js, json, parentKey;\r\n  options = validateOptions(userOptions);\r\n  js = xml2js(xml, options);\r\n  parentKey = 'compact' in options && options.compact ? '_parent' : 'parent';\r\n  // parentKey = ptions.compact ? '_parent' : 'parent'; // consider this\r\n  if ('addParent' in options && options.addParent) {\r\n    json = JSON.stringify(js, function (k, v) { return k === parentKey? '_' : v; }, options.spaces);\r\n  } else {\r\n    json = JSON.stringify(js, null, options.spaces);\r\n  }\r\n  return json.replace(/\\u2028/g, '\\\\u2028').replace(/\\u2029/g, '\\\\u2029');\r\n};\r\n","module.exports = require('./lib/_stream_duplex.js');\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict';\n\nmodule.exports = Transform;\n\nvar Duplex = require('./_stream_duplex');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n  var ts = this._transformState;\n  ts.transforming = false;\n\n  var cb = ts.writecb;\n\n  if (!cb) {\n    return this.emit('error', new Error('write callback called multiple times'));\n  }\n\n  ts.writechunk = null;\n  ts.writecb = null;\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    this.push(data);\n\n  cb(er);\n\n  var rs = this._readableState;\n  rs.reading = false;\n  if (rs.needReadable || rs.length < rs.highWaterMark) {\n    this._read(rs.highWaterMark);\n  }\n}\n\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options);\n\n  Duplex.call(this, options);\n\n  this._transformState = {\n    afterTransform: afterTransform.bind(this),\n    needTransform: false,\n    transforming: false,\n    writecb: null,\n    writechunk: null,\n    writeencoding: null\n  };\n\n  // start out asking for a readable event once data is transformed.\n  this._readableState.needReadable = true;\n\n  // we have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false;\n\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform;\n\n    if (typeof options.flush === 'function') this._flush = options.flush;\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n  var _this = this;\n\n  if (typeof this._flush === 'function') {\n    this._flush(function (er, data) {\n      done(_this, er, data);\n    });\n  } else {\n    done(this, null, null);\n  }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n  this._transformState.needTransform = false;\n  return Duplex.prototype.push.call(this, chunk, encoding);\n};\n\n// This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side.  You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk.  If you pass\n// an error, then that'll put the hurt on the whole operation.  If you\n// never call cb(), then you'll never get another chunk.\nTransform.prototype._transform = function (chunk, encoding, cb) {\n  throw new Error('_transform() is not implemented');\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n  var ts = this._transformState;\n  ts.writecb = cb;\n  ts.writechunk = chunk;\n  ts.writeencoding = encoding;\n  if (!ts.transforming) {\n    var rs = this._readableState;\n    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n  }\n};\n\n// Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\nTransform.prototype._read = function (n) {\n  var ts = this._transformState;\n\n  if (ts.writechunk !== null && ts.writecb && !ts.transforming) {\n    ts.transforming = true;\n    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n  } else {\n    // mark that we need a transform, so that any data that comes in\n    // will get processed, now that we've asked for it.\n    ts.needTransform = true;\n  }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n  var _this2 = this;\n\n  Duplex.prototype._destroy.call(this, err, function (err2) {\n    cb(err2);\n    _this2.emit('close');\n  });\n};\n\nfunction done(stream, er, data) {\n  if (er) return stream.emit('error', er);\n\n  if (data != null) // single equals check for both `null` and `undefined`\n    stream.push(data);\n\n  // if there's nothing in the write buffer, then that means\n  // that nothing more will ever be provided\n  if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');\n\n  if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');\n\n  return stream.push(null);\n}","module.exports = require('./lib/_stream_writable.js');\n",";(function (sax) { // wrapper for non-node envs\n  sax.parser = function (strict, opt) { return new SAXParser(strict, opt) }\n  sax.SAXParser = SAXParser\n  sax.SAXStream = SAXStream\n  sax.createStream = createStream\n\n  // When we pass the MAX_BUFFER_LENGTH position, start checking for buffer overruns.\n  // When we check, schedule the next check for MAX_BUFFER_LENGTH - (max(buffer lengths)),\n  // since that's the earliest that a buffer overrun could occur.  This way, checks are\n  // as rare as required, but as often as necessary to ensure never crossing this bound.\n  // Furthermore, buffers are only tested at most once per write(), so passing a very\n  // large string into write() might have undesirable effects, but this is manageable by\n  // the caller, so it is assumed to be safe.  Thus, a call to write() may, in the extreme\n  // edge case, result in creating at most one complete copy of the string passed in.\n  // Set to Infinity to have unlimited buffers.\n  sax.MAX_BUFFER_LENGTH = 64 * 1024\n\n  var buffers = [\n    'comment', 'sgmlDecl', 'textNode', 'tagName', 'doctype',\n    'procInstName', 'procInstBody', 'entity', 'attribName',\n    'attribValue', 'cdata', 'script'\n  ]\n\n  sax.EVENTS = [\n    'text',\n    'processinginstruction',\n    'sgmldeclaration',\n    'doctype',\n    'comment',\n    'opentagstart',\n    'attribute',\n    'opentag',\n    'closetag',\n    'opencdata',\n    'cdata',\n    'closecdata',\n    'error',\n    'end',\n    'ready',\n    'script',\n    'opennamespace',\n    'closenamespace'\n  ]\n\n  function SAXParser (strict, opt) {\n    if (!(this instanceof SAXParser)) {\n      return new SAXParser(strict, opt)\n    }\n\n    var parser = this\n    clearBuffers(parser)\n    parser.q = parser.c = ''\n    parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH\n    parser.opt = opt || {}\n    parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags\n    parser.looseCase = parser.opt.lowercase ? 'toLowerCase' : 'toUpperCase'\n    parser.tags = []\n    parser.closed = parser.closedRoot = parser.sawRoot = false\n    parser.tag = parser.error = null\n    parser.strict = !!strict\n    parser.noscript = !!(strict || parser.opt.noscript)\n    parser.state = S.BEGIN\n    parser.strictEntities = parser.opt.strictEntities\n    parser.ENTITIES = parser.strictEntities ? Object.create(sax.XML_ENTITIES) : Object.create(sax.ENTITIES)\n    parser.attribList = []\n\n    // namespaces form a prototype chain.\n    // it always points at the current tag,\n    // which protos to its parent tag.\n    if (parser.opt.xmlns) {\n      parser.ns = Object.create(rootNS)\n    }\n\n    // mostly just for error reporting\n    parser.trackPosition = parser.opt.position !== false\n    if (parser.trackPosition) {\n      parser.position = parser.line = parser.column = 0\n    }\n    emit(parser, 'onready')\n  }\n\n  if (!Object.create) {\n    Object.create = function (o) {\n      function F () {}\n      F.prototype = o\n      var newf = new F()\n      return newf\n    }\n  }\n\n  if (!Object.keys) {\n    Object.keys = function (o) {\n      var a = []\n      for (var i in o) if (o.hasOwnProperty(i)) a.push(i)\n      return a\n    }\n  }\n\n  function checkBufferLength (parser) {\n    var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10)\n    var maxActual = 0\n    for (var i = 0, l = buffers.length; i < l; i++) {\n      var len = parser[buffers[i]].length\n      if (len > maxAllowed) {\n        // Text/cdata nodes can get big, and since they're buffered,\n        // we can get here under normal conditions.\n        // Avoid issues by emitting the text node now,\n        // so at least it won't get any bigger.\n        switch (buffers[i]) {\n          case 'textNode':\n            closeText(parser)\n            break\n\n          case 'cdata':\n            emitNode(parser, 'oncdata', parser.cdata)\n            parser.cdata = ''\n            break\n\n          case 'script':\n            emitNode(parser, 'onscript', parser.script)\n            parser.script = ''\n            break\n\n          default:\n            error(parser, 'Max buffer length exceeded: ' + buffers[i])\n        }\n      }\n      maxActual = Math.max(maxActual, len)\n    }\n    // schedule the next check for the earliest possible buffer overrun.\n    var m = sax.MAX_BUFFER_LENGTH - maxActual\n    parser.bufferCheckPosition = m + parser.position\n  }\n\n  function clearBuffers (parser) {\n    for (var i = 0, l = buffers.length; i < l; i++) {\n      parser[buffers[i]] = ''\n    }\n  }\n\n  function flushBuffers (parser) {\n    closeText(parser)\n    if (parser.cdata !== '') {\n      emitNode(parser, 'oncdata', parser.cdata)\n      parser.cdata = ''\n    }\n    if (parser.script !== '') {\n      emitNode(parser, 'onscript', parser.script)\n      parser.script = ''\n    }\n  }\n\n  SAXParser.prototype = {\n    end: function () { end(this) },\n    write: write,\n    resume: function () { this.error = null; return this },\n    close: function () { return this.write(null) },\n    flush: function () { flushBuffers(this) }\n  }\n\n  var Stream\n  try {\n    Stream = require('stream').Stream\n  } catch (ex) {\n    Stream = function () {}\n  }\n\n  var streamWraps = sax.EVENTS.filter(function (ev) {\n    return ev !== 'error' && ev !== 'end'\n  })\n\n  function createStream (strict, opt) {\n    return new SAXStream(strict, opt)\n  }\n\n  function SAXStream (strict, opt) {\n    if (!(this instanceof SAXStream)) {\n      return new SAXStream(strict, opt)\n    }\n\n    Stream.apply(this)\n\n    this._parser = new SAXParser(strict, opt)\n    this.writable = true\n    this.readable = true\n\n    var me = this\n\n    this._parser.onend = function () {\n      me.emit('end')\n    }\n\n    this._parser.onerror = function (er) {\n      me.emit('error', er)\n\n      // if didn't throw, then means error was handled.\n      // go ahead and clear error, so we can write again.\n      me._parser.error = null\n    }\n\n    this._decoder = null\n\n    streamWraps.forEach(function (ev) {\n      Object.defineProperty(me, 'on' + ev, {\n        get: function () {\n          return me._parser['on' + ev]\n        },\n        set: function (h) {\n          if (!h) {\n            me.removeAllListeners(ev)\n            me._parser['on' + ev] = h\n            return h\n          }\n          me.on(ev, h)\n        },\n        enumerable: true,\n        configurable: false\n      })\n    })\n  }\n\n  SAXStream.prototype = Object.create(Stream.prototype, {\n    constructor: {\n      value: SAXStream\n    }\n  })\n\n  SAXStream.prototype.write = function (data) {\n    if (typeof Buffer === 'function' &&\n      typeof Buffer.isBuffer === 'function' &&\n      Buffer.isBuffer(data)) {\n      if (!this._decoder) {\n        var SD = require('string_decoder').StringDecoder\n        this._decoder = new SD('utf8')\n      }\n      data = this._decoder.write(data)\n    }\n\n    this._parser.write(data.toString())\n    this.emit('data', data)\n    return true\n  }\n\n  SAXStream.prototype.end = function (chunk) {\n    if (chunk && chunk.length) {\n      this.write(chunk)\n    }\n    this._parser.end()\n    return true\n  }\n\n  SAXStream.prototype.on = function (ev, handler) {\n    var me = this\n    if (!me._parser['on' + ev] && streamWraps.indexOf(ev) !== -1) {\n      me._parser['on' + ev] = function () {\n        var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments)\n        args.splice(0, 0, ev)\n        me.emit.apply(me, args)\n      }\n    }\n\n    return Stream.prototype.on.call(me, ev, handler)\n  }\n\n  // this really needs to be replaced with character classes.\n  // XML allows all manner of ridiculous numbers and digits.\n  var CDATA = '[CDATA['\n  var DOCTYPE = 'DOCTYPE'\n  var XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace'\n  var XMLNS_NAMESPACE = 'http://www.w3.org/2000/xmlns/'\n  var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }\n\n  // http://www.w3.org/TR/REC-xml/#NT-NameStartChar\n  // This implementation works on strings, a single character at a time\n  // as such, it cannot ever support astral-plane characters (10000-EFFFF)\n  // without a significant breaking change to either this  parser, or the\n  // JavaScript language.  Implementation of an emoji-capable xml parser\n  // is left as an exercise for the reader.\n  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]/\n\n  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-]/\n\n  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]/\n  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-]/\n\n  function isWhitespace (c) {\n    return c === ' ' || c === '\\n' || c === '\\r' || c === '\\t'\n  }\n\n  function isQuote (c) {\n    return c === '\"' || c === '\\''\n  }\n\n  function isAttribEnd (c) {\n    return c === '>' || isWhitespace(c)\n  }\n\n  function isMatch (regex, c) {\n    return regex.test(c)\n  }\n\n  function notMatch (regex, c) {\n    return !isMatch(regex, c)\n  }\n\n  var S = 0\n  sax.STATE = {\n    BEGIN: S++, // leading byte order mark or whitespace\n    BEGIN_WHITESPACE: S++, // leading whitespace\n    TEXT: S++, // general stuff\n    TEXT_ENTITY: S++, // &amp and such.\n    OPEN_WAKA: S++, // <\n    SGML_DECL: S++, // <!BLARG\n    SGML_DECL_QUOTED: S++, // <!BLARG foo \"bar\n    DOCTYPE: S++, // <!DOCTYPE\n    DOCTYPE_QUOTED: S++, // <!DOCTYPE \"//blah\n    DOCTYPE_DTD: S++, // <!DOCTYPE \"//blah\" [ ...\n    DOCTYPE_DTD_QUOTED: S++, // <!DOCTYPE \"//blah\" [ \"foo\n    COMMENT_STARTING: S++, // <!-\n    COMMENT: S++, // <!--\n    COMMENT_ENDING: S++, // <!-- blah -\n    COMMENT_ENDED: S++, // <!-- blah --\n    CDATA: S++, // <![CDATA[ something\n    CDATA_ENDING: S++, // ]\n    CDATA_ENDING_2: S++, // ]]\n    PROC_INST: S++, // <?hi\n    PROC_INST_BODY: S++, // <?hi there\n    PROC_INST_ENDING: S++, // <?hi \"there\" ?\n    OPEN_TAG: S++, // <strong\n    OPEN_TAG_SLASH: S++, // <strong /\n    ATTRIB: S++, // <a\n    ATTRIB_NAME: S++, // <a foo\n    ATTRIB_NAME_SAW_WHITE: S++, // <a foo _\n    ATTRIB_VALUE: S++, // <a foo=\n    ATTRIB_VALUE_QUOTED: S++, // <a foo=\"bar\n    ATTRIB_VALUE_CLOSED: S++, // <a foo=\"bar\"\n    ATTRIB_VALUE_UNQUOTED: S++, // <a foo=bar\n    ATTRIB_VALUE_ENTITY_Q: S++, // <foo bar=\"&quot;\"\n    ATTRIB_VALUE_ENTITY_U: S++, // <foo bar=&quot\n    CLOSE_TAG: S++, // </a\n    CLOSE_TAG_SAW_WHITE: S++, // </a   >\n    SCRIPT: S++, // <script> ...\n    SCRIPT_ENDING: S++ // <script> ... <\n  }\n\n  sax.XML_ENTITIES = {\n    'amp': '&',\n    'gt': '>',\n    'lt': '<',\n    'quot': '\"',\n    'apos': \"'\"\n  }\n\n  sax.ENTITIES = {\n    'amp': '&',\n    'gt': '>',\n    'lt': '<',\n    'quot': '\"',\n    'apos': \"'\",\n    'AElig': 198,\n    'Aacute': 193,\n    'Acirc': 194,\n    'Agrave': 192,\n    'Aring': 197,\n    'Atilde': 195,\n    'Auml': 196,\n    'Ccedil': 199,\n    'ETH': 208,\n    'Eacute': 201,\n    'Ecirc': 202,\n    'Egrave': 200,\n    'Euml': 203,\n    'Iacute': 205,\n    'Icirc': 206,\n    'Igrave': 204,\n    'Iuml': 207,\n    'Ntilde': 209,\n    'Oacute': 211,\n    'Ocirc': 212,\n    'Ograve': 210,\n    'Oslash': 216,\n    'Otilde': 213,\n    'Ouml': 214,\n    'THORN': 222,\n    'Uacute': 218,\n    'Ucirc': 219,\n    'Ugrave': 217,\n    'Uuml': 220,\n    'Yacute': 221,\n    'aacute': 225,\n    'acirc': 226,\n    'aelig': 230,\n    'agrave': 224,\n    'aring': 229,\n    'atilde': 227,\n    'auml': 228,\n    'ccedil': 231,\n    'eacute': 233,\n    'ecirc': 234,\n    'egrave': 232,\n    'eth': 240,\n    'euml': 235,\n    'iacute': 237,\n    'icirc': 238,\n    'igrave': 236,\n    'iuml': 239,\n    'ntilde': 241,\n    'oacute': 243,\n    'ocirc': 244,\n    'ograve': 242,\n    'oslash': 248,\n    'otilde': 245,\n    'ouml': 246,\n    'szlig': 223,\n    'thorn': 254,\n    'uacute': 250,\n    'ucirc': 251,\n    'ugrave': 249,\n    'uuml': 252,\n    'yacute': 253,\n    'yuml': 255,\n    'copy': 169,\n    'reg': 174,\n    'nbsp': 160,\n    'iexcl': 161,\n    'cent': 162,\n    'pound': 163,\n    'curren': 164,\n    'yen': 165,\n    'brvbar': 166,\n    'sect': 167,\n    'uml': 168,\n    'ordf': 170,\n    'laquo': 171,\n    'not': 172,\n    'shy': 173,\n    'macr': 175,\n    'deg': 176,\n    'plusmn': 177,\n    'sup1': 185,\n    'sup2': 178,\n    'sup3': 179,\n    'acute': 180,\n    'micro': 181,\n    'para': 182,\n    'middot': 183,\n    'cedil': 184,\n    'ordm': 186,\n    'raquo': 187,\n    'frac14': 188,\n    'frac12': 189,\n    'frac34': 190,\n    'iquest': 191,\n    'times': 215,\n    'divide': 247,\n    'OElig': 338,\n    'oelig': 339,\n    'Scaron': 352,\n    'scaron': 353,\n    'Yuml': 376,\n    'fnof': 402,\n    'circ': 710,\n    'tilde': 732,\n    'Alpha': 913,\n    'Beta': 914,\n    'Gamma': 915,\n    'Delta': 916,\n    'Epsilon': 917,\n    'Zeta': 918,\n    'Eta': 919,\n    'Theta': 920,\n    'Iota': 921,\n    'Kappa': 922,\n    'Lambda': 923,\n    'Mu': 924,\n    'Nu': 925,\n    'Xi': 926,\n    'Omicron': 927,\n    'Pi': 928,\n    'Rho': 929,\n    'Sigma': 931,\n    'Tau': 932,\n    'Upsilon': 933,\n    'Phi': 934,\n    'Chi': 935,\n    'Psi': 936,\n    'Omega': 937,\n    'alpha': 945,\n    'beta': 946,\n    'gamma': 947,\n    'delta': 948,\n    'epsilon': 949,\n    'zeta': 950,\n    'eta': 951,\n    'theta': 952,\n    'iota': 953,\n    'kappa': 954,\n    'lambda': 955,\n    'mu': 956,\n    'nu': 957,\n    'xi': 958,\n    'omicron': 959,\n    'pi': 960,\n    'rho': 961,\n    'sigmaf': 962,\n    'sigma': 963,\n    'tau': 964,\n    'upsilon': 965,\n    'phi': 966,\n    'chi': 967,\n    'psi': 968,\n    'omega': 969,\n    'thetasym': 977,\n    'upsih': 978,\n    'piv': 982,\n    'ensp': 8194,\n    'emsp': 8195,\n    'thinsp': 8201,\n    'zwnj': 8204,\n    'zwj': 8205,\n    'lrm': 8206,\n    'rlm': 8207,\n    'ndash': 8211,\n    'mdash': 8212,\n    'lsquo': 8216,\n    'rsquo': 8217,\n    'sbquo': 8218,\n    'ldquo': 8220,\n    'rdquo': 8221,\n    'bdquo': 8222,\n    'dagger': 8224,\n    'Dagger': 8225,\n    'bull': 8226,\n    'hellip': 8230,\n    'permil': 8240,\n    'prime': 8242,\n    'Prime': 8243,\n    'lsaquo': 8249,\n    'rsaquo': 8250,\n    'oline': 8254,\n    'frasl': 8260,\n    'euro': 8364,\n    'image': 8465,\n    'weierp': 8472,\n    'real': 8476,\n    'trade': 8482,\n    'alefsym': 8501,\n    'larr': 8592,\n    'uarr': 8593,\n    'rarr': 8594,\n    'darr': 8595,\n    'harr': 8596,\n    'crarr': 8629,\n    'lArr': 8656,\n    'uArr': 8657,\n    'rArr': 8658,\n    'dArr': 8659,\n    'hArr': 8660,\n    'forall': 8704,\n    'part': 8706,\n    'exist': 8707,\n    'empty': 8709,\n    'nabla': 8711,\n    'isin': 8712,\n    'notin': 8713,\n    'ni': 8715,\n    'prod': 8719,\n    'sum': 8721,\n    'minus': 8722,\n    'lowast': 8727,\n    'radic': 8730,\n    'prop': 8733,\n    'infin': 8734,\n    'ang': 8736,\n    'and': 8743,\n    'or': 8744,\n    'cap': 8745,\n    'cup': 8746,\n    'int': 8747,\n    'there4': 8756,\n    'sim': 8764,\n    'cong': 8773,\n    'asymp': 8776,\n    'ne': 8800,\n    'equiv': 8801,\n    'le': 8804,\n    'ge': 8805,\n    'sub': 8834,\n    'sup': 8835,\n    'nsub': 8836,\n    'sube': 8838,\n    'supe': 8839,\n    'oplus': 8853,\n    'otimes': 8855,\n    'perp': 8869,\n    'sdot': 8901,\n    'lceil': 8968,\n    'rceil': 8969,\n    'lfloor': 8970,\n    'rfloor': 8971,\n    'lang': 9001,\n    'rang': 9002,\n    'loz': 9674,\n    'spades': 9824,\n    'clubs': 9827,\n    'hearts': 9829,\n    'diams': 9830\n  }\n\n  Object.keys(sax.ENTITIES).forEach(function (key) {\n    var e = sax.ENTITIES[key]\n    var s = typeof e === 'number' ? String.fromCharCode(e) : e\n    sax.ENTITIES[key] = s\n  })\n\n  for (var s in sax.STATE) {\n    sax.STATE[sax.STATE[s]] = s\n  }\n\n  // shorthand\n  S = sax.STATE\n\n  function emit (parser, event, data) {\n    parser[event] && parser[event](data)\n  }\n\n  function emitNode (parser, nodeType, data) {\n    if (parser.textNode) closeText(parser)\n    emit(parser, nodeType, data)\n  }\n\n  function closeText (parser) {\n    parser.textNode = textopts(parser.opt, parser.textNode)\n    if (parser.textNode) emit(parser, 'ontext', parser.textNode)\n    parser.textNode = ''\n  }\n\n  function textopts (opt, text) {\n    if (opt.trim) text = text.trim()\n    if (opt.normalize) text = text.replace(/\\s+/g, ' ')\n    return text\n  }\n\n  function error (parser, er) {\n    closeText(parser)\n    if (parser.trackPosition) {\n      er += '\\nLine: ' + parser.line +\n        '\\nColumn: ' + parser.column +\n        '\\nChar: ' + parser.c\n    }\n    er = new Error(er)\n    parser.error = er\n    emit(parser, 'onerror', er)\n    return parser\n  }\n\n  function end (parser) {\n    if (parser.sawRoot && !parser.closedRoot) strictFail(parser, 'Unclosed root tag')\n    if ((parser.state !== S.BEGIN) &&\n      (parser.state !== S.BEGIN_WHITESPACE) &&\n      (parser.state !== S.TEXT)) {\n      error(parser, 'Unexpected end')\n    }\n    closeText(parser)\n    parser.c = ''\n    parser.closed = true\n    emit(parser, 'onend')\n    SAXParser.call(parser, parser.strict, parser.opt)\n    return parser\n  }\n\n  function strictFail (parser, message) {\n    if (typeof parser !== 'object' || !(parser instanceof SAXParser)) {\n      throw new Error('bad call to strictFail')\n    }\n    if (parser.strict) {\n      error(parser, message)\n    }\n  }\n\n  function newTag (parser) {\n    if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()\n    var parent = parser.tags[parser.tags.length - 1] || parser\n    var tag = parser.tag = { name: parser.tagName, attributes: {} }\n\n    // will be overridden if tag contails an xmlns=\"foo\" or xmlns:foo=\"bar\"\n    if (parser.opt.xmlns) {\n      tag.ns = parent.ns\n    }\n    parser.attribList.length = 0\n    emitNode(parser, 'onopentagstart', tag)\n  }\n\n  function qname (name, attribute) {\n    var i = name.indexOf(':')\n    var qualName = i < 0 ? [ '', name ] : name.split(':')\n    var prefix = qualName[0]\n    var local = qualName[1]\n\n    // <x \"xmlns\"=\"http://foo\">\n    if (attribute && name === 'xmlns') {\n      prefix = 'xmlns'\n      local = ''\n    }\n\n    return { prefix: prefix, local: local }\n  }\n\n  function attrib (parser) {\n    if (!parser.strict) {\n      parser.attribName = parser.attribName[parser.looseCase]()\n    }\n\n    if (parser.attribList.indexOf(parser.attribName) !== -1 ||\n      parser.tag.attributes.hasOwnProperty(parser.attribName)) {\n      parser.attribName = parser.attribValue = ''\n      return\n    }\n\n    if (parser.opt.xmlns) {\n      var qn = qname(parser.attribName, true)\n      var prefix = qn.prefix\n      var local = qn.local\n\n      if (prefix === 'xmlns') {\n        // namespace binding attribute. push the binding into scope\n        if (local === 'xml' && parser.attribValue !== XML_NAMESPACE) {\n          strictFail(parser,\n            'xml: prefix must be bound to ' + XML_NAMESPACE + '\\n' +\n            'Actual: ' + parser.attribValue)\n        } else if (local === 'xmlns' && parser.attribValue !== XMLNS_NAMESPACE) {\n          strictFail(parser,\n            'xmlns: prefix must be bound to ' + XMLNS_NAMESPACE + '\\n' +\n            'Actual: ' + parser.attribValue)\n        } else {\n          var tag = parser.tag\n          var parent = parser.tags[parser.tags.length - 1] || parser\n          if (tag.ns === parent.ns) {\n            tag.ns = Object.create(parent.ns)\n          }\n          tag.ns[local] = parser.attribValue\n        }\n      }\n\n      // defer onattribute events until all attributes have been seen\n      // so any new bindings can take effect. preserve attribute order\n      // so deferred events can be emitted in document order\n      parser.attribList.push([parser.attribName, parser.attribValue])\n    } else {\n      // in non-xmlns mode, we can emit the event right away\n      parser.tag.attributes[parser.attribName] = parser.attribValue\n      emitNode(parser, 'onattribute', {\n        name: parser.attribName,\n        value: parser.attribValue\n      })\n    }\n\n    parser.attribName = parser.attribValue = ''\n  }\n\n  function openTag (parser, selfClosing) {\n    if (parser.opt.xmlns) {\n      // emit namespace binding events\n      var tag = parser.tag\n\n      // add namespace info to tag\n      var qn = qname(parser.tagName)\n      tag.prefix = qn.prefix\n      tag.local = qn.local\n      tag.uri = tag.ns[qn.prefix] || ''\n\n      if (tag.prefix && !tag.uri) {\n        strictFail(parser, 'Unbound namespace prefix: ' +\n          JSON.stringify(parser.tagName))\n        tag.uri = qn.prefix\n      }\n\n      var parent = parser.tags[parser.tags.length - 1] || parser\n      if (tag.ns && parent.ns !== tag.ns) {\n        Object.keys(tag.ns).forEach(function (p) {\n          emitNode(parser, 'onopennamespace', {\n            prefix: p,\n            uri: tag.ns[p]\n          })\n        })\n      }\n\n      // handle deferred onattribute events\n      // Note: do not apply default ns to attributes:\n      //   http://www.w3.org/TR/REC-xml-names/#defaulting\n      for (var i = 0, l = parser.attribList.length; i < l; i++) {\n        var nv = parser.attribList[i]\n        var name = nv[0]\n        var value = nv[1]\n        var qualName = qname(name, true)\n        var prefix = qualName.prefix\n        var local = qualName.local\n        var uri = prefix === '' ? '' : (tag.ns[prefix] || '')\n        var a = {\n          name: name,\n          value: value,\n          prefix: prefix,\n          local: local,\n          uri: uri\n        }\n\n        // if there's any attributes with an undefined namespace,\n        // then fail on them now.\n        if (prefix && prefix !== 'xmlns' && !uri) {\n          strictFail(parser, 'Unbound namespace prefix: ' +\n            JSON.stringify(prefix))\n          a.uri = prefix\n        }\n        parser.tag.attributes[name] = a\n        emitNode(parser, 'onattribute', a)\n      }\n      parser.attribList.length = 0\n    }\n\n    parser.tag.isSelfClosing = !!selfClosing\n\n    // process the tag\n    parser.sawRoot = true\n    parser.tags.push(parser.tag)\n    emitNode(parser, 'onopentag', parser.tag)\n    if (!selfClosing) {\n      // special case for <script> in non-strict mode.\n      if (!parser.noscript && parser.tagName.toLowerCase() === 'script') {\n        parser.state = S.SCRIPT\n      } else {\n        parser.state = S.TEXT\n      }\n      parser.tag = null\n      parser.tagName = ''\n    }\n    parser.attribName = parser.attribValue = ''\n    parser.attribList.length = 0\n  }\n\n  function closeTag (parser) {\n    if (!parser.tagName) {\n      strictFail(parser, 'Weird empty close tag.')\n      parser.textNode += '</>'\n      parser.state = S.TEXT\n      return\n    }\n\n    if (parser.script) {\n      if (parser.tagName !== 'script') {\n        parser.script += '</' + parser.tagName + '>'\n        parser.tagName = ''\n        parser.state = S.SCRIPT\n        return\n      }\n      emitNode(parser, 'onscript', parser.script)\n      parser.script = ''\n    }\n\n    // first make sure that the closing tag actually exists.\n    // <a><b></c></b></a> will close everything, otherwise.\n    var t = parser.tags.length\n    var tagName = parser.tagName\n    if (!parser.strict) {\n      tagName = tagName[parser.looseCase]()\n    }\n    var closeTo = tagName\n    while (t--) {\n      var close = parser.tags[t]\n      if (close.name !== closeTo) {\n        // fail the first time in strict mode\n        strictFail(parser, 'Unexpected close tag')\n      } else {\n        break\n      }\n    }\n\n    // didn't find it.  we already failed for strict, so just abort.\n    if (t < 0) {\n      strictFail(parser, 'Unmatched closing tag: ' + parser.tagName)\n      parser.textNode += '</' + parser.tagName + '>'\n      parser.state = S.TEXT\n      return\n    }\n    parser.tagName = tagName\n    var s = parser.tags.length\n    while (s-- > t) {\n      var tag = parser.tag = parser.tags.pop()\n      parser.tagName = parser.tag.name\n      emitNode(parser, 'onclosetag', parser.tagName)\n\n      var x = {}\n      for (var i in tag.ns) {\n        x[i] = tag.ns[i]\n      }\n\n      var parent = parser.tags[parser.tags.length - 1] || parser\n      if (parser.opt.xmlns && tag.ns !== parent.ns) {\n        // remove namespace bindings introduced by tag\n        Object.keys(tag.ns).forEach(function (p) {\n          var n = tag.ns[p]\n          emitNode(parser, 'onclosenamespace', { prefix: p, uri: n })\n        })\n      }\n    }\n    if (t === 0) parser.closedRoot = true\n    parser.tagName = parser.attribValue = parser.attribName = ''\n    parser.attribList.length = 0\n    parser.state = S.TEXT\n  }\n\n  function parseEntity (parser) {\n    var entity = parser.entity\n    var entityLC = entity.toLowerCase()\n    var num\n    var numStr = ''\n\n    if (parser.ENTITIES[entity]) {\n      return parser.ENTITIES[entity]\n    }\n    if (parser.ENTITIES[entityLC]) {\n      return parser.ENTITIES[entityLC]\n    }\n    entity = entityLC\n    if (entity.charAt(0) === '#') {\n      if (entity.charAt(1) === 'x') {\n        entity = entity.slice(2)\n        num = parseInt(entity, 16)\n        numStr = num.toString(16)\n      } else {\n        entity = entity.slice(1)\n        num = parseInt(entity, 10)\n        numStr = num.toString(10)\n      }\n    }\n    entity = entity.replace(/^0+/, '')\n    if (isNaN(num) || numStr.toLowerCase() !== entity) {\n      strictFail(parser, 'Invalid character entity')\n      return '&' + parser.entity + ';'\n    }\n\n    return String.fromCodePoint(num)\n  }\n\n  function beginWhiteSpace (parser, c) {\n    if (c === '<') {\n      parser.state = S.OPEN_WAKA\n      parser.startTagPosition = parser.position\n    } else if (!isWhitespace(c)) {\n      // have to process this as a text node.\n      // weird, but happens.\n      strictFail(parser, 'Non-whitespace before first tag.')\n      parser.textNode = c\n      parser.state = S.TEXT\n    }\n  }\n\n  function charAt (chunk, i) {\n    var result = ''\n    if (i < chunk.length) {\n      result = chunk.charAt(i)\n    }\n    return result\n  }\n\n  function write (chunk) {\n    var parser = this\n    if (this.error) {\n      throw this.error\n    }\n    if (parser.closed) {\n      return error(parser,\n        'Cannot write after close. Assign an onready handler.')\n    }\n    if (chunk === null) {\n      return end(parser)\n    }\n    if (typeof chunk === 'object') {\n      chunk = chunk.toString()\n    }\n    var i = 0\n    var c = ''\n    while (true) {\n      c = charAt(chunk, i++)\n      parser.c = c\n\n      if (!c) {\n        break\n      }\n\n      if (parser.trackPosition) {\n        parser.position++\n        if (c === '\\n') {\n          parser.line++\n          parser.column = 0\n        } else {\n          parser.column++\n        }\n      }\n\n      switch (parser.state) {\n        case S.BEGIN:\n          parser.state = S.BEGIN_WHITESPACE\n          if (c === '\\uFEFF') {\n            continue\n          }\n          beginWhiteSpace(parser, c)\n          continue\n\n        case S.BEGIN_WHITESPACE:\n          beginWhiteSpace(parser, c)\n          continue\n\n        case S.TEXT:\n          if (parser.sawRoot && !parser.closedRoot) {\n            var starti = i - 1\n            while (c && c !== '<' && c !== '&') {\n              c = charAt(chunk, i++)\n              if (c && parser.trackPosition) {\n                parser.position++\n                if (c === '\\n') {\n                  parser.line++\n                  parser.column = 0\n                } else {\n                  parser.column++\n                }\n              }\n            }\n            parser.textNode += chunk.substring(starti, i - 1)\n          }\n          if (c === '<' && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {\n            parser.state = S.OPEN_WAKA\n            parser.startTagPosition = parser.position\n          } else {\n            if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {\n              strictFail(parser, 'Text data outside of root node.')\n            }\n            if (c === '&') {\n              parser.state = S.TEXT_ENTITY\n            } else {\n              parser.textNode += c\n            }\n          }\n          continue\n\n        case S.SCRIPT:\n          // only non-strict\n          if (c === '<') {\n            parser.state = S.SCRIPT_ENDING\n          } else {\n            parser.script += c\n          }\n          continue\n\n        case S.SCRIPT_ENDING:\n          if (c === '/') {\n            parser.state = S.CLOSE_TAG\n          } else {\n            parser.script += '<' + c\n            parser.state = S.SCRIPT\n          }\n          continue\n\n        case S.OPEN_WAKA:\n          // either a /, ?, !, or text is coming next.\n          if (c === '!') {\n            parser.state = S.SGML_DECL\n            parser.sgmlDecl = ''\n          } else if (isWhitespace(c)) {\n            // wait for it...\n          } else if (isMatch(nameStart, c)) {\n            parser.state = S.OPEN_TAG\n            parser.tagName = c\n          } else if (c === '/') {\n            parser.state = S.CLOSE_TAG\n            parser.tagName = ''\n          } else if (c === '?') {\n            parser.state = S.PROC_INST\n            parser.procInstName = parser.procInstBody = ''\n          } else {\n            strictFail(parser, 'Unencoded <')\n            // if there was some whitespace, then add that in.\n            if (parser.startTagPosition + 1 < parser.position) {\n              var pad = parser.position - parser.startTagPosition\n              c = new Array(pad).join(' ') + c\n            }\n            parser.textNode += '<' + c\n            parser.state = S.TEXT\n          }\n          continue\n\n        case S.SGML_DECL:\n          if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {\n            emitNode(parser, 'onopencdata')\n            parser.state = S.CDATA\n            parser.sgmlDecl = ''\n            parser.cdata = ''\n          } else if (parser.sgmlDecl + c === '--') {\n            parser.state = S.COMMENT\n            parser.comment = ''\n            parser.sgmlDecl = ''\n          } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {\n            parser.state = S.DOCTYPE\n            if (parser.doctype || parser.sawRoot) {\n              strictFail(parser,\n                'Inappropriately located doctype declaration')\n            }\n            parser.doctype = ''\n            parser.sgmlDecl = ''\n          } else if (c === '>') {\n            emitNode(parser, 'onsgmldeclaration', parser.sgmlDecl)\n            parser.sgmlDecl = ''\n            parser.state = S.TEXT\n          } else if (isQuote(c)) {\n            parser.state = S.SGML_DECL_QUOTED\n            parser.sgmlDecl += c\n          } else {\n            parser.sgmlDecl += c\n          }\n          continue\n\n        case S.SGML_DECL_QUOTED:\n          if (c === parser.q) {\n            parser.state = S.SGML_DECL\n            parser.q = ''\n          }\n          parser.sgmlDecl += c\n          continue\n\n        case S.DOCTYPE:\n          if (c === '>') {\n            parser.state = S.TEXT\n            emitNode(parser, 'ondoctype', parser.doctype)\n            parser.doctype = true // just remember that we saw it.\n          } else {\n            parser.doctype += c\n            if (c === '[') {\n              parser.state = S.DOCTYPE_DTD\n            } else if (isQuote(c)) {\n              parser.state = S.DOCTYPE_QUOTED\n              parser.q = c\n            }\n          }\n          continue\n\n        case S.DOCTYPE_QUOTED:\n          parser.doctype += c\n          if (c === parser.q) {\n            parser.q = ''\n            parser.state = S.DOCTYPE\n          }\n          continue\n\n        case S.DOCTYPE_DTD:\n          parser.doctype += c\n          if (c === ']') {\n            parser.state = S.DOCTYPE\n          } else if (isQuote(c)) {\n            parser.state = S.DOCTYPE_DTD_QUOTED\n            parser.q = c\n          }\n          continue\n\n        case S.DOCTYPE_DTD_QUOTED:\n          parser.doctype += c\n          if (c === parser.q) {\n            parser.state = S.DOCTYPE_DTD\n            parser.q = ''\n          }\n          continue\n\n        case S.COMMENT:\n          if (c === '-') {\n            parser.state = S.COMMENT_ENDING\n          } else {\n            parser.comment += c\n          }\n          continue\n\n        case S.COMMENT_ENDING:\n          if (c === '-') {\n            parser.state = S.COMMENT_ENDED\n            parser.comment = textopts(parser.opt, parser.comment)\n            if (parser.comment) {\n              emitNode(parser, 'oncomment', parser.comment)\n            }\n            parser.comment = ''\n          } else {\n            parser.comment += '-' + c\n            parser.state = S.COMMENT\n          }\n          continue\n\n        case S.COMMENT_ENDED:\n          if (c !== '>') {\n            strictFail(parser, 'Malformed comment')\n            // allow <!-- blah -- bloo --> in non-strict mode,\n            // which is a comment of \" blah -- bloo \"\n            parser.comment += '--' + c\n            parser.state = S.COMMENT\n          } else {\n            parser.state = S.TEXT\n          }\n          continue\n\n        case S.CDATA:\n          if (c === ']') {\n            parser.state = S.CDATA_ENDING\n          } else {\n            parser.cdata += c\n          }\n          continue\n\n        case S.CDATA_ENDING:\n          if (c === ']') {\n            parser.state = S.CDATA_ENDING_2\n          } else {\n            parser.cdata += ']' + c\n            parser.state = S.CDATA\n          }\n          continue\n\n        case S.CDATA_ENDING_2:\n          if (c === '>') {\n            if (parser.cdata) {\n              emitNode(parser, 'oncdata', parser.cdata)\n            }\n            emitNode(parser, 'onclosecdata')\n            parser.cdata = ''\n            parser.state = S.TEXT\n          } else if (c === ']') {\n            parser.cdata += ']'\n          } else {\n            parser.cdata += ']]' + c\n            parser.state = S.CDATA\n          }\n          continue\n\n        case S.PROC_INST:\n          if (c === '?') {\n            parser.state = S.PROC_INST_ENDING\n          } else if (isWhitespace(c)) {\n            parser.state = S.PROC_INST_BODY\n          } else {\n            parser.procInstName += c\n          }\n          continue\n\n        case S.PROC_INST_BODY:\n          if (!parser.procInstBody && isWhitespace(c)) {\n            continue\n          } else if (c === '?') {\n            parser.state = S.PROC_INST_ENDING\n          } else {\n            parser.procInstBody += c\n          }\n          continue\n\n        case S.PROC_INST_ENDING:\n          if (c === '>') {\n            emitNode(parser, 'onprocessinginstruction', {\n              name: parser.procInstName,\n              body: parser.procInstBody\n            })\n            parser.procInstName = parser.procInstBody = ''\n            parser.state = S.TEXT\n          } else {\n            parser.procInstBody += '?' + c\n            parser.state = S.PROC_INST_BODY\n          }\n          continue\n\n        case S.OPEN_TAG:\n          if (isMatch(nameBody, c)) {\n            parser.tagName += c\n          } else {\n            newTag(parser)\n            if (c === '>') {\n              openTag(parser)\n            } else if (c === '/') {\n              parser.state = S.OPEN_TAG_SLASH\n            } else {\n              if (!isWhitespace(c)) {\n                strictFail(parser, 'Invalid character in tag name')\n              }\n              parser.state = S.ATTRIB\n            }\n          }\n          continue\n\n        case S.OPEN_TAG_SLASH:\n          if (c === '>') {\n            openTag(parser, true)\n            closeTag(parser)\n          } else {\n            strictFail(parser, 'Forward-slash in opening tag not followed by >')\n            parser.state = S.ATTRIB\n          }\n          continue\n\n        case S.ATTRIB:\n          // haven't read the attribute name yet.\n          if (isWhitespace(c)) {\n            continue\n          } else if (c === '>') {\n            openTag(parser)\n          } else if (c === '/') {\n            parser.state = S.OPEN_TAG_SLASH\n          } else if (isMatch(nameStart, c)) {\n            parser.attribName = c\n            parser.attribValue = ''\n            parser.state = S.ATTRIB_NAME\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_NAME:\n          if (c === '=') {\n            parser.state = S.ATTRIB_VALUE\n          } else if (c === '>') {\n            strictFail(parser, 'Attribute without value')\n            parser.attribValue = parser.attribName\n            attrib(parser)\n            openTag(parser)\n          } else if (isWhitespace(c)) {\n            parser.state = S.ATTRIB_NAME_SAW_WHITE\n          } else if (isMatch(nameBody, c)) {\n            parser.attribName += c\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_NAME_SAW_WHITE:\n          if (c === '=') {\n            parser.state = S.ATTRIB_VALUE\n          } else if (isWhitespace(c)) {\n            continue\n          } else {\n            strictFail(parser, 'Attribute without value')\n            parser.tag.attributes[parser.attribName] = ''\n            parser.attribValue = ''\n            emitNode(parser, 'onattribute', {\n              name: parser.attribName,\n              value: ''\n            })\n            parser.attribName = ''\n            if (c === '>') {\n              openTag(parser)\n            } else if (isMatch(nameStart, c)) {\n              parser.attribName = c\n              parser.state = S.ATTRIB_NAME\n            } else {\n              strictFail(parser, 'Invalid attribute name')\n              parser.state = S.ATTRIB\n            }\n          }\n          continue\n\n        case S.ATTRIB_VALUE:\n          if (isWhitespace(c)) {\n            continue\n          } else if (isQuote(c)) {\n            parser.q = c\n            parser.state = S.ATTRIB_VALUE_QUOTED\n          } else {\n            strictFail(parser, 'Unquoted attribute value')\n            parser.state = S.ATTRIB_VALUE_UNQUOTED\n            parser.attribValue = c\n          }\n          continue\n\n        case S.ATTRIB_VALUE_QUOTED:\n          if (c !== parser.q) {\n            if (c === '&') {\n              parser.state = S.ATTRIB_VALUE_ENTITY_Q\n            } else {\n              parser.attribValue += c\n            }\n            continue\n          }\n          attrib(parser)\n          parser.q = ''\n          parser.state = S.ATTRIB_VALUE_CLOSED\n          continue\n\n        case S.ATTRIB_VALUE_CLOSED:\n          if (isWhitespace(c)) {\n            parser.state = S.ATTRIB\n          } else if (c === '>') {\n            openTag(parser)\n          } else if (c === '/') {\n            parser.state = S.OPEN_TAG_SLASH\n          } else if (isMatch(nameStart, c)) {\n            strictFail(parser, 'No whitespace between attributes')\n            parser.attribName = c\n            parser.attribValue = ''\n            parser.state = S.ATTRIB_NAME\n          } else {\n            strictFail(parser, 'Invalid attribute name')\n          }\n          continue\n\n        case S.ATTRIB_VALUE_UNQUOTED:\n          if (!isAttribEnd(c)) {\n            if (c === '&') {\n              parser.state = S.ATTRIB_VALUE_ENTITY_U\n            } else {\n              parser.attribValue += c\n            }\n            continue\n          }\n          attrib(parser)\n          if (c === '>') {\n            openTag(parser)\n          } else {\n            parser.state = S.ATTRIB\n          }\n          continue\n\n        case S.CLOSE_TAG:\n          if (!parser.tagName) {\n            if (isWhitespace(c)) {\n              continue\n            } else if (notMatch(nameStart, c)) {\n              if (parser.script) {\n                parser.script += '</' + c\n                parser.state = S.SCRIPT\n              } else {\n                strictFail(parser, 'Invalid tagname in closing tag.')\n              }\n            } else {\n              parser.tagName = c\n            }\n          } else if (c === '>') {\n            closeTag(parser)\n          } else if (isMatch(nameBody, c)) {\n            parser.tagName += c\n          } else if (parser.script) {\n            parser.script += '</' + parser.tagName\n            parser.tagName = ''\n            parser.state = S.SCRIPT\n          } else {\n            if (!isWhitespace(c)) {\n              strictFail(parser, 'Invalid tagname in closing tag')\n            }\n            parser.state = S.CLOSE_TAG_SAW_WHITE\n          }\n          continue\n\n        case S.CLOSE_TAG_SAW_WHITE:\n          if (isWhitespace(c)) {\n            continue\n          }\n          if (c === '>') {\n            closeTag(parser)\n          } else {\n            strictFail(parser, 'Invalid characters in closing tag')\n          }\n          continue\n\n        case S.TEXT_ENTITY:\n        case S.ATTRIB_VALUE_ENTITY_Q:\n        case S.ATTRIB_VALUE_ENTITY_U:\n          var returnState\n          var buffer\n          switch (parser.state) {\n            case S.TEXT_ENTITY:\n              returnState = S.TEXT\n              buffer = 'textNode'\n              break\n\n            case S.ATTRIB_VALUE_ENTITY_Q:\n              returnState = S.ATTRIB_VALUE_QUOTED\n              buffer = 'attribValue'\n              break\n\n            case S.ATTRIB_VALUE_ENTITY_U:\n              returnState = S.ATTRIB_VALUE_UNQUOTED\n              buffer = 'attribValue'\n              break\n          }\n\n          if (c === ';') {\n            parser[buffer] += parseEntity(parser)\n            parser.entity = ''\n            parser.state = returnState\n          } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {\n            parser.entity += c\n          } else {\n            strictFail(parser, 'Invalid character in entity name')\n            parser[buffer] += '&' + parser.entity + c\n            parser.entity = ''\n            parser.state = returnState\n          }\n\n          continue\n\n        default:\n          throw new Error(parser, 'Unknown state: ' + parser.state)\n      }\n    } // while\n\n    if (parser.position >= parser.bufferCheckPosition) {\n      checkBufferLength(parser)\n    }\n    return parser\n  }\n\n  /*! http://mths.be/fromcodepoint v0.1.0 by @mathias */\n  /* istanbul ignore next */\n  if (!String.fromCodePoint) {\n    (function () {\n      var stringFromCharCode = String.fromCharCode\n      var floor = Math.floor\n      var fromCodePoint = function () {\n        var MAX_SIZE = 0x4000\n        var codeUnits = []\n        var highSurrogate\n        var lowSurrogate\n        var index = -1\n        var length = arguments.length\n        if (!length) {\n          return ''\n        }\n        var result = ''\n        while (++index < length) {\n          var codePoint = Number(arguments[index])\n          if (\n            !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`\n            codePoint < 0 || // not a valid Unicode code point\n            codePoint > 0x10FFFF || // not a valid Unicode code point\n            floor(codePoint) !== codePoint // not an integer\n          ) {\n            throw RangeError('Invalid code point: ' + codePoint)\n          }\n          if (codePoint <= 0xFFFF) { // BMP code point\n            codeUnits.push(codePoint)\n          } else { // Astral code point; split in surrogate halves\n            // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae\n            codePoint -= 0x10000\n            highSurrogate = (codePoint >> 10) + 0xD800\n            lowSurrogate = (codePoint % 0x400) + 0xDC00\n            codeUnits.push(highSurrogate, lowSurrogate)\n          }\n          if (index + 1 === length || codeUnits.length > MAX_SIZE) {\n            result += stringFromCharCode.apply(null, codeUnits)\n            codeUnits.length = 0\n          }\n        }\n        return result\n      }\n      /* istanbul ignore next */\n      if (Object.defineProperty) {\n        Object.defineProperty(String, 'fromCodePoint', {\n          value: fromCodePoint,\n          configurable: true,\n          writable: true\n        })\n      } else {\n        String.fromCodePoint = fromCodePoint\n      }\n    }())\n  }\n})(typeof exports === 'undefined' ? this.sax = {} : exports)\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('buffer').Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","module.exports = require('events').EventEmitter;\n","'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n// undocumented cb() API, needed for core, not for public API\nfunction destroy(err, cb) {\n  var _this = this;\n\n  var readableDestroyed = this._readableState && this._readableState.destroyed;\n  var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n  if (readableDestroyed || writableDestroyed) {\n    if (cb) {\n      cb(err);\n    } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {\n      pna.nextTick(emitErrorNT, this, err);\n    }\n    return this;\n  }\n\n  // we set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n\n  if (this._readableState) {\n    this._readableState.destroyed = true;\n  }\n\n  // if this is a duplex stream mark the writable part as destroyed as well\n  if (this._writableState) {\n    this._writableState.destroyed = true;\n  }\n\n  this._destroy(err || null, function (err) {\n    if (!cb && err) {\n      pna.nextTick(emitErrorNT, _this, err);\n      if (_this._writableState) {\n        _this._writableState.errorEmitted = true;\n      }\n    } else if (cb) {\n      cb(err);\n    }\n  });\n\n  return this;\n}\n\nfunction undestroy() {\n  if (this._readableState) {\n    this._readableState.destroyed = false;\n    this._readableState.reading = false;\n    this._readableState.ended = false;\n    this._readableState.endEmitted = false;\n  }\n\n  if (this._writableState) {\n    this._writableState.destroyed = false;\n    this._writableState.ended = false;\n    this._writableState.ending = false;\n    this._writableState.finished = false;\n    this._writableState.errorEmitted = false;\n  }\n}\n\nfunction emitErrorNT(self, err) {\n  self.emit('error', err);\n}\n\nmodule.exports = {\n  destroy: destroy,\n  undestroy: undestroy\n};","var js2xml = require('./js2xml.js');\r\n\r\nmodule.exports = function (json, options) {\r\n  if (json instanceof Buffer) {\r\n    json = json.toString();\r\n  }\r\n  var js = null;\r\n  if (typeof (json) === 'string') {\r\n    try {\r\n      js = JSON.parse(json);\r\n    } catch (e) {\r\n      throw new Error('The JSON structure is invalid');\r\n    }\r\n  } else {\r\n    js = json;\r\n  }\r\n  return js2xml(js, options);\r\n};\r\n","'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Buffer = require('safe-buffer').Buffer;\nvar util = require('util');\n\nfunction copyBuffer(src, target, offset) {\n  src.copy(target, offset);\n}\n\nmodule.exports = function () {\n  function BufferList() {\n    _classCallCheck(this, BufferList);\n\n    this.head = null;\n    this.tail = null;\n    this.length = 0;\n  }\n\n  BufferList.prototype.push = function push(v) {\n    var entry = { data: v, next: null };\n    if (this.length > 0) this.tail.next = entry;else this.head = entry;\n    this.tail = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.unshift = function unshift(v) {\n    var entry = { data: v, next: this.head };\n    if (this.length === 0) this.tail = entry;\n    this.head = entry;\n    ++this.length;\n  };\n\n  BufferList.prototype.shift = function shift() {\n    if (this.length === 0) return;\n    var ret = this.head.data;\n    if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n    --this.length;\n    return ret;\n  };\n\n  BufferList.prototype.clear = function clear() {\n    this.head = this.tail = null;\n    this.length = 0;\n  };\n\n  BufferList.prototype.join = function join(s) {\n    if (this.length === 0) return '';\n    var p = this.head;\n    var ret = '' + p.data;\n    while (p = p.next) {\n      ret += s + p.data;\n    }return ret;\n  };\n\n  BufferList.prototype.concat = function concat(n) {\n    if (this.length === 0) return Buffer.alloc(0);\n    if (this.length === 1) return this.head.data;\n    var ret = Buffer.allocUnsafe(n >>> 0);\n    var p = this.head;\n    var i = 0;\n    while (p) {\n      copyBuffer(p.data, ret, i);\n      i += p.data.length;\n      p = p.next;\n    }\n    return ret;\n  };\n\n  return BufferList;\n}();\n\nif (util && util.inspect && util.inspect.custom) {\n  module.exports.prototype[util.inspect.custom] = function () {\n    var obj = util.inspect({ length: this.length });\n    return this.constructor.name + ' ' + obj;\n  };\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nutil.inherits(PassThrough, Transform);\n\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options);\n\n  Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    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':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  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;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","var sax = require('sax');\r\nvar expat /*= require('node-expat');*/ = { on: function () { }, parse: function () { } };\r\nvar helper = require('./options-helper');\r\nvar isArray = require('./array-helper').isArray;\r\n\r\nvar options;\r\nvar pureJsParser = true;\r\nvar currentElement;\r\n\r\nfunction validateOptions(userOptions) {\r\n  options = helper.copyOptions(userOptions);\r\n  helper.ensureFlagExists('ignoreDeclaration', options);\r\n  helper.ensureFlagExists('ignoreInstruction', options);\r\n  helper.ensureFlagExists('ignoreAttributes', options);\r\n  helper.ensureFlagExists('ignoreText', options);\r\n  helper.ensureFlagExists('ignoreComment', options);\r\n  helper.ensureFlagExists('ignoreCdata', options);\r\n  helper.ensureFlagExists('ignoreDoctype', options);\r\n  helper.ensureFlagExists('compact', options);\r\n  helper.ensureFlagExists('alwaysChildren', options);\r\n  helper.ensureFlagExists('addParent', options);\r\n  helper.ensureFlagExists('trim', options);\r\n  helper.ensureFlagExists('nativeType', options);\r\n  helper.ensureFlagExists('nativeTypeAttributes', options);\r\n  helper.ensureFlagExists('sanitize', options);\r\n  helper.ensureFlagExists('instructionHasAttributes', options);\r\n  helper.ensureFlagExists('captureSpacesBetweenElements', options);\r\n  helper.ensureAlwaysArrayExists(options);\r\n  helper.ensureKeyExists('declaration', options);\r\n  helper.ensureKeyExists('instruction', options);\r\n  helper.ensureKeyExists('attributes', options);\r\n  helper.ensureKeyExists('text', options);\r\n  helper.ensureKeyExists('comment', options);\r\n  helper.ensureKeyExists('cdata', options);\r\n  helper.ensureKeyExists('doctype', options);\r\n  helper.ensureKeyExists('type', options);\r\n  helper.ensureKeyExists('name', options);\r\n  helper.ensureKeyExists('elements', options);\r\n  helper.ensureKeyExists('parent', options);\r\n  helper.checkFnExists('doctype', options);\r\n  helper.checkFnExists('instruction', options);\r\n  helper.checkFnExists('cdata', options);\r\n  helper.checkFnExists('comment', options);\r\n  helper.checkFnExists('text', options);\r\n  helper.checkFnExists('instructionName', options);\r\n  helper.checkFnExists('elementName', options);\r\n  helper.checkFnExists('attributeName', options);\r\n  helper.checkFnExists('attributeValue', options);\r\n  helper.checkFnExists('attributes', options);\r\n  return options;\r\n}\r\n\r\nfunction nativeType(value) {\r\n  var nValue = Number(value);\r\n  if (!isNaN(nValue)) {\r\n    return nValue;\r\n  }\r\n  var bValue = value.toLowerCase();\r\n  if (bValue === 'true') {\r\n    return true;\r\n  } else if (bValue === 'false') {\r\n    return false;\r\n  }\r\n  return value;\r\n}\r\n\r\nfunction addField(type, value) {\r\n  var key;\r\n  if (options.compact) {\r\n    if (\r\n      !currentElement[options[type + 'Key']] &&\r\n      (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(options[type + 'Key']) !== -1 : options.alwaysArray)\r\n    ) {\r\n      currentElement[options[type + 'Key']] = [];\r\n    }\r\n    if (currentElement[options[type + 'Key']] && !isArray(currentElement[options[type + 'Key']])) {\r\n      currentElement[options[type + 'Key']] = [currentElement[options[type + 'Key']]];\r\n    }\r\n    if (type + 'Fn' in options && typeof value === 'string') {\r\n      value = options[type + 'Fn'](value, currentElement);\r\n    }\r\n    if (type === 'instruction' && ('instructionFn' in options || 'instructionNameFn' in options)) {\r\n      for (key in value) {\r\n        if (value.hasOwnProperty(key)) {\r\n          if ('instructionFn' in options) {\r\n            value[key] = options.instructionFn(value[key], key, currentElement);\r\n          } else {\r\n            var temp = value[key];\r\n            delete value[key];\r\n            value[options.instructionNameFn(key, temp, currentElement)] = temp;\r\n          }\r\n        }\r\n      }\r\n    }\r\n    if (isArray(currentElement[options[type + 'Key']])) {\r\n      currentElement[options[type + 'Key']].push(value);\r\n    } else {\r\n      currentElement[options[type + 'Key']] = value;\r\n    }\r\n  } else {\r\n    if (!currentElement[options.elementsKey]) {\r\n      currentElement[options.elementsKey] = [];\r\n    }\r\n    var element = {};\r\n    element[options.typeKey] = type;\r\n    if (type === 'instruction') {\r\n      for (key in value) {\r\n        if (value.hasOwnProperty(key)) {\r\n          break;\r\n        }\r\n      }\r\n      element[options.nameKey] = 'instructionNameFn' in options ? options.instructionNameFn(key, value, currentElement) : key;\r\n      if (options.instructionHasAttributes) {\r\n        element[options.attributesKey] = value[key][options.attributesKey];\r\n        if ('instructionFn' in options) {\r\n          element[options.attributesKey] = options.instructionFn(element[options.attributesKey], key, currentElement);\r\n        }\r\n      } else {\r\n        if ('instructionFn' in options) {\r\n          value[key] = options.instructionFn(value[key], key, currentElement);\r\n        }\r\n        element[options.instructionKey] = value[key];\r\n      }\r\n    } else {\r\n      if (type + 'Fn' in options) {\r\n        value = options[type + 'Fn'](value, currentElement);\r\n      }\r\n      element[options[type + 'Key']] = value;\r\n    }\r\n    if (options.addParent) {\r\n      element[options.parentKey] = currentElement;\r\n    }\r\n    currentElement[options.elementsKey].push(element);\r\n  }\r\n}\r\n\r\nfunction manipulateAttributes(attributes) {\r\n  if ('attributesFn' in options && attributes) {\r\n    attributes = options.attributesFn(attributes, currentElement);\r\n  }\r\n  if ((options.trim || 'attributeValueFn' in options || 'attributeNameFn' in options || options.nativeTypeAttributes) && attributes) {\r\n    var key;\r\n    for (key in attributes) {\r\n      if (attributes.hasOwnProperty(key)) {\r\n        if (options.trim) attributes[key] = attributes[key].trim();\r\n        if (options.nativeTypeAttributes) {\r\n          attributes[key] = nativeType(attributes[key]);\r\n        }\r\n        if ('attributeValueFn' in options) attributes[key] = options.attributeValueFn(attributes[key], key, currentElement);\r\n        if ('attributeNameFn' in options) {\r\n          var temp = attributes[key];\r\n          delete attributes[key];\r\n          attributes[options.attributeNameFn(key, attributes[key], currentElement)] = temp;\r\n        }\r\n      }\r\n    }\r\n  }\r\n  return attributes;\r\n}\r\n\r\nfunction onInstruction(instruction) {\r\n  var attributes = {};\r\n  if (instruction.body && (instruction.name.toLowerCase() === 'xml' || options.instructionHasAttributes)) {\r\n    var attrsRegExp = /([\\w:-]+)\\s*=\\s*(?:\"([^\"]*)\"|'([^']*)'|(\\w+))\\s*/g;\r\n    var match;\r\n    while ((match = attrsRegExp.exec(instruction.body)) !== null) {\r\n      attributes[match[1]] = match[2] || match[3] || match[4];\r\n    }\r\n    attributes = manipulateAttributes(attributes);\r\n  }\r\n  if (instruction.name.toLowerCase() === 'xml') {\r\n    if (options.ignoreDeclaration) {\r\n      return;\r\n    }\r\n    currentElement[options.declarationKey] = {};\r\n    if (Object.keys(attributes).length) {\r\n      currentElement[options.declarationKey][options.attributesKey] = attributes;\r\n    }\r\n    if (options.addParent) {\r\n      currentElement[options.declarationKey][options.parentKey] = currentElement;\r\n    }\r\n  } else {\r\n    if (options.ignoreInstruction) {\r\n      return;\r\n    }\r\n    if (options.trim) {\r\n      instruction.body = instruction.body.trim();\r\n    }\r\n    var value = {};\r\n    if (options.instructionHasAttributes && Object.keys(attributes).length) {\r\n      value[instruction.name] = {};\r\n      value[instruction.name][options.attributesKey] = attributes;\r\n    } else {\r\n      value[instruction.name] = instruction.body;\r\n    }\r\n    addField('instruction', value);\r\n  }\r\n}\r\n\r\nfunction onStartElement(name, attributes) {\r\n  var element;\r\n  if (typeof name === 'object') {\r\n    attributes = name.attributes;\r\n    name = name.name;\r\n  }\r\n  attributes = manipulateAttributes(attributes);\r\n  if ('elementNameFn' in options) {\r\n    name = options.elementNameFn(name, currentElement);\r\n  }\r\n  if (options.compact) {\r\n    element = {};\r\n    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {\r\n      element[options.attributesKey] = {};\r\n      var key;\r\n      for (key in attributes) {\r\n        if (attributes.hasOwnProperty(key)) {\r\n          element[options.attributesKey][key] = attributes[key];\r\n        }\r\n      }\r\n    }\r\n    if (\r\n      !(name in currentElement) &&\r\n      (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(name) !== -1 : options.alwaysArray)\r\n    ) {\r\n      currentElement[name] = [];\r\n    }\r\n    if (currentElement[name] && !isArray(currentElement[name])) {\r\n      currentElement[name] = [currentElement[name]];\r\n    }\r\n    if (isArray(currentElement[name])) {\r\n      currentElement[name].push(element);\r\n    } else {\r\n      currentElement[name] = element;\r\n    }\r\n  } else {\r\n    if (!currentElement[options.elementsKey]) {\r\n      currentElement[options.elementsKey] = [];\r\n    }\r\n    element = {};\r\n    element[options.typeKey] = 'element';\r\n    element[options.nameKey] = name;\r\n    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {\r\n      element[options.attributesKey] = attributes;\r\n    }\r\n    if (options.alwaysChildren) {\r\n      element[options.elementsKey] = [];\r\n    }\r\n    currentElement[options.elementsKey].push(element);\r\n  }\r\n  element[options.parentKey] = currentElement; // will be deleted in onEndElement() if !options.addParent\r\n  currentElement = element;\r\n}\r\n\r\nfunction onText(text) {\r\n  if (options.ignoreText) {\r\n    return;\r\n  }\r\n  if (!text.trim() && !options.captureSpacesBetweenElements) {\r\n    return;\r\n  }\r\n  if (options.trim) {\r\n    text = text.trim();\r\n  }\r\n  if (options.nativeType) {\r\n    text = nativeType(text);\r\n  }\r\n  if (options.sanitize) {\r\n    text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\r\n  }\r\n  addField('text', text);\r\n}\r\n\r\nfunction onComment(comment) {\r\n  if (options.ignoreComment) {\r\n    return;\r\n  }\r\n  if (options.trim) {\r\n    comment = comment.trim();\r\n  }\r\n  addField('comment', comment);\r\n}\r\n\r\nfunction onEndElement(name) {\r\n  var parentElement = currentElement[options.parentKey];\r\n  if (!options.addParent) {\r\n    delete currentElement[options.parentKey];\r\n  }\r\n  currentElement = parentElement;\r\n}\r\n\r\nfunction onCdata(cdata) {\r\n  if (options.ignoreCdata) {\r\n    return;\r\n  }\r\n  if (options.trim) {\r\n    cdata = cdata.trim();\r\n  }\r\n  addField('cdata', cdata);\r\n}\r\n\r\nfunction onDoctype(doctype) {\r\n  if (options.ignoreDoctype) {\r\n    return;\r\n  }\r\n  doctype = doctype.replace(/^ /, '');\r\n  if (options.trim) {\r\n    doctype = doctype.trim();\r\n  }\r\n  addField('doctype', doctype);\r\n}\r\n\r\nfunction onError(error) {\r\n  error.note = error; //console.error(error);\r\n}\r\n\r\nmodule.exports = function (xml, userOptions) {\r\n\r\n  var parser = pureJsParser ? sax.parser(true, {}) : parser = new expat.Parser('UTF-8');\r\n  var result = {};\r\n  currentElement = result;\r\n\r\n  options = validateOptions(userOptions);\r\n\r\n  if (pureJsParser) {\r\n    parser.opt = {strictEntities: true};\r\n    parser.onopentag = onStartElement;\r\n    parser.ontext = onText;\r\n    parser.oncomment = onComment;\r\n    parser.onclosetag = onEndElement;\r\n    parser.onerror = onError;\r\n    parser.oncdata = onCdata;\r\n    parser.ondoctype = onDoctype;\r\n    parser.onprocessinginstruction = onInstruction;\r\n  } else {\r\n    parser.on('startElement', onStartElement);\r\n    parser.on('text', onText);\r\n    parser.on('comment', onComment);\r\n    parser.on('endElement', onEndElement);\r\n    parser.on('error', onError);\r\n    //parser.on('startCdata', onStartCdata);\r\n    //parser.on('endCdata', onEndCdata);\r\n    //parser.on('entityDecl', onEntityDecl);\r\n  }\r\n\r\n  if (pureJsParser) {\r\n    parser.write(xml).close();\r\n  } else {\r\n    if (!parser.parse(xml)) {\r\n      throw new Error('XML parsing error: ' + parser.getError());\r\n    }\r\n  }\r\n\r\n  if (result[options.elementsKey]) {\r\n    var temp = result[options.elementsKey];\r\n    delete result[options.elementsKey];\r\n    result[options.elementsKey] = temp;\r\n    delete result.text;\r\n  }\r\n\r\n  return result;\r\n\r\n};\r\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","'use strict';\n\nif (typeof process === 'undefined' ||\n    !process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","var isArray = require('./array-helper').isArray;\r\n\r\nmodule.exports = {\r\n\r\n  copyOptions: function (options) {\r\n    var key, copy = {};\r\n    for (key in options) {\r\n      if (options.hasOwnProperty(key)) {\r\n        copy[key] = options[key];\r\n      }\r\n    }\r\n    return copy;\r\n  },\r\n\r\n  ensureFlagExists: function (item, options) {\r\n    if (!(item in options) || typeof options[item] !== 'boolean') {\r\n      options[item] = false;\r\n    }\r\n  },\r\n\r\n  ensureSpacesExists: function (options) {\r\n    if (!('spaces' in options) || (typeof options.spaces !== 'number' && typeof options.spaces !== 'string')) {\r\n      options.spaces = 0;\r\n    }\r\n  },\r\n\r\n  ensureAlwaysArrayExists: function (options) {\r\n    if (!('alwaysArray' in options) || (typeof options.alwaysArray !== 'boolean' && !isArray(options.alwaysArray))) {\r\n      options.alwaysArray = false;\r\n    }\r\n  },\r\n\r\n  ensureKeyExists: function (key, options) {\r\n    if (!(key + 'Key' in options) || typeof options[key + 'Key'] !== 'string') {\r\n      options[key + 'Key'] = options.compact ? '_' + key : key;\r\n    }\r\n  },\r\n\r\n  checkFnExists: function (key, options) {\r\n    return key + 'Fn' in options;\r\n  }\r\n\r\n};\r\n","module.exports = {\r\n\r\n  isArray: function(value) {\r\n    if (Array.isArray) {\r\n      return Array.isArray(value);\r\n    }\r\n    // fallback for older browsers like  IE 8\r\n    return Object.prototype.toString.call( value ) === '[object Array]';\r\n  }\r\n\r\n};\r\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Readable;\n\n/*<replacement>*/\nvar isArray = require('isarray');\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n\n/*<replacement>*/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n  return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n  debug = debugUtil.debuglog('stream');\n} else {\n  debug = function () {};\n}\n/*</replacement>*/\n\nvar BufferList = require('./internal/streams/BufferList');\nvar destroyImpl = require('./internal/streams/destroy');\nvar StringDecoder;\n\nutil.inherits(Readable, Stream);\n\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  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]];\n}\n\nfunction ReadableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;\n\n  // the point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  var hwm = options.highWaterMark;\n  var readableHwm = options.readableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift()\n  this.buffer = new BufferList();\n  this.length = 0;\n  this.pipes = null;\n  this.pipesCount = 0;\n  this.flowing = null;\n  this.ended = false;\n  this.endEmitted = false;\n  this.reading = false;\n\n  // a flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true;\n\n  // whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false;\n  this.emittedReadable = false;\n  this.readableListening = false;\n  this.resumeScheduled = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // the number of writers that are awaiting a drain event in .pipe()s\n  this.awaitDrain = 0;\n\n  // if true, a maybeReadMore has been scheduled\n  this.readingMore = false;\n\n  this.decoder = null;\n  this.encoding = null;\n  if (options.encoding) {\n    if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n    this.decoder = new StringDecoder(options.encoding);\n    this.encoding = options.encoding;\n  }\n}\n\nfunction Readable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  if (!(this instanceof Readable)) return new Readable(options);\n\n  this._readableState = new ReadableState(options, this);\n\n  // legacy\n  this.readable = true;\n\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n  }\n\n  Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._readableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n  }\n});\n\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\nReadable.prototype._destroy = function (err, cb) {\n  this.push(null);\n  cb(err);\n};\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  var state = this._readableState;\n  var skipChunkCheck;\n\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding;\n      if (encoding !== state.encoding) {\n        chunk = Buffer.from(chunk, encoding);\n        encoding = '';\n      }\n      skipChunkCheck = true;\n    }\n  } else {\n    skipChunkCheck = true;\n  }\n\n  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n};\n\n// Unshift should *always* be something directly out of read()\nReadable.prototype.unshift = function (chunk) {\n  return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n  var state = stream._readableState;\n  if (chunk === null) {\n    state.reading = false;\n    onEofChunk(stream, state);\n  } else {\n    var er;\n    if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n    if (er) {\n      stream.emit('error', er);\n    } else if (state.objectMode || chunk && chunk.length > 0) {\n      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n        chunk = _uint8ArrayToBuffer(chunk);\n      }\n\n      if (addToFront) {\n        if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);\n      } else if (state.ended) {\n        stream.emit('error', new Error('stream.push() after EOF'));\n      } else {\n        state.reading = false;\n        if (state.decoder && !encoding) {\n          chunk = state.decoder.write(chunk);\n          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n        } else {\n          addChunk(stream, state, chunk, false);\n        }\n      }\n    } else if (!addToFront) {\n      state.reading = false;\n    }\n  }\n\n  return needMoreData(state);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync) {\n    stream.emit('data', chunk);\n    stream.read(0);\n  } else {\n    // update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length;\n    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n\n    if (state.needReadable) emitReadable(stream);\n  }\n  maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n  var er;\n  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  return er;\n}\n\n// if it's past the high water mark, we can push in some more.\n// Also, if we have no data yet, we can stand some\n// more bytes.  This is to work around cases where hwm=0,\n// such as the repl.  Also, if the push() triggered a\n// readable event, and the user called read(largeNumber) such that\n// needReadable was set, then we ought to push more, so that another\n// 'readable' event will be triggered.\nfunction needMoreData(state) {\n  return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);\n}\n\nReadable.prototype.isPaused = function () {\n  return this._readableState.flowing === false;\n};\n\n// backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n  this._readableState.decoder = new StringDecoder(enc);\n  this._readableState.encoding = enc;\n  return this;\n};\n\n// Don't raise the hwm > 8MB\nvar MAX_HWM = 0x800000;\nfunction computeNewHighWaterMark(n) {\n  if (n >= MAX_HWM) {\n    n = MAX_HWM;\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts\n    n--;\n    n |= n >>> 1;\n    n |= n >>> 2;\n    n |= n >>> 4;\n    n |= n >>> 8;\n    n |= n >>> 16;\n    n++;\n  }\n  return n;\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || state.length === 0 && state.ended) return 0;\n  if (state.objectMode) return 1;\n  if (n !== n) {\n    // Only flow one buffer at a time\n    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n  }\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n  if (n <= state.length) return n;\n  // Don't have enough\n  if (!state.ended) {\n    state.needReadable = true;\n    return 0;\n  }\n  return state.length;\n}\n\n// you can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n);\n  n = parseInt(n, 10);\n  var state = this._readableState;\n  var nOrig = n;\n\n  if (n !== 0) state.emittedReadable = false;\n\n  // if we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {\n    debug('read: emitReadable', state.length, state.ended);\n    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n    return null;\n  }\n\n  n = howMuchToRead(n, state);\n\n  // if we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this);\n    return null;\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  var doRead = state.needReadable;\n  debug('need readable', doRead);\n\n  // if we currently have less than the highWaterMark, then also read some\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true;\n    debug('length less than watermark', doRead);\n  }\n\n  // however, if we've ended, then there's no point, and if we're already\n  // reading, then it's unnecessary.\n  if (state.ended || state.reading) {\n    doRead = false;\n    debug('reading or ended', doRead);\n  } else if (doRead) {\n    debug('do read');\n    state.reading = true;\n    state.sync = true;\n    // if the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true;\n    // call internal read method\n    this._read(state.highWaterMark);\n    state.sync = false;\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state);\n  }\n\n  var ret;\n  if (n > 0) ret = fromList(n, state);else ret = null;\n\n  if (ret === null) {\n    state.needReadable = true;\n    n = 0;\n  } else {\n    state.length -= n;\n  }\n\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true;\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this);\n  }\n\n  if (ret !== null) this.emit('data', ret);\n\n  return ret;\n};\n\nfunction onEofChunk(stream, state) {\n  if (state.ended) return;\n  if (state.decoder) {\n    var chunk = state.decoder.end();\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk);\n      state.length += state.objectMode ? 1 : chunk.length;\n    }\n  }\n  state.ended = true;\n\n  // emit 'readable' now to make sure it gets picked up.\n  emitReadable(stream);\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  var state = stream._readableState;\n  state.needReadable = false;\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing);\n    state.emittedReadable = true;\n    if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);\n  }\n}\n\nfunction emitReadable_(stream) {\n  debug('emit readable');\n  stream.emit('readable');\n  flow(stream);\n}\n\n// at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore) {\n    state.readingMore = true;\n    pna.nextTick(maybeReadMore_, stream, state);\n  }\n}\n\nfunction maybeReadMore_(stream, state) {\n  var len = state.length;\n  while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {\n    debug('maybeReadMore read 0');\n    stream.read(0);\n    if (len === state.length)\n      // didn't get any data, stop spinning.\n      break;else len = state.length;\n  }\n  state.readingMore = false;\n}\n\n// abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  this.emit('error', new Error('_read() is not implemented'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  var src = this;\n  var state = this._readableState;\n\n  switch (state.pipesCount) {\n    case 0:\n      state.pipes = dest;\n      break;\n    case 1:\n      state.pipes = [state.pipes, dest];\n      break;\n    default:\n      state.pipes.push(dest);\n      break;\n  }\n  state.pipesCount += 1;\n  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n\n  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n\n  var endFn = doEnd ? onend : unpipe;\n  if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);\n\n  dest.on('unpipe', onunpipe);\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe');\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true;\n        cleanup();\n      }\n    }\n  }\n\n  function onend() {\n    debug('onend');\n    dest.end();\n  }\n\n  // when the dest drains, it reduces the awaitDrain counter\n  // on the source.  This would be more elegant with a .once()\n  // handler in flow(), but adding and removing repeatedly is\n  // too slow.\n  var ondrain = pipeOnDrain(src);\n  dest.on('drain', ondrain);\n\n  var cleanedUp = false;\n  function cleanup() {\n    debug('cleanup');\n    // cleanup event handlers once the pipe is broken\n    dest.removeListener('close', onclose);\n    dest.removeListener('finish', onfinish);\n    dest.removeListener('drain', ondrain);\n    dest.removeListener('error', onerror);\n    dest.removeListener('unpipe', onunpipe);\n    src.removeListener('end', onend);\n    src.removeListener('end', unpipe);\n    src.removeListener('data', ondata);\n\n    cleanedUp = true;\n\n    // if the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n  }\n\n  // If the user pushes more data while we're writing to dest then we'll end up\n  // in ondata again. However, we only want to increase awaitDrain once because\n  // dest will only emit one 'drain' event for the multiple writes.\n  // => Introduce a guard on increasing awaitDrain.\n  var increasedAwaitDrain = false;\n  src.on('data', ondata);\n  function ondata(chunk) {\n    debug('ondata');\n    increasedAwaitDrain = false;\n    var ret = dest.write(chunk);\n    if (false === ret && !increasedAwaitDrain) {\n      // If the user unpiped during `dest.write()`, it is possible\n      // to get stuck in a permanently paused state if that write\n      // also returned false.\n      // => Check whether `dest` is still a piping destination.\n      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n        debug('false write response, pause', src._readableState.awaitDrain);\n        src._readableState.awaitDrain++;\n        increasedAwaitDrain = true;\n      }\n      src.pause();\n    }\n  }\n\n  // if the dest has an error, then stop piping into it.\n  // however, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er);\n    unpipe();\n    dest.removeListener('error', onerror);\n    if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror);\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish);\n    unpipe();\n  }\n  dest.once('close', onclose);\n  function onfinish() {\n    debug('onfinish');\n    dest.removeListener('close', onclose);\n    unpipe();\n  }\n  dest.once('finish', onfinish);\n\n  function unpipe() {\n    debug('unpipe');\n    src.unpipe(dest);\n  }\n\n  // tell the dest that it's being piped to\n  dest.emit('pipe', src);\n\n  // start the flow if it hasn't been started already.\n  if (!state.flowing) {\n    debug('pipe resume');\n    src.resume();\n  }\n\n  return dest;\n};\n\nfunction pipeOnDrain(src) {\n  return function () {\n    var state = src._readableState;\n    debug('pipeOnDrain', state.awaitDrain);\n    if (state.awaitDrain) state.awaitDrain--;\n    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n      state.flowing = true;\n      flow(src);\n    }\n  };\n}\n\nReadable.prototype.unpipe = function (dest) {\n  var state = this._readableState;\n  var unpipeInfo = { hasUnpiped: false };\n\n  // if we're not piping anywhere, then do nothing.\n  if (state.pipesCount === 0) return this;\n\n  // just one destination.  most common case.\n  if (state.pipesCount === 1) {\n    // passed in one, but it's not the right one.\n    if (dest && dest !== state.pipes) return this;\n\n    if (!dest) dest = state.pipes;\n\n    // got a match.\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n    if (dest) dest.emit('unpipe', this, unpipeInfo);\n    return this;\n  }\n\n  // slow case. multiple pipe destinations.\n\n  if (!dest) {\n    // remove all.\n    var dests = state.pipes;\n    var len = state.pipesCount;\n    state.pipes = null;\n    state.pipesCount = 0;\n    state.flowing = false;\n\n    for (var i = 0; i < len; i++) {\n      dests[i].emit('unpipe', this, unpipeInfo);\n    }return this;\n  }\n\n  // try to find the right one.\n  var index = indexOf(state.pipes, dest);\n  if (index === -1) return this;\n\n  state.pipes.splice(index, 1);\n  state.pipesCount -= 1;\n  if (state.pipesCount === 1) state.pipes = state.pipes[0];\n\n  dest.emit('unpipe', this, unpipeInfo);\n\n  return this;\n};\n\n// set up data events if they are asked for\n// Ensure readable listeners eventually get something\nReadable.prototype.on = function (ev, fn) {\n  var res = Stream.prototype.on.call(this, ev, fn);\n\n  if (ev === 'data') {\n    // Start flowing on next tick if stream isn't explicitly paused\n    if (this._readableState.flowing !== false) this.resume();\n  } else if (ev === 'readable') {\n    var state = this._readableState;\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true;\n      state.emittedReadable = false;\n      if (!state.reading) {\n        pna.nextTick(nReadingNextTick, this);\n      } else if (state.length) {\n        emitReadable(this);\n      }\n    }\n  }\n\n  return res;\n};\nReadable.prototype.addListener = Readable.prototype.on;\n\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0');\n  self.read(0);\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  var state = this._readableState;\n  if (!state.flowing) {\n    debug('resume');\n    state.flowing = true;\n    resume(this, state);\n  }\n  return this;\n};\n\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true;\n    pna.nextTick(resume_, stream, state);\n  }\n}\n\nfunction resume_(stream, state) {\n  if (!state.reading) {\n    debug('resume read 0');\n    stream.read(0);\n  }\n\n  state.resumeScheduled = false;\n  state.awaitDrain = 0;\n  stream.emit('resume');\n  flow(stream);\n  if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing);\n  if (false !== this._readableState.flowing) {\n    debug('pause');\n    this._readableState.flowing = false;\n    this.emit('pause');\n  }\n  return this;\n};\n\nfunction flow(stream) {\n  var state = stream._readableState;\n  debug('flow', state.flowing);\n  while (state.flowing && stream.read() !== null) {}\n}\n\n// wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  var _this = this;\n\n  var state = this._readableState;\n  var paused = false;\n\n  stream.on('end', function () {\n    debug('wrapped end');\n    if (state.decoder && !state.ended) {\n      var chunk = state.decoder.end();\n      if (chunk && chunk.length) _this.push(chunk);\n    }\n\n    _this.push(null);\n  });\n\n  stream.on('data', function (chunk) {\n    debug('wrapped data');\n    if (state.decoder) chunk = state.decoder.write(chunk);\n\n    // don't skip over falsy values in objectMode\n    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n    var ret = _this.push(chunk);\n    if (!ret) {\n      paused = true;\n      stream.pause();\n    }\n  });\n\n  // proxy all the other methods.\n  // important when wrapping filters and duplexes.\n  for (var i in stream) {\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = function (method) {\n        return function () {\n          return stream[method].apply(stream, arguments);\n        };\n      }(i);\n    }\n  }\n\n  // proxy certain important events.\n  for (var n = 0; n < kProxyEvents.length; n++) {\n    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n  }\n\n  // when we try to consume some more bytes, simply unpause the\n  // underlying stream.\n  this._read = function (n) {\n    debug('wrapped _read', n);\n    if (paused) {\n      paused = false;\n      stream.resume();\n    }\n  };\n\n  return this;\n};\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._readableState.highWaterMark;\n  }\n});\n\n// exposed for testing purposes only.\nReadable._fromList = fromList;\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered\n  if (state.length === 0) return null;\n\n  var ret;\n  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n    // read it all, truncate the list\n    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);\n    state.buffer.clear();\n  } else {\n    // read part of list\n    ret = fromListPartial(n, state.buffer, state.decoder);\n  }\n\n  return ret;\n}\n\n// Extracts only enough buffered data to satisfy the amount requested.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromListPartial(n, list, hasStrings) {\n  var ret;\n  if (n < list.head.data.length) {\n    // slice is the same for buffers and strings\n    ret = list.head.data.slice(0, n);\n    list.head.data = list.head.data.slice(n);\n  } else if (n === list.head.data.length) {\n    // first chunk is a perfect match\n    ret = list.shift();\n  } else {\n    // result spans more than one buffer\n    ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);\n  }\n  return ret;\n}\n\n// Copies a specified amount of characters from the list of buffered data\n// chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBufferString(n, list) {\n  var p = list.head;\n  var c = 1;\n  var ret = p.data;\n  n -= ret.length;\n  while (p = p.next) {\n    var str = p.data;\n    var nb = n > str.length ? str.length : n;\n    if (nb === str.length) ret += str;else ret += str.slice(0, n);\n    n -= nb;\n    if (n === 0) {\n      if (nb === str.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = str.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\n// Copies a specified amount of bytes from the list of buffered data chunks.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction copyFromBuffer(n, list) {\n  var ret = Buffer.allocUnsafe(n);\n  var p = list.head;\n  var c = 1;\n  p.data.copy(ret);\n  n -= p.data.length;\n  while (p = p.next) {\n    var buf = p.data;\n    var nb = n > buf.length ? buf.length : n;\n    buf.copy(ret, ret.length - n, 0, nb);\n    n -= nb;\n    if (n === 0) {\n      if (nb === buf.length) {\n        ++c;\n        if (p.next) list.head = p.next;else list.head = list.tail = null;\n      } else {\n        list.head = p;\n        p.data = buf.slice(nb);\n      }\n      break;\n    }\n    ++c;\n  }\n  list.length -= c;\n  return ret;\n}\n\nfunction endReadable(stream) {\n  var state = stream._readableState;\n\n  // If we get here before consuming all the bytes, then that is a\n  // bug in node.  Should never happen.\n  if (state.length > 0) throw new Error('\"endReadable()\" called on non-empty stream');\n\n  if (!state.endEmitted) {\n    state.ended = true;\n    pna.nextTick(endReadableNT, state, stream);\n  }\n}\n\nfunction endReadableNT(state, stream) {\n  // Check that we didn't get one last unshift.\n  if (!state.endEmitted && state.length === 0) {\n    state.endEmitted = true;\n    stream.readable = false;\n    stream.emit('end');\n  }\n}\n\nfunction indexOf(xs, x) {\n  for (var i = 0, l = xs.length; i < l; i++) {\n    if (xs[i] === x) return i;\n  }\n  return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\n/*<replacement>*/\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    keys.push(key);\n  }return keys;\n};\n/*</replacement>*/\n\nmodule.exports = Duplex;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\nvar Readable = require('./_stream_readable');\nvar Writable = require('./_stream_writable');\n\nutil.inherits(Duplex, Readable);\n\n{\n  // avoid scope creep, the keys array can then be collected\n  var keys = objectKeys(Writable.prototype);\n  for (var v = 0; v < keys.length; v++) {\n    var method = keys[v];\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n  }\n}\n\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options);\n\n  Readable.call(this, options);\n  Writable.call(this, options);\n\n  if (options && options.readable === false) this.readable = false;\n\n  if (options && options.writable === false) this.writable = false;\n\n  this.allowHalfOpen = true;\n  if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;\n\n  this.once('end', onend);\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// the no-half-open enforcer\nfunction onend() {\n  // if we allow half-open state, or if the writable side ended,\n  // then we're ok.\n  if (this.allowHalfOpen || this._writableState.ended) return;\n\n  // no more data can be written.\n  // But allow more writes to happen in this tick.\n  pna.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n  self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n  get: function () {\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return false;\n    }\n    return this._readableState.destroyed && this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (this._readableState === undefined || this._writableState === undefined) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._readableState.destroyed = value;\n    this._writableState.destroyed = value;\n  }\n});\n\nDuplex.prototype._destroy = function (err, cb) {\n  this.push(null);\n  this.end();\n\n  pna.nextTick(cb, err);\n};","module.exports = require('./readable').PassThrough\n","/*jslint node:true */\r\n\r\nvar xml2js = require('./xml2js');\r\nvar xml2json = require('./xml2json');\r\nvar js2xml = require('./js2xml');\r\nvar json2xml = require('./json2xml');\r\n\r\nmodule.exports = {\r\n  xml2js: xml2js,\r\n  xml2json: xml2json,\r\n  js2xml: js2xml,\r\n  json2xml: json2xml\r\n};\r\n","var helper = require('./options-helper');\nvar isArray = require('./array-helper').isArray;\n\nvar currentElement, currentElementName;\n\nfunction validateOptions(userOptions) {\n  var options = helper.copyOptions(userOptions);\n  helper.ensureFlagExists('ignoreDeclaration', options);\n  helper.ensureFlagExists('ignoreInstruction', options);\n  helper.ensureFlagExists('ignoreAttributes', options);\n  helper.ensureFlagExists('ignoreText', options);\n  helper.ensureFlagExists('ignoreComment', options);\n  helper.ensureFlagExists('ignoreCdata', options);\n  helper.ensureFlagExists('ignoreDoctype', options);\n  helper.ensureFlagExists('compact', options);\n  helper.ensureFlagExists('indentText', options);\n  helper.ensureFlagExists('indentCdata', options);\n  helper.ensureFlagExists('indentAttributes', options);\n  helper.ensureFlagExists('indentInstruction', options);\n  helper.ensureFlagExists('fullTagEmptyElement', options);\n  helper.ensureFlagExists('noQuotesForNativeAttributes', options);\n  helper.ensureSpacesExists(options);\n  if (typeof options.spaces === 'number') {\n    options.spaces = Array(options.spaces + 1).join(' ');\n  }\n  helper.ensureKeyExists('declaration', options);\n  helper.ensureKeyExists('instruction', options);\n  helper.ensureKeyExists('attributes', options);\n  helper.ensureKeyExists('text', options);\n  helper.ensureKeyExists('comment', options);\n  helper.ensureKeyExists('cdata', options);\n  helper.ensureKeyExists('doctype', options);\n  helper.ensureKeyExists('type', options);\n  helper.ensureKeyExists('name', options);\n  helper.ensureKeyExists('elements', options);\n  helper.checkFnExists('doctype', options);\n  helper.checkFnExists('instruction', options);\n  helper.checkFnExists('cdata', options);\n  helper.checkFnExists('comment', options);\n  helper.checkFnExists('text', options);\n  helper.checkFnExists('instructionName', options);\n  helper.checkFnExists('elementName', options);\n  helper.checkFnExists('attributeName', options);\n  helper.checkFnExists('attributeValue', options);\n  helper.checkFnExists('attributes', options);\n  helper.checkFnExists('fullTagEmptyElement', options);\n  return options;\n}\n\nfunction writeIndentation(options, depth, firstLine) {\n  return (!firstLine && options.spaces ? '\\n' : '') + Array(depth + 1).join(options.spaces);\n}\n\nfunction writeAttributes(attributes, options, depth) {\n  if (options.ignoreAttributes) {\n    return '';\n  }\n  if ('attributesFn' in options) {\n    attributes = options.attributesFn(attributes, currentElementName, currentElement);\n  }\n  var key, attr, attrName, quote, result = [];\n  for (key in attributes) {\n    if (attributes.hasOwnProperty(key) && attributes[key] !== null && attributes[key] !== undefined) {\n      quote = options.noQuotesForNativeAttributes && typeof attributes[key] !== 'string' ? '' : '\"';\n      attr = '' + attributes[key]; // ensure number and boolean are converted to String\n      attr = attr.replace(/\"/g, '&quot;');\n      attrName = 'attributeNameFn' in options ? options.attributeNameFn(key, attr, currentElementName, currentElement) : key;\n      result.push((options.spaces && options.indentAttributes? writeIndentation(options, depth+1, false) : ' '));\n      result.push(attrName + '=' + quote + ('attributeValueFn' in options ? options.attributeValueFn(attr, key, currentElementName, currentElement) : attr) + quote);\n    }\n  }\n  if (attributes && Object.keys(attributes).length && options.spaces && options.indentAttributes) {\n    result.push(writeIndentation(options, depth, false));\n  }\n  return result.join('');\n}\n\nfunction writeDeclaration(declaration, options, depth) {\n  currentElement = declaration;\n  currentElementName = 'xml';\n  return options.ignoreDeclaration ? '' :  '<?' + 'xml' + writeAttributes(declaration[options.attributesKey], options, depth) + '?>';\n}\n\nfunction writeInstruction(instruction, options, depth) {\n  if (options.ignoreInstruction) {\n    return '';\n  }\n  var key;\n  for (key in instruction) {\n    if (instruction.hasOwnProperty(key)) {\n      break;\n    }\n  }\n  var instructionName = 'instructionNameFn' in options ? options.instructionNameFn(key, instruction[key], currentElementName, currentElement) : key;\n  if (typeof instruction[key] === 'object') {\n    currentElement = instruction;\n    currentElementName = instructionName;\n    return '<?' + instructionName + writeAttributes(instruction[key][options.attributesKey], options, depth) + '?>';\n  } else {\n    var instructionValue = instruction[key] ? instruction[key] : '';\n    if ('instructionFn' in options) instructionValue = options.instructionFn(instructionValue, key, currentElementName, currentElement);\n    return '<?' + instructionName + (instructionValue ? ' ' + instructionValue : '') + '?>';\n  }\n}\n\nfunction writeComment(comment, options) {\n  return options.ignoreComment ? '' : '<!--' + ('commentFn' in options ? options.commentFn(comment, currentElementName, currentElement) : comment) + '-->';\n}\n\nfunction writeCdata(cdata, options) {\n  return options.ignoreCdata ? '' : '<![CDATA[' + ('cdataFn' in options ? options.cdataFn(cdata, currentElementName, currentElement) : cdata.replace(']]>', ']]]]><![CDATA[>')) + ']]>';\n}\n\nfunction writeDoctype(doctype, options) {\n  return options.ignoreDoctype ? '' : '<!DOCTYPE ' + ('doctypeFn' in options ? options.doctypeFn(doctype, currentElementName, currentElement) : doctype) + '>';\n}\n\nfunction writeText(text, options) {\n  if (options.ignoreText) return '';\n  text = '' + text; // ensure Number and Boolean are converted to String\n  text = text.replace(/&amp;/g, '&'); // desanitize to avoid double sanitization\n  text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\n  return 'textFn' in options ? options.textFn(text, currentElementName, currentElement) : text;\n}\n\nfunction hasContent(element, options) {\n  var i;\n  if (element.elements && element.elements.length) {\n    for (i = 0; i < element.elements.length; ++i) {\n      switch (element.elements[i][options.typeKey]) {\n      case 'text':\n        if (options.indentText) {\n          return true;\n        }\n        break; // skip to next key\n      case 'cdata':\n        if (options.indentCdata) {\n          return true;\n        }\n        break; // skip to next key\n      case 'instruction':\n        if (options.indentInstruction) {\n          return true;\n        }\n        break; // skip to next key\n      case 'doctype':\n      case 'comment':\n      case 'element':\n        return true;\n      default:\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction writeElement(element, options, depth) {\n  currentElement = element;\n  currentElementName = element.name;\n  var xml = [], elementName = 'elementNameFn' in options ? options.elementNameFn(element.name, element) : element.name;\n  xml.push('<' + elementName);\n  if (element[options.attributesKey]) {\n    xml.push(writeAttributes(element[options.attributesKey], options, depth));\n  }\n  var withClosingTag = element[options.elementsKey] && element[options.elementsKey].length || element[options.attributesKey] && element[options.attributesKey]['xml:space'] === 'preserve';\n  if (!withClosingTag) {\n    if ('fullTagEmptyElementFn' in options) {\n      withClosingTag = options.fullTagEmptyElementFn(element.name, element);\n    } else {\n      withClosingTag = options.fullTagEmptyElement;\n    }\n  }\n  if (withClosingTag) {\n    xml.push('>');\n    if (element[options.elementsKey] && element[options.elementsKey].length) {\n      xml.push(writeElements(element[options.elementsKey], options, depth + 1));\n      currentElement = element;\n      currentElementName = element.name;\n    }\n    xml.push(options.spaces && hasContent(element, options) ? '\\n' + Array(depth + 1).join(options.spaces) : '');\n    xml.push('</' + elementName + '>');\n  } else {\n    xml.push('/>');\n  }\n  return xml.join('');\n}\n\nfunction writeElements(elements, options, depth, firstLine) {\n  return elements.reduce(function (xml, element) {\n    var indent = writeIndentation(options, depth, firstLine && !xml);\n    switch (element.type) {\n    case 'element': return xml + indent + writeElement(element, options, depth);\n    case 'comment': return xml + indent + writeComment(element[options.commentKey], options);\n    case 'doctype': return xml + indent + writeDoctype(element[options.doctypeKey], options);\n    case 'cdata': return xml + (options.indentCdata ? indent : '') + writeCdata(element[options.cdataKey], options);\n    case 'text': return xml + (options.indentText ? indent : '') + writeText(element[options.textKey], options);\n    case 'instruction':\n      var instruction = {};\n      instruction[element[options.nameKey]] = element[options.attributesKey] ? element : element[options.instructionKey];\n      return xml + (options.indentInstruction ? indent : '') + writeInstruction(instruction, options, depth);\n    }\n  }, '');\n}\n\nfunction hasContentCompact(element, options, anyContent) {\n  var key;\n  for (key in element) {\n    if (element.hasOwnProperty(key)) {\n      switch (key) {\n      case options.parentKey:\n      case options.attributesKey:\n        break; // skip to next key\n      case options.textKey:\n        if (options.indentText || anyContent) {\n          return true;\n        }\n        break; // skip to next key\n      case options.cdataKey:\n        if (options.indentCdata || anyContent) {\n          return true;\n        }\n        break; // skip to next key\n      case options.instructionKey:\n        if (options.indentInstruction || anyContent) {\n          return true;\n        }\n        break; // skip to next key\n      case options.doctypeKey:\n      case options.commentKey:\n        return true;\n      default:\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction writeElementCompact(element, name, options, depth, indent) {\n  currentElement = element;\n  currentElementName = name;\n  var elementName = 'elementNameFn' in options ? options.elementNameFn(name, element) : name;\n  if (typeof element === 'undefined' || element === null || element === '') {\n    return 'fullTagEmptyElementFn' in options && options.fullTagEmptyElementFn(name, element) || options.fullTagEmptyElement ? '<' + elementName + '></' + elementName + '>' : '<' + elementName + '/>';\n  }\n  var xml = [];\n  if (name) {\n    xml.push('<' + elementName);\n    if (typeof element !== 'object') {\n      xml.push('>' + writeText(element,options) + '</' + elementName + '>');\n      return xml.join('');\n    }\n    if (element[options.attributesKey]) {\n      xml.push(writeAttributes(element[options.attributesKey], options, depth));\n    }\n    var withClosingTag = hasContentCompact(element, options, true) || element[options.attributesKey] && element[options.attributesKey]['xml:space'] === 'preserve';\n    if (!withClosingTag) {\n      if ('fullTagEmptyElementFn' in options) {\n        withClosingTag = options.fullTagEmptyElementFn(name, element);\n      } else {\n        withClosingTag = options.fullTagEmptyElement;\n      }\n    }\n    if (withClosingTag) {\n      xml.push('>');\n    } else {\n      xml.push('/>');\n      return xml.join('');\n    }\n  }\n  xml.push(writeElementsCompact(element, options, depth + 1, false));\n  currentElement = element;\n  currentElementName = name;\n  if (name) {\n    xml.push((indent ? writeIndentation(options, depth, false) : '') + '</' + elementName + '>');\n  }\n  return xml.join('');\n}\n\nfunction writeElementsCompact(element, options, depth, firstLine) {\n  var i, key, nodes, xml = [];\n  for (key in element) {\n    if (element.hasOwnProperty(key)) {\n      nodes = isArray(element[key]) ? element[key] : [element[key]];\n      for (i = 0; i < nodes.length; ++i) {\n        switch (key) {\n        case options.declarationKey: xml.push(writeDeclaration(nodes[i], options, depth)); break;\n        case options.instructionKey: xml.push((options.indentInstruction ? writeIndentation(options, depth, firstLine) : '') + writeInstruction(nodes[i], options, depth)); break;\n        case options.attributesKey: case options.parentKey: break; // skip\n        case options.textKey: xml.push((options.indentText ? writeIndentation(options, depth, firstLine) : '') + writeText(nodes[i], options)); break;\n        case options.cdataKey: xml.push((options.indentCdata ? writeIndentation(options, depth, firstLine) : '') + writeCdata(nodes[i], options)); break;\n        case options.doctypeKey: xml.push(writeIndentation(options, depth, firstLine) + writeDoctype(nodes[i], options)); break;\n        case options.commentKey: xml.push(writeIndentation(options, depth, firstLine) + writeComment(nodes[i], options)); break;\n        default: xml.push(writeIndentation(options, depth, firstLine) + writeElementCompact(nodes[i], key, options, depth, hasContentCompact(nodes[i], options)));\n        }\n        firstLine = firstLine && !xml.length;\n      }\n    }\n  }\n  return xml.join('');\n}\n\nmodule.exports = function (js, options) {\n  options = validateOptions(options);\n  var xml = [];\n  currentElement = js;\n  currentElementName = '_root_';\n  if (options.compact) {\n    xml.push(writeElementsCompact(js, options, 0, true));\n  } else {\n    if (js[options.declarationKey]) {\n      xml.push(writeDeclaration(js[options.declarationKey], options, 0));\n    }\n    if (js[options.elementsKey] && js[options.elementsKey].length) {\n      xml.push(writeElements(js[options.elementsKey], options, 0, !xml.length));\n    }\n  }\n  return xml.join('');\n};\n","module.exports = require('./readable').Transform\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  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);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n  --state.pendingcb;\n\n  if (sync) {\n    // defer the callback if we are being called synchronously\n    // to avoid piling up things on the stack\n    pna.nextTick(cb, er);\n    // this can emit finish, and it will always happen\n    // after error\n    pna.nextTick(finishMaybe, stream, state);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n  } else {\n    // the caller expect this to happen before if\n    // it is async\n    cb(er);\n    stream._writableState.errorEmitted = true;\n    stream.emit('error', er);\n    // this can emit finish, but finish must\n    // always follow error\n    finishMaybe(stream, state);\n  }\n}\n\nfunction onwriteStateUpdate(state) {\n  state.writing = false;\n  state.writecb = null;\n  state.length -= state.writelen;\n  state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n  var state = stream._writableState;\n  var sync = state.sync;\n  var cb = state.writecb;\n\n  onwriteStateUpdate(state);\n\n  if (er) onwriteError(stream, state, sync, er, cb);else {\n    // Check if we're actually ready to finish, but don't emit yet\n    var finished = needFinish(state);\n\n    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n      clearBuffer(stream, state);\n    }\n\n    if (sync) {\n      /*<replacement>*/\n      asyncWrite(afterWrite, stream, state, finished, cb);\n      /*</replacement>*/\n    } else {\n      afterWrite(stream, state, finished, cb);\n    }\n  }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n  if (!finished) onwriteDrain(stream, state);\n  state.pendingcb--;\n  cb();\n  finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n  if (state.length === 0 && state.needDrain) {\n    state.needDrain = false;\n    stream.emit('drain');\n  }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n  state.bufferProcessing = true;\n  var entry = state.bufferedRequest;\n\n  if (stream._writev && entry && entry.next) {\n    // Fast case, write everything using _writev()\n    var l = state.bufferedRequestCount;\n    var buffer = new Array(l);\n    var holder = state.corkedRequestsFree;\n    holder.entry = entry;\n\n    var count = 0;\n    var allBuffers = true;\n    while (entry) {\n      buffer[count] = entry;\n      if (!entry.isBuf) allBuffers = false;\n      entry = entry.next;\n      count += 1;\n    }\n    buffer.allBuffers = allBuffers;\n\n    doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n    // doWrite is almost always async, defer these to save a bit of time\n    // as the hot path ends with doWrite\n    state.pendingcb++;\n    state.lastBufferedRequest = null;\n    if (holder.next) {\n      state.corkedRequestsFree = holder.next;\n      holder.next = null;\n    } else {\n      state.corkedRequestsFree = new CorkedRequest(state);\n    }\n    state.bufferedRequestCount = 0;\n  } else {\n    // Slow case, write chunks one-by-one\n    while (entry) {\n      var chunk = entry.chunk;\n      var encoding = entry.encoding;\n      var cb = entry.callback;\n      var len = state.objectMode ? 1 : chunk.length;\n\n      doWrite(stream, state, false, len, chunk, encoding, cb);\n      entry = entry.next;\n      state.bufferedRequestCount--;\n      // if we didn't call the onwrite immediately, then\n      // it means that we need to wait until it does.\n      // also, that means that the chunk and cb are currently\n      // being processed, so move the buffer counter past them.\n      if (state.writing) {\n        break;\n      }\n    }\n\n    if (entry === null) state.lastBufferedRequest = null;\n  }\n\n  state.bufferedRequest = entry;\n  state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n  cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n  var state = this._writableState;\n\n  if (typeof chunk === 'function') {\n    cb = chunk;\n    chunk = null;\n    encoding = null;\n  } else if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n  // .end() fully uncorks\n  if (state.corked) {\n    state.corked = 1;\n    this.uncork();\n  }\n\n  // ignore unnecessary end() calls.\n  if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n  stream._final(function (err) {\n    state.pendingcb--;\n    if (err) {\n      stream.emit('error', err);\n    }\n    state.prefinished = true;\n    stream.emit('prefinish');\n    finishMaybe(stream, state);\n  });\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function') {\n      state.pendingcb++;\n      state.finalCalled = true;\n      pna.nextTick(callFinal, stream, state);\n    } else {\n      state.prefinished = true;\n      stream.emit('prefinish');\n    }\n  }\n}\n\nfunction finishMaybe(stream, state) {\n  var need = needFinish(state);\n  if (need) {\n    prefinish(stream, state);\n    if (state.pendingcb === 0) {\n      state.finished = true;\n      stream.emit('finish');\n    }\n  }\n  return need;\n}\n\nfunction endWritable(stream, state, cb) {\n  state.ending = true;\n  finishMaybe(stream, state);\n  if (cb) {\n    if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n  }\n  state.ended = true;\n  stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n  var entry = corkReq.entry;\n  corkReq.entry = null;\n  while (entry) {\n    var cb = entry.callback;\n    state.pendingcb--;\n    cb(err);\n    entry = entry.next;\n  }\n  if (state.corkedRequestsFree) {\n    state.corkedRequestsFree.next = corkReq;\n  } else {\n    state.corkedRequestsFree = corkReq;\n  }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n  get: function () {\n    if (this._writableState === undefined) {\n      return false;\n    }\n    return this._writableState.destroyed;\n  },\n  set: function (value) {\n    // we ignore the value if the stream\n    // has not been initialized yet\n    if (!this._writableState) {\n      return;\n    }\n\n    // backward compatibility, the user is explicitly\n    // managing destroyed\n    this._writableState.destroyed = value;\n  }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n  this.end();\n  cb(err);\n};","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n"],"sourceRoot":""}