{"version":3,"sources":["webpack:///./node_modules/xml-js/lib/xml2json.js","webpack:///./node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/base64-js/index.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:///./src/components/ErrorHandler.vue","webpack:///./src/components/ErrorHandler.vue?1beb","webpack:///./src/components/Player.vue?925f","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/node-libs-browser/mock/process.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:///./src/components/VideoItem.vue","webpack:///./src/components/VideoItem.vue?5c02","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./src/utils/DashUtils.js","webpack:///./node_modules/xml-js/lib/xml2js.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/ieee754/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/node_modules/safe-buffer/index.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/buffer/index.js","webpack:///./node_modules/util-deprecate/browser.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/path-browserify/index.js","webpack:///./node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/isarray/index.js","webpack:///./node_modules/mux.js/dist/mux.js","webpack:///./src/components/WatchVideo.vue","webpack:///./src/components/Player.vue","webpack:///./src/components/Player.vue?68a3","webpack:///./src/components/Comment.vue","webpack:///./src/components/Comment.vue?cd81","webpack:///./src/components/WatchVideo.vue?a6c1","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","byteLength","toByteArray","fromByteArray","lookup","revLookup","Arr","Uint8Array","Array","code","i","len","length","charCodeAt","getLens","b64","Error","validLen","indexOf","placeHoldersLen","lens","_byteLength","tmp","arr","curByte","tripletToBase64","num","encodeChunk","uint8","start","end","output","push","join","extraBytes","parts","maxChunkLength","len2","Transform","Duplex","util","Object","create","afterTransform","er","data","ts","this","_transformState","transforming","cb","writecb","emit","writechunk","rs","_readableState","reading","needReadable","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","l","closeText","emitNode","cdata","script","m","flushBuffers","EVENTS","o","F","newf","keys","a","hasOwnProperty","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","args","arguments","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","entity","entityLC","numStr","charAt","slice","parseInt","isNaN","fromCodePoint","beginWhiteSpace","startTagPosition","result","starti","substring","sgmlDecl","procInstName","procInstBody","pad","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","uk-toggle","class","style","type","id","hidden","$t","props","default","render","ctor","superCtor","super_","TempCtor","EventEmitter","nextTick","fn","shift","setTimeout","platform","arch","execPath","title","pid","browser","env","argv","binding","path","cwd","chdir","dir","resolve","exit","kill","umask","dlopen","uptime","memoryUsage","uvCounters","features","pna","destroy","readableDestroyed","destroyed","writableDestroyed","errorEmitted","emitErrorNT","undestroy","ended","endEmitted","ending","finished","self","parse","js2xml","_classCallCheck","instance","Constructor","TypeError","copyBuffer","src","target","offset","copy","BufferList","head","tail","entry","next","unshift","ret","clear","concat","alloc","allocUnsafe","inspect","custom","obj","backgroundColor","to","video","url","height","width","thumbnail","alt","loading","duration","timeFormat","watched","aria-label","icon","uploaderUrl","uploaderAvatar","uploaderName","hideChannel","uploaderVerified","views","uploadedDate","numberFormat","uploaded","timeAgo","Boolean","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","require","DashUtils","generate_dash_file_from_formats","VideoFormats","VideoLength","generatedJSON","generate_xmljs_json_from_data","json2xml","VideoFormatArray","convertJSON","declaration","version","elements","profiles","minBufferTime","mediaPresentationDuration","generate_adaptation_set","adaptationSets","mimeTypes","mimeObjects","videoFormat","mimeType","videoOnly","mimeTypeIndex","isVideoFormat","adapSet","startWithSAP","subsegmentAlignment","includes","scanType","format","generate_representation_video","generate_representation_audio","Format","representation","itag","codecs","codec","bandwidth","bitrate","schemeIdUri","indexRange","indexStart","indexEnd","range","initStart","initEnd","maxPlayoutRate","frameRate","fps","currentElement","expat","pureJsParser","ensureFlagExists","ensureAlwaysArrayExists","ensureKeyExists","checkFnExists","nativeType","nValue","bValue","addField","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","read","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","Infinity","pow","rt","abs","log","LN2","arg1","arg2","arg3","process","item","Readable","ReadableState","EElistenerCount","emitter","listeners","OurUint8Array","global","_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","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","base64","ieee754","typedArraySupport","__proto__","foo","subarray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","ArrayBuffer","fromArrayBuffer","fromString","fromObject","assertSize","checked","string","actual","fromArrayLike","array","byteOffset","isnan","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","bidirectionalIndexOf","val","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","readUInt16BE","foundIndex","found","hexWrite","remaining","strLen","parsed","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","min","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","bytesPerSequence","decodeCodePointsArray","INSPECT_MAX_BYTES","poolSize","_augment","Symbol","species","_isBuffer","compare","y","pos","swap16","swap32","swap64","equals","thisStart","thisEnd","thisCopy","targetCopy","toJSON","_arr","MAX_ARGUMENTS_LENGTH","codePoints","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","base64clean","stringtrim","units","leadSurrogate","byteArray","hi","lo","deprecate","msg","config","warned","deprecated","console","trace","warn","localStorage","_","xml2json","currentElementName","writeIndentation","depth","firstLine","writeAttributes","attr","attrName","quote","noQuotesForNativeAttributes","indentAttributes","writeDeclaration","writeInstruction","instructionName","instructionValue","writeComment","commentFn","writeCdata","cdataFn","writeDoctype","doctypeFn","writeText","textFn","hasContent","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","setImmediate","WritableState","internalUtil","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","hasInstance","Function","object","cork","uncork","setDefaultEncoding","normalizeArray","allowAboveRoot","up","basename","matchedSlash","f","resolvedPath","resolvedAbsolute","isAbsolute","trailingSlash","paths","relative","fromParts","toParts","samePartsLength","outputParts","sep","delimiter","dirname","hasRoot","extname","startDot","startPart","preDotState","factory","init","listener","off","trigger","callbacks","dispose","destination","flushSource","partialFlush","endTimeline","reset","secondsToVideoTs","secondsToAudioTs","videoTsToSeconds","audioTsToSeconds","audioTsToVideoTs","videoTsToAudioTs","metadataTsToSeconds","ONE_SECOND_IN_TS$5","seconds","sampleRate","timestamp","timelineStartPts","keepOriginalTimestamps","_AdtsStream","clock","ONE_SECOND_IN_TS","ONE_SECOND_IN_TS$4","ADTS_SAMPLING_FREQUENCIES$1","handlePartialSegments","frameNum","skipWarn_","level","packet","frameLength","protectionSkipBytes","oldBuffer","sampleCount","adtsFrameDuration","skip","pts","dts","audioobjecttype","channelcount","samplerate","samplingfrequencyindex","samplesize","ExpGolomb","adts","workingData","workingBytesAvailable","workingWord","workingBitsAvailable","bitsAvailable","loadWord","workingBytes","availableBytes","DataView","getUint32","skipBits","skipBytes","readBits","bits","valu","skipLeadingZeros","leadingZeroCount","skipUnsignedExpGolomb","skipExpGolomb","readUnsignedExpGolomb","clz","readExpGolomb","readBoolean","readUnsignedByte","_H264Stream","_NalByteStream","PROFILES_WITH_OPTIONAL_SPS_DATA","expGolomb","syncPoint","swapBuffer","100","110","122","244","44","83","86","118","128","138","139","134","trackId","currentPts","currentDts","discardEmulationPreventionBytes","readSequenceParameterSet","skipScalingList","nalByteStream","nalUnitTypeCode","nalUnitType","escapedRBSP","expGolombDecoder","deltaScale","lastScale","nextScale","newLength","newData","emulationPreventionBytesPositions","sourceIndex","profileIdc","levelIdc","profileCompatibility","chromaFormatIdc","picOrderCntType","numRefFramesInPicOrderCntCycle","picWidthInMbsMinus1","picHeightInMapUnitsMinus1","frameMbsOnlyFlag","scalingListCount","aspectRatioIdc","frameCropLeftOffset","frameCropRightOffset","frameCropTopOffset","frameCropBottomOffset","sarRatio","box","dinf","esds","ftyp","mdat","mfhd","minf","moof","moov","mvex","mvhd","trak","tkhd","mdia","mdhd","hdlr","sdtp","stbl","stsd","traf","trex","trun$1","types","MAJOR_BRAND","MINOR_VERSION","AVC1_BRAND","VIDEO_HDLR","AUDIO_HDLR","HDLR_TYPES","VMHD","SMHD","DREF","STCO","STSC","STSZ","STTS","h264","H264Stream","NalByteStream","Adts","UINT32_MAX","avc1","avcC","btrt","dref","mp4a","pasp","smhd","stco","stsc","stsz","stts","styp","tfdt","tfhd","trun","vmhd","audio","view","payload","setUint32","track","sequenceNumber","tracks","trackFragments","boxes","flags","samples","dependsOn","isDependedOn","hasRedundancy","videoSample","audioSample","avc1Box","sps","pps","sequenceParameterSets","pictureParameterSets","hSpacing","vSpacing","trackFragmentHeader","trackFragmentDecodeTime","trackFragmentRun","sampleDependencyTable","dataOffset","upperWordBaseMediaDecodeTime","lowerWordBaseMediaDecodeTime","baseMediaDecodeTime","audioTrun","videoTrun","trunHeader","durationPresent","sizePresent","flagsPresent","compositionTimeOffset","bytesOffest","header","sample","isLeading","paddingValue","isNonSyncSample","degradationPriority","timescale","startTime","compositionStartTime","getVideoTrackIds","getTracks","getTimescaleFromMediaHeader","mp4Generator","initSegment","fileType","movie","toUnsigned$3","toHexString$1","bin","toUnsigned","toHexString","parseType$2","parseType_1","toUnsigned$2","findBox","subresults","results","findBox_1","baseDataOffsetPresent","sampleDescriptionIndexPresent","defaultSampleDurationPresent","defaultSampleSizePresent","defaultSampleFlagsPresent","durationIsEmpty","defaultBaseIsMoof","baseDataOffset","sampleDescriptionIndex","defaultSampleDuration","defaultSampleSize","defaultSampleFlags","baseDataOffsetIsMoof","parseTfhd","parseSampleFlags","parseSampleFlags_1","dataOffsetPresent","firstSampleFlagsPresent","sampleDurationPresent","sampleSizePresent","sampleFlagsPresent","sampleCompositionTimeOffsetPresent","getInt32","parseTrun","toUnsigned$1","parseTfdt","traks","fragment","trafs","baseTimes","map","scale","baseTime","timescales","trafBoxes","parsedTfhd","parsedTfdt","parsedTrun","videoTrackIds","hdlrs","tkhds","handlerType","getUint8","tkhdVersion","sampleDescriptions","codecConfig","codecConfigType","codecBox","silence","probe$2","parseType","groupNalsIntoFrames","nalUnits","currentNal","currentFrame","frames","nalCount","keyFrame","groupFramesIntoGops","currentGop","gops","extendFirstKeyFrame","createDefaultSample","sampleForFrame","frame","generateSampleTable$1","concatenateNalData","nalsByteLength","numberOfNals","totalByteLength","generateSampleTableForFrame","concatenateNalDataForFrame","frameUtils","generateSampleTable","highPrefix","lowPrefix","zeroFill","makeTable","metaTable","part","silence_1","coneOfSilence","96000","88200","64000","48000","44100","32000","24000","16000","12000","11025","8000","sumFrameByteLengths","currentObj","sum","prefixWithSilence","audioAppendStartTs","videoBaseMediaDecodeTime","baseMediaDecodeTimeTs","silentFrame","firstFrame","frameDuration","audioGapDuration","audioFillFrameCount","audioFillDuration","ceil","trimAdtsFramesByEarliestDts","adtsFrames","earliestAllowedDts","minSegmentDts","minSegmentPts","concatenateFrameData","audioFrameUtils","ONE_SECOND_IN_TS$3","collectDtsInfo","timelineStartInfo","maxSegmentPts","maxSegmentDts","clearDtsInfo","calculateTrackBaseMediaDecodeTime","trackDecodeInfo","USER_DATA_REGISTERED_ITU_T_T35","RBSP_TRAILING_BITS","parseSei","payloadType","payloadSize","userIdentifier","parseUserData","sei","parseCaptionPackets","userData","ccData","discardEmulationPreventionBytes$1","captionPacketParser","CaptionStream$1","CaptionStream","parse708captions_","parse708captions","captionPackets_","ccStreams_","Cea608Stream","cc708Stream_","Cea708Stream","captionServices","cc","newCaptionPackets","latestDts_","ignoreNextEqualDts_","numSameDts_","flushCCStreams","flushType","flushStream","elem","idx","presortIndex","sort","dispatchCea608Packet","dispatchCea708Packet","activeCea608Channel_","ccStream","setsTextOrXDSActive","setsChannel1Active","setsChannel2Active","CHARACTER_TRANSLATION_708","get708CharFromCode","newCode","within708TextBlock","Cea708Window","windowNum","clearText","pendingNewLine","winAttr","penAttr","penLoc","penColor","visible","rowLock","columnLock","priority","relativePositioning","anchorVertical","anchorHorizontal","anchorPoint","rowCount","virtualRowCount","columnCount","windowStyle","penStyle","getText","rows","rowIdx","newLine","beforeRowOverflow","isEmpty","addText","backspace","row","Cea708Service","serviceNum","currentWindow","windows","createTextDecoder","startPts","win","setCurrentWindow","TextDecoder","textDecoder_","serviceProps","captionServiceEncodings","serviceName","serviceEncodings","current708Packet","services","new708Packet","add708Bytes","push708Packet","ptsVals","byte0","byte1","packet708","packetData","blockSize","seq","sizeCode","pushServiceBlock","service","initService","handleText","multiByteCharacter","extendedCommands","defineWindow","clearWindows","deleteWindows","displayWindows","hideWindows","toggleWindows","setWindowAttributes","setPenAttributes","setPenColor","setPenLocation","isExtended","getPts","byteIndex","flushDisplayed","char","charCodeArray","isMultiByte","extended","currentByte","nextByte","decode","fillOpacity","fillRed","fillGreen","fillBlue","borderType","borderRed","borderGreen","borderBlue","wordWrap","printDirection","scrollDirection","justify","effectSpeed","effectDirection","displayEffect","displayedText","winId","endPts","pushCaption","textTag","penSize","italics","underline","edgeType","fontStyle","fgOpacity","fgRed","fgGreen","fgBlue","bgOpacity","bgRed","bgGreen","bgBlue","edgeRed","edgeGreen","edgeBlue","CHARACTER_TRANSLATION","getCharFromCode","BOTTOM_ROW","ROWS","createDisplayBuffer","field","dataChannel","field_","dataChannel_","name_","setConstants","char0","char1","lastControlCode_","PADDING_","RESUME_CAPTION_LOADING_","mode_","END_OF_CAPTION_","clearFormatting","displayed_","nonDisplayed_","startPts_","ROLL_UP_2_ROWS_","rollUpRows_","setRollUp","ROLL_UP_3_ROWS_","ROLL_UP_4_ROWS_","CARRIAGE_RETURN_","shiftRowsUp_","BACKSPACE_","row_","ERASE_DISPLAYED_MEMORY_","ERASE_NON_DISPLAYED_MEMORY_","RESUME_DIRECT_CAPTIONING_","isSpecialCharacter","column_","isExtCharacter","isMidRowCode","addFormatting","isOffsetControlCode","isPAC","formatting_","isColorPAC","isNormalChar","content","topRow_","BASE_","EXT_","CONTROL_","OFFSET_","newBaseRow","reverse","popOn","baseRow","rollUp","paintOn","captionStream","streamTypes","H264_STREAM_TYPE","ADTS_STREAM_TYPE","METADATA_STREAM_TYPE","MAX_TS","RO_THRESH","TYPE_SHARED","handleRollover$1","reference","direction","TimestampRolloverStream$1","TimestampRolloverStream","lastDTS","referenceDTS","type_","discontinuity","_MetadataStream","timestampRolloverStream","handleRollover","percentEncode$1","parseUtf8","decodeURIComponent","parseIso88591$1","unescape","parseSyncSafeInteger$1","tagParsers","TXXX","description","WXXX","PRIV","owner","privateData","settings","descriptor","tagSize","bufferSize","dispatchType","frameStart","frameSize","frameHeader","dataAlignmentIndicator","timeStamp","_TransportPacketStream","_TransportParseStream","_ElementaryStream","metadataStream","MP2T_PACKET_LENGTH$1","SYNC_BYTE$1","bytesInBuffer","everything","startIndex","endIndex","parsePsi","parsePat","parsePmt","packetsWaitingForPmt","programMapTable","psi","payloadUnitStartIndicator","pat","section_number","last_section_number","pmtPid","pmt","sectionLength","tableEnd","programInfoLength","streamType","processPes_","STREAM_TYPES","segmentHadPmt","timedMetadata","parsePes","pes","ptsDtsFlags","startPrefix","packetLength","forceFlush","packetFlushable","flushStreams_","m2ts$1","PAT_PID","MP2T_PACKET_LENGTH","TransportPacketStream","TransportParseStream","ElementaryStream","MetadataStream","_AacStream","m2ts_1","ADTS_SAMPLING_FREQUENCIES","parseId3TagSize","returnSize","footerPresent","getId3Offset","isLikelyAacData$2","parseSyncSafeInteger","percentEncode","parseIso88591","parseAdtsSize","lowThree","middle","highTwo","parseType$1","parseSampleRate","parseAacTimestamp","utils","isLikelyAacData","setTimestamp","bytesLeft","tempLength","_VideoSegmentStream$1","_AudioSegmentStream$1","_Transmuxer$1","_CoalesceStream","aac","AUDIO_PROPERTIES","audioProperties","VIDEO_PROPERTIES","videoProperties","H264Stream$1","isLikelyAacData$1","ONE_SECOND_IN_TS$2","arrayEquals","generateSegmentTimingInfo","startDts","endDts","prependedContentDuration","ptsOffsetFromDts","decodeDuration","presentationDuration","firstSequenceNumber","prop","setEarliestDts","earliestDts","setVideoBaseMediaDecodeTime","setAudioAppendStart","segmentDuration","videoClockCyclesOfSilencePrefixed","gopsToAlignWith","minPTS","gopCache_","nalUnit","gopForFusion","firstGop","lastGop","resetStream_","getGopForFusion_","alignedGops","alignGopsAtEnd","alignGopsAtEnd_","alignGopsAtStart_","gop","dtsDistance","nearestGopObj","currentGopObj","halfSecond","allowableOverlap","nearestDistance","alignIndex","gopIndex","align","alignEndIndex","matchFound","trimIndex","metadata","alignGopsWith","newGopsToAlignWith","numberOfTracks","remux","remuxTracks","pendingTracks","videoTrack","pendingBoxes","pendingCaptions","pendingMetadata","pendingBytes","emittedTracks","audioTrack","caption","id3","captions","captionStreams","info","endTime","cueTime","setRemux","hasFlushed","transmuxPipeline_","setupAacPipeline","pipeline","aacStream","audioTimestampRolloverStream","timedMetadataTimestampRolloverStream","adtsStream","coalesceStream","headOfPipeline","audioSegmentStream","getLogTrigger_","hasAudio","hasVideo","setupTsPipeline","packetStream","parseStream","elementaryStream","h264Stream","videoSegmentStream","id3Frame","setBaseMediaDecodeTime","isAac","resetCaptions","_FlvTag","transmuxer$2","Transmuxer","VideoSegmentStream","AudioSegmentStream","mapToSample","approximateOffset","findSeiNals","avcStream","seiNal","lastMatchedSample","avcView","logs","seiNals","matchingSample","parseSamples","truns","allSamples","trackRun","parseCaptionNals","segment","videoTrackId","mdats","captionNals","mdatTrafPairs","matchingTraf","pair","headerInfo","parseEmbeddedCaptions","trackNals","CaptionParser","segmentCache","parsedCaptions","parsingPartial","isInitialized","isPartial","isNewInit","parsedData","cachedSegment","pushNals","nals","nal","clearParsedCaptions","resetCaptionStream","clearAllCaptions","captionParser","mp4","generator","probe","extraData","adHoc","bufferStartSize","prepareWrite","flv","minLength","widthBytes","heightBytes","videocodecidBytes","VIDEO_TAG","AUDIO_TAG","METADATA_TAG","writeBytes","writeByte","writeShort","short","setUint16","negIndex","nalUnitSize","startNalUnit","endNalUnit","nalContainer","nalStart","nalLength","writeMetaDataDouble","setFloat64","writeMetaDataBoolean","setUint8","finalize","dtsDelta","frameTime","isAudioFrame","isVideoFrame","isMetaData","isKeyFrame","flvTag","CoalesceStream","videoTags","audioTags","processedTracks","_Transmuxer","_VideoSegmentStream","_AudioSegmentStream","collectTimelineInfo","metaDataTag","extraDataTag","TagList","tagList","oldExtraData","videoKeyFrames","round","adtsFrame","lastMetaPts","writeMetaDataTags","onVideoKeyFrame","h264Frame","finishFrame","newMetadata","metaTag","extraTag","videoTimestampRolloverStream","coalesceStream$1","transmuxer$1","getFlvHeader","metadataLength","headBytes","flvHeader","m2ts","ONE_SECOND_IN_TS$1","segmentStartPts","segmentEndPts","processFrames_","timingInfo","resetTiming_","frameCache","ensureNextFrameIsKeyFrame","processNals_","cacheLastFrame","sequence","videoFrameDts","videoFramePts","resetTimingAndConfig_","createPipeline","tsPipeline","elementary","timestampRollover","aacPipeline","audioRollover","timedMetadataRollover","setupPipelineListeners","transmuxer","audioAppendStart","inspectMp4","_textifyMp","partial","MAX_UINT32$1","parseSidx","references","referenceId","earliestPresentationTime","firstOffset","referenceCount","getUint16","referenceType","referencedSize","subsegmentDuration","startsWithSap","sapType","sapDeltaTime","parseSidx_1","MAX_UINT32","parseMp4Date","Date","nalParse","dataReferenceIndex","horizresolution","vertresolution","frameCount","numOfPictureParameterSets","nalSize","configurationVersion","avcProfileIndication","avcLevelIndication","lengthSizeMinusOne","numOfSequenceParameterSets","bufferSizeDB","maxBitrate","avgBitrate","edts","elst","edits","entryCount","mediaTime","mediaRate","esId","streamPriority","decoderConfig","objectProfileIndication","decoderConfigDescriptor","audioObjectType","samplingFrequencyIndex","channelConfiguration","majorBrand","minorVersion","compatibleBrands","dataReferences","escape","language","creationTime","modificationTime","streamDescriptor","rate","volume","matrix","Uint32Array","nextTrackId","pdin","initialDelay","sidx","balance","ctts","compositionOffsets","sampleOffset","stss","syncSamples","chunkOffsets","sampleToChunks","firstChunk","samplesPerChunk","sampleSize","entries","timeToSamples","sampleDelta","layer","alternateGroup","defaultSampleDescriptionIndex","sampleDependsOn","sampleIsDependedOn","sampleHasRedundancy","samplePaddingValue","sampleIsDifferenceSample","sampleDegradationPriority","graphicsmode","opcolor","Uint16Array","ab","z","inspectedMp4","mp4Inspector","textify","parseTraf","parseHdlr","tagTypes","hex","hexStringList","parseAVCTag","avcPacketTypes","compositionTime","avcPacketType","CompositionTime","nalUnitTypeRaw","parseVideoTag","frameTypes","codecID","frameType","parseAACTag","packetTypes","aacPacketType","parseAudioTag","formatTable","samplingRateTable","soundFormat","soundRate","soundSize","soundType","parseGenericTag","tagType","dataSize","streamID","inspectFlvTag","inspectFlv","parsedResults","textifyFlv","flvTagArray","flvInspector","inspectTag","parsePid","parsePayloadUnitStartIndicator","parseAdaptionField","pusi","payloadOffset","parsePesType","parsePesTime","parseNalUnitType","videoPacketContainsKeyFrame","nalType","frameBuffer","frameI","frameSyncPoint","foundKeyFrame","probe$1","SYNC_BYTE","parsePsi_","table","parseAudioPes_","pesType","endLoop","parseVideoPes_","firstKeyFrame","adjustTimestamp_","segmentInfo","baseTimestamp","audioBaseTimestamp","dtsTime","ptsTime","videoBaseTimestamp","inspectAac_","audioCount","audioTimescale","inspectTs_","isAacData","tsInspector","muxjs","mp2t","tools","lib","for","uk-grid","ref","isEmbed","sponsors","selected-auto-play","selected-auto-loop","selectedAutoLoop","is-embed","selectedAutoPlay","addCommas","uploadDate","likes","dislikes","href","getVideoId","lbryId","toggleListenUrl","isListening","uploader","authenticated","subscribeHandler","subscribed","showDesc","foregroundColor","purifyHTML","segments","onChange","$event","comments","commentId","showRecs","relatedStreams","related","smallView","data-shaka-player-container","data-shaka-player","autoplay","shouldAutoPlay","loop","shaka","window","$player","$ui","computed","getPreferenceBoolean","preferredVideoCodecs","enabledCodecs","getPreferenceString","$refs","videoEl","canPlayType","shakaPromise","then","mod","hotkeys","getControls","toggleFullScreen","preventDefault","muted","currentTime","play","methods","component","setAttribute","thumbnailUrl","$route","query","noPrevPlayer","streams","audioStreams","videoStreams","MseSupport","MediaSource","lbry","quality","mime","livestream","hls","dash","btoa","URL","searchParams","host","proxyUrl","contentType","fetch","response","headers","polyfill","installAll","localPlayer","Player","proxyHost","getNetworkingEngine","registerRequestFilter","_type","request","uris","endsWith","Range","pathname","configure","getPreferenceNumber","setPlayerAttrs","addEventListener","time","skipped","setPreference","playbackRate","params","URLSearchParams","param","paramStr","$router","ui","Overlay","container","overflowMenuButtons","seekBarColors","base","buffered","played","player","getPlayer","disableVideo","preferredAudioCodecs","manifest","qualityConds","load","leastDiff","MAX_VALUE","bestStream","getVariantTracks","diff","selectVariantTrack","subtitles","subtitle","addTextTrackAsync","unbind","querySelectorAll","node","remove","pinned","commentorUrl","author","verified","commentedTime","commentText","likeCount","hearted","components","VideoItem","ErrorHandler","Comment","smallViewQuery","matchMedia","channelId","active","matches","location","toLocaleString","month","day","year","getVideoData","db","tx","transaction","store","objectStore","videoId","watchedAt","now","add","videoPlayer","loadVideo","getSponsors","getComments","document","handleScroll","removeEventListener","fetchJson","apiUrl","category","replaceAll","fetchVideo","fetchSubscribedStatus","fetchSponsors","fetchComments","Authorization","getAuthToken","nextpage","innerHeight","scrollY","offsetHeight","ReflectOwnKeys","R","Reflect","ReflectApply","receiver","ProcessEmitWarning","warning","ownKeys","getOwnPropertySymbols","getOwnPropertyNames","NumberIsNaN","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","_getMaxListeners","_addListener","prepend","events","existing","newListener","w","onceWrapper","fired","wrapFn","_onceWrap","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","spliceOne","Promise","reject","errorListener","resolver","eventTargetAgnosticAddListener","addErrorHandlerIfEventEmitter","wrapListener","setMaxListeners","getMaxListeners","doError","context","prependOnceListener","originalListener","rawListeners","eventNames"],"mappings":"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","file":"js/chunk-f240a110.b6f38c2b.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","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  var i\n  for (i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\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 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 = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","<template>\n    <p>{{ message }}</p>\n    <button uk-toggle=\"target: #stacktrace\" class=\"uk-button uk-button-small\" style=\"background: #222\" type=\"button\">\n        {{ $t(\"actions.show_more\") }}\n    </button>\n    <p id=\"stacktrace\" style=\"white-space: pre-wrap\" hidden>{{ error }}</p>\n</template>\n\n<script>\nexport default {\n    props: {\n        error: { type: String, default: null },\n        message: { type: String, default: null },\n    },\n};\n</script>\n","import { render } from \"./ErrorHandler.vue?vue&type=template&id=0a09c06f\"\nimport script from \"./ErrorHandler.vue?vue&type=script&lang=js\"\nexport * from \"./ErrorHandler.vue?vue&type=script&lang=js\"\nscript.render = render\n\nexport default script","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--6-oneOf-1-0!../../node_modules/@vue/cli-service/node_modules/css-loader/dist/cjs.js??ref--6-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--6-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader-v16/dist/index.js??ref--0-1!./Player.vue?vue&type=style&index=0&id=53107514&lang=css\"","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","exports.nextTick = function nextTick(fn) {\n    var args = Array.prototype.slice.call(arguments);\n    args.shift();\n    setTimeout(function () {\n        fn.apply(null, args);\n    }, 0);\n};\n\nexports.platform = exports.arch = \nexports.execPath = exports.title = 'browser';\nexports.pid = 1;\nexports.browser = true;\nexports.env = {};\nexports.argv = [];\n\nexports.binding = function (name) {\n\tthrow new Error('No such module. (Possibly not yet loaded)')\n};\n\n(function () {\n    var cwd = '/';\n    var path;\n    exports.cwd = function () { return cwd };\n    exports.chdir = function (dir) {\n        if (!path) path = require('path');\n        cwd = path.resolve(dir, cwd);\n    };\n})();\n\nexports.exit = exports.kill = \nexports.umask = exports.dlopen = \nexports.uptime = exports.memoryUsage = \nexports.uvCounters = function() {};\nexports.features = {};\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}","<template>\n    <div class=\"uk-text-secondary\" :style=\"[{ background: backgroundColor }]\">\n        <router-link class=\"uk-text-emphasis\" :to=\"video.url\">\n            <img :height=\"height\" :width=\"width\" style=\"width: 100%\" :src=\"video.thumbnail\" alt=\"\" loading=\"lazy\" />\n            <div class=\"uk-position-relative\">\n                <span\n                    v-if=\"video.duration\"\n                    class=\"uk-label uk-border-rounded uk-position-absolute video-duration\"\n                    style=\"bottom: 5px; right: 5px; background: rgba(0, 0, 0, .75); color: white; padding: 0 5px;\"\n                    >{{ timeFormat(video.duration) }}</span\n                >\n                <span\n                    v-if=\"video.watched\"\n                    class=\"uk-label uk-border-rounded uk-position-absolute video-duration\"\n                    style=\"bottom: 5px; left: 5px; background: rgba(0, 0, 0, .75); color: white; padding: 0 5px;\"\n                    >{{ $t(\"video.watched\") }}</span\n                >\n            </div>\n\n            <div>\n                <p\n                    style=\"padding-top: 0.5rem; margin-bottom: 0.5rem; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; overflow: hidden;\"\n                    :title=\"video.title\"\n                >\n                    {{ video.title }}\n                </p>\n            </div>\n        </router-link>\n\n        <div class=\"uk-align-right\" style=\"margin-left: 0; margin-bottom: 0; display: inline-block; width: 10%\">\n            <router-link\n                :to=\"video.url + '&listen=1'\"\n                :aria-label=\"'Listen to ' + video.title\"\n                :title=\"'Listen to ' + video.title\"\n            >\n                <font-awesome-icon icon=\"headphones\"></font-awesome-icon>\n            </router-link>\n        </div>\n\n        <div style=\"display: flex; flex-flow: row; height: 15%\">\n            <router-link class=\"uk-link-muted\" :to=\"video.uploaderUrl\">\n                <img\n                    v-if=\"video.uploaderAvatar\"\n                    :src=\"video.uploaderAvatar\"\n                    loading=\"lazy\"\n                    :alt=\"video.uploaderName\"\n                    class=\"uk-border-circle\"\n                    style=\"margin-right: 0.5rem; margin-top:0.5rem; width: 32px; height: 32px;\"\n                />\n            </router-link>\n\n            <div style=\"width: calc(100% - 32px - 8px);\">\n                <router-link\n                    v-if=\"video.uploaderUrl && video.uploaderName && !hideChannel\"\n                    class=\"uk-link-muted uk-overflow-hidden\"\n                    :to=\"video.uploaderUrl\"\n                    :title=\"video.uploaderName\"\n                    style=\"display:block; width: 90%\"\n                >\n                    {{ video.uploaderName }}&thinsp;<font-awesome-icon\n                        v-if=\"video.uploaderVerified\"\n                        icon=\"check\"\n                    ></font-awesome-icon>\n                </router-link>\n\n                <b v-if=\"video.views >= 0 || video.uploadedDate\" class=\"uk-text-small\">\n                    <span v-if=\"video.views >= 0\">\n                        <font-awesome-icon icon=\"eye\"></font-awesome-icon>\n                        {{ numberFormat(video.views) }} •\n                    </span>\n                    <span v-if=\"video.uploadedDate\">\n                        {{ video.uploadedDate }}\n                    </span>\n                    <span v-if=\"video.uploaded\">\n                        {{ timeAgo(video.uploaded) }}\n                    </span>\n                </b>\n            </div>\n        </div>\n    </div>\n</template>\n\n<script>\nexport default {\n    props: {\n        video: {\n            type: Object,\n            default: () => {\n                return {};\n            },\n        },\n        height: { type: String, default: \"118\" },\n        width: { type: String, default: \"210\" },\n        hideChannel: { type: Boolean, default: false },\n    },\n};\n</script>\n","import { render } from \"./VideoItem.vue?vue&type=template&id=6d67c9d7\"\nimport script from \"./VideoItem.vue?vue&type=script&lang=js\"\nexport * from \"./VideoItem.vue?vue&type=script&lang=js\"\nscript.render = render\n\nexport default script","// 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}","// Based of https://github.com/GilgusMaximus/yt-dash-manifest-generator/blob/master/src/DashGenerator.js\n\nconst xml = require(\"xml-js\");\n\nconst DashUtils = {\n    generate_dash_file_from_formats(VideoFormats, VideoLength) {\n        const generatedJSON = this.generate_xmljs_json_from_data(VideoFormats, VideoLength);\n        return xml.json2xml(generatedJSON);\n    },\n    generate_xmljs_json_from_data(VideoFormatArray, VideoLength) {\n        const convertJSON = {\n            declaration: {\n                attributes: {\n                    version: \"1.0\",\n                    encoding: \"utf-8\",\n                },\n            },\n            elements: [\n                {\n                    type: \"element\",\n                    name: \"MPD\",\n                    attributes: {\n                        xmlns: \"urn:mpeg:dash:schema:mpd:2011\",\n                        profiles: \"urn:mpeg:dash:profile:full:2011\",\n                        minBufferTime: \"PT1.5S\",\n                        type: \"static\",\n                        mediaPresentationDuration: `PT${VideoLength}S`,\n                    },\n                    elements: [\n                        {\n                            type: \"element\",\n                            name: \"Period\",\n                            elements: this.generate_adaptation_set(VideoFormatArray),\n                        },\n                    ],\n                },\n            ],\n        };\n        return convertJSON;\n    },\n    generate_adaptation_set(VideoFormatArray) {\n        const adaptationSets = [];\n        const mimeTypes = [];\n        const mimeObjects = [[]];\n        // sort the formats by mime types\n        VideoFormatArray.forEach(videoFormat => {\n            // the dual formats should not be used\n            if (videoFormat.mimeType.indexOf(\"video\") != -1 && !videoFormat.videoOnly) {\n                return;\n            }\n            // if these properties are not available, then we skip it because we cannot set these properties\n            //if (!(videoFormat.hasOwnProperty('initRange') && videoFormat.hasOwnProperty('indexRange'))) {\n            //   return\n            //}\n            const mimeType = videoFormat.mimeType;\n            const mimeTypeIndex = mimeTypes.indexOf(mimeType);\n            if (mimeTypeIndex > -1) {\n                mimeObjects[mimeTypeIndex].push(videoFormat);\n            } else {\n                mimeTypes.push(mimeType);\n                mimeObjects.push([]);\n                mimeObjects[mimeTypes.length - 1].push(videoFormat);\n            }\n        });\n        // for each MimeType generate a new Adaptation set with Representations as sub elements\n        for (let i = 0; i < mimeTypes.length; i++) {\n            let isVideoFormat = false;\n            const adapSet = {\n                type: \"element\",\n                name: \"AdaptationSet\",\n                attributes: {\n                    id: i,\n                    mimeType: mimeTypes[i],\n                    startWithSAP: \"1\",\n                    subsegmentAlignment: \"true\",\n                },\n                elements: [],\n            };\n            if (!mimeTypes[i].includes(\"audio\")) {\n                adapSet.attributes.scanType = \"progressive\";\n                isVideoFormat = true;\n            }\n            mimeObjects[i].forEach(format => {\n                if (isVideoFormat) {\n                    adapSet.elements.push(this.generate_representation_video(format));\n                } else {\n                    adapSet.elements.push(this.generate_representation_audio(format));\n                }\n            });\n            adaptationSets.push(adapSet);\n        }\n        return adaptationSets;\n    },\n    generate_representation_audio(Format) {\n        const representation = {\n            type: \"element\",\n            name: \"Representation\",\n            attributes: {\n                id: Format.itag,\n                codecs: Format.codec,\n                bandwidth: Format.bitrate,\n            },\n            elements: [\n                {\n                    type: \"element\",\n                    name: \"AudioChannelConfiguration\",\n                    attributes: {\n                        schemeIdUri: \"urn:mpeg:dash:23003:3:audio_channel_configuration:2011\",\n                        value: \"2\",\n                    },\n                },\n                {\n                    type: \"element\",\n                    name: \"BaseURL\",\n                    elements: [\n                        {\n                            type: \"text\",\n                            text: Format.url,\n                        },\n                    ],\n                },\n                {\n                    type: \"element\",\n                    name: \"SegmentBase\",\n                    attributes: {\n                        indexRange: `${Format.indexStart}-${Format.indexEnd}`,\n                    },\n                    elements: [\n                        {\n                            type: \"element\",\n                            name: \"Initialization\",\n                            attributes: {\n                                range: `${Format.initStart}-${Format.initEnd}`,\n                            },\n                        },\n                    ],\n                },\n            ],\n        };\n        return representation;\n    },\n    generate_representation_video(Format) {\n        const representation = {\n            type: \"element\",\n            name: \"Representation\",\n            attributes: {\n                id: Format.itag,\n                codecs: Format.codec,\n                bandwidth: Format.bitrate,\n                width: Format.width,\n                height: Format.height,\n                maxPlayoutRate: \"1\",\n                frameRate: Format.fps,\n            },\n            elements: [\n                {\n                    type: \"element\",\n                    name: \"BaseURL\",\n                    elements: [\n                        {\n                            type: \"text\",\n                            text: Format.url,\n                        },\n                    ],\n                },\n                {\n                    type: \"element\",\n                    name: \"SegmentBase\",\n                    attributes: {\n                        indexRange: `${Format.indexStart}-${Format.indexEnd}`,\n                    },\n                    elements: [\n                        {\n                            type: \"element\",\n                            name: \"Initialization\",\n                            attributes: {\n                                range: `${Format.initStart}-${Format.initEnd}`,\n                            },\n                        },\n                    ],\n                },\n            ],\n        };\n        return representation;\n    },\n};\n\nexport default DashUtils;\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","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\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\nSafeBuffer.prototype = Object.create(Buffer.prototype)\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","/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */\nexports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\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","/* 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","// 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};","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n  if (config('noDeprecation')) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (config('throwDeprecation')) {\n        throw new Error(msg);\n      } else if (config('traceDeprecation')) {\n        console.trace(msg);\n      } else {\n        console.warn(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n  // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n  try {\n    if (!global.localStorage) return false;\n  } catch (_) {\n    return false;\n  }\n  var val = global.localStorage[name];\n  if (null == val) return false;\n  return String(val).toLowerCase() === 'true';\n}\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};","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\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// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n  // if the path tries to go above the root, `up` ends up > 0\n  var up = 0;\n  for (var i = parts.length - 1; i >= 0; i--) {\n    var last = parts[i];\n    if (last === '.') {\n      parts.splice(i, 1);\n    } else if (last === '..') {\n      parts.splice(i, 1);\n      up++;\n    } else if (up) {\n      parts.splice(i, 1);\n      up--;\n    }\n  }\n\n  // if the path is allowed to go above the root, restore leading ..s\n  if (allowAboveRoot) {\n    for (; up--; up) {\n      parts.unshift('..');\n    }\n  }\n\n  return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n  var resolvedPath = '',\n      resolvedAbsolute = false;\n\n  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n    var path = (i >= 0) ? arguments[i] : process.cwd();\n\n    // Skip empty and invalid entries\n    if (typeof path !== 'string') {\n      throw new TypeError('Arguments to path.resolve must be strings');\n    } else if (!path) {\n      continue;\n    }\n\n    resolvedPath = path + '/' + resolvedPath;\n    resolvedAbsolute = path.charAt(0) === '/';\n  }\n\n  // At this point the path should be resolved to a full absolute path, but\n  // handle relative paths to be safe (might happen when process.cwd() fails)\n\n  // Normalize the path\n  resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n    return !!p;\n  }), !resolvedAbsolute).join('/');\n\n  return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n  var isAbsolute = exports.isAbsolute(path),\n      trailingSlash = substr(path, -1) === '/';\n\n  // Normalize the path\n  path = normalizeArray(filter(path.split('/'), function(p) {\n    return !!p;\n  }), !isAbsolute).join('/');\n\n  if (!path && !isAbsolute) {\n    path = '.';\n  }\n  if (path && trailingSlash) {\n    path += '/';\n  }\n\n  return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n  return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n  var paths = Array.prototype.slice.call(arguments, 0);\n  return exports.normalize(filter(paths, function(p, index) {\n    if (typeof p !== 'string') {\n      throw new TypeError('Arguments to path.join must be strings');\n    }\n    return p;\n  }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n  from = exports.resolve(from).substr(1);\n  to = exports.resolve(to).substr(1);\n\n  function trim(arr) {\n    var start = 0;\n    for (; start < arr.length; start++) {\n      if (arr[start] !== '') break;\n    }\n\n    var end = arr.length - 1;\n    for (; end >= 0; end--) {\n      if (arr[end] !== '') break;\n    }\n\n    if (start > end) return [];\n    return arr.slice(start, end - start + 1);\n  }\n\n  var fromParts = trim(from.split('/'));\n  var toParts = trim(to.split('/'));\n\n  var length = Math.min(fromParts.length, toParts.length);\n  var samePartsLength = length;\n  for (var i = 0; i < length; i++) {\n    if (fromParts[i] !== toParts[i]) {\n      samePartsLength = i;\n      break;\n    }\n  }\n\n  var outputParts = [];\n  for (var i = samePartsLength; i < fromParts.length; i++) {\n    outputParts.push('..');\n  }\n\n  outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n  return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  if (path.length === 0) return '.';\n  var code = path.charCodeAt(0);\n  var hasRoot = code === 47 /*/*/;\n  var end = -1;\n  var matchedSlash = true;\n  for (var i = path.length - 1; i >= 1; --i) {\n    code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        if (!matchedSlash) {\n          end = i;\n          break;\n        }\n      } else {\n      // We saw the first non-path separator\n      matchedSlash = false;\n    }\n  }\n\n  if (end === -1) return hasRoot ? '/' : '.';\n  if (hasRoot && end === 1) {\n    // return '//';\n    // Backwards-compat fix:\n    return '/';\n  }\n  return path.slice(0, end);\n};\n\nfunction basename(path) {\n  if (typeof path !== 'string') path = path + '';\n\n  var start = 0;\n  var end = -1;\n  var matchedSlash = true;\n  var i;\n\n  for (i = path.length - 1; i >= 0; --i) {\n    if (path.charCodeAt(i) === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          start = i + 1;\n          break;\n        }\n      } else if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // path component\n      matchedSlash = false;\n      end = i + 1;\n    }\n  }\n\n  if (end === -1) return '';\n  return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n  var f = basename(path);\n  if (ext && f.substr(-1 * ext.length) === ext) {\n    f = f.substr(0, f.length - ext.length);\n  }\n  return f;\n};\n\nexports.extname = function (path) {\n  if (typeof path !== 'string') path = path + '';\n  var startDot = -1;\n  var startPart = 0;\n  var end = -1;\n  var matchedSlash = true;\n  // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find\n  var preDotState = 0;\n  for (var i = path.length - 1; i >= 0; --i) {\n    var code = path.charCodeAt(i);\n    if (code === 47 /*/*/) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now\n        if (!matchedSlash) {\n          startPart = i + 1;\n          break;\n        }\n        continue;\n      }\n    if (end === -1) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension\n      matchedSlash = false;\n      end = i + 1;\n    }\n    if (code === 46 /*.*/) {\n        // If this is our first dot, mark it as the start of our extension\n        if (startDot === -1)\n          startDot = i;\n        else if (preDotState !== 1)\n          preDotState = 1;\n    } else if (startDot !== -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension\n      preDotState = -1;\n    }\n  }\n\n  if (startDot === -1 || end === -1 ||\n      // We saw a non-dot character immediately before the dot\n      preDotState === 0 ||\n      // The (right-most) trimmed path component is exactly '..'\n      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n  return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n    if (xs.filter) return xs.filter(f);\n    var res = [];\n    for (var i = 0; i < xs.length; i++) {\n        if (f(xs[i], i, xs)) res.push(xs[i]);\n    }\n    return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n    ? function (str, start, len) { return str.substr(start, len) }\n    : function (str, start, len) {\n        if (start < 0) start = str.length + start;\n        return str.substr(start, len);\n    }\n;\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","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","/*! @name mux.js @version 5.14.0 @license Apache-2.0 */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.muxjs = factory());\n}(this, (function () { 'use strict';\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   *\n   * A lightweight readable stream implemention that handles event dispatching.\n   * Objects that inherit from streams should call init in their constructors.\n   */\n\n  var Stream = function Stream() {\n    this.init = function () {\n      var listeners = {};\n      /**\n       * Add a listener for a specified event type.\n       * @param type {string} the event name\n       * @param listener {function} the callback to be invoked when an event of\n       * the specified type occurs\n       */\n\n      this.on = function (type, listener) {\n        if (!listeners[type]) {\n          listeners[type] = [];\n        }\n\n        listeners[type] = listeners[type].concat(listener);\n      };\n      /**\n       * Remove a listener for a specified event type.\n       * @param type {string} the event name\n       * @param listener {function} a function previously registered for this\n       * type of event through `on`\n       */\n\n\n      this.off = function (type, listener) {\n        var index;\n\n        if (!listeners[type]) {\n          return false;\n        }\n\n        index = listeners[type].indexOf(listener);\n        listeners[type] = listeners[type].slice();\n        listeners[type].splice(index, 1);\n        return index > -1;\n      };\n      /**\n       * Trigger an event of the specified type on this stream. Any additional\n       * arguments to this function are passed as parameters to event listeners.\n       * @param type {string} the event name\n       */\n\n\n      this.trigger = function (type) {\n        var callbacks, i, length, args;\n        callbacks = listeners[type];\n\n        if (!callbacks) {\n          return;\n        } // Slicing the arguments on every invocation of this method\n        // can add a significant amount of overhead. Avoid the\n        // intermediate object creation for the common case of a\n        // single callback argument\n\n\n        if (arguments.length === 2) {\n          length = callbacks.length;\n\n          for (i = 0; i < length; ++i) {\n            callbacks[i].call(this, arguments[1]);\n          }\n        } else {\n          args = [];\n          i = arguments.length;\n\n          for (i = 1; i < arguments.length; ++i) {\n            args.push(arguments[i]);\n          }\n\n          length = callbacks.length;\n\n          for (i = 0; i < length; ++i) {\n            callbacks[i].apply(this, args);\n          }\n        }\n      };\n      /**\n       * Destroys the stream and cleans up.\n       */\n\n\n      this.dispose = function () {\n        listeners = {};\n      };\n    };\n  };\n  /**\n   * Forwards all `data` events on this stream to the destination stream. The\n   * destination stream should provide a method `push` to receive the data\n   * events as they arrive.\n   * @param destination {stream} the stream that will receive all `data` events\n   * @param autoFlush {boolean} if false, we will not call `flush` on the destination\n   *                            when the current stream emits a 'done' event\n   * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options\n   */\n\n\n  Stream.prototype.pipe = function (destination) {\n    this.on('data', function (data) {\n      destination.push(data);\n    });\n    this.on('done', function (flushSource) {\n      destination.flush(flushSource);\n    });\n    this.on('partialdone', function (flushSource) {\n      destination.partialFlush(flushSource);\n    });\n    this.on('endedtimeline', function (flushSource) {\n      destination.endTimeline(flushSource);\n    });\n    this.on('reset', function (flushSource) {\n      destination.reset(flushSource);\n    });\n    return destination;\n  }; // Default stream functions that are expected to be overridden to perform\n  // actual work. These are provided by the prototype as a sort of no-op\n  // implementation so that we don't have to check for their existence in the\n  // `pipe` function above.\n\n\n  Stream.prototype.push = function (data) {\n    this.trigger('data', data);\n  };\n\n  Stream.prototype.flush = function (flushSource) {\n    this.trigger('done', flushSource);\n  };\n\n  Stream.prototype.partialFlush = function (flushSource) {\n    this.trigger('partialdone', flushSource);\n  };\n\n  Stream.prototype.endTimeline = function (flushSource) {\n    this.trigger('endedtimeline', flushSource);\n  };\n\n  Stream.prototype.reset = function (flushSource) {\n    this.trigger('reset', flushSource);\n  };\n\n  var stream = Stream;\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n  var ONE_SECOND_IN_TS$5 = 90000,\n      // 90kHz clock\n  secondsToVideoTs,\n      secondsToAudioTs,\n      videoTsToSeconds,\n      audioTsToSeconds,\n      audioTsToVideoTs,\n      videoTsToAudioTs,\n      metadataTsToSeconds;\n\n  secondsToVideoTs = function secondsToVideoTs(seconds) {\n    return seconds * ONE_SECOND_IN_TS$5;\n  };\n\n  secondsToAudioTs = function secondsToAudioTs(seconds, sampleRate) {\n    return seconds * sampleRate;\n  };\n\n  videoTsToSeconds = function videoTsToSeconds(timestamp) {\n    return timestamp / ONE_SECOND_IN_TS$5;\n  };\n\n  audioTsToSeconds = function audioTsToSeconds(timestamp, sampleRate) {\n    return timestamp / sampleRate;\n  };\n\n  audioTsToVideoTs = function audioTsToVideoTs(timestamp, sampleRate) {\n    return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));\n  };\n\n  videoTsToAudioTs = function videoTsToAudioTs(timestamp, sampleRate) {\n    return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);\n  };\n  /**\n   * Adjust ID3 tag or caption timing information by the timeline pts values\n   * (if keepOriginalTimestamps is false) and convert to seconds\n   */\n\n\n  metadataTsToSeconds = function metadataTsToSeconds(timestamp, timelineStartPts, keepOriginalTimestamps) {\n    return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);\n  };\n\n  var clock = {\n    ONE_SECOND_IN_TS: ONE_SECOND_IN_TS$5,\n    secondsToVideoTs: secondsToVideoTs,\n    secondsToAudioTs: secondsToAudioTs,\n    videoTsToSeconds: videoTsToSeconds,\n    audioTsToSeconds: audioTsToSeconds,\n    audioTsToVideoTs: audioTsToVideoTs,\n    videoTsToAudioTs: videoTsToAudioTs,\n    metadataTsToSeconds: metadataTsToSeconds\n  };\n\n  var ONE_SECOND_IN_TS$4 = clock.ONE_SECOND_IN_TS;\n\n  var _AdtsStream;\n\n  var ADTS_SAMPLING_FREQUENCIES$1 = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];\n  /*\n   * Accepts a ElementaryStream and emits data events with parsed\n   * AAC Audio Frames of the individual packets. Input audio in ADTS\n   * format is unpacked and re-emitted as AAC frames.\n   *\n   * @see http://wiki.multimedia.cx/index.php?title=ADTS\n   * @see http://wiki.multimedia.cx/?title=Understanding_AAC\n   */\n\n  _AdtsStream = function AdtsStream(handlePartialSegments) {\n    var buffer,\n        frameNum = 0;\n\n    _AdtsStream.prototype.init.call(this);\n\n    this.skipWarn_ = function (start, end) {\n      this.trigger('log', {\n        level: 'warn',\n        message: \"adts skiping bytes \" + start + \" to \" + end + \" in frame \" + frameNum + \" outside syncword\"\n      });\n    };\n\n    this.push = function (packet) {\n      var i = 0,\n          frameLength,\n          protectionSkipBytes,\n          oldBuffer,\n          sampleCount,\n          adtsFrameDuration;\n\n      if (!handlePartialSegments) {\n        frameNum = 0;\n      }\n\n      if (packet.type !== 'audio') {\n        // ignore non-audio data\n        return;\n      } // Prepend any data in the buffer to the input data so that we can parse\n      // aac frames the cross a PES packet boundary\n\n\n      if (buffer && buffer.length) {\n        oldBuffer = buffer;\n        buffer = new Uint8Array(oldBuffer.byteLength + packet.data.byteLength);\n        buffer.set(oldBuffer);\n        buffer.set(packet.data, oldBuffer.byteLength);\n      } else {\n        buffer = packet.data;\n      } // unpack any ADTS frames which have been fully received\n      // for details on the ADTS header, see http://wiki.multimedia.cx/index.php?title=ADTS\n\n\n      var skip; // We use i + 7 here because we want to be able to parse the entire header.\n      // If we don't have enough bytes to do that, then we definitely won't have a full frame.\n\n      while (i + 7 < buffer.length) {\n        // Look for the start of an ADTS header..\n        if (buffer[i] !== 0xFF || (buffer[i + 1] & 0xF6) !== 0xF0) {\n          if (typeof skip !== 'number') {\n            skip = i;\n          } // If a valid header was not found,  jump one forward and attempt to\n          // find a valid ADTS header starting at the next byte\n\n\n          i++;\n          continue;\n        }\n\n        if (typeof skip === 'number') {\n          this.skipWarn_(skip, i);\n          skip = null;\n        } // The protection skip bit tells us if we have 2 bytes of CRC data at the\n        // end of the ADTS header\n\n\n        protectionSkipBytes = (~buffer[i + 1] & 0x01) * 2; // Frame length is a 13 bit integer starting 16 bits from the\n        // end of the sync sequence\n        // NOTE: frame length includes the size of the header\n\n        frameLength = (buffer[i + 3] & 0x03) << 11 | buffer[i + 4] << 3 | (buffer[i + 5] & 0xe0) >> 5;\n        sampleCount = ((buffer[i + 6] & 0x03) + 1) * 1024;\n        adtsFrameDuration = sampleCount * ONE_SECOND_IN_TS$4 / ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2]; // If we don't have enough data to actually finish this ADTS frame,\n        // then we have to wait for more data\n\n        if (buffer.byteLength - i < frameLength) {\n          break;\n        } // Otherwise, deliver the complete AAC frame\n\n\n        this.trigger('data', {\n          pts: packet.pts + frameNum * adtsFrameDuration,\n          dts: packet.dts + frameNum * adtsFrameDuration,\n          sampleCount: sampleCount,\n          audioobjecttype: (buffer[i + 2] >>> 6 & 0x03) + 1,\n          channelcount: (buffer[i + 2] & 1) << 2 | (buffer[i + 3] & 0xc0) >>> 6,\n          samplerate: ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2],\n          samplingfrequencyindex: (buffer[i + 2] & 0x3c) >>> 2,\n          // assume ISO/IEC 14496-12 AudioSampleEntry default of 16\n          samplesize: 16,\n          // data is the frame without it's header\n          data: buffer.subarray(i + 7 + protectionSkipBytes, i + frameLength)\n        });\n        frameNum++;\n        i += frameLength;\n      }\n\n      if (typeof skip === 'number') {\n        this.skipWarn_(skip, i);\n        skip = null;\n      } // remove processed bytes from the buffer.\n\n\n      buffer = buffer.subarray(i);\n    };\n\n    this.flush = function () {\n      frameNum = 0;\n      this.trigger('done');\n    };\n\n    this.reset = function () {\n      buffer = void 0;\n      this.trigger('reset');\n    };\n\n    this.endTimeline = function () {\n      buffer = void 0;\n      this.trigger('endedtimeline');\n    };\n  };\n\n  _AdtsStream.prototype = new stream();\n  var adts = _AdtsStream;\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var ExpGolomb;\n  /**\n   * Parser for exponential Golomb codes, a variable-bitwidth number encoding\n   * scheme used by h264.\n   */\n\n  ExpGolomb = function ExpGolomb(workingData) {\n    var // the number of bytes left to examine in workingData\n    workingBytesAvailable = workingData.byteLength,\n        // the current word being examined\n    workingWord = 0,\n        // :uint\n    // the number of bits left to examine in the current word\n    workingBitsAvailable = 0; // :uint;\n    // ():uint\n\n    this.length = function () {\n      return 8 * workingBytesAvailable;\n    }; // ():uint\n\n\n    this.bitsAvailable = function () {\n      return 8 * workingBytesAvailable + workingBitsAvailable;\n    }; // ():void\n\n\n    this.loadWord = function () {\n      var position = workingData.byteLength - workingBytesAvailable,\n          workingBytes = new Uint8Array(4),\n          availableBytes = Math.min(4, workingBytesAvailable);\n\n      if (availableBytes === 0) {\n        throw new Error('no bytes available');\n      }\n\n      workingBytes.set(workingData.subarray(position, position + availableBytes));\n      workingWord = new DataView(workingBytes.buffer).getUint32(0); // track the amount of workingData that has been processed\n\n      workingBitsAvailable = availableBytes * 8;\n      workingBytesAvailable -= availableBytes;\n    }; // (count:int):void\n\n\n    this.skipBits = function (count) {\n      var skipBytes; // :int\n\n      if (workingBitsAvailable > count) {\n        workingWord <<= count;\n        workingBitsAvailable -= count;\n      } else {\n        count -= workingBitsAvailable;\n        skipBytes = Math.floor(count / 8);\n        count -= skipBytes * 8;\n        workingBytesAvailable -= skipBytes;\n        this.loadWord();\n        workingWord <<= count;\n        workingBitsAvailable -= count;\n      }\n    }; // (size:int):uint\n\n\n    this.readBits = function (size) {\n      var bits = Math.min(workingBitsAvailable, size),\n          // :uint\n      valu = workingWord >>> 32 - bits; // :uint\n      // if size > 31, handle error\n\n      workingBitsAvailable -= bits;\n\n      if (workingBitsAvailable > 0) {\n        workingWord <<= bits;\n      } else if (workingBytesAvailable > 0) {\n        this.loadWord();\n      }\n\n      bits = size - bits;\n\n      if (bits > 0) {\n        return valu << bits | this.readBits(bits);\n      }\n\n      return valu;\n    }; // ():uint\n\n\n    this.skipLeadingZeros = function () {\n      var leadingZeroCount; // :uint\n\n      for (leadingZeroCount = 0; leadingZeroCount < workingBitsAvailable; ++leadingZeroCount) {\n        if ((workingWord & 0x80000000 >>> leadingZeroCount) !== 0) {\n          // the first bit of working word is 1\n          workingWord <<= leadingZeroCount;\n          workingBitsAvailable -= leadingZeroCount;\n          return leadingZeroCount;\n        }\n      } // we exhausted workingWord and still have not found a 1\n\n\n      this.loadWord();\n      return leadingZeroCount + this.skipLeadingZeros();\n    }; // ():void\n\n\n    this.skipUnsignedExpGolomb = function () {\n      this.skipBits(1 + this.skipLeadingZeros());\n    }; // ():void\n\n\n    this.skipExpGolomb = function () {\n      this.skipBits(1 + this.skipLeadingZeros());\n    }; // ():uint\n\n\n    this.readUnsignedExpGolomb = function () {\n      var clz = this.skipLeadingZeros(); // :uint\n\n      return this.readBits(clz + 1) - 1;\n    }; // ():int\n\n\n    this.readExpGolomb = function () {\n      var valu = this.readUnsignedExpGolomb(); // :int\n\n      if (0x01 & valu) {\n        // the number is odd if the low order bit is set\n        return 1 + valu >>> 1; // add 1 to make it even, and divide by 2\n      }\n\n      return -1 * (valu >>> 1); // divide by two then make it negative\n    }; // Some convenience functions\n    // :Boolean\n\n\n    this.readBoolean = function () {\n      return this.readBits(1) === 1;\n    }; // ():int\n\n\n    this.readUnsignedByte = function () {\n      return this.readBits(8);\n    };\n\n    this.loadWord();\n  };\n\n  var expGolomb = ExpGolomb;\n\n  var _H264Stream, _NalByteStream;\n\n  var PROFILES_WITH_OPTIONAL_SPS_DATA;\n  /**\n   * Accepts a NAL unit byte stream and unpacks the embedded NAL units.\n   */\n\n  _NalByteStream = function NalByteStream() {\n    var syncPoint = 0,\n        i,\n        buffer;\n\n    _NalByteStream.prototype.init.call(this);\n    /*\n     * Scans a byte stream and triggers a data event with the NAL units found.\n     * @param {Object} data Event received from H264Stream\n     * @param {Uint8Array} data.data The h264 byte stream to be scanned\n     *\n     * @see H264Stream.push\n     */\n\n\n    this.push = function (data) {\n      var swapBuffer;\n\n      if (!buffer) {\n        buffer = data.data;\n      } else {\n        swapBuffer = new Uint8Array(buffer.byteLength + data.data.byteLength);\n        swapBuffer.set(buffer);\n        swapBuffer.set(data.data, buffer.byteLength);\n        buffer = swapBuffer;\n      }\n\n      var len = buffer.byteLength; // Rec. ITU-T H.264, Annex B\n      // scan for NAL unit boundaries\n      // a match looks like this:\n      // 0 0 1 .. NAL .. 0 0 1\n      // ^ sync point        ^ i\n      // or this:\n      // 0 0 1 .. NAL .. 0 0 0\n      // ^ sync point        ^ i\n      // advance the sync point to a NAL start, if necessary\n\n      for (; syncPoint < len - 3; syncPoint++) {\n        if (buffer[syncPoint + 2] === 1) {\n          // the sync point is properly aligned\n          i = syncPoint + 5;\n          break;\n        }\n      }\n\n      while (i < len) {\n        // look at the current byte to determine if we've hit the end of\n        // a NAL unit boundary\n        switch (buffer[i]) {\n          case 0:\n            // skip past non-sync sequences\n            if (buffer[i - 1] !== 0) {\n              i += 2;\n              break;\n            } else if (buffer[i - 2] !== 0) {\n              i++;\n              break;\n            } // deliver the NAL unit if it isn't empty\n\n\n            if (syncPoint + 3 !== i - 2) {\n              this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));\n            } // drop trailing zeroes\n\n\n            do {\n              i++;\n            } while (buffer[i] !== 1 && i < len);\n\n            syncPoint = i - 2;\n            i += 3;\n            break;\n\n          case 1:\n            // skip past non-sync sequences\n            if (buffer[i - 1] !== 0 || buffer[i - 2] !== 0) {\n              i += 3;\n              break;\n            } // deliver the NAL unit\n\n\n            this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));\n            syncPoint = i - 2;\n            i += 3;\n            break;\n\n          default:\n            // the current byte isn't a one or zero, so it cannot be part\n            // of a sync sequence\n            i += 3;\n            break;\n        }\n      } // filter out the NAL units that were delivered\n\n\n      buffer = buffer.subarray(syncPoint);\n      i -= syncPoint;\n      syncPoint = 0;\n    };\n\n    this.reset = function () {\n      buffer = null;\n      syncPoint = 0;\n      this.trigger('reset');\n    };\n\n    this.flush = function () {\n      // deliver the last buffered NAL unit\n      if (buffer && buffer.byteLength > 3) {\n        this.trigger('data', buffer.subarray(syncPoint + 3));\n      } // reset the stream state\n\n\n      buffer = null;\n      syncPoint = 0;\n      this.trigger('done');\n    };\n\n    this.endTimeline = function () {\n      this.flush();\n      this.trigger('endedtimeline');\n    };\n  };\n\n  _NalByteStream.prototype = new stream(); // values of profile_idc that indicate additional fields are included in the SPS\n  // see Recommendation ITU-T H.264 (4/2013),\n  // 7.3.2.1.1 Sequence parameter set data syntax\n\n  PROFILES_WITH_OPTIONAL_SPS_DATA = {\n    100: true,\n    110: true,\n    122: true,\n    244: true,\n    44: true,\n    83: true,\n    86: true,\n    118: true,\n    128: true,\n    // TODO: the three profiles below don't\n    // appear to have sps data in the specificiation anymore?\n    138: true,\n    139: true,\n    134: true\n  };\n  /**\n   * Accepts input from a ElementaryStream and produces H.264 NAL unit data\n   * events.\n   */\n\n  _H264Stream = function H264Stream() {\n    var nalByteStream = new _NalByteStream(),\n        self,\n        trackId,\n        currentPts,\n        currentDts,\n        discardEmulationPreventionBytes,\n        readSequenceParameterSet,\n        skipScalingList;\n\n    _H264Stream.prototype.init.call(this);\n\n    self = this;\n    /*\n     * Pushes a packet from a stream onto the NalByteStream\n     *\n     * @param {Object} packet - A packet received from a stream\n     * @param {Uint8Array} packet.data - The raw bytes of the packet\n     * @param {Number} packet.dts - Decode timestamp of the packet\n     * @param {Number} packet.pts - Presentation timestamp of the packet\n     * @param {Number} packet.trackId - The id of the h264 track this packet came from\n     * @param {('video'|'audio')} packet.type - The type of packet\n     *\n     */\n\n    this.push = function (packet) {\n      if (packet.type !== 'video') {\n        return;\n      }\n\n      trackId = packet.trackId;\n      currentPts = packet.pts;\n      currentDts = packet.dts;\n      nalByteStream.push(packet);\n    };\n    /*\n     * Identify NAL unit types and pass on the NALU, trackId, presentation and decode timestamps\n     * for the NALUs to the next stream component.\n     * Also, preprocess caption and sequence parameter NALUs.\n     *\n     * @param {Uint8Array} data - A NAL unit identified by `NalByteStream.push`\n     * @see NalByteStream.push\n     */\n\n\n    nalByteStream.on('data', function (data) {\n      var event = {\n        trackId: trackId,\n        pts: currentPts,\n        dts: currentDts,\n        data: data,\n        nalUnitTypeCode: data[0] & 0x1f\n      };\n\n      switch (event.nalUnitTypeCode) {\n        case 0x05:\n          event.nalUnitType = 'slice_layer_without_partitioning_rbsp_idr';\n          break;\n\n        case 0x06:\n          event.nalUnitType = 'sei_rbsp';\n          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));\n          break;\n\n        case 0x07:\n          event.nalUnitType = 'seq_parameter_set_rbsp';\n          event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));\n          event.config = readSequenceParameterSet(event.escapedRBSP);\n          break;\n\n        case 0x08:\n          event.nalUnitType = 'pic_parameter_set_rbsp';\n          break;\n\n        case 0x09:\n          event.nalUnitType = 'access_unit_delimiter_rbsp';\n          break;\n      } // This triggers data on the H264Stream\n\n\n      self.trigger('data', event);\n    });\n    nalByteStream.on('done', function () {\n      self.trigger('done');\n    });\n    nalByteStream.on('partialdone', function () {\n      self.trigger('partialdone');\n    });\n    nalByteStream.on('reset', function () {\n      self.trigger('reset');\n    });\n    nalByteStream.on('endedtimeline', function () {\n      self.trigger('endedtimeline');\n    });\n\n    this.flush = function () {\n      nalByteStream.flush();\n    };\n\n    this.partialFlush = function () {\n      nalByteStream.partialFlush();\n    };\n\n    this.reset = function () {\n      nalByteStream.reset();\n    };\n\n    this.endTimeline = function () {\n      nalByteStream.endTimeline();\n    };\n    /**\n     * Advance the ExpGolomb decoder past a scaling list. The scaling\n     * list is optionally transmitted as part of a sequence parameter\n     * set and is not relevant to transmuxing.\n     * @param count {number} the number of entries in this scaling list\n     * @param expGolombDecoder {object} an ExpGolomb pointed to the\n     * start of a scaling list\n     * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1\n     */\n\n\n    skipScalingList = function skipScalingList(count, expGolombDecoder) {\n      var lastScale = 8,\n          nextScale = 8,\n          j,\n          deltaScale;\n\n      for (j = 0; j < count; j++) {\n        if (nextScale !== 0) {\n          deltaScale = expGolombDecoder.readExpGolomb();\n          nextScale = (lastScale + deltaScale + 256) % 256;\n        }\n\n        lastScale = nextScale === 0 ? lastScale : nextScale;\n      }\n    };\n    /**\n     * Expunge any \"Emulation Prevention\" bytes from a \"Raw Byte\n     * Sequence Payload\"\n     * @param data {Uint8Array} the bytes of a RBSP from a NAL\n     * unit\n     * @return {Uint8Array} the RBSP without any Emulation\n     * Prevention Bytes\n     */\n\n\n    discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {\n      var length = data.byteLength,\n          emulationPreventionBytesPositions = [],\n          i = 1,\n          newLength,\n          newData; // Find all `Emulation Prevention Bytes`\n\n      while (i < length - 2) {\n        if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {\n          emulationPreventionBytesPositions.push(i + 2);\n          i += 2;\n        } else {\n          i++;\n        }\n      } // If no Emulation Prevention Bytes were found just return the original\n      // array\n\n\n      if (emulationPreventionBytesPositions.length === 0) {\n        return data;\n      } // Create a new array to hold the NAL unit data\n\n\n      newLength = length - emulationPreventionBytesPositions.length;\n      newData = new Uint8Array(newLength);\n      var sourceIndex = 0;\n\n      for (i = 0; i < newLength; sourceIndex++, i++) {\n        if (sourceIndex === emulationPreventionBytesPositions[0]) {\n          // Skip this byte\n          sourceIndex++; // Remove this position index\n\n          emulationPreventionBytesPositions.shift();\n        }\n\n        newData[i] = data[sourceIndex];\n      }\n\n      return newData;\n    };\n    /**\n     * Read a sequence parameter set and return some interesting video\n     * properties. A sequence parameter set is the H264 metadata that\n     * describes the properties of upcoming video frames.\n     * @param data {Uint8Array} the bytes of a sequence parameter set\n     * @return {object} an object with configuration parsed from the\n     * sequence parameter set, including the dimensions of the\n     * associated video frames.\n     */\n\n\n    readSequenceParameterSet = function readSequenceParameterSet(data) {\n      var frameCropLeftOffset = 0,\n          frameCropRightOffset = 0,\n          frameCropTopOffset = 0,\n          frameCropBottomOffset = 0,\n          expGolombDecoder,\n          profileIdc,\n          levelIdc,\n          profileCompatibility,\n          chromaFormatIdc,\n          picOrderCntType,\n          numRefFramesInPicOrderCntCycle,\n          picWidthInMbsMinus1,\n          picHeightInMapUnitsMinus1,\n          frameMbsOnlyFlag,\n          scalingListCount,\n          sarRatio = [1, 1],\n          aspectRatioIdc,\n          i;\n      expGolombDecoder = new expGolomb(data);\n      profileIdc = expGolombDecoder.readUnsignedByte(); // profile_idc\n\n      profileCompatibility = expGolombDecoder.readUnsignedByte(); // constraint_set[0-5]_flag\n\n      levelIdc = expGolombDecoder.readUnsignedByte(); // level_idc u(8)\n\n      expGolombDecoder.skipUnsignedExpGolomb(); // seq_parameter_set_id\n      // some profiles have more optional data we don't need\n\n      if (PROFILES_WITH_OPTIONAL_SPS_DATA[profileIdc]) {\n        chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();\n\n        if (chromaFormatIdc === 3) {\n          expGolombDecoder.skipBits(1); // separate_colour_plane_flag\n        }\n\n        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_luma_minus8\n\n        expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_chroma_minus8\n\n        expGolombDecoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag\n\n        if (expGolombDecoder.readBoolean()) {\n          // seq_scaling_matrix_present_flag\n          scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;\n\n          for (i = 0; i < scalingListCount; i++) {\n            if (expGolombDecoder.readBoolean()) {\n              // seq_scaling_list_present_flag[ i ]\n              if (i < 6) {\n                skipScalingList(16, expGolombDecoder);\n              } else {\n                skipScalingList(64, expGolombDecoder);\n              }\n            }\n          }\n        }\n      }\n\n      expGolombDecoder.skipUnsignedExpGolomb(); // log2_max_frame_num_minus4\n\n      picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();\n\n      if (picOrderCntType === 0) {\n        expGolombDecoder.readUnsignedExpGolomb(); // log2_max_pic_order_cnt_lsb_minus4\n      } else if (picOrderCntType === 1) {\n        expGolombDecoder.skipBits(1); // delta_pic_order_always_zero_flag\n\n        expGolombDecoder.skipExpGolomb(); // offset_for_non_ref_pic\n\n        expGolombDecoder.skipExpGolomb(); // offset_for_top_to_bottom_field\n\n        numRefFramesInPicOrderCntCycle = expGolombDecoder.readUnsignedExpGolomb();\n\n        for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {\n          expGolombDecoder.skipExpGolomb(); // offset_for_ref_frame[ i ]\n        }\n      }\n\n      expGolombDecoder.skipUnsignedExpGolomb(); // max_num_ref_frames\n\n      expGolombDecoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag\n\n      picWidthInMbsMinus1 = expGolombDecoder.readUnsignedExpGolomb();\n      picHeightInMapUnitsMinus1 = expGolombDecoder.readUnsignedExpGolomb();\n      frameMbsOnlyFlag = expGolombDecoder.readBits(1);\n\n      if (frameMbsOnlyFlag === 0) {\n        expGolombDecoder.skipBits(1); // mb_adaptive_frame_field_flag\n      }\n\n      expGolombDecoder.skipBits(1); // direct_8x8_inference_flag\n\n      if (expGolombDecoder.readBoolean()) {\n        // frame_cropping_flag\n        frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();\n        frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();\n        frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();\n        frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();\n      }\n\n      if (expGolombDecoder.readBoolean()) {\n        // vui_parameters_present_flag\n        if (expGolombDecoder.readBoolean()) {\n          // aspect_ratio_info_present_flag\n          aspectRatioIdc = expGolombDecoder.readUnsignedByte();\n\n          switch (aspectRatioIdc) {\n            case 1:\n              sarRatio = [1, 1];\n              break;\n\n            case 2:\n              sarRatio = [12, 11];\n              break;\n\n            case 3:\n              sarRatio = [10, 11];\n              break;\n\n            case 4:\n              sarRatio = [16, 11];\n              break;\n\n            case 5:\n              sarRatio = [40, 33];\n              break;\n\n            case 6:\n              sarRatio = [24, 11];\n              break;\n\n            case 7:\n              sarRatio = [20, 11];\n              break;\n\n            case 8:\n              sarRatio = [32, 11];\n              break;\n\n            case 9:\n              sarRatio = [80, 33];\n              break;\n\n            case 10:\n              sarRatio = [18, 11];\n              break;\n\n            case 11:\n              sarRatio = [15, 11];\n              break;\n\n            case 12:\n              sarRatio = [64, 33];\n              break;\n\n            case 13:\n              sarRatio = [160, 99];\n              break;\n\n            case 14:\n              sarRatio = [4, 3];\n              break;\n\n            case 15:\n              sarRatio = [3, 2];\n              break;\n\n            case 16:\n              sarRatio = [2, 1];\n              break;\n\n            case 255:\n              {\n                sarRatio = [expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte(), expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte()];\n                break;\n              }\n          }\n\n          if (sarRatio) {\n            sarRatio[0] / sarRatio[1];\n          }\n        }\n      }\n\n      return {\n        profileIdc: profileIdc,\n        levelIdc: levelIdc,\n        profileCompatibility: profileCompatibility,\n        width: (picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2,\n        height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - frameCropTopOffset * 2 - frameCropBottomOffset * 2,\n        // sar is sample aspect ratio\n        sarRatio: sarRatio\n      };\n    };\n  };\n\n  _H264Stream.prototype = new stream();\n  var h264 = {\n    H264Stream: _H264Stream,\n    NalByteStream: _NalByteStream\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var codecs = {\n    Adts: adts,\n    h264: h264\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   *\n   * Functions that generate fragmented MP4s suitable for use with Media\n   * Source Extensions.\n   */\n\n  var UINT32_MAX = Math.pow(2, 32) - 1;\n  var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd, trak, tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, traf, trex, trun$1, types, MAJOR_BRAND, MINOR_VERSION, AVC1_BRAND, VIDEO_HDLR, AUDIO_HDLR, HDLR_TYPES, VMHD, SMHD, DREF, STCO, STSC, STSZ, STTS; // pre-calculate constants\n\n  (function () {\n    var i;\n    types = {\n      avc1: [],\n      // codingname\n      avcC: [],\n      btrt: [],\n      dinf: [],\n      dref: [],\n      esds: [],\n      ftyp: [],\n      hdlr: [],\n      mdat: [],\n      mdhd: [],\n      mdia: [],\n      mfhd: [],\n      minf: [],\n      moof: [],\n      moov: [],\n      mp4a: [],\n      // codingname\n      mvex: [],\n      mvhd: [],\n      pasp: [],\n      sdtp: [],\n      smhd: [],\n      stbl: [],\n      stco: [],\n      stsc: [],\n      stsd: [],\n      stsz: [],\n      stts: [],\n      styp: [],\n      tfdt: [],\n      tfhd: [],\n      traf: [],\n      trak: [],\n      trun: [],\n      trex: [],\n      tkhd: [],\n      vmhd: []\n    }; // In environments where Uint8Array is undefined (e.g., IE8), skip set up so that we\n    // don't throw an error\n\n    if (typeof Uint8Array === 'undefined') {\n      return;\n    }\n\n    for (i in types) {\n      if (types.hasOwnProperty(i)) {\n        types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];\n      }\n    }\n\n    MAJOR_BRAND = new Uint8Array(['i'.charCodeAt(0), 's'.charCodeAt(0), 'o'.charCodeAt(0), 'm'.charCodeAt(0)]);\n    AVC1_BRAND = new Uint8Array(['a'.charCodeAt(0), 'v'.charCodeAt(0), 'c'.charCodeAt(0), '1'.charCodeAt(0)]);\n    MINOR_VERSION = new Uint8Array([0, 0, 0, 1]);\n    VIDEO_HDLR = new Uint8Array([0x00, // version 0\n    0x00, 0x00, 0x00, // flags\n    0x00, 0x00, 0x00, 0x00, // pre_defined\n    0x76, 0x69, 0x64, 0x65, // handler_type: 'vide'\n    0x00, 0x00, 0x00, 0x00, // reserved\n    0x00, 0x00, 0x00, 0x00, // reserved\n    0x00, 0x00, 0x00, 0x00, // reserved\n    0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'\n    ]);\n    AUDIO_HDLR = new Uint8Array([0x00, // version 0\n    0x00, 0x00, 0x00, // flags\n    0x00, 0x00, 0x00, 0x00, // pre_defined\n    0x73, 0x6f, 0x75, 0x6e, // handler_type: 'soun'\n    0x00, 0x00, 0x00, 0x00, // reserved\n    0x00, 0x00, 0x00, 0x00, // reserved\n    0x00, 0x00, 0x00, 0x00, // reserved\n    0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'\n    ]);\n    HDLR_TYPES = {\n      video: VIDEO_HDLR,\n      audio: AUDIO_HDLR\n    };\n    DREF = new Uint8Array([0x00, // version 0\n    0x00, 0x00, 0x00, // flags\n    0x00, 0x00, 0x00, 0x01, // entry_count\n    0x00, 0x00, 0x00, 0x0c, // entry_size\n    0x75, 0x72, 0x6c, 0x20, // 'url' type\n    0x00, // version 0\n    0x00, 0x00, 0x01 // entry_flags\n    ]);\n    SMHD = new Uint8Array([0x00, // version\n    0x00, 0x00, 0x00, // flags\n    0x00, 0x00, // balance, 0 means centered\n    0x00, 0x00 // reserved\n    ]);\n    STCO = new Uint8Array([0x00, // version\n    0x00, 0x00, 0x00, // flags\n    0x00, 0x00, 0x00, 0x00 // entry_count\n    ]);\n    STSC = STCO;\n    STSZ = new Uint8Array([0x00, // version\n    0x00, 0x00, 0x00, // flags\n    0x00, 0x00, 0x00, 0x00, // sample_size\n    0x00, 0x00, 0x00, 0x00 // sample_count\n    ]);\n    STTS = STCO;\n    VMHD = new Uint8Array([0x00, // version\n    0x00, 0x00, 0x01, // flags\n    0x00, 0x00, // graphicsmode\n    0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor\n    ]);\n  })();\n\n  box = function box(type) {\n    var payload = [],\n        size = 0,\n        i,\n        result,\n        view;\n\n    for (i = 1; i < arguments.length; i++) {\n      payload.push(arguments[i]);\n    }\n\n    i = payload.length; // calculate the total size we need to allocate\n\n    while (i--) {\n      size += payload[i].byteLength;\n    }\n\n    result = new Uint8Array(size + 8);\n    view = new DataView(result.buffer, result.byteOffset, result.byteLength);\n    view.setUint32(0, result.byteLength);\n    result.set(type, 4); // copy the payload into the result\n\n    for (i = 0, size = 8; i < payload.length; i++) {\n      result.set(payload[i], size);\n      size += payload[i].byteLength;\n    }\n\n    return result;\n  };\n\n  dinf = function dinf() {\n    return box(types.dinf, box(types.dref, DREF));\n  };\n\n  esds = function esds(track) {\n    return box(types.esds, new Uint8Array([0x00, // version\n    0x00, 0x00, 0x00, // flags\n    // ES_Descriptor\n    0x03, // tag, ES_DescrTag\n    0x19, // length\n    0x00, 0x00, // ES_ID\n    0x00, // streamDependenceFlag, URL_flag, reserved, streamPriority\n    // DecoderConfigDescriptor\n    0x04, // tag, DecoderConfigDescrTag\n    0x11, // length\n    0x40, // object type\n    0x15, // streamType\n    0x00, 0x06, 0x00, // bufferSizeDB\n    0x00, 0x00, 0xda, 0xc0, // maxBitrate\n    0x00, 0x00, 0xda, 0xc0, // avgBitrate\n    // DecoderSpecificInfo\n    0x05, // tag, DecoderSpecificInfoTag\n    0x02, // length\n    // ISO/IEC 14496-3, AudioSpecificConfig\n    // for samplingFrequencyIndex see ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35\n    track.audioobjecttype << 3 | track.samplingfrequencyindex >>> 1, track.samplingfrequencyindex << 7 | track.channelcount << 3, 0x06, 0x01, 0x02 // GASpecificConfig\n    ]));\n  };\n\n  ftyp = function ftyp() {\n    return box(types.ftyp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND, AVC1_BRAND);\n  };\n\n  hdlr = function hdlr(type) {\n    return box(types.hdlr, HDLR_TYPES[type]);\n  };\n\n  mdat = function mdat(data) {\n    return box(types.mdat, data);\n  };\n\n  mdhd = function mdhd(track) {\n    var result = new Uint8Array([0x00, // version 0\n    0x00, 0x00, 0x00, // flags\n    0x00, 0x00, 0x00, 0x02, // creation_time\n    0x00, 0x00, 0x00, 0x03, // modification_time\n    0x00, 0x01, 0x5f, 0x90, // timescale, 90,000 \"ticks\" per second\n    track.duration >>> 24 & 0xFF, track.duration >>> 16 & 0xFF, track.duration >>> 8 & 0xFF, track.duration & 0xFF, // duration\n    0x55, 0xc4, // 'und' language (undetermined)\n    0x00, 0x00]); // Use the sample rate from the track metadata, when it is\n    // defined. The sample rate can be parsed out of an ADTS header, for\n    // instance.\n\n    if (track.samplerate) {\n      result[12] = track.samplerate >>> 24 & 0xFF;\n      result[13] = track.samplerate >>> 16 & 0xFF;\n      result[14] = track.samplerate >>> 8 & 0xFF;\n      result[15] = track.samplerate & 0xFF;\n    }\n\n    return box(types.mdhd, result);\n  };\n\n  mdia = function mdia(track) {\n    return box(types.mdia, mdhd(track), hdlr(track.type), minf(track));\n  };\n\n  mfhd = function mfhd(sequenceNumber) {\n    return box(types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00, // flags\n    (sequenceNumber & 0xFF000000) >> 24, (sequenceNumber & 0xFF0000) >> 16, (sequenceNumber & 0xFF00) >> 8, sequenceNumber & 0xFF // sequence_number\n    ]));\n  };\n\n  minf = function minf(track) {\n    return box(types.minf, track.type === 'video' ? box(types.vmhd, VMHD) : box(types.smhd, SMHD), dinf(), stbl(track));\n  };\n\n  moof = function moof(sequenceNumber, tracks) {\n    var trackFragments = [],\n        i = tracks.length; // build traf boxes for each track fragment\n\n    while (i--) {\n      trackFragments[i] = traf(tracks[i]);\n    }\n\n    return box.apply(null, [types.moof, mfhd(sequenceNumber)].concat(trackFragments));\n  };\n  /**\n   * Returns a movie box.\n   * @param tracks {array} the tracks associated with this movie\n   * @see ISO/IEC 14496-12:2012(E), section 8.2.1\n   */\n\n\n  moov = function moov(tracks) {\n    var i = tracks.length,\n        boxes = [];\n\n    while (i--) {\n      boxes[i] = trak(tracks[i]);\n    }\n\n    return box.apply(null, [types.moov, mvhd(0xffffffff)].concat(boxes).concat(mvex(tracks)));\n  };\n\n  mvex = function mvex(tracks) {\n    var i = tracks.length,\n        boxes = [];\n\n    while (i--) {\n      boxes[i] = trex(tracks[i]);\n    }\n\n    return box.apply(null, [types.mvex].concat(boxes));\n  };\n\n  mvhd = function mvhd(duration) {\n    var bytes = new Uint8Array([0x00, // version 0\n    0x00, 0x00, 0x00, // flags\n    0x00, 0x00, 0x00, 0x01, // creation_time\n    0x00, 0x00, 0x00, 0x02, // modification_time\n    0x00, 0x01, 0x5f, 0x90, // timescale, 90,000 \"ticks\" per second\n    (duration & 0xFF000000) >> 24, (duration & 0xFF0000) >> 16, (duration & 0xFF00) >> 8, duration & 0xFF, // duration\n    0x00, 0x01, 0x00, 0x00, // 1.0 rate\n    0x01, 0x00, // 1.0 volume\n    0x00, 0x00, // reserved\n    0x00, 0x00, 0x00, 0x00, // reserved\n    0x00, 0x00, 0x00, 0x00, // reserved\n    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // transformation: unity matrix\n    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined\n    0xff, 0xff, 0xff, 0xff // next_track_ID\n    ]);\n    return box(types.mvhd, bytes);\n  };\n\n  sdtp = function sdtp(track) {\n    var samples = track.samples || [],\n        bytes = new Uint8Array(4 + samples.length),\n        flags,\n        i; // leave the full box header (4 bytes) all zero\n    // write the sample table\n\n    for (i = 0; i < samples.length; i++) {\n      flags = samples[i].flags;\n      bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;\n    }\n\n    return box(types.sdtp, bytes);\n  };\n\n  stbl = function stbl(track) {\n    return box(types.stbl, stsd(track), box(types.stts, STTS), box(types.stsc, STSC), box(types.stsz, STSZ), box(types.stco, STCO));\n  };\n\n  (function () {\n    var videoSample, audioSample;\n\n    stsd = function stsd(track) {\n      return box(types.stsd, new Uint8Array([0x00, // version 0\n      0x00, 0x00, 0x00, // flags\n      0x00, 0x00, 0x00, 0x01]), track.type === 'video' ? videoSample(track) : audioSample(track));\n    };\n\n    videoSample = function videoSample(track) {\n      var sps = track.sps || [],\n          pps = track.pps || [],\n          sequenceParameterSets = [],\n          pictureParameterSets = [],\n          i,\n          avc1Box; // assemble the SPSs\n\n      for (i = 0; i < sps.length; i++) {\n        sequenceParameterSets.push((sps[i].byteLength & 0xFF00) >>> 8);\n        sequenceParameterSets.push(sps[i].byteLength & 0xFF); // sequenceParameterSetLength\n\n        sequenceParameterSets = sequenceParameterSets.concat(Array.prototype.slice.call(sps[i])); // SPS\n      } // assemble the PPSs\n\n\n      for (i = 0; i < pps.length; i++) {\n        pictureParameterSets.push((pps[i].byteLength & 0xFF00) >>> 8);\n        pictureParameterSets.push(pps[i].byteLength & 0xFF);\n        pictureParameterSets = pictureParameterSets.concat(Array.prototype.slice.call(pps[i]));\n      }\n\n      avc1Box = [types.avc1, new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved\n      0x00, 0x01, // data_reference_index\n      0x00, 0x00, // pre_defined\n      0x00, 0x00, // reserved\n      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined\n      (track.width & 0xff00) >> 8, track.width & 0xff, // width\n      (track.height & 0xff00) >> 8, track.height & 0xff, // height\n      0x00, 0x48, 0x00, 0x00, // horizresolution\n      0x00, 0x48, 0x00, 0x00, // vertresolution\n      0x00, 0x00, 0x00, 0x00, // reserved\n      0x00, 0x01, // frame_count\n      0x13, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6a, 0x73, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x2d, 0x68, 0x6c, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // compressorname\n      0x00, 0x18, // depth = 24\n      0x11, 0x11 // pre_defined = -1\n      ]), box(types.avcC, new Uint8Array([0x01, // configurationVersion\n      track.profileIdc, // AVCProfileIndication\n      track.profileCompatibility, // profile_compatibility\n      track.levelIdc, // AVCLevelIndication\n      0xff // lengthSizeMinusOne, hard-coded to 4 bytes\n      ].concat([sps.length], // numOfSequenceParameterSets\n      sequenceParameterSets, // \"SPS\"\n      [pps.length], // numOfPictureParameterSets\n      pictureParameterSets // \"PPS\"\n      ))), box(types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80, // bufferSizeDB\n      0x00, 0x2d, 0xc6, 0xc0, // maxBitrate\n      0x00, 0x2d, 0xc6, 0xc0 // avgBitrate\n      ]))];\n\n      if (track.sarRatio) {\n        var hSpacing = track.sarRatio[0],\n            vSpacing = track.sarRatio[1];\n        avc1Box.push(box(types.pasp, new Uint8Array([(hSpacing & 0xFF000000) >> 24, (hSpacing & 0xFF0000) >> 16, (hSpacing & 0xFF00) >> 8, hSpacing & 0xFF, (vSpacing & 0xFF000000) >> 24, (vSpacing & 0xFF0000) >> 16, (vSpacing & 0xFF00) >> 8, vSpacing & 0xFF])));\n      }\n\n      return box.apply(null, avc1Box);\n    };\n\n    audioSample = function audioSample(track) {\n      return box(types.mp4a, new Uint8Array([// SampleEntry, ISO/IEC 14496-12\n      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved\n      0x00, 0x01, // data_reference_index\n      // AudioSampleEntry, ISO/IEC 14496-12\n      0x00, 0x00, 0x00, 0x00, // reserved\n      0x00, 0x00, 0x00, 0x00, // reserved\n      (track.channelcount & 0xff00) >> 8, track.channelcount & 0xff, // channelcount\n      (track.samplesize & 0xff00) >> 8, track.samplesize & 0xff, // samplesize\n      0x00, 0x00, // pre_defined\n      0x00, 0x00, // reserved\n      (track.samplerate & 0xff00) >> 8, track.samplerate & 0xff, 0x00, 0x00 // samplerate, 16.16\n      // MP4AudioSampleEntry, ISO/IEC 14496-14\n      ]), esds(track));\n    };\n  })();\n\n  tkhd = function tkhd(track) {\n    var result = new Uint8Array([0x00, // version 0\n    0x00, 0x00, 0x07, // flags\n    0x00, 0x00, 0x00, 0x00, // creation_time\n    0x00, 0x00, 0x00, 0x00, // modification_time\n    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF, // track_ID\n    0x00, 0x00, 0x00, 0x00, // reserved\n    (track.duration & 0xFF000000) >> 24, (track.duration & 0xFF0000) >> 16, (track.duration & 0xFF00) >> 8, track.duration & 0xFF, // duration\n    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved\n    0x00, 0x00, // layer\n    0x00, 0x00, // alternate_group\n    0x01, 0x00, // non-audio track volume\n    0x00, 0x00, // reserved\n    0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // transformation: unity matrix\n    (track.width & 0xFF00) >> 8, track.width & 0xFF, 0x00, 0x00, // width\n    (track.height & 0xFF00) >> 8, track.height & 0xFF, 0x00, 0x00 // height\n    ]);\n    return box(types.tkhd, result);\n  };\n  /**\n   * Generate a track fragment (traf) box. A traf box collects metadata\n   * about tracks in a movie fragment (moof) box.\n   */\n\n\n  traf = function traf(track) {\n    var trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable, dataOffset, upperWordBaseMediaDecodeTime, lowerWordBaseMediaDecodeTime;\n    trackFragmentHeader = box(types.tfhd, new Uint8Array([0x00, // version 0\n    0x00, 0x00, 0x3a, // flags\n    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF, // track_ID\n    0x00, 0x00, 0x00, 0x01, // sample_description_index\n    0x00, 0x00, 0x00, 0x00, // default_sample_duration\n    0x00, 0x00, 0x00, 0x00, // default_sample_size\n    0x00, 0x00, 0x00, 0x00 // default_sample_flags\n    ]));\n    upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / (UINT32_MAX + 1));\n    lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % (UINT32_MAX + 1));\n    trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([0x01, // version 1\n    0x00, 0x00, 0x00, // flags\n    // baseMediaDecodeTime\n    upperWordBaseMediaDecodeTime >>> 24 & 0xFF, upperWordBaseMediaDecodeTime >>> 16 & 0xFF, upperWordBaseMediaDecodeTime >>> 8 & 0xFF, upperWordBaseMediaDecodeTime & 0xFF, lowerWordBaseMediaDecodeTime >>> 24 & 0xFF, lowerWordBaseMediaDecodeTime >>> 16 & 0xFF, lowerWordBaseMediaDecodeTime >>> 8 & 0xFF, lowerWordBaseMediaDecodeTime & 0xFF])); // the data offset specifies the number of bytes from the start of\n    // the containing moof to the first payload byte of the associated\n    // mdat\n\n    dataOffset = 32 + // tfhd\n    20 + // tfdt\n    8 + // traf header\n    16 + // mfhd\n    8 + // moof header\n    8; // mdat header\n    // audio tracks require less metadata\n\n    if (track.type === 'audio') {\n      trackFragmentRun = trun$1(track, dataOffset);\n      return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun);\n    } // video tracks should contain an independent and disposable samples\n    // box (sdtp)\n    // generate one and adjust offsets to match\n\n\n    sampleDependencyTable = sdtp(track);\n    trackFragmentRun = trun$1(track, sampleDependencyTable.length + dataOffset);\n    return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable);\n  };\n  /**\n   * Generate a track box.\n   * @param track {object} a track definition\n   * @return {Uint8Array} the track box\n   */\n\n\n  trak = function trak(track) {\n    track.duration = track.duration || 0xffffffff;\n    return box(types.trak, tkhd(track), mdia(track));\n  };\n\n  trex = function trex(track) {\n    var result = new Uint8Array([0x00, // version 0\n    0x00, 0x00, 0x00, // flags\n    (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF, // track_ID\n    0x00, 0x00, 0x00, 0x01, // default_sample_description_index\n    0x00, 0x00, 0x00, 0x00, // default_sample_duration\n    0x00, 0x00, 0x00, 0x00, // default_sample_size\n    0x00, 0x01, 0x00, 0x01 // default_sample_flags\n    ]); // the last two bytes of default_sample_flags is the sample\n    // degradation priority, a hint about the importance of this sample\n    // relative to others. Lower the degradation priority for all sample\n    // types other than video.\n\n    if (track.type !== 'video') {\n      result[result.length - 1] = 0x00;\n    }\n\n    return box(types.trex, result);\n  };\n\n  (function () {\n    var audioTrun, videoTrun, trunHeader; // This method assumes all samples are uniform. That is, if a\n    // duration is present for the first sample, it will be present for\n    // all subsequent samples.\n    // see ISO/IEC 14496-12:2012, Section 8.8.8.1\n\n    trunHeader = function trunHeader(samples, offset) {\n      var durationPresent = 0,\n          sizePresent = 0,\n          flagsPresent = 0,\n          compositionTimeOffset = 0; // trun flag constants\n\n      if (samples.length) {\n        if (samples[0].duration !== undefined) {\n          durationPresent = 0x1;\n        }\n\n        if (samples[0].size !== undefined) {\n          sizePresent = 0x2;\n        }\n\n        if (samples[0].flags !== undefined) {\n          flagsPresent = 0x4;\n        }\n\n        if (samples[0].compositionTimeOffset !== undefined) {\n          compositionTimeOffset = 0x8;\n        }\n      }\n\n      return [0x00, // version 0\n      0x00, durationPresent | sizePresent | flagsPresent | compositionTimeOffset, 0x01, // flags\n      (samples.length & 0xFF000000) >>> 24, (samples.length & 0xFF0000) >>> 16, (samples.length & 0xFF00) >>> 8, samples.length & 0xFF, // sample_count\n      (offset & 0xFF000000) >>> 24, (offset & 0xFF0000) >>> 16, (offset & 0xFF00) >>> 8, offset & 0xFF // data_offset\n      ];\n    };\n\n    videoTrun = function videoTrun(track, offset) {\n      var bytesOffest, bytes, header, samples, sample, i;\n      samples = track.samples || [];\n      offset += 8 + 12 + 16 * samples.length;\n      header = trunHeader(samples, offset);\n      bytes = new Uint8Array(header.length + samples.length * 16);\n      bytes.set(header);\n      bytesOffest = header.length;\n\n      for (i = 0; i < samples.length; i++) {\n        sample = samples[i];\n        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;\n        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;\n        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;\n        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration\n\n        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;\n        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;\n        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;\n        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size\n\n        bytes[bytesOffest++] = sample.flags.isLeading << 2 | sample.flags.dependsOn;\n        bytes[bytesOffest++] = sample.flags.isDependedOn << 6 | sample.flags.hasRedundancy << 4 | sample.flags.paddingValue << 1 | sample.flags.isNonSyncSample;\n        bytes[bytesOffest++] = sample.flags.degradationPriority & 0xF0 << 8;\n        bytes[bytesOffest++] = sample.flags.degradationPriority & 0x0F; // sample_flags\n\n        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF000000) >>> 24;\n        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF0000) >>> 16;\n        bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF00) >>> 8;\n        bytes[bytesOffest++] = sample.compositionTimeOffset & 0xFF; // sample_composition_time_offset\n      }\n\n      return box(types.trun, bytes);\n    };\n\n    audioTrun = function audioTrun(track, offset) {\n      var bytes, bytesOffest, header, samples, sample, i;\n      samples = track.samples || [];\n      offset += 8 + 12 + 8 * samples.length;\n      header = trunHeader(samples, offset);\n      bytes = new Uint8Array(header.length + samples.length * 8);\n      bytes.set(header);\n      bytesOffest = header.length;\n\n      for (i = 0; i < samples.length; i++) {\n        sample = samples[i];\n        bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;\n        bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;\n        bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;\n        bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration\n\n        bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;\n        bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;\n        bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;\n        bytes[bytesOffest++] = sample.size & 0xFF; // sample_size\n      }\n\n      return box(types.trun, bytes);\n    };\n\n    trun$1 = function trun(track, offset) {\n      if (track.type === 'audio') {\n        return audioTrun(track, offset);\n      }\n\n      return videoTrun(track, offset);\n    };\n  })();\n\n  var mp4Generator = {\n    ftyp: ftyp,\n    mdat: mdat,\n    moof: moof,\n    moov: moov,\n    initSegment: function initSegment(tracks) {\n      var fileType = ftyp(),\n          movie = moov(tracks),\n          result;\n      result = new Uint8Array(fileType.byteLength + movie.byteLength);\n      result.set(fileType);\n      result.set(movie, fileType.byteLength);\n      return result;\n    }\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n  var toUnsigned$3 = function toUnsigned(value) {\n    return value >>> 0;\n  };\n\n  var toHexString$1 = function toHexString(value) {\n    return ('00' + value.toString(16)).slice(-2);\n  };\n\n  var bin = {\n    toUnsigned: toUnsigned$3,\n    toHexString: toHexString$1\n  };\n\n  var parseType$2 = function parseType(buffer) {\n    var result = '';\n    result += String.fromCharCode(buffer[0]);\n    result += String.fromCharCode(buffer[1]);\n    result += String.fromCharCode(buffer[2]);\n    result += String.fromCharCode(buffer[3]);\n    return result;\n  };\n\n  var parseType_1 = parseType$2;\n\n  var toUnsigned$2 = bin.toUnsigned;\n\n  var findBox = function findBox(data, path) {\n    var results = [],\n        i,\n        size,\n        type,\n        end,\n        subresults;\n\n    if (!path.length) {\n      // short-circuit the search for empty paths\n      return null;\n    }\n\n    for (i = 0; i < data.byteLength;) {\n      size = toUnsigned$2(data[i] << 24 | data[i + 1] << 16 | data[i + 2] << 8 | data[i + 3]);\n      type = parseType_1(data.subarray(i + 4, i + 8));\n      end = size > 1 ? i + size : data.byteLength;\n\n      if (type === path[0]) {\n        if (path.length === 1) {\n          // this is the end of the path and we've found the box we were\n          // looking for\n          results.push(data.subarray(i + 8, end));\n        } else {\n          // recursively search for the next box along the path\n          subresults = findBox(data.subarray(i + 8, end), path.slice(1));\n\n          if (subresults.length) {\n            results = results.concat(subresults);\n          }\n        }\n      }\n\n      i = end;\n    } // we've finished searching all of data\n\n\n    return results;\n  };\n\n  var findBox_1 = findBox;\n\n  var tfhd = function tfhd(data) {\n    var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n        result = {\n      version: data[0],\n      flags: new Uint8Array(data.subarray(1, 4)),\n      trackId: view.getUint32(4)\n    },\n        baseDataOffsetPresent = result.flags[2] & 0x01,\n        sampleDescriptionIndexPresent = result.flags[2] & 0x02,\n        defaultSampleDurationPresent = result.flags[2] & 0x08,\n        defaultSampleSizePresent = result.flags[2] & 0x10,\n        defaultSampleFlagsPresent = result.flags[2] & 0x20,\n        durationIsEmpty = result.flags[0] & 0x010000,\n        defaultBaseIsMoof = result.flags[0] & 0x020000,\n        i;\n    i = 8;\n\n    if (baseDataOffsetPresent) {\n      i += 4; // truncate top 4 bytes\n      // FIXME: should we read the full 64 bits?\n\n      result.baseDataOffset = view.getUint32(12);\n      i += 4;\n    }\n\n    if (sampleDescriptionIndexPresent) {\n      result.sampleDescriptionIndex = view.getUint32(i);\n      i += 4;\n    }\n\n    if (defaultSampleDurationPresent) {\n      result.defaultSampleDuration = view.getUint32(i);\n      i += 4;\n    }\n\n    if (defaultSampleSizePresent) {\n      result.defaultSampleSize = view.getUint32(i);\n      i += 4;\n    }\n\n    if (defaultSampleFlagsPresent) {\n      result.defaultSampleFlags = view.getUint32(i);\n    }\n\n    if (durationIsEmpty) {\n      result.durationIsEmpty = true;\n    }\n\n    if (!baseDataOffsetPresent && defaultBaseIsMoof) {\n      result.baseDataOffsetIsMoof = true;\n    }\n\n    return result;\n  };\n\n  var parseTfhd = tfhd;\n\n  var parseSampleFlags = function parseSampleFlags(flags) {\n    return {\n      isLeading: (flags[0] & 0x0c) >>> 2,\n      dependsOn: flags[0] & 0x03,\n      isDependedOn: (flags[1] & 0xc0) >>> 6,\n      hasRedundancy: (flags[1] & 0x30) >>> 4,\n      paddingValue: (flags[1] & 0x0e) >>> 1,\n      isNonSyncSample: flags[1] & 0x01,\n      degradationPriority: flags[2] << 8 | flags[3]\n    };\n  };\n\n  var parseSampleFlags_1 = parseSampleFlags;\n\n  var trun = function trun(data) {\n    var result = {\n      version: data[0],\n      flags: new Uint8Array(data.subarray(1, 4)),\n      samples: []\n    },\n        view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n        // Flag interpretation\n    dataOffsetPresent = result.flags[2] & 0x01,\n        // compare with 2nd byte of 0x1\n    firstSampleFlagsPresent = result.flags[2] & 0x04,\n        // compare with 2nd byte of 0x4\n    sampleDurationPresent = result.flags[1] & 0x01,\n        // compare with 2nd byte of 0x100\n    sampleSizePresent = result.flags[1] & 0x02,\n        // compare with 2nd byte of 0x200\n    sampleFlagsPresent = result.flags[1] & 0x04,\n        // compare with 2nd byte of 0x400\n    sampleCompositionTimeOffsetPresent = result.flags[1] & 0x08,\n        // compare with 2nd byte of 0x800\n    sampleCount = view.getUint32(4),\n        offset = 8,\n        sample;\n\n    if (dataOffsetPresent) {\n      // 32 bit signed integer\n      result.dataOffset = view.getInt32(offset);\n      offset += 4;\n    } // Overrides the flags for the first sample only. The order of\n    // optional values will be: duration, size, compositionTimeOffset\n\n\n    if (firstSampleFlagsPresent && sampleCount) {\n      sample = {\n        flags: parseSampleFlags_1(data.subarray(offset, offset + 4))\n      };\n      offset += 4;\n\n      if (sampleDurationPresent) {\n        sample.duration = view.getUint32(offset);\n        offset += 4;\n      }\n\n      if (sampleSizePresent) {\n        sample.size = view.getUint32(offset);\n        offset += 4;\n      }\n\n      if (sampleCompositionTimeOffsetPresent) {\n        if (result.version === 1) {\n          sample.compositionTimeOffset = view.getInt32(offset);\n        } else {\n          sample.compositionTimeOffset = view.getUint32(offset);\n        }\n\n        offset += 4;\n      }\n\n      result.samples.push(sample);\n      sampleCount--;\n    }\n\n    while (sampleCount--) {\n      sample = {};\n\n      if (sampleDurationPresent) {\n        sample.duration = view.getUint32(offset);\n        offset += 4;\n      }\n\n      if (sampleSizePresent) {\n        sample.size = view.getUint32(offset);\n        offset += 4;\n      }\n\n      if (sampleFlagsPresent) {\n        sample.flags = parseSampleFlags_1(data.subarray(offset, offset + 4));\n        offset += 4;\n      }\n\n      if (sampleCompositionTimeOffsetPresent) {\n        if (result.version === 1) {\n          sample.compositionTimeOffset = view.getInt32(offset);\n        } else {\n          sample.compositionTimeOffset = view.getUint32(offset);\n        }\n\n        offset += 4;\n      }\n\n      result.samples.push(sample);\n    }\n\n    return result;\n  };\n\n  var parseTrun = trun;\n\n  var toUnsigned$1 = bin.toUnsigned;\n\n  var tfdt = function tfdt(data) {\n    var result = {\n      version: data[0],\n      flags: new Uint8Array(data.subarray(1, 4)),\n      baseMediaDecodeTime: toUnsigned$1(data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7])\n    };\n\n    if (result.version === 1) {\n      result.baseMediaDecodeTime *= Math.pow(2, 32);\n      result.baseMediaDecodeTime += toUnsigned$1(data[8] << 24 | data[9] << 16 | data[10] << 8 | data[11]);\n    }\n\n    return result;\n  };\n\n  var parseTfdt = tfdt;\n\n  var toUnsigned = bin.toUnsigned;\n  var toHexString = bin.toHexString;\n  var timescale, startTime, compositionStartTime, getVideoTrackIds, getTracks, getTimescaleFromMediaHeader;\n  /**\n   * Parses an MP4 initialization segment and extracts the timescale\n   * values for any declared tracks. Timescale values indicate the\n   * number of clock ticks per second to assume for time-based values\n   * elsewhere in the MP4.\n   *\n   * To determine the start time of an MP4, you need two pieces of\n   * information: the timescale unit and the earliest base media decode\n   * time. Multiple timescales can be specified within an MP4 but the\n   * base media decode time is always expressed in the timescale from\n   * the media header box for the track:\n   * ```\n   * moov > trak > mdia > mdhd.timescale\n   * ```\n   * @param init {Uint8Array} the bytes of the init segment\n   * @return {object} a hash of track ids to timescale values or null if\n   * the init segment is malformed.\n   */\n\n  timescale = function timescale(init) {\n    var result = {},\n        traks = findBox_1(init, ['moov', 'trak']); // mdhd timescale\n\n    return traks.reduce(function (result, trak) {\n      var tkhd, version, index, id, mdhd;\n      tkhd = findBox_1(trak, ['tkhd'])[0];\n\n      if (!tkhd) {\n        return null;\n      }\n\n      version = tkhd[0];\n      index = version === 0 ? 12 : 20;\n      id = toUnsigned(tkhd[index] << 24 | tkhd[index + 1] << 16 | tkhd[index + 2] << 8 | tkhd[index + 3]);\n      mdhd = findBox_1(trak, ['mdia', 'mdhd'])[0];\n\n      if (!mdhd) {\n        return null;\n      }\n\n      version = mdhd[0];\n      index = version === 0 ? 12 : 20;\n      result[id] = toUnsigned(mdhd[index] << 24 | mdhd[index + 1] << 16 | mdhd[index + 2] << 8 | mdhd[index + 3]);\n      return result;\n    }, result);\n  };\n  /**\n   * Determine the base media decode start time, in seconds, for an MP4\n   * fragment. If multiple fragments are specified, the earliest time is\n   * returned.\n   *\n   * The base media decode time can be parsed from track fragment\n   * metadata:\n   * ```\n   * moof > traf > tfdt.baseMediaDecodeTime\n   * ```\n   * It requires the timescale value from the mdhd to interpret.\n   *\n   * @param timescale {object} a hash of track ids to timescale values.\n   * @return {number} the earliest base media decode start time for the\n   * fragment, in seconds\n   */\n\n\n  startTime = function startTime(timescale, fragment) {\n    var trafs, baseTimes, result; // we need info from two childrend of each track fragment box\n\n    trafs = findBox_1(fragment, ['moof', 'traf']); // determine the start times for each track\n\n    baseTimes = [].concat.apply([], trafs.map(function (traf) {\n      return findBox_1(traf, ['tfhd']).map(function (tfhd) {\n        var id, scale, baseTime; // get the track id from the tfhd\n\n        id = toUnsigned(tfhd[4] << 24 | tfhd[5] << 16 | tfhd[6] << 8 | tfhd[7]); // assume a 90kHz clock if no timescale was specified\n\n        scale = timescale[id] || 90e3; // get the base media decode time from the tfdt\n\n        baseTime = findBox_1(traf, ['tfdt']).map(function (tfdt) {\n          var version, result;\n          version = tfdt[0];\n          result = toUnsigned(tfdt[4] << 24 | tfdt[5] << 16 | tfdt[6] << 8 | tfdt[7]);\n\n          if (version === 1) {\n            result *= Math.pow(2, 32);\n            result += toUnsigned(tfdt[8] << 24 | tfdt[9] << 16 | tfdt[10] << 8 | tfdt[11]);\n          }\n\n          return result;\n        })[0];\n        baseTime = typeof baseTime === 'number' && !isNaN(baseTime) ? baseTime : Infinity; // convert base time to seconds\n\n        return baseTime / scale;\n      });\n    })); // return the minimum\n\n    result = Math.min.apply(null, baseTimes);\n    return isFinite(result) ? result : 0;\n  };\n  /**\n   * Determine the composition start, in seconds, for an MP4\n   * fragment.\n   *\n   * The composition start time of a fragment can be calculated using the base\n   * media decode time, composition time offset, and timescale, as follows:\n   *\n   * compositionStartTime = (baseMediaDecodeTime + compositionTimeOffset) / timescale\n   *\n   * All of the aforementioned information is contained within a media fragment's\n   * `traf` box, except for timescale info, which comes from the initialization\n   * segment, so a track id (also contained within a `traf`) is also necessary to\n   * associate it with a timescale\n   *\n   *\n   * @param timescales {object} - a hash of track ids to timescale values.\n   * @param fragment {Unit8Array} - the bytes of a media segment\n   * @return {number} the composition start time for the fragment, in seconds\n   **/\n\n\n  compositionStartTime = function compositionStartTime(timescales, fragment) {\n    var trafBoxes = findBox_1(fragment, ['moof', 'traf']);\n    var baseMediaDecodeTime = 0;\n    var compositionTimeOffset = 0;\n    var trackId;\n\n    if (trafBoxes && trafBoxes.length) {\n      // The spec states that track run samples contained within a `traf` box are contiguous, but\n      // it does not explicitly state whether the `traf` boxes themselves are contiguous.\n      // We will assume that they are, so we only need the first to calculate start time.\n      var tfhd = findBox_1(trafBoxes[0], ['tfhd'])[0];\n      var trun = findBox_1(trafBoxes[0], ['trun'])[0];\n      var tfdt = findBox_1(trafBoxes[0], ['tfdt'])[0];\n\n      if (tfhd) {\n        var parsedTfhd = parseTfhd(tfhd);\n        trackId = parsedTfhd.trackId;\n      }\n\n      if (tfdt) {\n        var parsedTfdt = parseTfdt(tfdt);\n        baseMediaDecodeTime = parsedTfdt.baseMediaDecodeTime;\n      }\n\n      if (trun) {\n        var parsedTrun = parseTrun(trun);\n\n        if (parsedTrun.samples && parsedTrun.samples.length) {\n          compositionTimeOffset = parsedTrun.samples[0].compositionTimeOffset || 0;\n        }\n      }\n    } // Get timescale for this specific track. Assume a 90kHz clock if no timescale was\n    // specified.\n\n\n    var timescale = timescales[trackId] || 90e3; // return the composition start time, in seconds\n\n    return (baseMediaDecodeTime + compositionTimeOffset) / timescale;\n  };\n  /**\n    * Find the trackIds of the video tracks in this source.\n    * Found by parsing the Handler Reference and Track Header Boxes:\n    *   moov > trak > mdia > hdlr\n    *   moov > trak > tkhd\n    *\n    * @param {Uint8Array} init - The bytes of the init segment for this source\n    * @return {Number[]} A list of trackIds\n    *\n    * @see ISO-BMFF-12/2015, Section 8.4.3\n   **/\n\n\n  getVideoTrackIds = function getVideoTrackIds(init) {\n    var traks = findBox_1(init, ['moov', 'trak']);\n    var videoTrackIds = [];\n    traks.forEach(function (trak) {\n      var hdlrs = findBox_1(trak, ['mdia', 'hdlr']);\n      var tkhds = findBox_1(trak, ['tkhd']);\n      hdlrs.forEach(function (hdlr, index) {\n        var handlerType = parseType_1(hdlr.subarray(8, 12));\n        var tkhd = tkhds[index];\n        var view;\n        var version;\n        var trackId;\n\n        if (handlerType === 'vide') {\n          view = new DataView(tkhd.buffer, tkhd.byteOffset, tkhd.byteLength);\n          version = view.getUint8(0);\n          trackId = version === 0 ? view.getUint32(12) : view.getUint32(20);\n          videoTrackIds.push(trackId);\n        }\n      });\n    });\n    return videoTrackIds;\n  };\n\n  getTimescaleFromMediaHeader = function getTimescaleFromMediaHeader(mdhd) {\n    // mdhd is a FullBox, meaning it will have its own version as the first byte\n    var version = mdhd[0];\n    var index = version === 0 ? 12 : 20;\n    return toUnsigned(mdhd[index] << 24 | mdhd[index + 1] << 16 | mdhd[index + 2] << 8 | mdhd[index + 3]);\n  };\n  /**\n   * Get all the video, audio, and hint tracks from a non fragmented\n   * mp4 segment\n   */\n\n\n  getTracks = function getTracks(init) {\n    var traks = findBox_1(init, ['moov', 'trak']);\n    var tracks = [];\n    traks.forEach(function (trak) {\n      var track = {};\n      var tkhd = findBox_1(trak, ['tkhd'])[0];\n      var view, tkhdVersion; // id\n\n      if (tkhd) {\n        view = new DataView(tkhd.buffer, tkhd.byteOffset, tkhd.byteLength);\n        tkhdVersion = view.getUint8(0);\n        track.id = tkhdVersion === 0 ? view.getUint32(12) : view.getUint32(20);\n      }\n\n      var hdlr = findBox_1(trak, ['mdia', 'hdlr'])[0]; // type\n\n      if (hdlr) {\n        var type = parseType_1(hdlr.subarray(8, 12));\n\n        if (type === 'vide') {\n          track.type = 'video';\n        } else if (type === 'soun') {\n          track.type = 'audio';\n        } else {\n          track.type = type;\n        }\n      } // codec\n\n\n      var stsd = findBox_1(trak, ['mdia', 'minf', 'stbl', 'stsd'])[0];\n\n      if (stsd) {\n        var sampleDescriptions = stsd.subarray(8); // gives the codec type string\n\n        track.codec = parseType_1(sampleDescriptions.subarray(4, 8));\n        var codecBox = findBox_1(sampleDescriptions, [track.codec])[0];\n        var codecConfig, codecConfigType;\n\n        if (codecBox) {\n          // https://tools.ietf.org/html/rfc6381#section-3.3\n          if (/^[a-z]vc[1-9]$/i.test(track.codec)) {\n            // we don't need anything but the \"config\" parameter of the\n            // avc1 codecBox\n            codecConfig = codecBox.subarray(78);\n            codecConfigType = parseType_1(codecConfig.subarray(4, 8));\n\n            if (codecConfigType === 'avcC' && codecConfig.length > 11) {\n              track.codec += '.'; // left padded with zeroes for single digit hex\n              // profile idc\n\n              track.codec += toHexString(codecConfig[9]); // the byte containing the constraint_set flags\n\n              track.codec += toHexString(codecConfig[10]); // level idc\n\n              track.codec += toHexString(codecConfig[11]);\n            } else {\n              // TODO: show a warning that we couldn't parse the codec\n              // and are using the default\n              track.codec = 'avc1.4d400d';\n            }\n          } else if (/^mp4[a,v]$/i.test(track.codec)) {\n            // we do not need anything but the streamDescriptor of the mp4a codecBox\n            codecConfig = codecBox.subarray(28);\n            codecConfigType = parseType_1(codecConfig.subarray(4, 8));\n\n            if (codecConfigType === 'esds' && codecConfig.length > 20 && codecConfig[19] !== 0) {\n              track.codec += '.' + toHexString(codecConfig[19]); // this value is only a single digit\n\n              track.codec += '.' + toHexString(codecConfig[20] >>> 2 & 0x3f).replace(/^0/, '');\n            } else {\n              // TODO: show a warning that we couldn't parse the codec\n              // and are using the default\n              track.codec = 'mp4a.40.2';\n            }\n          } else {\n            // flac, opus, etc\n            track.codec = track.codec.toLowerCase();\n          }\n        }\n      }\n\n      var mdhd = findBox_1(trak, ['mdia', 'mdhd'])[0];\n\n      if (mdhd) {\n        track.timescale = getTimescaleFromMediaHeader(mdhd);\n      }\n\n      tracks.push(track);\n    });\n    return tracks;\n  };\n\n  var probe$2 = {\n    // export mp4 inspector's findBox and parseType for backwards compatibility\n    findBox: findBox_1,\n    parseType: parseType_1,\n    timescale: timescale,\n    startTime: startTime,\n    compositionStartTime: compositionStartTime,\n    videoTrackIds: getVideoTrackIds,\n    tracks: getTracks,\n    getTimescaleFromMediaHeader: getTimescaleFromMediaHeader\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n  // Convert an array of nal units into an array of frames with each frame being\n  // composed of the nal units that make up that frame\n  // Also keep track of cummulative data about the frame from the nal units such\n  // as the frame duration, starting pts, etc.\n  var groupNalsIntoFrames = function groupNalsIntoFrames(nalUnits) {\n    var i,\n        currentNal,\n        currentFrame = [],\n        frames = []; // TODO added for LHLS, make sure this is OK\n\n    frames.byteLength = 0;\n    frames.nalCount = 0;\n    frames.duration = 0;\n    currentFrame.byteLength = 0;\n\n    for (i = 0; i < nalUnits.length; i++) {\n      currentNal = nalUnits[i]; // Split on 'aud'-type nal units\n\n      if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {\n        // Since the very first nal unit is expected to be an AUD\n        // only push to the frames array when currentFrame is not empty\n        if (currentFrame.length) {\n          currentFrame.duration = currentNal.dts - currentFrame.dts; // TODO added for LHLS, make sure this is OK\n\n          frames.byteLength += currentFrame.byteLength;\n          frames.nalCount += currentFrame.length;\n          frames.duration += currentFrame.duration;\n          frames.push(currentFrame);\n        }\n\n        currentFrame = [currentNal];\n        currentFrame.byteLength = currentNal.data.byteLength;\n        currentFrame.pts = currentNal.pts;\n        currentFrame.dts = currentNal.dts;\n      } else {\n        // Specifically flag key frames for ease of use later\n        if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {\n          currentFrame.keyFrame = true;\n        }\n\n        currentFrame.duration = currentNal.dts - currentFrame.dts;\n        currentFrame.byteLength += currentNal.data.byteLength;\n        currentFrame.push(currentNal);\n      }\n    } // For the last frame, use the duration of the previous frame if we\n    // have nothing better to go on\n\n\n    if (frames.length && (!currentFrame.duration || currentFrame.duration <= 0)) {\n      currentFrame.duration = frames[frames.length - 1].duration;\n    } // Push the final frame\n    // TODO added for LHLS, make sure this is OK\n\n\n    frames.byteLength += currentFrame.byteLength;\n    frames.nalCount += currentFrame.length;\n    frames.duration += currentFrame.duration;\n    frames.push(currentFrame);\n    return frames;\n  }; // Convert an array of frames into an array of Gop with each Gop being composed\n  // of the frames that make up that Gop\n  // Also keep track of cummulative data about the Gop from the frames such as the\n  // Gop duration, starting pts, etc.\n\n\n  var groupFramesIntoGops = function groupFramesIntoGops(frames) {\n    var i,\n        currentFrame,\n        currentGop = [],\n        gops = []; // We must pre-set some of the values on the Gop since we\n    // keep running totals of these values\n\n    currentGop.byteLength = 0;\n    currentGop.nalCount = 0;\n    currentGop.duration = 0;\n    currentGop.pts = frames[0].pts;\n    currentGop.dts = frames[0].dts; // store some metadata about all the Gops\n\n    gops.byteLength = 0;\n    gops.nalCount = 0;\n    gops.duration = 0;\n    gops.pts = frames[0].pts;\n    gops.dts = frames[0].dts;\n\n    for (i = 0; i < frames.length; i++) {\n      currentFrame = frames[i];\n\n      if (currentFrame.keyFrame) {\n        // Since the very first frame is expected to be an keyframe\n        // only push to the gops array when currentGop is not empty\n        if (currentGop.length) {\n          gops.push(currentGop);\n          gops.byteLength += currentGop.byteLength;\n          gops.nalCount += currentGop.nalCount;\n          gops.duration += currentGop.duration;\n        }\n\n        currentGop = [currentFrame];\n        currentGop.nalCount = currentFrame.length;\n        currentGop.byteLength = currentFrame.byteLength;\n        currentGop.pts = currentFrame.pts;\n        currentGop.dts = currentFrame.dts;\n        currentGop.duration = currentFrame.duration;\n      } else {\n        currentGop.duration += currentFrame.duration;\n        currentGop.nalCount += currentFrame.length;\n        currentGop.byteLength += currentFrame.byteLength;\n        currentGop.push(currentFrame);\n      }\n    }\n\n    if (gops.length && currentGop.duration <= 0) {\n      currentGop.duration = gops[gops.length - 1].duration;\n    }\n\n    gops.byteLength += currentGop.byteLength;\n    gops.nalCount += currentGop.nalCount;\n    gops.duration += currentGop.duration; // push the final Gop\n\n    gops.push(currentGop);\n    return gops;\n  };\n  /*\n   * Search for the first keyframe in the GOPs and throw away all frames\n   * until that keyframe. Then extend the duration of the pulled keyframe\n   * and pull the PTS and DTS of the keyframe so that it covers the time\n   * range of the frames that were disposed.\n   *\n   * @param {Array} gops video GOPs\n   * @returns {Array} modified video GOPs\n   */\n\n\n  var extendFirstKeyFrame = function extendFirstKeyFrame(gops) {\n    var currentGop;\n\n    if (!gops[0][0].keyFrame && gops.length > 1) {\n      // Remove the first GOP\n      currentGop = gops.shift();\n      gops.byteLength -= currentGop.byteLength;\n      gops.nalCount -= currentGop.nalCount; // Extend the first frame of what is now the\n      // first gop to cover the time period of the\n      // frames we just removed\n\n      gops[0][0].dts = currentGop.dts;\n      gops[0][0].pts = currentGop.pts;\n      gops[0][0].duration += currentGop.duration;\n    }\n\n    return gops;\n  };\n  /**\n   * Default sample object\n   * see ISO/IEC 14496-12:2012, section 8.6.4.3\n   */\n\n\n  var createDefaultSample = function createDefaultSample() {\n    return {\n      size: 0,\n      flags: {\n        isLeading: 0,\n        dependsOn: 1,\n        isDependedOn: 0,\n        hasRedundancy: 0,\n        degradationPriority: 0,\n        isNonSyncSample: 1\n      }\n    };\n  };\n  /*\n   * Collates information from a video frame into an object for eventual\n   * entry into an MP4 sample table.\n   *\n   * @param {Object} frame the video frame\n   * @param {Number} dataOffset the byte offset to position the sample\n   * @return {Object} object containing sample table info for a frame\n   */\n\n\n  var sampleForFrame = function sampleForFrame(frame, dataOffset) {\n    var sample = createDefaultSample();\n    sample.dataOffset = dataOffset;\n    sample.compositionTimeOffset = frame.pts - frame.dts;\n    sample.duration = frame.duration;\n    sample.size = 4 * frame.length; // Space for nal unit size\n\n    sample.size += frame.byteLength;\n\n    if (frame.keyFrame) {\n      sample.flags.dependsOn = 2;\n      sample.flags.isNonSyncSample = 0;\n    }\n\n    return sample;\n  }; // generate the track's sample table from an array of gops\n\n\n  var generateSampleTable$1 = function generateSampleTable(gops, baseDataOffset) {\n    var h,\n        i,\n        sample,\n        currentGop,\n        currentFrame,\n        dataOffset = baseDataOffset || 0,\n        samples = [];\n\n    for (h = 0; h < gops.length; h++) {\n      currentGop = gops[h];\n\n      for (i = 0; i < currentGop.length; i++) {\n        currentFrame = currentGop[i];\n        sample = sampleForFrame(currentFrame, dataOffset);\n        dataOffset += sample.size;\n        samples.push(sample);\n      }\n    }\n\n    return samples;\n  }; // generate the track's raw mdat data from an array of gops\n\n\n  var concatenateNalData = function concatenateNalData(gops) {\n    var h,\n        i,\n        j,\n        currentGop,\n        currentFrame,\n        currentNal,\n        dataOffset = 0,\n        nalsByteLength = gops.byteLength,\n        numberOfNals = gops.nalCount,\n        totalByteLength = nalsByteLength + 4 * numberOfNals,\n        data = new Uint8Array(totalByteLength),\n        view = new DataView(data.buffer); // For each Gop..\n\n    for (h = 0; h < gops.length; h++) {\n      currentGop = gops[h]; // For each Frame..\n\n      for (i = 0; i < currentGop.length; i++) {\n        currentFrame = currentGop[i]; // For each NAL..\n\n        for (j = 0; j < currentFrame.length; j++) {\n          currentNal = currentFrame[j];\n          view.setUint32(dataOffset, currentNal.data.byteLength);\n          dataOffset += 4;\n          data.set(currentNal.data, dataOffset);\n          dataOffset += currentNal.data.byteLength;\n        }\n      }\n    }\n\n    return data;\n  }; // generate the track's sample table from a frame\n\n\n  var generateSampleTableForFrame = function generateSampleTableForFrame(frame, baseDataOffset) {\n    var sample,\n        dataOffset = baseDataOffset || 0,\n        samples = [];\n    sample = sampleForFrame(frame, dataOffset);\n    samples.push(sample);\n    return samples;\n  }; // generate the track's raw mdat data from a frame\n\n\n  var concatenateNalDataForFrame = function concatenateNalDataForFrame(frame) {\n    var i,\n        currentNal,\n        dataOffset = 0,\n        nalsByteLength = frame.byteLength,\n        numberOfNals = frame.length,\n        totalByteLength = nalsByteLength + 4 * numberOfNals,\n        data = new Uint8Array(totalByteLength),\n        view = new DataView(data.buffer); // For each NAL..\n\n    for (i = 0; i < frame.length; i++) {\n      currentNal = frame[i];\n      view.setUint32(dataOffset, currentNal.data.byteLength);\n      dataOffset += 4;\n      data.set(currentNal.data, dataOffset);\n      dataOffset += currentNal.data.byteLength;\n    }\n\n    return data;\n  };\n\n  var frameUtils = {\n    groupNalsIntoFrames: groupNalsIntoFrames,\n    groupFramesIntoGops: groupFramesIntoGops,\n    extendFirstKeyFrame: extendFirstKeyFrame,\n    generateSampleTable: generateSampleTable$1,\n    concatenateNalData: concatenateNalData,\n    generateSampleTableForFrame: generateSampleTableForFrame,\n    concatenateNalDataForFrame: concatenateNalDataForFrame\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n  var highPrefix = [33, 16, 5, 32, 164, 27];\n  var lowPrefix = [33, 65, 108, 84, 1, 2, 4, 8, 168, 2, 4, 8, 17, 191, 252];\n\n  var zeroFill = function zeroFill(count) {\n    var a = [];\n\n    while (count--) {\n      a.push(0);\n    }\n\n    return a;\n  };\n\n  var makeTable = function makeTable(metaTable) {\n    return Object.keys(metaTable).reduce(function (obj, key) {\n      obj[key] = new Uint8Array(metaTable[key].reduce(function (arr, part) {\n        return arr.concat(part);\n      }, []));\n      return obj;\n    }, {});\n  };\n\n  var silence;\n\n  var silence_1 = function silence_1() {\n    if (!silence) {\n      // Frames-of-silence to use for filling in missing AAC frames\n      var coneOfSilence = {\n        96000: [highPrefix, [227, 64], zeroFill(154), [56]],\n        88200: [highPrefix, [231], zeroFill(170), [56]],\n        64000: [highPrefix, [248, 192], zeroFill(240), [56]],\n        48000: [highPrefix, [255, 192], zeroFill(268), [55, 148, 128], zeroFill(54), [112]],\n        44100: [highPrefix, [255, 192], zeroFill(268), [55, 163, 128], zeroFill(84), [112]],\n        32000: [highPrefix, [255, 192], zeroFill(268), [55, 234], zeroFill(226), [112]],\n        24000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 112], zeroFill(126), [224]],\n        16000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 255], zeroFill(269), [223, 108], zeroFill(195), [1, 192]],\n        12000: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 253, 128], zeroFill(259), [56]],\n        11025: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 255, 192], zeroFill(268), [55, 175, 128], zeroFill(108), [112]],\n        8000: [lowPrefix, zeroFill(268), [3, 121, 16], zeroFill(47), [7]]\n      };\n      silence = makeTable(coneOfSilence);\n    }\n\n    return silence;\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  /**\n   * Sum the `byteLength` properties of the data in each AAC frame\n   */\n\n  var sumFrameByteLengths = function sumFrameByteLengths(array) {\n    var i,\n        currentObj,\n        sum = 0; // sum the byteLength's all each nal unit in the frame\n\n    for (i = 0; i < array.length; i++) {\n      currentObj = array[i];\n      sum += currentObj.data.byteLength;\n    }\n\n    return sum;\n  }; // Possibly pad (prefix) the audio track with silence if appending this track\n  // would lead to the introduction of a gap in the audio buffer\n\n\n  var prefixWithSilence = function prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime) {\n    var baseMediaDecodeTimeTs,\n        frameDuration = 0,\n        audioGapDuration = 0,\n        audioFillFrameCount = 0,\n        audioFillDuration = 0,\n        silentFrame,\n        i,\n        firstFrame;\n\n    if (!frames.length) {\n      return;\n    }\n\n    baseMediaDecodeTimeTs = clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate); // determine frame clock duration based on sample rate, round up to avoid overfills\n\n    frameDuration = Math.ceil(clock.ONE_SECOND_IN_TS / (track.samplerate / 1024));\n\n    if (audioAppendStartTs && videoBaseMediaDecodeTime) {\n      // insert the shortest possible amount (audio gap or audio to video gap)\n      audioGapDuration = baseMediaDecodeTimeTs - Math.max(audioAppendStartTs, videoBaseMediaDecodeTime); // number of full frames in the audio gap\n\n      audioFillFrameCount = Math.floor(audioGapDuration / frameDuration);\n      audioFillDuration = audioFillFrameCount * frameDuration;\n    } // don't attempt to fill gaps smaller than a single frame or larger\n    // than a half second\n\n\n    if (audioFillFrameCount < 1 || audioFillDuration > clock.ONE_SECOND_IN_TS / 2) {\n      return;\n    }\n\n    silentFrame = silence_1()[track.samplerate];\n\n    if (!silentFrame) {\n      // we don't have a silent frame pregenerated for the sample rate, so use a frame\n      // from the content instead\n      silentFrame = frames[0].data;\n    }\n\n    for (i = 0; i < audioFillFrameCount; i++) {\n      firstFrame = frames[0];\n      frames.splice(0, 0, {\n        data: silentFrame,\n        dts: firstFrame.dts - frameDuration,\n        pts: firstFrame.pts - frameDuration\n      });\n    }\n\n    track.baseMediaDecodeTime -= Math.floor(clock.videoTsToAudioTs(audioFillDuration, track.samplerate));\n    return audioFillDuration;\n  }; // If the audio segment extends before the earliest allowed dts\n  // value, remove AAC frames until starts at or after the earliest\n  // allowed DTS so that we don't end up with a negative baseMedia-\n  // DecodeTime for the audio track\n\n\n  var trimAdtsFramesByEarliestDts = function trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts) {\n    if (track.minSegmentDts >= earliestAllowedDts) {\n      return adtsFrames;\n    } // We will need to recalculate the earliest segment Dts\n\n\n    track.minSegmentDts = Infinity;\n    return adtsFrames.filter(function (currentFrame) {\n      // If this is an allowed frame, keep it and record it's Dts\n      if (currentFrame.dts >= earliestAllowedDts) {\n        track.minSegmentDts = Math.min(track.minSegmentDts, currentFrame.dts);\n        track.minSegmentPts = track.minSegmentDts;\n        return true;\n      } // Otherwise, discard it\n\n\n      return false;\n    });\n  }; // generate the track's raw mdat data from an array of frames\n\n\n  var generateSampleTable = function generateSampleTable(frames) {\n    var i,\n        currentFrame,\n        samples = [];\n\n    for (i = 0; i < frames.length; i++) {\n      currentFrame = frames[i];\n      samples.push({\n        size: currentFrame.data.byteLength,\n        duration: 1024 // For AAC audio, all samples contain 1024 samples\n\n      });\n    }\n\n    return samples;\n  }; // generate the track's sample table from an array of frames\n\n\n  var concatenateFrameData = function concatenateFrameData(frames) {\n    var i,\n        currentFrame,\n        dataOffset = 0,\n        data = new Uint8Array(sumFrameByteLengths(frames));\n\n    for (i = 0; i < frames.length; i++) {\n      currentFrame = frames[i];\n      data.set(currentFrame.data, dataOffset);\n      dataOffset += currentFrame.data.byteLength;\n    }\n\n    return data;\n  };\n\n  var audioFrameUtils = {\n    prefixWithSilence: prefixWithSilence,\n    trimAdtsFramesByEarliestDts: trimAdtsFramesByEarliestDts,\n    generateSampleTable: generateSampleTable,\n    concatenateFrameData: concatenateFrameData\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var ONE_SECOND_IN_TS$3 = clock.ONE_SECOND_IN_TS;\n  /**\n   * Store information about the start and end of the track and the\n   * duration for each frame/sample we process in order to calculate\n   * the baseMediaDecodeTime\n   */\n\n  var collectDtsInfo = function collectDtsInfo(track, data) {\n    if (typeof data.pts === 'number') {\n      if (track.timelineStartInfo.pts === undefined) {\n        track.timelineStartInfo.pts = data.pts;\n      }\n\n      if (track.minSegmentPts === undefined) {\n        track.minSegmentPts = data.pts;\n      } else {\n        track.minSegmentPts = Math.min(track.minSegmentPts, data.pts);\n      }\n\n      if (track.maxSegmentPts === undefined) {\n        track.maxSegmentPts = data.pts;\n      } else {\n        track.maxSegmentPts = Math.max(track.maxSegmentPts, data.pts);\n      }\n    }\n\n    if (typeof data.dts === 'number') {\n      if (track.timelineStartInfo.dts === undefined) {\n        track.timelineStartInfo.dts = data.dts;\n      }\n\n      if (track.minSegmentDts === undefined) {\n        track.minSegmentDts = data.dts;\n      } else {\n        track.minSegmentDts = Math.min(track.minSegmentDts, data.dts);\n      }\n\n      if (track.maxSegmentDts === undefined) {\n        track.maxSegmentDts = data.dts;\n      } else {\n        track.maxSegmentDts = Math.max(track.maxSegmentDts, data.dts);\n      }\n    }\n  };\n  /**\n   * Clear values used to calculate the baseMediaDecodeTime between\n   * tracks\n   */\n\n\n  var clearDtsInfo = function clearDtsInfo(track) {\n    delete track.minSegmentDts;\n    delete track.maxSegmentDts;\n    delete track.minSegmentPts;\n    delete track.maxSegmentPts;\n  };\n  /**\n   * Calculate the track's baseMediaDecodeTime based on the earliest\n   * DTS the transmuxer has ever seen and the minimum DTS for the\n   * current track\n   * @param track {object} track metadata configuration\n   * @param keepOriginalTimestamps {boolean} If true, keep the timestamps\n   *        in the source; false to adjust the first segment to start at 0.\n   */\n\n\n  var calculateTrackBaseMediaDecodeTime = function calculateTrackBaseMediaDecodeTime(track, keepOriginalTimestamps) {\n    var baseMediaDecodeTime,\n        scale,\n        minSegmentDts = track.minSegmentDts; // Optionally adjust the time so the first segment starts at zero.\n\n    if (!keepOriginalTimestamps) {\n      minSegmentDts -= track.timelineStartInfo.dts;\n    } // track.timelineStartInfo.baseMediaDecodeTime is the location, in time, where\n    // we want the start of the first segment to be placed\n\n\n    baseMediaDecodeTime = track.timelineStartInfo.baseMediaDecodeTime; // Add to that the distance this segment is from the very first\n\n    baseMediaDecodeTime += minSegmentDts; // baseMediaDecodeTime must not become negative\n\n    baseMediaDecodeTime = Math.max(0, baseMediaDecodeTime);\n\n    if (track.type === 'audio') {\n      // Audio has a different clock equal to the sampling_rate so we need to\n      // scale the PTS values into the clock rate of the track\n      scale = track.samplerate / ONE_SECOND_IN_TS$3;\n      baseMediaDecodeTime *= scale;\n      baseMediaDecodeTime = Math.floor(baseMediaDecodeTime);\n    }\n\n    return baseMediaDecodeTime;\n  };\n\n  var trackDecodeInfo = {\n    clearDtsInfo: clearDtsInfo,\n    calculateTrackBaseMediaDecodeTime: calculateTrackBaseMediaDecodeTime,\n    collectDtsInfo: collectDtsInfo\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   *\n   * Reads in-band caption information from a video elementary\n   * stream. Captions must follow the CEA-708 standard for injection\n   * into an MPEG-2 transport streams.\n   * @see https://en.wikipedia.org/wiki/CEA-708\n   * @see https://www.gpo.gov/fdsys/pkg/CFR-2007-title47-vol1/pdf/CFR-2007-title47-vol1-sec15-119.pdf\n   */\n  // payload type field to indicate how they are to be\n  // interpreted. CEAS-708 caption content is always transmitted with\n  // payload type 0x04.\n\n  var USER_DATA_REGISTERED_ITU_T_T35 = 4,\n      RBSP_TRAILING_BITS = 128;\n  /**\n    * Parse a supplemental enhancement information (SEI) NAL unit.\n    * Stops parsing once a message of type ITU T T35 has been found.\n    *\n    * @param bytes {Uint8Array} the bytes of a SEI NAL unit\n    * @return {object} the parsed SEI payload\n    * @see Rec. ITU-T H.264, 7.3.2.3.1\n    */\n\n  var parseSei = function parseSei(bytes) {\n    var i = 0,\n        result = {\n      payloadType: -1,\n      payloadSize: 0\n    },\n        payloadType = 0,\n        payloadSize = 0; // go through the sei_rbsp parsing each each individual sei_message\n\n    while (i < bytes.byteLength) {\n      // stop once we have hit the end of the sei_rbsp\n      if (bytes[i] === RBSP_TRAILING_BITS) {\n        break;\n      } // Parse payload type\n\n\n      while (bytes[i] === 0xFF) {\n        payloadType += 255;\n        i++;\n      }\n\n      payloadType += bytes[i++]; // Parse payload size\n\n      while (bytes[i] === 0xFF) {\n        payloadSize += 255;\n        i++;\n      }\n\n      payloadSize += bytes[i++]; // this sei_message is a 608/708 caption so save it and break\n      // there can only ever be one caption message in a frame's sei\n\n      if (!result.payload && payloadType === USER_DATA_REGISTERED_ITU_T_T35) {\n        var userIdentifier = String.fromCharCode(bytes[i + 3], bytes[i + 4], bytes[i + 5], bytes[i + 6]);\n\n        if (userIdentifier === 'GA94') {\n          result.payloadType = payloadType;\n          result.payloadSize = payloadSize;\n          result.payload = bytes.subarray(i, i + payloadSize);\n          break;\n        } else {\n          result.payload = void 0;\n        }\n      } // skip the payload and parse the next message\n\n\n      i += payloadSize;\n      payloadType = 0;\n      payloadSize = 0;\n    }\n\n    return result;\n  }; // see ANSI/SCTE 128-1 (2013), section 8.1\n\n\n  var parseUserData = function parseUserData(sei) {\n    // itu_t_t35_contry_code must be 181 (United States) for\n    // captions\n    if (sei.payload[0] !== 181) {\n      return null;\n    } // itu_t_t35_provider_code should be 49 (ATSC) for captions\n\n\n    if ((sei.payload[1] << 8 | sei.payload[2]) !== 49) {\n      return null;\n    } // the user_identifier should be \"GA94\" to indicate ATSC1 data\n\n\n    if (String.fromCharCode(sei.payload[3], sei.payload[4], sei.payload[5], sei.payload[6]) !== 'GA94') {\n      return null;\n    } // finally, user_data_type_code should be 0x03 for caption data\n\n\n    if (sei.payload[7] !== 0x03) {\n      return null;\n    } // return the user_data_type_structure and strip the trailing\n    // marker bits\n\n\n    return sei.payload.subarray(8, sei.payload.length - 1);\n  }; // see CEA-708-D, section 4.4\n\n\n  var parseCaptionPackets = function parseCaptionPackets(pts, userData) {\n    var results = [],\n        i,\n        count,\n        offset,\n        data; // if this is just filler, return immediately\n\n    if (!(userData[0] & 0x40)) {\n      return results;\n    } // parse out the cc_data_1 and cc_data_2 fields\n\n\n    count = userData[0] & 0x1f;\n\n    for (i = 0; i < count; i++) {\n      offset = i * 3;\n      data = {\n        type: userData[offset + 2] & 0x03,\n        pts: pts\n      }; // capture cc data when cc_valid is 1\n\n      if (userData[offset + 2] & 0x04) {\n        data.ccData = userData[offset + 3] << 8 | userData[offset + 4];\n        results.push(data);\n      }\n    }\n\n    return results;\n  };\n\n  var discardEmulationPreventionBytes$1 = function discardEmulationPreventionBytes(data) {\n    var length = data.byteLength,\n        emulationPreventionBytesPositions = [],\n        i = 1,\n        newLength,\n        newData; // Find all `Emulation Prevention Bytes`\n\n    while (i < length - 2) {\n      if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {\n        emulationPreventionBytesPositions.push(i + 2);\n        i += 2;\n      } else {\n        i++;\n      }\n    } // If no Emulation Prevention Bytes were found just return the original\n    // array\n\n\n    if (emulationPreventionBytesPositions.length === 0) {\n      return data;\n    } // Create a new array to hold the NAL unit data\n\n\n    newLength = length - emulationPreventionBytesPositions.length;\n    newData = new Uint8Array(newLength);\n    var sourceIndex = 0;\n\n    for (i = 0; i < newLength; sourceIndex++, i++) {\n      if (sourceIndex === emulationPreventionBytesPositions[0]) {\n        // Skip this byte\n        sourceIndex++; // Remove this position index\n\n        emulationPreventionBytesPositions.shift();\n      }\n\n      newData[i] = data[sourceIndex];\n    }\n\n    return newData;\n  }; // exports\n\n\n  var captionPacketParser = {\n    parseSei: parseSei,\n    parseUserData: parseUserData,\n    parseCaptionPackets: parseCaptionPackets,\n    discardEmulationPreventionBytes: discardEmulationPreventionBytes$1,\n    USER_DATA_REGISTERED_ITU_T_T35: USER_DATA_REGISTERED_ITU_T_T35\n  };\n\n  // Link To Transport\n  // -----------------\n\n\n  var CaptionStream$1 = function CaptionStream(options) {\n    options = options || {};\n    CaptionStream.prototype.init.call(this); // parse708captions flag, default to true\n\n    this.parse708captions_ = typeof options.parse708captions === 'boolean' ? options.parse708captions : true;\n    this.captionPackets_ = [];\n    this.ccStreams_ = [new Cea608Stream(0, 0), // eslint-disable-line no-use-before-define\n    new Cea608Stream(0, 1), // eslint-disable-line no-use-before-define\n    new Cea608Stream(1, 0), // eslint-disable-line no-use-before-define\n    new Cea608Stream(1, 1) // eslint-disable-line no-use-before-define\n    ];\n\n    if (this.parse708captions_) {\n      this.cc708Stream_ = new Cea708Stream({\n        captionServices: options.captionServices\n      }); // eslint-disable-line no-use-before-define\n    }\n\n    this.reset(); // forward data and done events from CCs to this CaptionStream\n\n    this.ccStreams_.forEach(function (cc) {\n      cc.on('data', this.trigger.bind(this, 'data'));\n      cc.on('partialdone', this.trigger.bind(this, 'partialdone'));\n      cc.on('done', this.trigger.bind(this, 'done'));\n    }, this);\n\n    if (this.parse708captions_) {\n      this.cc708Stream_.on('data', this.trigger.bind(this, 'data'));\n      this.cc708Stream_.on('partialdone', this.trigger.bind(this, 'partialdone'));\n      this.cc708Stream_.on('done', this.trigger.bind(this, 'done'));\n    }\n  };\n\n  CaptionStream$1.prototype = new stream();\n\n  CaptionStream$1.prototype.push = function (event) {\n    var sei, userData, newCaptionPackets; // only examine SEI NALs\n\n    if (event.nalUnitType !== 'sei_rbsp') {\n      return;\n    } // parse the sei\n\n\n    sei = captionPacketParser.parseSei(event.escapedRBSP); // no payload data, skip\n\n    if (!sei.payload) {\n      return;\n    } // ignore everything but user_data_registered_itu_t_t35\n\n\n    if (sei.payloadType !== captionPacketParser.USER_DATA_REGISTERED_ITU_T_T35) {\n      return;\n    } // parse out the user data payload\n\n\n    userData = captionPacketParser.parseUserData(sei); // ignore unrecognized userData\n\n    if (!userData) {\n      return;\n    } // Sometimes, the same segment # will be downloaded twice. To stop the\n    // caption data from being processed twice, we track the latest dts we've\n    // received and ignore everything with a dts before that. However, since\n    // data for a specific dts can be split across packets on either side of\n    // a segment boundary, we need to make sure we *don't* ignore the packets\n    // from the *next* segment that have dts === this.latestDts_. By constantly\n    // tracking the number of packets received with dts === this.latestDts_, we\n    // know how many should be ignored once we start receiving duplicates.\n\n\n    if (event.dts < this.latestDts_) {\n      // We've started getting older data, so set the flag.\n      this.ignoreNextEqualDts_ = true;\n      return;\n    } else if (event.dts === this.latestDts_ && this.ignoreNextEqualDts_) {\n      this.numSameDts_--;\n\n      if (!this.numSameDts_) {\n        // We've received the last duplicate packet, time to start processing again\n        this.ignoreNextEqualDts_ = false;\n      }\n\n      return;\n    } // parse out CC data packets and save them for later\n\n\n    newCaptionPackets = captionPacketParser.parseCaptionPackets(event.pts, userData);\n    this.captionPackets_ = this.captionPackets_.concat(newCaptionPackets);\n\n    if (this.latestDts_ !== event.dts) {\n      this.numSameDts_ = 0;\n    }\n\n    this.numSameDts_++;\n    this.latestDts_ = event.dts;\n  };\n\n  CaptionStream$1.prototype.flushCCStreams = function (flushType) {\n    this.ccStreams_.forEach(function (cc) {\n      return flushType === 'flush' ? cc.flush() : cc.partialFlush();\n    }, this);\n  };\n\n  CaptionStream$1.prototype.flushStream = function (flushType) {\n    // make sure we actually parsed captions before proceeding\n    if (!this.captionPackets_.length) {\n      this.flushCCStreams(flushType);\n      return;\n    } // In Chrome, the Array#sort function is not stable so add a\n    // presortIndex that we can use to ensure we get a stable-sort\n\n\n    this.captionPackets_.forEach(function (elem, idx) {\n      elem.presortIndex = idx;\n    }); // sort caption byte-pairs based on their PTS values\n\n    this.captionPackets_.sort(function (a, b) {\n      if (a.pts === b.pts) {\n        return a.presortIndex - b.presortIndex;\n      }\n\n      return a.pts - b.pts;\n    });\n    this.captionPackets_.forEach(function (packet) {\n      if (packet.type < 2) {\n        // Dispatch packet to the right Cea608Stream\n        this.dispatchCea608Packet(packet);\n      } else {\n        // Dispatch packet to the Cea708Stream\n        this.dispatchCea708Packet(packet);\n      }\n    }, this);\n    this.captionPackets_.length = 0;\n    this.flushCCStreams(flushType);\n  };\n\n  CaptionStream$1.prototype.flush = function () {\n    return this.flushStream('flush');\n  }; // Only called if handling partial data\n\n\n  CaptionStream$1.prototype.partialFlush = function () {\n    return this.flushStream('partialFlush');\n  };\n\n  CaptionStream$1.prototype.reset = function () {\n    this.latestDts_ = null;\n    this.ignoreNextEqualDts_ = false;\n    this.numSameDts_ = 0;\n    this.activeCea608Channel_ = [null, null];\n    this.ccStreams_.forEach(function (ccStream) {\n      ccStream.reset();\n    });\n  }; // From the CEA-608 spec:\n\n  /*\n   * When XDS sub-packets are interleaved with other services, the end of each sub-packet shall be followed\n   * by a control pair to change to a different service. When any of the control codes from 0x10 to 0x1F is\n   * used to begin a control code pair, it indicates the return to captioning or Text data. The control code pair\n   * and subsequent data should then be processed according to the FCC rules. It may be necessary for the\n   * line 21 data encoder to automatically insert a control code pair (i.e. RCL, RU2, RU3, RU4, RDC, or RTD)\n   * to switch to captioning or Text.\n  */\n  // With that in mind, we ignore any data between an XDS control code and a\n  // subsequent closed-captioning control code.\n\n\n  CaptionStream$1.prototype.dispatchCea608Packet = function (packet) {\n    // NOTE: packet.type is the CEA608 field\n    if (this.setsTextOrXDSActive(packet)) {\n      this.activeCea608Channel_[packet.type] = null;\n    } else if (this.setsChannel1Active(packet)) {\n      this.activeCea608Channel_[packet.type] = 0;\n    } else if (this.setsChannel2Active(packet)) {\n      this.activeCea608Channel_[packet.type] = 1;\n    }\n\n    if (this.activeCea608Channel_[packet.type] === null) {\n      // If we haven't received anything to set the active channel, or the\n      // packets are Text/XDS data, discard the data; we don't want jumbled\n      // captions\n      return;\n    }\n\n    this.ccStreams_[(packet.type << 1) + this.activeCea608Channel_[packet.type]].push(packet);\n  };\n\n  CaptionStream$1.prototype.setsChannel1Active = function (packet) {\n    return (packet.ccData & 0x7800) === 0x1000;\n  };\n\n  CaptionStream$1.prototype.setsChannel2Active = function (packet) {\n    return (packet.ccData & 0x7800) === 0x1800;\n  };\n\n  CaptionStream$1.prototype.setsTextOrXDSActive = function (packet) {\n    return (packet.ccData & 0x7100) === 0x0100 || (packet.ccData & 0x78fe) === 0x102a || (packet.ccData & 0x78fe) === 0x182a;\n  };\n\n  CaptionStream$1.prototype.dispatchCea708Packet = function (packet) {\n    if (this.parse708captions_) {\n      this.cc708Stream_.push(packet);\n    }\n  }; // ----------------------\n  // Session to Application\n  // ----------------------\n  // This hash maps special and extended character codes to their\n  // proper Unicode equivalent. The first one-byte key is just a\n  // non-standard character code. The two-byte keys that follow are\n  // the extended CEA708 character codes, along with the preceding\n  // 0x10 extended character byte to distinguish these codes from\n  // non-extended character codes. Every CEA708 character code that\n  // is not in this object maps directly to a standard unicode\n  // character code.\n  // The transparent space and non-breaking transparent space are\n  // technically not fully supported since there is no code to\n  // make them transparent, so they have normal non-transparent\n  // stand-ins.\n  // The special closed caption (CC) character isn't a standard\n  // unicode character, so a fairly similar unicode character was\n  // chosen in it's place.\n\n\n  var CHARACTER_TRANSLATION_708 = {\n    0x7f: 0x266a,\n    // ♪\n    0x1020: 0x20,\n    // Transparent Space\n    0x1021: 0xa0,\n    // Nob-breaking Transparent Space\n    0x1025: 0x2026,\n    // …\n    0x102a: 0x0160,\n    // Š\n    0x102c: 0x0152,\n    // Œ\n    0x1030: 0x2588,\n    // █\n    0x1031: 0x2018,\n    // ‘\n    0x1032: 0x2019,\n    // ’\n    0x1033: 0x201c,\n    // “\n    0x1034: 0x201d,\n    // ”\n    0x1035: 0x2022,\n    // •\n    0x1039: 0x2122,\n    // ™\n    0x103a: 0x0161,\n    // š\n    0x103c: 0x0153,\n    // œ\n    0x103d: 0x2120,\n    // ℠\n    0x103f: 0x0178,\n    // Ÿ\n    0x1076: 0x215b,\n    // ⅛\n    0x1077: 0x215c,\n    // ⅜\n    0x1078: 0x215d,\n    // ⅝\n    0x1079: 0x215e,\n    // ⅞\n    0x107a: 0x23d0,\n    // ⏐\n    0x107b: 0x23a4,\n    // ⎤\n    0x107c: 0x23a3,\n    // ⎣\n    0x107d: 0x23af,\n    // ⎯\n    0x107e: 0x23a6,\n    // ⎦\n    0x107f: 0x23a1,\n    // ⎡\n    0x10a0: 0x3138 // ㄸ (CC char)\n\n  };\n\n  var get708CharFromCode = function get708CharFromCode(code) {\n    var newCode = CHARACTER_TRANSLATION_708[code] || code;\n\n    if (code & 0x1000 && code === newCode) {\n      // Invalid extended code\n      return '';\n    }\n\n    return String.fromCharCode(newCode);\n  };\n\n  var within708TextBlock = function within708TextBlock(b) {\n    return 0x20 <= b && b <= 0x7f || 0xa0 <= b && b <= 0xff;\n  };\n\n  var Cea708Window = function Cea708Window(windowNum) {\n    this.windowNum = windowNum;\n    this.reset();\n  };\n\n  Cea708Window.prototype.reset = function () {\n    this.clearText();\n    this.pendingNewLine = false;\n    this.winAttr = {};\n    this.penAttr = {};\n    this.penLoc = {};\n    this.penColor = {}; // These default values are arbitrary,\n    // defineWindow will usually override them\n\n    this.visible = 0;\n    this.rowLock = 0;\n    this.columnLock = 0;\n    this.priority = 0;\n    this.relativePositioning = 0;\n    this.anchorVertical = 0;\n    this.anchorHorizontal = 0;\n    this.anchorPoint = 0;\n    this.rowCount = 1;\n    this.virtualRowCount = this.rowCount + 1;\n    this.columnCount = 41;\n    this.windowStyle = 0;\n    this.penStyle = 0;\n  };\n\n  Cea708Window.prototype.getText = function () {\n    return this.rows.join('\\n');\n  };\n\n  Cea708Window.prototype.clearText = function () {\n    this.rows = [''];\n    this.rowIdx = 0;\n  };\n\n  Cea708Window.prototype.newLine = function (pts) {\n    if (this.rows.length >= this.virtualRowCount && typeof this.beforeRowOverflow === 'function') {\n      this.beforeRowOverflow(pts);\n    }\n\n    if (this.rows.length > 0) {\n      this.rows.push('');\n      this.rowIdx++;\n    } // Show all virtual rows since there's no visible scrolling\n\n\n    while (this.rows.length > this.virtualRowCount) {\n      this.rows.shift();\n      this.rowIdx--;\n    }\n  };\n\n  Cea708Window.prototype.isEmpty = function () {\n    if (this.rows.length === 0) {\n      return true;\n    } else if (this.rows.length === 1) {\n      return this.rows[0] === '';\n    }\n\n    return false;\n  };\n\n  Cea708Window.prototype.addText = function (text) {\n    this.rows[this.rowIdx] += text;\n  };\n\n  Cea708Window.prototype.backspace = function () {\n    if (!this.isEmpty()) {\n      var row = this.rows[this.rowIdx];\n      this.rows[this.rowIdx] = row.substr(0, row.length - 1);\n    }\n  };\n\n  var Cea708Service = function Cea708Service(serviceNum, encoding, stream) {\n    this.serviceNum = serviceNum;\n    this.text = '';\n    this.currentWindow = new Cea708Window(-1);\n    this.windows = [];\n    this.stream = stream; // Try to setup a TextDecoder if an `encoding` value was provided\n\n    if (typeof encoding === 'string') {\n      this.createTextDecoder(encoding);\n    }\n  };\n  /**\n   * Initialize service windows\n   * Must be run before service use\n   *\n   * @param  {Integer}  pts               PTS value\n   * @param  {Function} beforeRowOverflow Function to execute before row overflow of a window\n   */\n\n\n  Cea708Service.prototype.init = function (pts, beforeRowOverflow) {\n    this.startPts = pts;\n\n    for (var win = 0; win < 8; win++) {\n      this.windows[win] = new Cea708Window(win);\n\n      if (typeof beforeRowOverflow === 'function') {\n        this.windows[win].beforeRowOverflow = beforeRowOverflow;\n      }\n    }\n  };\n  /**\n   * Set current window of service to be affected by commands\n   *\n   * @param  {Integer} windowNum Window number\n   */\n\n\n  Cea708Service.prototype.setCurrentWindow = function (windowNum) {\n    this.currentWindow = this.windows[windowNum];\n  };\n  /**\n   * Try to create a TextDecoder if it is natively supported\n   */\n\n\n  Cea708Service.prototype.createTextDecoder = function (encoding) {\n    if (typeof TextDecoder === 'undefined') {\n      this.stream.trigger('log', {\n        level: 'warn',\n        message: 'The `encoding` option is unsupported without TextDecoder support'\n      });\n    } else {\n      try {\n        this.textDecoder_ = new TextDecoder(encoding);\n      } catch (error) {\n        this.stream.trigger('log', {\n          level: 'warn',\n          message: 'TextDecoder could not be created with ' + encoding + ' encoding. ' + error\n        });\n      }\n    }\n  };\n\n  var Cea708Stream = function Cea708Stream(options) {\n    options = options || {};\n    Cea708Stream.prototype.init.call(this);\n    var self = this;\n    var captionServices = options.captionServices || {};\n    var captionServiceEncodings = {};\n    var serviceProps; // Get service encodings from captionServices option block\n\n    Object.keys(captionServices).forEach(function (serviceName) {\n      serviceProps = captionServices[serviceName];\n\n      if (/^SERVICE/.test(serviceName)) {\n        captionServiceEncodings[serviceName] = serviceProps.encoding;\n      }\n    });\n    this.serviceEncodings = captionServiceEncodings;\n    this.current708Packet = null;\n    this.services = {};\n\n    this.push = function (packet) {\n      if (packet.type === 3) {\n        // 708 packet start\n        self.new708Packet();\n        self.add708Bytes(packet);\n      } else {\n        if (self.current708Packet === null) {\n          // This should only happen at the start of a file if there's no packet start.\n          self.new708Packet();\n        }\n\n        self.add708Bytes(packet);\n      }\n    };\n  };\n\n  Cea708Stream.prototype = new stream();\n  /**\n   * Push current 708 packet, create new 708 packet.\n   */\n\n  Cea708Stream.prototype.new708Packet = function () {\n    if (this.current708Packet !== null) {\n      this.push708Packet();\n    }\n\n    this.current708Packet = {\n      data: [],\n      ptsVals: []\n    };\n  };\n  /**\n   * Add pts and both bytes from packet into current 708 packet.\n   */\n\n\n  Cea708Stream.prototype.add708Bytes = function (packet) {\n    var data = packet.ccData;\n    var byte0 = data >>> 8;\n    var byte1 = data & 0xff; // I would just keep a list of packets instead of bytes, but it isn't clear in the spec\n    // that service blocks will always line up with byte pairs.\n\n    this.current708Packet.ptsVals.push(packet.pts);\n    this.current708Packet.data.push(byte0);\n    this.current708Packet.data.push(byte1);\n  };\n  /**\n   * Parse completed 708 packet into service blocks and push each service block.\n   */\n\n\n  Cea708Stream.prototype.push708Packet = function () {\n    var packet708 = this.current708Packet;\n    var packetData = packet708.data;\n    var serviceNum = null;\n    var blockSize = null;\n    var i = 0;\n    var b = packetData[i++];\n    packet708.seq = b >> 6;\n    packet708.sizeCode = b & 0x3f; // 0b00111111;\n\n    for (; i < packetData.length; i++) {\n      b = packetData[i++];\n      serviceNum = b >> 5;\n      blockSize = b & 0x1f; // 0b00011111\n\n      if (serviceNum === 7 && blockSize > 0) {\n        // Extended service num\n        b = packetData[i++];\n        serviceNum = b;\n      }\n\n      this.pushServiceBlock(serviceNum, i, blockSize);\n\n      if (blockSize > 0) {\n        i += blockSize - 1;\n      }\n    }\n  };\n  /**\n   * Parse service block, execute commands, read text.\n   *\n   * Note: While many of these commands serve important purposes,\n   * many others just parse out the parameters or attributes, but\n   * nothing is done with them because this is not a full and complete\n   * implementation of the entire 708 spec.\n   *\n   * @param  {Integer} serviceNum Service number\n   * @param  {Integer} start      Start index of the 708 packet data\n   * @param  {Integer} size       Block size\n   */\n\n\n  Cea708Stream.prototype.pushServiceBlock = function (serviceNum, start, size) {\n    var b;\n    var i = start;\n    var packetData = this.current708Packet.data;\n    var service = this.services[serviceNum];\n\n    if (!service) {\n      service = this.initService(serviceNum, i);\n    }\n\n    for (; i < start + size && i < packetData.length; i++) {\n      b = packetData[i];\n\n      if (within708TextBlock(b)) {\n        i = this.handleText(i, service);\n      } else if (b === 0x18) {\n        i = this.multiByteCharacter(i, service);\n      } else if (b === 0x10) {\n        i = this.extendedCommands(i, service);\n      } else if (0x80 <= b && b <= 0x87) {\n        i = this.setCurrentWindow(i, service);\n      } else if (0x98 <= b && b <= 0x9f) {\n        i = this.defineWindow(i, service);\n      } else if (b === 0x88) {\n        i = this.clearWindows(i, service);\n      } else if (b === 0x8c) {\n        i = this.deleteWindows(i, service);\n      } else if (b === 0x89) {\n        i = this.displayWindows(i, service);\n      } else if (b === 0x8a) {\n        i = this.hideWindows(i, service);\n      } else if (b === 0x8b) {\n        i = this.toggleWindows(i, service);\n      } else if (b === 0x97) {\n        i = this.setWindowAttributes(i, service);\n      } else if (b === 0x90) {\n        i = this.setPenAttributes(i, service);\n      } else if (b === 0x91) {\n        i = this.setPenColor(i, service);\n      } else if (b === 0x92) {\n        i = this.setPenLocation(i, service);\n      } else if (b === 0x8f) {\n        service = this.reset(i, service);\n      } else if (b === 0x08) {\n        // BS: Backspace\n        service.currentWindow.backspace();\n      } else if (b === 0x0c) {\n        // FF: Form feed\n        service.currentWindow.clearText();\n      } else if (b === 0x0d) {\n        // CR: Carriage return\n        service.currentWindow.pendingNewLine = true;\n      } else if (b === 0x0e) {\n        // HCR: Horizontal carriage return\n        service.currentWindow.clearText();\n      } else if (b === 0x8d) {\n        // DLY: Delay, nothing to do\n        i++;\n      } else ;\n    }\n  };\n  /**\n   * Execute an extended command\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.extendedCommands = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[++i];\n\n    if (within708TextBlock(b)) {\n      i = this.handleText(i, service, {\n        isExtended: true\n      });\n    }\n\n    return i;\n  };\n  /**\n   * Get PTS value of a given byte index\n   *\n   * @param  {Integer} byteIndex  Index of the byte\n   * @return {Integer}            PTS\n   */\n\n\n  Cea708Stream.prototype.getPts = function (byteIndex) {\n    // There's 1 pts value per 2 bytes\n    return this.current708Packet.ptsVals[Math.floor(byteIndex / 2)];\n  };\n  /**\n   * Initializes a service\n   *\n   * @param  {Integer} serviceNum Service number\n   * @return {Service}            Initialized service object\n   */\n\n\n  Cea708Stream.prototype.initService = function (serviceNum, i) {\n    var serviceName = 'SERVICE' + serviceNum;\n    var self = this;\n    var serviceName;\n    var encoding;\n\n    if (serviceName in this.serviceEncodings) {\n      encoding = this.serviceEncodings[serviceName];\n    }\n\n    this.services[serviceNum] = new Cea708Service(serviceNum, encoding, self);\n    this.services[serviceNum].init(this.getPts(i), function (pts) {\n      self.flushDisplayed(pts, self.services[serviceNum]);\n    });\n    return this.services[serviceNum];\n  };\n  /**\n   * Execute text writing to current window\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.handleText = function (i, service, options) {\n    var isExtended = options && options.isExtended;\n    var isMultiByte = options && options.isMultiByte;\n    var packetData = this.current708Packet.data;\n    var extended = isExtended ? 0x1000 : 0x0000;\n    var currentByte = packetData[i];\n    var nextByte = packetData[i + 1];\n    var win = service.currentWindow;\n    var char;\n    var charCodeArray; // Use the TextDecoder if one was created for this service\n\n    if (service.textDecoder_ && !isExtended) {\n      if (isMultiByte) {\n        charCodeArray = [currentByte, nextByte];\n        i++;\n      } else {\n        charCodeArray = [currentByte];\n      }\n\n      char = service.textDecoder_.decode(new Uint8Array(charCodeArray));\n    } else {\n      char = get708CharFromCode(extended | currentByte);\n    }\n\n    if (win.pendingNewLine && !win.isEmpty()) {\n      win.newLine(this.getPts(i));\n    }\n\n    win.pendingNewLine = false;\n    win.addText(char);\n    return i;\n  };\n  /**\n   * Handle decoding of multibyte character\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.multiByteCharacter = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var firstByte = packetData[i + 1];\n    var secondByte = packetData[i + 2];\n\n    if (within708TextBlock(firstByte) && within708TextBlock(secondByte)) {\n      i = this.handleText(++i, service, {\n        isMultiByte: true\n      });\n    }\n\n    return i;\n  };\n  /**\n   * Parse and execute the CW# command.\n   *\n   * Set the current window.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.setCurrentWindow = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[i];\n    var windowNum = b & 0x07;\n    service.setCurrentWindow(windowNum);\n    return i;\n  };\n  /**\n   * Parse and execute the DF# command.\n   *\n   * Define a window and set it as the current window.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.defineWindow = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[i];\n    var windowNum = b & 0x07;\n    service.setCurrentWindow(windowNum);\n    var win = service.currentWindow;\n    b = packetData[++i];\n    win.visible = (b & 0x20) >> 5; // v\n\n    win.rowLock = (b & 0x10) >> 4; // rl\n\n    win.columnLock = (b & 0x08) >> 3; // cl\n\n    win.priority = b & 0x07; // p\n\n    b = packetData[++i];\n    win.relativePositioning = (b & 0x80) >> 7; // rp\n\n    win.anchorVertical = b & 0x7f; // av\n\n    b = packetData[++i];\n    win.anchorHorizontal = b; // ah\n\n    b = packetData[++i];\n    win.anchorPoint = (b & 0xf0) >> 4; // ap\n\n    win.rowCount = b & 0x0f; // rc\n\n    b = packetData[++i];\n    win.columnCount = b & 0x3f; // cc\n\n    b = packetData[++i];\n    win.windowStyle = (b & 0x38) >> 3; // ws\n\n    win.penStyle = b & 0x07; // ps\n    // The spec says there are (rowCount+1) \"virtual rows\"\n\n    win.virtualRowCount = win.rowCount + 1;\n    return i;\n  };\n  /**\n   * Parse and execute the SWA command.\n   *\n   * Set attributes of the current window.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.setWindowAttributes = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[i];\n    var winAttr = service.currentWindow.winAttr;\n    b = packetData[++i];\n    winAttr.fillOpacity = (b & 0xc0) >> 6; // fo\n\n    winAttr.fillRed = (b & 0x30) >> 4; // fr\n\n    winAttr.fillGreen = (b & 0x0c) >> 2; // fg\n\n    winAttr.fillBlue = b & 0x03; // fb\n\n    b = packetData[++i];\n    winAttr.borderType = (b & 0xc0) >> 6; // bt\n\n    winAttr.borderRed = (b & 0x30) >> 4; // br\n\n    winAttr.borderGreen = (b & 0x0c) >> 2; // bg\n\n    winAttr.borderBlue = b & 0x03; // bb\n\n    b = packetData[++i];\n    winAttr.borderType += (b & 0x80) >> 5; // bt\n\n    winAttr.wordWrap = (b & 0x40) >> 6; // ww\n\n    winAttr.printDirection = (b & 0x30) >> 4; // pd\n\n    winAttr.scrollDirection = (b & 0x0c) >> 2; // sd\n\n    winAttr.justify = b & 0x03; // j\n\n    b = packetData[++i];\n    winAttr.effectSpeed = (b & 0xf0) >> 4; // es\n\n    winAttr.effectDirection = (b & 0x0c) >> 2; // ed\n\n    winAttr.displayEffect = b & 0x03; // de\n\n    return i;\n  };\n  /**\n   * Gather text from all displayed windows and push a caption to output.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   */\n\n\n  Cea708Stream.prototype.flushDisplayed = function (pts, service) {\n    var displayedText = []; // TODO: Positioning not supported, displaying multiple windows will not necessarily\n    // display text in the correct order, but sample files so far have not shown any issue.\n\n    for (var winId = 0; winId < 8; winId++) {\n      if (service.windows[winId].visible && !service.windows[winId].isEmpty()) {\n        displayedText.push(service.windows[winId].getText());\n      }\n    }\n\n    service.endPts = pts;\n    service.text = displayedText.join('\\n\\n');\n    this.pushCaption(service);\n    service.startPts = pts;\n  };\n  /**\n   * Push a caption to output if the caption contains text.\n   *\n   * @param  {Service} service  The service object to be affected\n   */\n\n\n  Cea708Stream.prototype.pushCaption = function (service) {\n    if (service.text !== '') {\n      this.trigger('data', {\n        startPts: service.startPts,\n        endPts: service.endPts,\n        text: service.text,\n        stream: 'cc708_' + service.serviceNum\n      });\n      service.text = '';\n      service.startPts = service.endPts;\n    }\n  };\n  /**\n   * Parse and execute the DSW command.\n   *\n   * Set visible property of windows based on the parsed bitmask.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.displayWindows = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[++i];\n    var pts = this.getPts(i);\n    this.flushDisplayed(pts, service);\n\n    for (var winId = 0; winId < 8; winId++) {\n      if (b & 0x01 << winId) {\n        service.windows[winId].visible = 1;\n      }\n    }\n\n    return i;\n  };\n  /**\n   * Parse and execute the HDW command.\n   *\n   * Set visible property of windows based on the parsed bitmask.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.hideWindows = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[++i];\n    var pts = this.getPts(i);\n    this.flushDisplayed(pts, service);\n\n    for (var winId = 0; winId < 8; winId++) {\n      if (b & 0x01 << winId) {\n        service.windows[winId].visible = 0;\n      }\n    }\n\n    return i;\n  };\n  /**\n   * Parse and execute the TGW command.\n   *\n   * Set visible property of windows based on the parsed bitmask.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.toggleWindows = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[++i];\n    var pts = this.getPts(i);\n    this.flushDisplayed(pts, service);\n\n    for (var winId = 0; winId < 8; winId++) {\n      if (b & 0x01 << winId) {\n        service.windows[winId].visible ^= 1;\n      }\n    }\n\n    return i;\n  };\n  /**\n   * Parse and execute the CLW command.\n   *\n   * Clear text of windows based on the parsed bitmask.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.clearWindows = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[++i];\n    var pts = this.getPts(i);\n    this.flushDisplayed(pts, service);\n\n    for (var winId = 0; winId < 8; winId++) {\n      if (b & 0x01 << winId) {\n        service.windows[winId].clearText();\n      }\n    }\n\n    return i;\n  };\n  /**\n   * Parse and execute the DLW command.\n   *\n   * Re-initialize windows based on the parsed bitmask.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.deleteWindows = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[++i];\n    var pts = this.getPts(i);\n    this.flushDisplayed(pts, service);\n\n    for (var winId = 0; winId < 8; winId++) {\n      if (b & 0x01 << winId) {\n        service.windows[winId].reset();\n      }\n    }\n\n    return i;\n  };\n  /**\n   * Parse and execute the SPA command.\n   *\n   * Set pen attributes of the current window.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.setPenAttributes = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[i];\n    var penAttr = service.currentWindow.penAttr;\n    b = packetData[++i];\n    penAttr.textTag = (b & 0xf0) >> 4; // tt\n\n    penAttr.offset = (b & 0x0c) >> 2; // o\n\n    penAttr.penSize = b & 0x03; // s\n\n    b = packetData[++i];\n    penAttr.italics = (b & 0x80) >> 7; // i\n\n    penAttr.underline = (b & 0x40) >> 6; // u\n\n    penAttr.edgeType = (b & 0x38) >> 3; // et\n\n    penAttr.fontStyle = b & 0x07; // fs\n\n    return i;\n  };\n  /**\n   * Parse and execute the SPC command.\n   *\n   * Set pen color of the current window.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.setPenColor = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[i];\n    var penColor = service.currentWindow.penColor;\n    b = packetData[++i];\n    penColor.fgOpacity = (b & 0xc0) >> 6; // fo\n\n    penColor.fgRed = (b & 0x30) >> 4; // fr\n\n    penColor.fgGreen = (b & 0x0c) >> 2; // fg\n\n    penColor.fgBlue = b & 0x03; // fb\n\n    b = packetData[++i];\n    penColor.bgOpacity = (b & 0xc0) >> 6; // bo\n\n    penColor.bgRed = (b & 0x30) >> 4; // br\n\n    penColor.bgGreen = (b & 0x0c) >> 2; // bg\n\n    penColor.bgBlue = b & 0x03; // bb\n\n    b = packetData[++i];\n    penColor.edgeRed = (b & 0x30) >> 4; // er\n\n    penColor.edgeGreen = (b & 0x0c) >> 2; // eg\n\n    penColor.edgeBlue = b & 0x03; // eb\n\n    return i;\n  };\n  /**\n   * Parse and execute the SPL command.\n   *\n   * Set pen location of the current window.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Integer}          New index after parsing\n   */\n\n\n  Cea708Stream.prototype.setPenLocation = function (i, service) {\n    var packetData = this.current708Packet.data;\n    var b = packetData[i];\n    var penLoc = service.currentWindow.penLoc; // Positioning isn't really supported at the moment, so this essentially just inserts a linebreak\n\n    service.currentWindow.pendingNewLine = true;\n    b = packetData[++i];\n    penLoc.row = b & 0x0f; // r\n\n    b = packetData[++i];\n    penLoc.column = b & 0x3f; // c\n\n    return i;\n  };\n  /**\n   * Execute the RST command.\n   *\n   * Reset service to a clean slate. Re-initialize.\n   *\n   * @param  {Integer} i        Current index in the 708 packet\n   * @param  {Service} service  The service object to be affected\n   * @return {Service}          Re-initialized service\n   */\n\n\n  Cea708Stream.prototype.reset = function (i, service) {\n    var pts = this.getPts(i);\n    this.flushDisplayed(pts, service);\n    return this.initService(service.serviceNum, i);\n  }; // This hash maps non-ASCII, special, and extended character codes to their\n  // proper Unicode equivalent. The first keys that are only a single byte\n  // are the non-standard ASCII characters, which simply map the CEA608 byte\n  // to the standard ASCII/Unicode. The two-byte keys that follow are the CEA608\n  // character codes, but have their MSB bitmasked with 0x03 so that a lookup\n  // can be performed regardless of the field and data channel on which the\n  // character code was received.\n\n\n  var CHARACTER_TRANSLATION = {\n    0x2a: 0xe1,\n    // á\n    0x5c: 0xe9,\n    // é\n    0x5e: 0xed,\n    // í\n    0x5f: 0xf3,\n    // ó\n    0x60: 0xfa,\n    // ú\n    0x7b: 0xe7,\n    // ç\n    0x7c: 0xf7,\n    // ÷\n    0x7d: 0xd1,\n    // Ñ\n    0x7e: 0xf1,\n    // ñ\n    0x7f: 0x2588,\n    // █\n    0x0130: 0xae,\n    // ®\n    0x0131: 0xb0,\n    // °\n    0x0132: 0xbd,\n    // ½\n    0x0133: 0xbf,\n    // ¿\n    0x0134: 0x2122,\n    // ™\n    0x0135: 0xa2,\n    // ¢\n    0x0136: 0xa3,\n    // £\n    0x0137: 0x266a,\n    // ♪\n    0x0138: 0xe0,\n    // à\n    0x0139: 0xa0,\n    //\n    0x013a: 0xe8,\n    // è\n    0x013b: 0xe2,\n    // â\n    0x013c: 0xea,\n    // ê\n    0x013d: 0xee,\n    // î\n    0x013e: 0xf4,\n    // ô\n    0x013f: 0xfb,\n    // û\n    0x0220: 0xc1,\n    // Á\n    0x0221: 0xc9,\n    // É\n    0x0222: 0xd3,\n    // Ó\n    0x0223: 0xda,\n    // Ú\n    0x0224: 0xdc,\n    // Ü\n    0x0225: 0xfc,\n    // ü\n    0x0226: 0x2018,\n    // ‘\n    0x0227: 0xa1,\n    // ¡\n    0x0228: 0x2a,\n    // *\n    0x0229: 0x27,\n    // '\n    0x022a: 0x2014,\n    // —\n    0x022b: 0xa9,\n    // ©\n    0x022c: 0x2120,\n    // ℠\n    0x022d: 0x2022,\n    // •\n    0x022e: 0x201c,\n    // “\n    0x022f: 0x201d,\n    // ”\n    0x0230: 0xc0,\n    // À\n    0x0231: 0xc2,\n    // Â\n    0x0232: 0xc7,\n    // Ç\n    0x0233: 0xc8,\n    // È\n    0x0234: 0xca,\n    // Ê\n    0x0235: 0xcb,\n    // Ë\n    0x0236: 0xeb,\n    // ë\n    0x0237: 0xce,\n    // Î\n    0x0238: 0xcf,\n    // Ï\n    0x0239: 0xef,\n    // ï\n    0x023a: 0xd4,\n    // Ô\n    0x023b: 0xd9,\n    // Ù\n    0x023c: 0xf9,\n    // ù\n    0x023d: 0xdb,\n    // Û\n    0x023e: 0xab,\n    // «\n    0x023f: 0xbb,\n    // »\n    0x0320: 0xc3,\n    // Ã\n    0x0321: 0xe3,\n    // ã\n    0x0322: 0xcd,\n    // Í\n    0x0323: 0xcc,\n    // Ì\n    0x0324: 0xec,\n    // ì\n    0x0325: 0xd2,\n    // Ò\n    0x0326: 0xf2,\n    // ò\n    0x0327: 0xd5,\n    // Õ\n    0x0328: 0xf5,\n    // õ\n    0x0329: 0x7b,\n    // {\n    0x032a: 0x7d,\n    // }\n    0x032b: 0x5c,\n    // \\\n    0x032c: 0x5e,\n    // ^\n    0x032d: 0x5f,\n    // _\n    0x032e: 0x7c,\n    // |\n    0x032f: 0x7e,\n    // ~\n    0x0330: 0xc4,\n    // Ä\n    0x0331: 0xe4,\n    // ä\n    0x0332: 0xd6,\n    // Ö\n    0x0333: 0xf6,\n    // ö\n    0x0334: 0xdf,\n    // ß\n    0x0335: 0xa5,\n    // ¥\n    0x0336: 0xa4,\n    // ¤\n    0x0337: 0x2502,\n    // │\n    0x0338: 0xc5,\n    // Å\n    0x0339: 0xe5,\n    // å\n    0x033a: 0xd8,\n    // Ø\n    0x033b: 0xf8,\n    // ø\n    0x033c: 0x250c,\n    // ┌\n    0x033d: 0x2510,\n    // ┐\n    0x033e: 0x2514,\n    // └\n    0x033f: 0x2518 // ┘\n\n  };\n\n  var getCharFromCode = function getCharFromCode(code) {\n    if (code === null) {\n      return '';\n    }\n\n    code = CHARACTER_TRANSLATION[code] || code;\n    return String.fromCharCode(code);\n  }; // the index of the last row in a CEA-608 display buffer\n\n\n  var BOTTOM_ROW = 14; // This array is used for mapping PACs -> row #, since there's no way of\n  // getting it through bit logic.\n\n  var ROWS = [0x1100, 0x1120, 0x1200, 0x1220, 0x1500, 0x1520, 0x1600, 0x1620, 0x1700, 0x1720, 0x1000, 0x1300, 0x1320, 0x1400, 0x1420]; // CEA-608 captions are rendered onto a 34x15 matrix of character\n  // cells. The \"bottom\" row is the last element in the outer array.\n\n  var createDisplayBuffer = function createDisplayBuffer() {\n    var result = [],\n        i = BOTTOM_ROW + 1;\n\n    while (i--) {\n      result.push('');\n    }\n\n    return result;\n  };\n\n  var Cea608Stream = function Cea608Stream(field, dataChannel) {\n    Cea608Stream.prototype.init.call(this);\n    this.field_ = field || 0;\n    this.dataChannel_ = dataChannel || 0;\n    this.name_ = 'CC' + ((this.field_ << 1 | this.dataChannel_) + 1);\n    this.setConstants();\n    this.reset();\n\n    this.push = function (packet) {\n      var data, swap, char0, char1, text; // remove the parity bits\n\n      data = packet.ccData & 0x7f7f; // ignore duplicate control codes; the spec demands they're sent twice\n\n      if (data === this.lastControlCode_) {\n        this.lastControlCode_ = null;\n        return;\n      } // Store control codes\n\n\n      if ((data & 0xf000) === 0x1000) {\n        this.lastControlCode_ = data;\n      } else if (data !== this.PADDING_) {\n        this.lastControlCode_ = null;\n      }\n\n      char0 = data >>> 8;\n      char1 = data & 0xff;\n\n      if (data === this.PADDING_) {\n        return;\n      } else if (data === this.RESUME_CAPTION_LOADING_) {\n        this.mode_ = 'popOn';\n      } else if (data === this.END_OF_CAPTION_) {\n        // If an EOC is received while in paint-on mode, the displayed caption\n        // text should be swapped to non-displayed memory as if it was a pop-on\n        // caption. Because of that, we should explicitly switch back to pop-on\n        // mode\n        this.mode_ = 'popOn';\n        this.clearFormatting(packet.pts); // if a caption was being displayed, it's gone now\n\n        this.flushDisplayed(packet.pts); // flip memory\n\n        swap = this.displayed_;\n        this.displayed_ = this.nonDisplayed_;\n        this.nonDisplayed_ = swap; // start measuring the time to display the caption\n\n        this.startPts_ = packet.pts;\n      } else if (data === this.ROLL_UP_2_ROWS_) {\n        this.rollUpRows_ = 2;\n        this.setRollUp(packet.pts);\n      } else if (data === this.ROLL_UP_3_ROWS_) {\n        this.rollUpRows_ = 3;\n        this.setRollUp(packet.pts);\n      } else if (data === this.ROLL_UP_4_ROWS_) {\n        this.rollUpRows_ = 4;\n        this.setRollUp(packet.pts);\n      } else if (data === this.CARRIAGE_RETURN_) {\n        this.clearFormatting(packet.pts);\n        this.flushDisplayed(packet.pts);\n        this.shiftRowsUp_();\n        this.startPts_ = packet.pts;\n      } else if (data === this.BACKSPACE_) {\n        if (this.mode_ === 'popOn') {\n          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);\n        } else {\n          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);\n        }\n      } else if (data === this.ERASE_DISPLAYED_MEMORY_) {\n        this.flushDisplayed(packet.pts);\n        this.displayed_ = createDisplayBuffer();\n      } else if (data === this.ERASE_NON_DISPLAYED_MEMORY_) {\n        this.nonDisplayed_ = createDisplayBuffer();\n      } else if (data === this.RESUME_DIRECT_CAPTIONING_) {\n        if (this.mode_ !== 'paintOn') {\n          // NOTE: This should be removed when proper caption positioning is\n          // implemented\n          this.flushDisplayed(packet.pts);\n          this.displayed_ = createDisplayBuffer();\n        }\n\n        this.mode_ = 'paintOn';\n        this.startPts_ = packet.pts; // Append special characters to caption text\n      } else if (this.isSpecialCharacter(char0, char1)) {\n        // Bitmask char0 so that we can apply character transformations\n        // regardless of field and data channel.\n        // Then byte-shift to the left and OR with char1 so we can pass the\n        // entire character code to `getCharFromCode`.\n        char0 = (char0 & 0x03) << 8;\n        text = getCharFromCode(char0 | char1);\n        this[this.mode_](packet.pts, text);\n        this.column_++; // Append extended characters to caption text\n      } else if (this.isExtCharacter(char0, char1)) {\n        // Extended characters always follow their \"non-extended\" equivalents.\n        // IE if a \"è\" is desired, you'll always receive \"eè\"; non-compliant\n        // decoders are supposed to drop the \"è\", while compliant decoders\n        // backspace the \"e\" and insert \"è\".\n        // Delete the previous character\n        if (this.mode_ === 'popOn') {\n          this.nonDisplayed_[this.row_] = this.nonDisplayed_[this.row_].slice(0, -1);\n        } else {\n          this.displayed_[this.row_] = this.displayed_[this.row_].slice(0, -1);\n        } // Bitmask char0 so that we can apply character transformations\n        // regardless of field and data channel.\n        // Then byte-shift to the left and OR with char1 so we can pass the\n        // entire character code to `getCharFromCode`.\n\n\n        char0 = (char0 & 0x03) << 8;\n        text = getCharFromCode(char0 | char1);\n        this[this.mode_](packet.pts, text);\n        this.column_++; // Process mid-row codes\n      } else if (this.isMidRowCode(char0, char1)) {\n        // Attributes are not additive, so clear all formatting\n        this.clearFormatting(packet.pts); // According to the standard, mid-row codes\n        // should be replaced with spaces, so add one now\n\n        this[this.mode_](packet.pts, ' ');\n        this.column_++;\n\n        if ((char1 & 0xe) === 0xe) {\n          this.addFormatting(packet.pts, ['i']);\n        }\n\n        if ((char1 & 0x1) === 0x1) {\n          this.addFormatting(packet.pts, ['u']);\n        } // Detect offset control codes and adjust cursor\n\n      } else if (this.isOffsetControlCode(char0, char1)) {\n        // Cursor position is set by indent PAC (see below) in 4-column\n        // increments, with an additional offset code of 1-3 to reach any\n        // of the 32 columns specified by CEA-608. So all we need to do\n        // here is increment the column cursor by the given offset.\n        this.column_ += char1 & 0x03; // Detect PACs (Preamble Address Codes)\n      } else if (this.isPAC(char0, char1)) {\n        // There's no logic for PAC -> row mapping, so we have to just\n        // find the row code in an array and use its index :(\n        var row = ROWS.indexOf(data & 0x1f20); // Configure the caption window if we're in roll-up mode\n\n        if (this.mode_ === 'rollUp') {\n          // This implies that the base row is incorrectly set.\n          // As per the recommendation in CEA-608(Base Row Implementation), defer to the number\n          // of roll-up rows set.\n          if (row - this.rollUpRows_ + 1 < 0) {\n            row = this.rollUpRows_ - 1;\n          }\n\n          this.setRollUp(packet.pts, row);\n        }\n\n        if (row !== this.row_) {\n          // formatting is only persistent for current row\n          this.clearFormatting(packet.pts);\n          this.row_ = row;\n        } // All PACs can apply underline, so detect and apply\n        // (All odd-numbered second bytes set underline)\n\n\n        if (char1 & 0x1 && this.formatting_.indexOf('u') === -1) {\n          this.addFormatting(packet.pts, ['u']);\n        }\n\n        if ((data & 0x10) === 0x10) {\n          // We've got an indent level code. Each successive even number\n          // increments the column cursor by 4, so we can get the desired\n          // column position by bit-shifting to the right (to get n/2)\n          // and multiplying by 4.\n          this.column_ = ((data & 0xe) >> 1) * 4;\n        }\n\n        if (this.isColorPAC(char1)) {\n          // it's a color code, though we only support white, which\n          // can be either normal or italicized. white italics can be\n          // either 0x4e or 0x6e depending on the row, so we just\n          // bitwise-and with 0xe to see if italics should be turned on\n          if ((char1 & 0xe) === 0xe) {\n            this.addFormatting(packet.pts, ['i']);\n          }\n        } // We have a normal character in char0, and possibly one in char1\n\n      } else if (this.isNormalChar(char0)) {\n        if (char1 === 0x00) {\n          char1 = null;\n        }\n\n        text = getCharFromCode(char0);\n        text += getCharFromCode(char1);\n        this[this.mode_](packet.pts, text);\n        this.column_ += text.length;\n      } // finish data processing\n\n    };\n  };\n\n  Cea608Stream.prototype = new stream(); // Trigger a cue point that captures the current state of the\n  // display buffer\n\n  Cea608Stream.prototype.flushDisplayed = function (pts) {\n    var content = this.displayed_ // remove spaces from the start and end of the string\n    .map(function (row, index) {\n      try {\n        return row.trim();\n      } catch (e) {\n        // Ordinarily, this shouldn't happen. However, caption\n        // parsing errors should not throw exceptions and\n        // break playback.\n        this.trigger('log', {\n          level: 'warn',\n          message: 'Skipping a malformed 608 caption at index ' + index + '.'\n        });\n        return '';\n      }\n    }, this) // combine all text rows to display in one cue\n    .join('\\n') // and remove blank rows from the start and end, but not the middle\n    .replace(/^\\n+|\\n+$/g, '');\n\n    if (content.length) {\n      this.trigger('data', {\n        startPts: this.startPts_,\n        endPts: pts,\n        text: content,\n        stream: this.name_\n      });\n    }\n  };\n  /**\n   * Zero out the data, used for startup and on seek\n   */\n\n\n  Cea608Stream.prototype.reset = function () {\n    this.mode_ = 'popOn'; // When in roll-up mode, the index of the last row that will\n    // actually display captions. If a caption is shifted to a row\n    // with a lower index than this, it is cleared from the display\n    // buffer\n\n    this.topRow_ = 0;\n    this.startPts_ = 0;\n    this.displayed_ = createDisplayBuffer();\n    this.nonDisplayed_ = createDisplayBuffer();\n    this.lastControlCode_ = null; // Track row and column for proper line-breaking and spacing\n\n    this.column_ = 0;\n    this.row_ = BOTTOM_ROW;\n    this.rollUpRows_ = 2; // This variable holds currently-applied formatting\n\n    this.formatting_ = [];\n  };\n  /**\n   * Sets up control code and related constants for this instance\n   */\n\n\n  Cea608Stream.prototype.setConstants = function () {\n    // The following attributes have these uses:\n    // ext_ :    char0 for mid-row codes, and the base for extended\n    //           chars (ext_+0, ext_+1, and ext_+2 are char0s for\n    //           extended codes)\n    // control_: char0 for control codes, except byte-shifted to the\n    //           left so that we can do this.control_ | CONTROL_CODE\n    // offset_:  char0 for tab offset codes\n    //\n    // It's also worth noting that control codes, and _only_ control codes,\n    // differ between field 1 and field2. Field 2 control codes are always\n    // their field 1 value plus 1. That's why there's the \"| field\" on the\n    // control value.\n    if (this.dataChannel_ === 0) {\n      this.BASE_ = 0x10;\n      this.EXT_ = 0x11;\n      this.CONTROL_ = (0x14 | this.field_) << 8;\n      this.OFFSET_ = 0x17;\n    } else if (this.dataChannel_ === 1) {\n      this.BASE_ = 0x18;\n      this.EXT_ = 0x19;\n      this.CONTROL_ = (0x1c | this.field_) << 8;\n      this.OFFSET_ = 0x1f;\n    } // Constants for the LSByte command codes recognized by Cea608Stream. This\n    // list is not exhaustive. For a more comprehensive listing and semantics see\n    // http://www.gpo.gov/fdsys/pkg/CFR-2010-title47-vol1/pdf/CFR-2010-title47-vol1-sec15-119.pdf\n    // Padding\n\n\n    this.PADDING_ = 0x0000; // Pop-on Mode\n\n    this.RESUME_CAPTION_LOADING_ = this.CONTROL_ | 0x20;\n    this.END_OF_CAPTION_ = this.CONTROL_ | 0x2f; // Roll-up Mode\n\n    this.ROLL_UP_2_ROWS_ = this.CONTROL_ | 0x25;\n    this.ROLL_UP_3_ROWS_ = this.CONTROL_ | 0x26;\n    this.ROLL_UP_4_ROWS_ = this.CONTROL_ | 0x27;\n    this.CARRIAGE_RETURN_ = this.CONTROL_ | 0x2d; // paint-on mode\n\n    this.RESUME_DIRECT_CAPTIONING_ = this.CONTROL_ | 0x29; // Erasure\n\n    this.BACKSPACE_ = this.CONTROL_ | 0x21;\n    this.ERASE_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2c;\n    this.ERASE_NON_DISPLAYED_MEMORY_ = this.CONTROL_ | 0x2e;\n  };\n  /**\n   * Detects if the 2-byte packet data is a special character\n   *\n   * Special characters have a second byte in the range 0x30 to 0x3f,\n   * with the first byte being 0x11 (for data channel 1) or 0x19 (for\n   * data channel 2).\n   *\n   * @param  {Integer} char0 The first byte\n   * @param  {Integer} char1 The second byte\n   * @return {Boolean}       Whether the 2 bytes are an special character\n   */\n\n\n  Cea608Stream.prototype.isSpecialCharacter = function (char0, char1) {\n    return char0 === this.EXT_ && char1 >= 0x30 && char1 <= 0x3f;\n  };\n  /**\n   * Detects if the 2-byte packet data is an extended character\n   *\n   * Extended characters have a second byte in the range 0x20 to 0x3f,\n   * with the first byte being 0x12 or 0x13 (for data channel 1) or\n   * 0x1a or 0x1b (for data channel 2).\n   *\n   * @param  {Integer} char0 The first byte\n   * @param  {Integer} char1 The second byte\n   * @return {Boolean}       Whether the 2 bytes are an extended character\n   */\n\n\n  Cea608Stream.prototype.isExtCharacter = function (char0, char1) {\n    return (char0 === this.EXT_ + 1 || char0 === this.EXT_ + 2) && char1 >= 0x20 && char1 <= 0x3f;\n  };\n  /**\n   * Detects if the 2-byte packet is a mid-row code\n   *\n   * Mid-row codes have a second byte in the range 0x20 to 0x2f, with\n   * the first byte being 0x11 (for data channel 1) or 0x19 (for data\n   * channel 2).\n   *\n   * @param  {Integer} char0 The first byte\n   * @param  {Integer} char1 The second byte\n   * @return {Boolean}       Whether the 2 bytes are a mid-row code\n   */\n\n\n  Cea608Stream.prototype.isMidRowCode = function (char0, char1) {\n    return char0 === this.EXT_ && char1 >= 0x20 && char1 <= 0x2f;\n  };\n  /**\n   * Detects if the 2-byte packet is an offset control code\n   *\n   * Offset control codes have a second byte in the range 0x21 to 0x23,\n   * with the first byte being 0x17 (for data channel 1) or 0x1f (for\n   * data channel 2).\n   *\n   * @param  {Integer} char0 The first byte\n   * @param  {Integer} char1 The second byte\n   * @return {Boolean}       Whether the 2 bytes are an offset control code\n   */\n\n\n  Cea608Stream.prototype.isOffsetControlCode = function (char0, char1) {\n    return char0 === this.OFFSET_ && char1 >= 0x21 && char1 <= 0x23;\n  };\n  /**\n   * Detects if the 2-byte packet is a Preamble Address Code\n   *\n   * PACs have a first byte in the range 0x10 to 0x17 (for data channel 1)\n   * or 0x18 to 0x1f (for data channel 2), with the second byte in the\n   * range 0x40 to 0x7f.\n   *\n   * @param  {Integer} char0 The first byte\n   * @param  {Integer} char1 The second byte\n   * @return {Boolean}       Whether the 2 bytes are a PAC\n   */\n\n\n  Cea608Stream.prototype.isPAC = function (char0, char1) {\n    return char0 >= this.BASE_ && char0 < this.BASE_ + 8 && char1 >= 0x40 && char1 <= 0x7f;\n  };\n  /**\n   * Detects if a packet's second byte is in the range of a PAC color code\n   *\n   * PAC color codes have the second byte be in the range 0x40 to 0x4f, or\n   * 0x60 to 0x6f.\n   *\n   * @param  {Integer} char1 The second byte\n   * @return {Boolean}       Whether the byte is a color PAC\n   */\n\n\n  Cea608Stream.prototype.isColorPAC = function (char1) {\n    return char1 >= 0x40 && char1 <= 0x4f || char1 >= 0x60 && char1 <= 0x7f;\n  };\n  /**\n   * Detects if a single byte is in the range of a normal character\n   *\n   * Normal text bytes are in the range 0x20 to 0x7f.\n   *\n   * @param  {Integer} char  The byte\n   * @return {Boolean}       Whether the byte is a normal character\n   */\n\n\n  Cea608Stream.prototype.isNormalChar = function (char) {\n    return char >= 0x20 && char <= 0x7f;\n  };\n  /**\n   * Configures roll-up\n   *\n   * @param  {Integer} pts         Current PTS\n   * @param  {Integer} newBaseRow  Used by PACs to slide the current window to\n   *                               a new position\n   */\n\n\n  Cea608Stream.prototype.setRollUp = function (pts, newBaseRow) {\n    // Reset the base row to the bottom row when switching modes\n    if (this.mode_ !== 'rollUp') {\n      this.row_ = BOTTOM_ROW;\n      this.mode_ = 'rollUp'; // Spec says to wipe memories when switching to roll-up\n\n      this.flushDisplayed(pts);\n      this.nonDisplayed_ = createDisplayBuffer();\n      this.displayed_ = createDisplayBuffer();\n    }\n\n    if (newBaseRow !== undefined && newBaseRow !== this.row_) {\n      // move currently displayed captions (up or down) to the new base row\n      for (var i = 0; i < this.rollUpRows_; i++) {\n        this.displayed_[newBaseRow - i] = this.displayed_[this.row_ - i];\n        this.displayed_[this.row_ - i] = '';\n      }\n    }\n\n    if (newBaseRow === undefined) {\n      newBaseRow = this.row_;\n    }\n\n    this.topRow_ = newBaseRow - this.rollUpRows_ + 1;\n  }; // Adds the opening HTML tag for the passed character to the caption text,\n  // and keeps track of it for later closing\n\n\n  Cea608Stream.prototype.addFormatting = function (pts, format) {\n    this.formatting_ = this.formatting_.concat(format);\n    var text = format.reduce(function (text, format) {\n      return text + '<' + format + '>';\n    }, '');\n    this[this.mode_](pts, text);\n  }; // Adds HTML closing tags for current formatting to caption text and\n  // clears remembered formatting\n\n\n  Cea608Stream.prototype.clearFormatting = function (pts) {\n    if (!this.formatting_.length) {\n      return;\n    }\n\n    var text = this.formatting_.reverse().reduce(function (text, format) {\n      return text + '</' + format + '>';\n    }, '');\n    this.formatting_ = [];\n    this[this.mode_](pts, text);\n  }; // Mode Implementations\n\n\n  Cea608Stream.prototype.popOn = function (pts, text) {\n    var baseRow = this.nonDisplayed_[this.row_]; // buffer characters\n\n    baseRow += text;\n    this.nonDisplayed_[this.row_] = baseRow;\n  };\n\n  Cea608Stream.prototype.rollUp = function (pts, text) {\n    var baseRow = this.displayed_[this.row_];\n    baseRow += text;\n    this.displayed_[this.row_] = baseRow;\n  };\n\n  Cea608Stream.prototype.shiftRowsUp_ = function () {\n    var i; // clear out inactive rows\n\n    for (i = 0; i < this.topRow_; i++) {\n      this.displayed_[i] = '';\n    }\n\n    for (i = this.row_ + 1; i < BOTTOM_ROW + 1; i++) {\n      this.displayed_[i] = '';\n    } // shift displayed rows up\n\n\n    for (i = this.topRow_; i < this.row_; i++) {\n      this.displayed_[i] = this.displayed_[i + 1];\n    } // clear out the bottom row\n\n\n    this.displayed_[this.row_] = '';\n  };\n\n  Cea608Stream.prototype.paintOn = function (pts, text) {\n    var baseRow = this.displayed_[this.row_];\n    baseRow += text;\n    this.displayed_[this.row_] = baseRow;\n  }; // exports\n\n\n  var captionStream = {\n    CaptionStream: CaptionStream$1,\n    Cea608Stream: Cea608Stream,\n    Cea708Stream: Cea708Stream\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var streamTypes = {\n    H264_STREAM_TYPE: 0x1B,\n    ADTS_STREAM_TYPE: 0x0F,\n    METADATA_STREAM_TYPE: 0x15\n  };\n\n  var MAX_TS = 8589934592;\n  var RO_THRESH = 4294967296;\n  var TYPE_SHARED = 'shared';\n\n  var handleRollover$1 = function handleRollover(value, reference) {\n    var direction = 1;\n\n    if (value > reference) {\n      // If the current timestamp value is greater than our reference timestamp and we detect a\n      // timestamp rollover, this means the roll over is happening in the opposite direction.\n      // Example scenario: Enter a long stream/video just after a rollover occurred. The reference\n      // point will be set to a small number, e.g. 1. The user then seeks backwards over the\n      // rollover point. In loading this segment, the timestamp values will be very large,\n      // e.g. 2^33 - 1. Since this comes before the data we loaded previously, we want to adjust\n      // the time stamp to be `value - 2^33`.\n      direction = -1;\n    } // Note: A seek forwards or back that is greater than the RO_THRESH (2^32, ~13 hours) will\n    // cause an incorrect adjustment.\n\n\n    while (Math.abs(reference - value) > RO_THRESH) {\n      value += direction * MAX_TS;\n    }\n\n    return value;\n  };\n\n  var TimestampRolloverStream$1 = function TimestampRolloverStream(type) {\n    var lastDTS, referenceDTS;\n    TimestampRolloverStream.prototype.init.call(this); // The \"shared\" type is used in cases where a stream will contain muxed\n    // video and audio. We could use `undefined` here, but having a string\n    // makes debugging a little clearer.\n\n    this.type_ = type || TYPE_SHARED;\n\n    this.push = function (data) {\n      // Any \"shared\" rollover streams will accept _all_ data. Otherwise,\n      // streams will only accept data that matches their type.\n      if (this.type_ !== TYPE_SHARED && data.type !== this.type_) {\n        return;\n      }\n\n      if (referenceDTS === undefined) {\n        referenceDTS = data.dts;\n      }\n\n      data.dts = handleRollover$1(data.dts, referenceDTS);\n      data.pts = handleRollover$1(data.pts, referenceDTS);\n      lastDTS = data.dts;\n      this.trigger('data', data);\n    };\n\n    this.flush = function () {\n      referenceDTS = lastDTS;\n      this.trigger('done');\n    };\n\n    this.endTimeline = function () {\n      this.flush();\n      this.trigger('endedtimeline');\n    };\n\n    this.discontinuity = function () {\n      referenceDTS = void 0;\n      lastDTS = void 0;\n    };\n\n    this.reset = function () {\n      this.discontinuity();\n      this.trigger('reset');\n    };\n  };\n\n  TimestampRolloverStream$1.prototype = new stream();\n  var timestampRolloverStream = {\n    TimestampRolloverStream: TimestampRolloverStream$1,\n    handleRollover: handleRollover$1\n  };\n\n  var percentEncode$1 = function percentEncode(bytes, start, end) {\n    var i,\n        result = '';\n\n    for (i = start; i < end; i++) {\n      result += '%' + ('00' + bytes[i].toString(16)).slice(-2);\n    }\n\n    return result;\n  },\n      // return the string representation of the specified byte range,\n  // interpreted as UTf-8.\n  parseUtf8 = function parseUtf8(bytes, start, end) {\n    return decodeURIComponent(percentEncode$1(bytes, start, end));\n  },\n      // return the string representation of the specified byte range,\n  // interpreted as ISO-8859-1.\n  parseIso88591$1 = function parseIso88591(bytes, start, end) {\n    return unescape(percentEncode$1(bytes, start, end)); // jshint ignore:line\n  },\n      parseSyncSafeInteger$1 = function parseSyncSafeInteger(data) {\n    return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];\n  },\n      tagParsers = {\n    TXXX: function TXXX(tag) {\n      var i;\n\n      if (tag.data[0] !== 3) {\n        // ignore frames with unrecognized character encodings\n        return;\n      }\n\n      for (i = 1; i < tag.data.length; i++) {\n        if (tag.data[i] === 0) {\n          // parse the text fields\n          tag.description = parseUtf8(tag.data, 1, i); // do not include the null terminator in the tag value\n\n          tag.value = parseUtf8(tag.data, i + 1, tag.data.length).replace(/\\0*$/, '');\n          break;\n        }\n      }\n\n      tag.data = tag.value;\n    },\n    WXXX: function WXXX(tag) {\n      var i;\n\n      if (tag.data[0] !== 3) {\n        // ignore frames with unrecognized character encodings\n        return;\n      }\n\n      for (i = 1; i < tag.data.length; i++) {\n        if (tag.data[i] === 0) {\n          // parse the description and URL fields\n          tag.description = parseUtf8(tag.data, 1, i);\n          tag.url = parseUtf8(tag.data, i + 1, tag.data.length);\n          break;\n        }\n      }\n    },\n    PRIV: function PRIV(tag) {\n      var i;\n\n      for (i = 0; i < tag.data.length; i++) {\n        if (tag.data[i] === 0) {\n          // parse the description and URL fields\n          tag.owner = parseIso88591$1(tag.data, 0, i);\n          break;\n        }\n      }\n\n      tag.privateData = tag.data.subarray(i + 1);\n      tag.data = tag.privateData;\n    }\n  },\n      _MetadataStream;\n\n  _MetadataStream = function MetadataStream(options) {\n    var settings = {\n      // the bytes of the program-level descriptor field in MP2T\n      // see ISO/IEC 13818-1:2013 (E), section 2.6 \"Program and\n      // program element descriptors\"\n      descriptor: options && options.descriptor\n    },\n        // the total size in bytes of the ID3 tag being parsed\n    tagSize = 0,\n        // tag data that is not complete enough to be parsed\n    buffer = [],\n        // the total number of bytes currently in the buffer\n    bufferSize = 0,\n        i;\n\n    _MetadataStream.prototype.init.call(this); // calculate the text track in-band metadata track dispatch type\n    // https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track\n\n\n    this.dispatchType = streamTypes.METADATA_STREAM_TYPE.toString(16);\n\n    if (settings.descriptor) {\n      for (i = 0; i < settings.descriptor.length; i++) {\n        this.dispatchType += ('00' + settings.descriptor[i].toString(16)).slice(-2);\n      }\n    }\n\n    this.push = function (chunk) {\n      var tag, frameStart, frameSize, frame, i, frameHeader;\n\n      if (chunk.type !== 'timed-metadata') {\n        return;\n      } // if data_alignment_indicator is set in the PES header,\n      // we must have the start of a new ID3 tag. Assume anything\n      // remaining in the buffer was malformed and throw it out\n\n\n      if (chunk.dataAlignmentIndicator) {\n        bufferSize = 0;\n        buffer.length = 0;\n      } // ignore events that don't look like ID3 data\n\n\n      if (buffer.length === 0 && (chunk.data.length < 10 || chunk.data[0] !== 'I'.charCodeAt(0) || chunk.data[1] !== 'D'.charCodeAt(0) || chunk.data[2] !== '3'.charCodeAt(0))) {\n        this.trigger('log', {\n          level: 'warn',\n          message: 'Skipping unrecognized metadata packet'\n        });\n        return;\n      } // add this chunk to the data we've collected so far\n\n\n      buffer.push(chunk);\n      bufferSize += chunk.data.byteLength; // grab the size of the entire frame from the ID3 header\n\n      if (buffer.length === 1) {\n        // the frame size is transmitted as a 28-bit integer in the\n        // last four bytes of the ID3 header.\n        // The most significant bit of each byte is dropped and the\n        // results concatenated to recover the actual value.\n        tagSize = parseSyncSafeInteger$1(chunk.data.subarray(6, 10)); // ID3 reports the tag size excluding the header but it's more\n        // convenient for our comparisons to include it\n\n        tagSize += 10;\n      } // if the entire frame has not arrived, wait for more data\n\n\n      if (bufferSize < tagSize) {\n        return;\n      } // collect the entire frame so it can be parsed\n\n\n      tag = {\n        data: new Uint8Array(tagSize),\n        frames: [],\n        pts: buffer[0].pts,\n        dts: buffer[0].dts\n      };\n\n      for (i = 0; i < tagSize;) {\n        tag.data.set(buffer[0].data.subarray(0, tagSize - i), i);\n        i += buffer[0].data.byteLength;\n        bufferSize -= buffer[0].data.byteLength;\n        buffer.shift();\n      } // find the start of the first frame and the end of the tag\n\n\n      frameStart = 10;\n\n      if (tag.data[5] & 0x40) {\n        // advance the frame start past the extended header\n        frameStart += 4; // header size field\n\n        frameStart += parseSyncSafeInteger$1(tag.data.subarray(10, 14)); // clip any padding off the end\n\n        tagSize -= parseSyncSafeInteger$1(tag.data.subarray(16, 20));\n      } // parse one or more ID3 frames\n      // http://id3.org/id3v2.3.0#ID3v2_frame_overview\n\n\n      do {\n        // determine the number of bytes in this frame\n        frameSize = parseSyncSafeInteger$1(tag.data.subarray(frameStart + 4, frameStart + 8));\n\n        if (frameSize < 1) {\n          this.trigger('log', {\n            level: 'warn',\n            message: 'Malformed ID3 frame encountered. Skipping metadata parsing.'\n          });\n          return;\n        }\n\n        frameHeader = String.fromCharCode(tag.data[frameStart], tag.data[frameStart + 1], tag.data[frameStart + 2], tag.data[frameStart + 3]);\n        frame = {\n          id: frameHeader,\n          data: tag.data.subarray(frameStart + 10, frameStart + frameSize + 10)\n        };\n        frame.key = frame.id;\n\n        if (tagParsers[frame.id]) {\n          tagParsers[frame.id](frame); // handle the special PRIV frame used to indicate the start\n          // time for raw AAC data\n\n          if (frame.owner === 'com.apple.streaming.transportStreamTimestamp') {\n            var d = frame.data,\n                size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;\n            size *= 4;\n            size += d[7] & 0x03;\n            frame.timeStamp = size; // in raw AAC, all subsequent data will be timestamped based\n            // on the value of this frame\n            // we couldn't have known the appropriate pts and dts before\n            // parsing this ID3 tag so set those values now\n\n            if (tag.pts === undefined && tag.dts === undefined) {\n              tag.pts = frame.timeStamp;\n              tag.dts = frame.timeStamp;\n            }\n\n            this.trigger('timestamp', frame);\n          }\n        }\n\n        tag.frames.push(frame);\n        frameStart += 10; // advance past the frame header\n\n        frameStart += frameSize; // advance past the frame body\n      } while (frameStart < tagSize);\n\n      this.trigger('data', tag);\n    };\n  };\n\n  _MetadataStream.prototype = new stream();\n  var metadataStream = _MetadataStream;\n\n  var TimestampRolloverStream = timestampRolloverStream.TimestampRolloverStream; // object types\n\n  var _TransportPacketStream, _TransportParseStream, _ElementaryStream; // constants\n\n\n  var MP2T_PACKET_LENGTH$1 = 188,\n      // bytes\n  SYNC_BYTE$1 = 0x47;\n  /**\n   * Splits an incoming stream of binary data into MPEG-2 Transport\n   * Stream packets.\n   */\n\n  _TransportPacketStream = function TransportPacketStream() {\n    var buffer = new Uint8Array(MP2T_PACKET_LENGTH$1),\n        bytesInBuffer = 0;\n\n    _TransportPacketStream.prototype.init.call(this); // Deliver new bytes to the stream.\n\n    /**\n     * Split a stream of data into M2TS packets\n    **/\n\n\n    this.push = function (bytes) {\n      var startIndex = 0,\n          endIndex = MP2T_PACKET_LENGTH$1,\n          everything; // If there are bytes remaining from the last segment, prepend them to the\n      // bytes that were pushed in\n\n      if (bytesInBuffer) {\n        everything = new Uint8Array(bytes.byteLength + bytesInBuffer);\n        everything.set(buffer.subarray(0, bytesInBuffer));\n        everything.set(bytes, bytesInBuffer);\n        bytesInBuffer = 0;\n      } else {\n        everything = bytes;\n      } // While we have enough data for a packet\n\n\n      while (endIndex < everything.byteLength) {\n        // Look for a pair of start and end sync bytes in the data..\n        if (everything[startIndex] === SYNC_BYTE$1 && everything[endIndex] === SYNC_BYTE$1) {\n          // We found a packet so emit it and jump one whole packet forward in\n          // the stream\n          this.trigger('data', everything.subarray(startIndex, endIndex));\n          startIndex += MP2T_PACKET_LENGTH$1;\n          endIndex += MP2T_PACKET_LENGTH$1;\n          continue;\n        } // If we get here, we have somehow become de-synchronized and we need to step\n        // forward one byte at a time until we find a pair of sync bytes that denote\n        // a packet\n\n\n        startIndex++;\n        endIndex++;\n      } // If there was some data left over at the end of the segment that couldn't\n      // possibly be a whole packet, keep it because it might be the start of a packet\n      // that continues in the next segment\n\n\n      if (startIndex < everything.byteLength) {\n        buffer.set(everything.subarray(startIndex), 0);\n        bytesInBuffer = everything.byteLength - startIndex;\n      }\n    };\n    /**\n     * Passes identified M2TS packets to the TransportParseStream to be parsed\n    **/\n\n\n    this.flush = function () {\n      // If the buffer contains a whole packet when we are being flushed, emit it\n      // and empty the buffer. Otherwise hold onto the data because it may be\n      // important for decoding the next segment\n      if (bytesInBuffer === MP2T_PACKET_LENGTH$1 && buffer[0] === SYNC_BYTE$1) {\n        this.trigger('data', buffer);\n        bytesInBuffer = 0;\n      }\n\n      this.trigger('done');\n    };\n\n    this.endTimeline = function () {\n      this.flush();\n      this.trigger('endedtimeline');\n    };\n\n    this.reset = function () {\n      bytesInBuffer = 0;\n      this.trigger('reset');\n    };\n  };\n\n  _TransportPacketStream.prototype = new stream();\n  /**\n   * Accepts an MP2T TransportPacketStream and emits data events with parsed\n   * forms of the individual transport stream packets.\n   */\n\n  _TransportParseStream = function TransportParseStream() {\n    var parsePsi, parsePat, parsePmt, self;\n\n    _TransportParseStream.prototype.init.call(this);\n\n    self = this;\n    this.packetsWaitingForPmt = [];\n    this.programMapTable = undefined;\n\n    parsePsi = function parsePsi(payload, psi) {\n      var offset = 0; // PSI packets may be split into multiple sections and those\n      // sections may be split into multiple packets. If a PSI\n      // section starts in this packet, the payload_unit_start_indicator\n      // will be true and the first byte of the payload will indicate\n      // the offset from the current position to the start of the\n      // section.\n\n      if (psi.payloadUnitStartIndicator) {\n        offset += payload[offset] + 1;\n      }\n\n      if (psi.type === 'pat') {\n        parsePat(payload.subarray(offset), psi);\n      } else {\n        parsePmt(payload.subarray(offset), psi);\n      }\n    };\n\n    parsePat = function parsePat(payload, pat) {\n      pat.section_number = payload[7]; // eslint-disable-line camelcase\n\n      pat.last_section_number = payload[8]; // eslint-disable-line camelcase\n      // skip the PSI header and parse the first PMT entry\n\n      self.pmtPid = (payload[10] & 0x1F) << 8 | payload[11];\n      pat.pmtPid = self.pmtPid;\n    };\n    /**\n     * Parse out the relevant fields of a Program Map Table (PMT).\n     * @param payload {Uint8Array} the PMT-specific portion of an MP2T\n     * packet. The first byte in this array should be the table_id\n     * field.\n     * @param pmt {object} the object that should be decorated with\n     * fields parsed from the PMT.\n     */\n\n\n    parsePmt = function parsePmt(payload, pmt) {\n      var sectionLength, tableEnd, programInfoLength, offset; // PMTs can be sent ahead of the time when they should actually\n      // take effect. We don't believe this should ever be the case\n      // for HLS but we'll ignore \"forward\" PMT declarations if we see\n      // them. Future PMT declarations have the current_next_indicator\n      // set to zero.\n\n      if (!(payload[5] & 0x01)) {\n        return;\n      } // overwrite any existing program map table\n\n\n      self.programMapTable = {\n        video: null,\n        audio: null,\n        'timed-metadata': {}\n      }; // the mapping table ends at the end of the current section\n\n      sectionLength = (payload[1] & 0x0f) << 8 | payload[2];\n      tableEnd = 3 + sectionLength - 4; // to determine where the table is, we have to figure out how\n      // long the program info descriptors are\n\n      programInfoLength = (payload[10] & 0x0f) << 8 | payload[11]; // advance the offset to the first entry in the mapping table\n\n      offset = 12 + programInfoLength;\n\n      while (offset < tableEnd) {\n        var streamType = payload[offset];\n        var pid = (payload[offset + 1] & 0x1F) << 8 | payload[offset + 2]; // only map a single elementary_pid for audio and video stream types\n        // TODO: should this be done for metadata too? for now maintain behavior of\n        //       multiple metadata streams\n\n        if (streamType === streamTypes.H264_STREAM_TYPE && self.programMapTable.video === null) {\n          self.programMapTable.video = pid;\n        } else if (streamType === streamTypes.ADTS_STREAM_TYPE && self.programMapTable.audio === null) {\n          self.programMapTable.audio = pid;\n        } else if (streamType === streamTypes.METADATA_STREAM_TYPE) {\n          // map pid to stream type for metadata streams\n          self.programMapTable['timed-metadata'][pid] = streamType;\n        } // move to the next table entry\n        // skip past the elementary stream descriptors, if present\n\n\n        offset += ((payload[offset + 3] & 0x0F) << 8 | payload[offset + 4]) + 5;\n      } // record the map on the packet as well\n\n\n      pmt.programMapTable = self.programMapTable;\n    };\n    /**\n     * Deliver a new MP2T packet to the next stream in the pipeline.\n     */\n\n\n    this.push = function (packet) {\n      var result = {},\n          offset = 4;\n      result.payloadUnitStartIndicator = !!(packet[1] & 0x40); // pid is a 13-bit field starting at the last bit of packet[1]\n\n      result.pid = packet[1] & 0x1f;\n      result.pid <<= 8;\n      result.pid |= packet[2]; // if an adaption field is present, its length is specified by the\n      // fifth byte of the TS packet header. The adaptation field is\n      // used to add stuffing to PES packets that don't fill a complete\n      // TS packet, and to specify some forms of timing and control data\n      // that we do not currently use.\n\n      if ((packet[3] & 0x30) >>> 4 > 0x01) {\n        offset += packet[offset] + 1;\n      } // parse the rest of the packet based on the type\n\n\n      if (result.pid === 0) {\n        result.type = 'pat';\n        parsePsi(packet.subarray(offset), result);\n        this.trigger('data', result);\n      } else if (result.pid === this.pmtPid) {\n        result.type = 'pmt';\n        parsePsi(packet.subarray(offset), result);\n        this.trigger('data', result); // if there are any packets waiting for a PMT to be found, process them now\n\n        while (this.packetsWaitingForPmt.length) {\n          this.processPes_.apply(this, this.packetsWaitingForPmt.shift());\n        }\n      } else if (this.programMapTable === undefined) {\n        // When we have not seen a PMT yet, defer further processing of\n        // PES packets until one has been parsed\n        this.packetsWaitingForPmt.push([packet, offset, result]);\n      } else {\n        this.processPes_(packet, offset, result);\n      }\n    };\n\n    this.processPes_ = function (packet, offset, result) {\n      // set the appropriate stream type\n      if (result.pid === this.programMapTable.video) {\n        result.streamType = streamTypes.H264_STREAM_TYPE;\n      } else if (result.pid === this.programMapTable.audio) {\n        result.streamType = streamTypes.ADTS_STREAM_TYPE;\n      } else {\n        // if not video or audio, it is timed-metadata or unknown\n        // if unknown, streamType will be undefined\n        result.streamType = this.programMapTable['timed-metadata'][result.pid];\n      }\n\n      result.type = 'pes';\n      result.data = packet.subarray(offset);\n      this.trigger('data', result);\n    };\n  };\n\n  _TransportParseStream.prototype = new stream();\n  _TransportParseStream.STREAM_TYPES = {\n    h264: 0x1b,\n    adts: 0x0f\n  };\n  /**\n   * Reconsistutes program elementary stream (PES) packets from parsed\n   * transport stream packets. That is, if you pipe an\n   * mp2t.TransportParseStream into a mp2t.ElementaryStream, the output\n   * events will be events which capture the bytes for individual PES\n   * packets plus relevant metadata that has been extracted from the\n   * container.\n   */\n\n  _ElementaryStream = function ElementaryStream() {\n    var self = this,\n        segmentHadPmt = false,\n        // PES packet fragments\n    video = {\n      data: [],\n      size: 0\n    },\n        audio = {\n      data: [],\n      size: 0\n    },\n        timedMetadata = {\n      data: [],\n      size: 0\n    },\n        programMapTable,\n        parsePes = function parsePes(payload, pes) {\n      var ptsDtsFlags;\n      var startPrefix = payload[0] << 16 | payload[1] << 8 | payload[2]; // default to an empty array\n\n      pes.data = new Uint8Array(); // In certain live streams, the start of a TS fragment has ts packets\n      // that are frame data that is continuing from the previous fragment. This\n      // is to check that the pes data is the start of a new pes payload\n\n      if (startPrefix !== 1) {\n        return;\n      } // get the packet length, this will be 0 for video\n\n\n      pes.packetLength = 6 + (payload[4] << 8 | payload[5]); // find out if this packets starts a new keyframe\n\n      pes.dataAlignmentIndicator = (payload[6] & 0x04) !== 0; // PES packets may be annotated with a PTS value, or a PTS value\n      // and a DTS value. Determine what combination of values is\n      // available to work with.\n\n      ptsDtsFlags = payload[7]; // PTS and DTS are normally stored as a 33-bit number.  Javascript\n      // performs all bitwise operations on 32-bit integers but javascript\n      // supports a much greater range (52-bits) of integer using standard\n      // mathematical operations.\n      // We construct a 31-bit value using bitwise operators over the 31\n      // most significant bits and then multiply by 4 (equal to a left-shift\n      // of 2) before we add the final 2 least significant bits of the\n      // timestamp (equal to an OR.)\n\n      if (ptsDtsFlags & 0xC0) {\n        // the PTS and DTS are not written out directly. For information\n        // on how they are encoded, see\n        // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html\n        pes.pts = (payload[9] & 0x0E) << 27 | (payload[10] & 0xFF) << 20 | (payload[11] & 0xFE) << 12 | (payload[12] & 0xFF) << 5 | (payload[13] & 0xFE) >>> 3;\n        pes.pts *= 4; // Left shift by 2\n\n        pes.pts += (payload[13] & 0x06) >>> 1; // OR by the two LSBs\n\n        pes.dts = pes.pts;\n\n        if (ptsDtsFlags & 0x40) {\n          pes.dts = (payload[14] & 0x0E) << 27 | (payload[15] & 0xFF) << 20 | (payload[16] & 0xFE) << 12 | (payload[17] & 0xFF) << 5 | (payload[18] & 0xFE) >>> 3;\n          pes.dts *= 4; // Left shift by 2\n\n          pes.dts += (payload[18] & 0x06) >>> 1; // OR by the two LSBs\n        }\n      } // the data section starts immediately after the PES header.\n      // pes_header_data_length specifies the number of header bytes\n      // that follow the last byte of the field.\n\n\n      pes.data = payload.subarray(9 + payload[8]);\n    },\n\n    /**\n      * Pass completely parsed PES packets to the next stream in the pipeline\n     **/\n    flushStream = function flushStream(stream, type, forceFlush) {\n      var packetData = new Uint8Array(stream.size),\n          event = {\n        type: type\n      },\n          i = 0,\n          offset = 0,\n          packetFlushable = false,\n          fragment; // do nothing if there is not enough buffered data for a complete\n      // PES header\n\n      if (!stream.data.length || stream.size < 9) {\n        return;\n      }\n\n      event.trackId = stream.data[0].pid; // reassemble the packet\n\n      for (i = 0; i < stream.data.length; i++) {\n        fragment = stream.data[i];\n        packetData.set(fragment.data, offset);\n        offset += fragment.data.byteLength;\n      } // parse assembled packet's PES header\n\n\n      parsePes(packetData, event); // non-video PES packets MUST have a non-zero PES_packet_length\n      // check that there is enough stream data to fill the packet\n\n      packetFlushable = type === 'video' || event.packetLength <= stream.size; // flush pending packets if the conditions are right\n\n      if (forceFlush || packetFlushable) {\n        stream.size = 0;\n        stream.data.length = 0;\n      } // only emit packets that are complete. this is to avoid assembling\n      // incomplete PES packets due to poor segmentation\n\n\n      if (packetFlushable) {\n        self.trigger('data', event);\n      }\n    };\n\n    _ElementaryStream.prototype.init.call(this);\n    /**\n     * Identifies M2TS packet types and parses PES packets using metadata\n     * parsed from the PMT\n     **/\n\n\n    this.push = function (data) {\n      ({\n        pat: function pat() {// we have to wait for the PMT to arrive as well before we\n          // have any meaningful metadata\n        },\n        pes: function pes() {\n          var stream, streamType;\n\n          switch (data.streamType) {\n            case streamTypes.H264_STREAM_TYPE:\n              stream = video;\n              streamType = 'video';\n              break;\n\n            case streamTypes.ADTS_STREAM_TYPE:\n              stream = audio;\n              streamType = 'audio';\n              break;\n\n            case streamTypes.METADATA_STREAM_TYPE:\n              stream = timedMetadata;\n              streamType = 'timed-metadata';\n              break;\n\n            default:\n              // ignore unknown stream types\n              return;\n          } // if a new packet is starting, we can flush the completed\n          // packet\n\n\n          if (data.payloadUnitStartIndicator) {\n            flushStream(stream, streamType, true);\n          } // buffer this fragment until we are sure we've received the\n          // complete payload\n\n\n          stream.data.push(data);\n          stream.size += data.data.byteLength;\n        },\n        pmt: function pmt() {\n          var event = {\n            type: 'metadata',\n            tracks: []\n          };\n          programMapTable = data.programMapTable; // translate audio and video streams to tracks\n\n          if (programMapTable.video !== null) {\n            event.tracks.push({\n              timelineStartInfo: {\n                baseMediaDecodeTime: 0\n              },\n              id: +programMapTable.video,\n              codec: 'avc',\n              type: 'video'\n            });\n          }\n\n          if (programMapTable.audio !== null) {\n            event.tracks.push({\n              timelineStartInfo: {\n                baseMediaDecodeTime: 0\n              },\n              id: +programMapTable.audio,\n              codec: 'adts',\n              type: 'audio'\n            });\n          }\n\n          segmentHadPmt = true;\n          self.trigger('data', event);\n        }\n      })[data.type]();\n    };\n\n    this.reset = function () {\n      video.size = 0;\n      video.data.length = 0;\n      audio.size = 0;\n      audio.data.length = 0;\n      this.trigger('reset');\n    };\n    /**\n     * Flush any remaining input. Video PES packets may be of variable\n     * length. Normally, the start of a new video packet can trigger the\n     * finalization of the previous packet. That is not possible if no\n     * more video is forthcoming, however. In that case, some other\n     * mechanism (like the end of the file) has to be employed. When it is\n     * clear that no additional data is forthcoming, calling this method\n     * will flush the buffered packets.\n     */\n\n\n    this.flushStreams_ = function () {\n      // !!THIS ORDER IS IMPORTANT!!\n      // video first then audio\n      flushStream(video, 'video');\n      flushStream(audio, 'audio');\n      flushStream(timedMetadata, 'timed-metadata');\n    };\n\n    this.flush = function () {\n      // if on flush we haven't had a pmt emitted\n      // and we have a pmt to emit. emit the pmt\n      // so that we trigger a trackinfo downstream.\n      if (!segmentHadPmt && programMapTable) {\n        var pmt = {\n          type: 'metadata',\n          tracks: []\n        }; // translate audio and video streams to tracks\n\n        if (programMapTable.video !== null) {\n          pmt.tracks.push({\n            timelineStartInfo: {\n              baseMediaDecodeTime: 0\n            },\n            id: +programMapTable.video,\n            codec: 'avc',\n            type: 'video'\n          });\n        }\n\n        if (programMapTable.audio !== null) {\n          pmt.tracks.push({\n            timelineStartInfo: {\n              baseMediaDecodeTime: 0\n            },\n            id: +programMapTable.audio,\n            codec: 'adts',\n            type: 'audio'\n          });\n        }\n\n        self.trigger('data', pmt);\n      }\n\n      segmentHadPmt = false;\n      this.flushStreams_();\n      this.trigger('done');\n    };\n  };\n\n  _ElementaryStream.prototype = new stream();\n  var m2ts$1 = {\n    PAT_PID: 0x0000,\n    MP2T_PACKET_LENGTH: MP2T_PACKET_LENGTH$1,\n    TransportPacketStream: _TransportPacketStream,\n    TransportParseStream: _TransportParseStream,\n    ElementaryStream: _ElementaryStream,\n    TimestampRolloverStream: TimestampRolloverStream,\n    CaptionStream: captionStream.CaptionStream,\n    Cea608Stream: captionStream.Cea608Stream,\n    Cea708Stream: captionStream.Cea708Stream,\n    MetadataStream: metadataStream\n  };\n\n  for (var type in streamTypes) {\n    if (streamTypes.hasOwnProperty(type)) {\n      m2ts$1[type] = streamTypes[type];\n    }\n  }\n\n  var m2ts_1 = m2ts$1;\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   *\n   * Utilities to detect basic properties and metadata about Aac data.\n   */\n\n  var ADTS_SAMPLING_FREQUENCIES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];\n\n  var parseId3TagSize = function parseId3TagSize(header, byteIndex) {\n    var returnSize = header[byteIndex + 6] << 21 | header[byteIndex + 7] << 14 | header[byteIndex + 8] << 7 | header[byteIndex + 9],\n        flags = header[byteIndex + 5],\n        footerPresent = (flags & 16) >> 4; // if we get a negative returnSize clamp it to 0\n\n    returnSize = returnSize >= 0 ? returnSize : 0;\n\n    if (footerPresent) {\n      return returnSize + 20;\n    }\n\n    return returnSize + 10;\n  };\n\n  var getId3Offset = function getId3Offset(data, offset) {\n    if (data.length - offset < 10 || data[offset] !== 'I'.charCodeAt(0) || data[offset + 1] !== 'D'.charCodeAt(0) || data[offset + 2] !== '3'.charCodeAt(0)) {\n      return offset;\n    }\n\n    offset += parseId3TagSize(data, offset);\n    return getId3Offset(data, offset);\n  }; // TODO: use vhs-utils\n\n\n  var isLikelyAacData$2 = function isLikelyAacData(data) {\n    var offset = getId3Offset(data, 0);\n    return data.length >= offset + 2 && (data[offset] & 0xFF) === 0xFF && (data[offset + 1] & 0xF0) === 0xF0 && // verify that the 2 layer bits are 0, aka this\n    // is not mp3 data but aac data.\n    (data[offset + 1] & 0x16) === 0x10;\n  };\n\n  var parseSyncSafeInteger = function parseSyncSafeInteger(data) {\n    return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];\n  }; // return a percent-encoded representation of the specified byte range\n  // @see http://en.wikipedia.org/wiki/Percent-encoding\n\n\n  var percentEncode = function percentEncode(bytes, start, end) {\n    var i,\n        result = '';\n\n    for (i = start; i < end; i++) {\n      result += '%' + ('00' + bytes[i].toString(16)).slice(-2);\n    }\n\n    return result;\n  }; // return the string representation of the specified byte range,\n  // interpreted as ISO-8859-1.\n\n\n  var parseIso88591 = function parseIso88591(bytes, start, end) {\n    return unescape(percentEncode(bytes, start, end)); // jshint ignore:line\n  };\n\n  var parseAdtsSize = function parseAdtsSize(header, byteIndex) {\n    var lowThree = (header[byteIndex + 5] & 0xE0) >> 5,\n        middle = header[byteIndex + 4] << 3,\n        highTwo = header[byteIndex + 3] & 0x3 << 11;\n    return highTwo | middle | lowThree;\n  };\n\n  var parseType$1 = function parseType(header, byteIndex) {\n    if (header[byteIndex] === 'I'.charCodeAt(0) && header[byteIndex + 1] === 'D'.charCodeAt(0) && header[byteIndex + 2] === '3'.charCodeAt(0)) {\n      return 'timed-metadata';\n    } else if (header[byteIndex] & 0xff === 0xff && (header[byteIndex + 1] & 0xf0) === 0xf0) {\n      return 'audio';\n    }\n\n    return null;\n  };\n\n  var parseSampleRate = function parseSampleRate(packet) {\n    var i = 0;\n\n    while (i + 5 < packet.length) {\n      if (packet[i] !== 0xFF || (packet[i + 1] & 0xF6) !== 0xF0) {\n        // If a valid header was not found,  jump one forward and attempt to\n        // find a valid ADTS header starting at the next byte\n        i++;\n        continue;\n      }\n\n      return ADTS_SAMPLING_FREQUENCIES[(packet[i + 2] & 0x3c) >>> 2];\n    }\n\n    return null;\n  };\n\n  var parseAacTimestamp = function parseAacTimestamp(packet) {\n    var frameStart, frameSize, frame, frameHeader; // find the start of the first frame and the end of the tag\n\n    frameStart = 10;\n\n    if (packet[5] & 0x40) {\n      // advance the frame start past the extended header\n      frameStart += 4; // header size field\n\n      frameStart += parseSyncSafeInteger(packet.subarray(10, 14));\n    } // parse one or more ID3 frames\n    // http://id3.org/id3v2.3.0#ID3v2_frame_overview\n\n\n    do {\n      // determine the number of bytes in this frame\n      frameSize = parseSyncSafeInteger(packet.subarray(frameStart + 4, frameStart + 8));\n\n      if (frameSize < 1) {\n        return null;\n      }\n\n      frameHeader = String.fromCharCode(packet[frameStart], packet[frameStart + 1], packet[frameStart + 2], packet[frameStart + 3]);\n\n      if (frameHeader === 'PRIV') {\n        frame = packet.subarray(frameStart + 10, frameStart + frameSize + 10);\n\n        for (var i = 0; i < frame.byteLength; i++) {\n          if (frame[i] === 0) {\n            var owner = parseIso88591(frame, 0, i);\n\n            if (owner === 'com.apple.streaming.transportStreamTimestamp') {\n              var d = frame.subarray(i + 1);\n              var size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;\n              size *= 4;\n              size += d[7] & 0x03;\n              return size;\n            }\n\n            break;\n          }\n        }\n      }\n\n      frameStart += 10; // advance past the frame header\n\n      frameStart += frameSize; // advance past the frame body\n    } while (frameStart < packet.byteLength);\n\n    return null;\n  };\n\n  var utils = {\n    isLikelyAacData: isLikelyAacData$2,\n    parseId3TagSize: parseId3TagSize,\n    parseAdtsSize: parseAdtsSize,\n    parseType: parseType$1,\n    parseSampleRate: parseSampleRate,\n    parseAacTimestamp: parseAacTimestamp\n  };\n\n  var _AacStream;\n  /**\n   * Splits an incoming stream of binary data into ADTS and ID3 Frames.\n   */\n\n\n  _AacStream = function AacStream() {\n    var everything = new Uint8Array(),\n        timeStamp = 0;\n\n    _AacStream.prototype.init.call(this);\n\n    this.setTimestamp = function (timestamp) {\n      timeStamp = timestamp;\n    };\n\n    this.push = function (bytes) {\n      var frameSize = 0,\n          byteIndex = 0,\n          bytesLeft,\n          chunk,\n          packet,\n          tempLength; // If there are bytes remaining from the last segment, prepend them to the\n      // bytes that were pushed in\n\n      if (everything.length) {\n        tempLength = everything.length;\n        everything = new Uint8Array(bytes.byteLength + tempLength);\n        everything.set(everything.subarray(0, tempLength));\n        everything.set(bytes, tempLength);\n      } else {\n        everything = bytes;\n      }\n\n      while (everything.length - byteIndex >= 3) {\n        if (everything[byteIndex] === 'I'.charCodeAt(0) && everything[byteIndex + 1] === 'D'.charCodeAt(0) && everything[byteIndex + 2] === '3'.charCodeAt(0)) {\n          // Exit early because we don't have enough to parse\n          // the ID3 tag header\n          if (everything.length - byteIndex < 10) {\n            break;\n          } // check framesize\n\n\n          frameSize = utils.parseId3TagSize(everything, byteIndex); // Exit early if we don't have enough in the buffer\n          // to emit a full packet\n          // Add to byteIndex to support multiple ID3 tags in sequence\n\n          if (byteIndex + frameSize > everything.length) {\n            break;\n          }\n\n          chunk = {\n            type: 'timed-metadata',\n            data: everything.subarray(byteIndex, byteIndex + frameSize)\n          };\n          this.trigger('data', chunk);\n          byteIndex += frameSize;\n          continue;\n        } else if ((everything[byteIndex] & 0xff) === 0xff && (everything[byteIndex + 1] & 0xf0) === 0xf0) {\n          // Exit early because we don't have enough to parse\n          // the ADTS frame header\n          if (everything.length - byteIndex < 7) {\n            break;\n          }\n\n          frameSize = utils.parseAdtsSize(everything, byteIndex); // Exit early if we don't have enough in the buffer\n          // to emit a full packet\n\n          if (byteIndex + frameSize > everything.length) {\n            break;\n          }\n\n          packet = {\n            type: 'audio',\n            data: everything.subarray(byteIndex, byteIndex + frameSize),\n            pts: timeStamp,\n            dts: timeStamp\n          };\n          this.trigger('data', packet);\n          byteIndex += frameSize;\n          continue;\n        }\n\n        byteIndex++;\n      }\n\n      bytesLeft = everything.length - byteIndex;\n\n      if (bytesLeft > 0) {\n        everything = everything.subarray(byteIndex);\n      } else {\n        everything = new Uint8Array();\n      }\n    };\n\n    this.reset = function () {\n      everything = new Uint8Array();\n      this.trigger('reset');\n    };\n\n    this.endTimeline = function () {\n      everything = new Uint8Array();\n      this.trigger('endedtimeline');\n    };\n  };\n\n  _AacStream.prototype = new stream();\n  var aac = _AacStream;\n\n  // constants\n  var AUDIO_PROPERTIES = ['audioobjecttype', 'channelcount', 'samplerate', 'samplingfrequencyindex', 'samplesize'];\n  var audioProperties = AUDIO_PROPERTIES;\n\n  var VIDEO_PROPERTIES = ['width', 'height', 'profileIdc', 'levelIdc', 'profileCompatibility', 'sarRatio'];\n  var videoProperties = VIDEO_PROPERTIES;\n\n  var H264Stream$1 = h264.H264Stream;\n  var isLikelyAacData$1 = utils.isLikelyAacData;\n  var ONE_SECOND_IN_TS$2 = clock.ONE_SECOND_IN_TS; // object types\n\n  var _VideoSegmentStream$1, _AudioSegmentStream$1, _Transmuxer$1, _CoalesceStream;\n  /**\n   * Compare two arrays (even typed) for same-ness\n   */\n\n\n  var arrayEquals = function arrayEquals(a, b) {\n    var i;\n\n    if (a.length !== b.length) {\n      return false;\n    } // compare the value of each element in the array\n\n\n    for (i = 0; i < a.length; i++) {\n      if (a[i] !== b[i]) {\n        return false;\n      }\n    }\n\n    return true;\n  };\n\n  var generateSegmentTimingInfo = function generateSegmentTimingInfo(baseMediaDecodeTime, startDts, startPts, endDts, endPts, prependedContentDuration) {\n    var ptsOffsetFromDts = startPts - startDts,\n        decodeDuration = endDts - startDts,\n        presentationDuration = endPts - startPts; // The PTS and DTS values are based on the actual stream times from the segment,\n    // however, the player time values will reflect a start from the baseMediaDecodeTime.\n    // In order to provide relevant values for the player times, base timing info on the\n    // baseMediaDecodeTime and the DTS and PTS durations of the segment.\n\n    return {\n      start: {\n        dts: baseMediaDecodeTime,\n        pts: baseMediaDecodeTime + ptsOffsetFromDts\n      },\n      end: {\n        dts: baseMediaDecodeTime + decodeDuration,\n        pts: baseMediaDecodeTime + presentationDuration\n      },\n      prependedContentDuration: prependedContentDuration,\n      baseMediaDecodeTime: baseMediaDecodeTime\n    };\n  };\n  /**\n   * Constructs a single-track, ISO BMFF media segment from AAC data\n   * events. The output of this stream can be fed to a SourceBuffer\n   * configured with a suitable initialization segment.\n   * @param track {object} track metadata configuration\n   * @param options {object} transmuxer options object\n   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps\n   *        in the source; false to adjust the first segment to start at 0.\n   */\n\n\n  _AudioSegmentStream$1 = function AudioSegmentStream(track, options) {\n    var adtsFrames = [],\n        sequenceNumber,\n        earliestAllowedDts = 0,\n        audioAppendStartTs = 0,\n        videoBaseMediaDecodeTime = Infinity;\n    options = options || {};\n    sequenceNumber = options.firstSequenceNumber || 0;\n\n    _AudioSegmentStream$1.prototype.init.call(this);\n\n    this.push = function (data) {\n      trackDecodeInfo.collectDtsInfo(track, data);\n\n      if (track) {\n        audioProperties.forEach(function (prop) {\n          track[prop] = data[prop];\n        });\n      } // buffer audio data until end() is called\n\n\n      adtsFrames.push(data);\n    };\n\n    this.setEarliestDts = function (earliestDts) {\n      earliestAllowedDts = earliestDts;\n    };\n\n    this.setVideoBaseMediaDecodeTime = function (baseMediaDecodeTime) {\n      videoBaseMediaDecodeTime = baseMediaDecodeTime;\n    };\n\n    this.setAudioAppendStart = function (timestamp) {\n      audioAppendStartTs = timestamp;\n    };\n\n    this.flush = function () {\n      var frames, moof, mdat, boxes, frameDuration, segmentDuration, videoClockCyclesOfSilencePrefixed; // return early if no audio data has been observed\n\n      if (adtsFrames.length === 0) {\n        this.trigger('done', 'AudioSegmentStream');\n        return;\n      }\n\n      frames = audioFrameUtils.trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts);\n      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps); // amount of audio filled but the value is in video clock rather than audio clock\n\n      videoClockCyclesOfSilencePrefixed = audioFrameUtils.prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime); // we have to build the index from byte locations to\n      // samples (that is, adts frames) in the audio data\n\n      track.samples = audioFrameUtils.generateSampleTable(frames); // concatenate the audio data to constuct the mdat\n\n      mdat = mp4Generator.mdat(audioFrameUtils.concatenateFrameData(frames));\n      adtsFrames = [];\n      moof = mp4Generator.moof(sequenceNumber, [track]);\n      boxes = new Uint8Array(moof.byteLength + mdat.byteLength); // bump the sequence number for next time\n\n      sequenceNumber++;\n      boxes.set(moof);\n      boxes.set(mdat, moof.byteLength);\n      trackDecodeInfo.clearDtsInfo(track);\n      frameDuration = Math.ceil(ONE_SECOND_IN_TS$2 * 1024 / track.samplerate); // TODO this check was added to maintain backwards compatibility (particularly with\n      // tests) on adding the timingInfo event. However, it seems unlikely that there's a\n      // valid use-case where an init segment/data should be triggered without associated\n      // frames. Leaving for now, but should be looked into.\n\n      if (frames.length) {\n        segmentDuration = frames.length * frameDuration;\n        this.trigger('segmentTimingInfo', generateSegmentTimingInfo( // The audio track's baseMediaDecodeTime is in audio clock cycles, but the\n        // frame info is in video clock cycles. Convert to match expectation of\n        // listeners (that all timestamps will be based on video clock cycles).\n        clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate), // frame times are already in video clock, as is segment duration\n        frames[0].dts, frames[0].pts, frames[0].dts + segmentDuration, frames[0].pts + segmentDuration, videoClockCyclesOfSilencePrefixed || 0));\n        this.trigger('timingInfo', {\n          start: frames[0].pts,\n          end: frames[0].pts + segmentDuration\n        });\n      }\n\n      this.trigger('data', {\n        track: track,\n        boxes: boxes\n      });\n      this.trigger('done', 'AudioSegmentStream');\n    };\n\n    this.reset = function () {\n      trackDecodeInfo.clearDtsInfo(track);\n      adtsFrames = [];\n      this.trigger('reset');\n    };\n  };\n\n  _AudioSegmentStream$1.prototype = new stream();\n  /**\n   * Constructs a single-track, ISO BMFF media segment from H264 data\n   * events. The output of this stream can be fed to a SourceBuffer\n   * configured with a suitable initialization segment.\n   * @param track {object} track metadata configuration\n   * @param options {object} transmuxer options object\n   * @param options.alignGopsAtEnd {boolean} If true, start from the end of the\n   *        gopsToAlignWith list when attempting to align gop pts\n   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps\n   *        in the source; false to adjust the first segment to start at 0.\n   */\n\n  _VideoSegmentStream$1 = function VideoSegmentStream(track, options) {\n    var sequenceNumber,\n        nalUnits = [],\n        gopsToAlignWith = [],\n        config,\n        pps;\n    options = options || {};\n    sequenceNumber = options.firstSequenceNumber || 0;\n\n    _VideoSegmentStream$1.prototype.init.call(this);\n\n    delete track.minPTS;\n    this.gopCache_ = [];\n    /**\n      * Constructs a ISO BMFF segment given H264 nalUnits\n      * @param {Object} nalUnit A data event representing a nalUnit\n      * @param {String} nalUnit.nalUnitType\n      * @param {Object} nalUnit.config Properties for a mp4 track\n      * @param {Uint8Array} nalUnit.data The nalUnit bytes\n      * @see lib/codecs/h264.js\n     **/\n\n    this.push = function (nalUnit) {\n      trackDecodeInfo.collectDtsInfo(track, nalUnit); // record the track config\n\n      if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {\n        config = nalUnit.config;\n        track.sps = [nalUnit.data];\n        videoProperties.forEach(function (prop) {\n          track[prop] = config[prop];\n        }, this);\n      }\n\n      if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {\n        pps = nalUnit.data;\n        track.pps = [nalUnit.data];\n      } // buffer video until flush() is called\n\n\n      nalUnits.push(nalUnit);\n    };\n    /**\n      * Pass constructed ISO BMFF track and boxes on to the\n      * next stream in the pipeline\n     **/\n\n\n    this.flush = function () {\n      var frames,\n          gopForFusion,\n          gops,\n          moof,\n          mdat,\n          boxes,\n          prependedContentDuration = 0,\n          firstGop,\n          lastGop; // Throw away nalUnits at the start of the byte stream until\n      // we find the first AUD\n\n      while (nalUnits.length) {\n        if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {\n          break;\n        }\n\n        nalUnits.shift();\n      } // Return early if no video data has been observed\n\n\n      if (nalUnits.length === 0) {\n        this.resetStream_();\n        this.trigger('done', 'VideoSegmentStream');\n        return;\n      } // Organize the raw nal-units into arrays that represent\n      // higher-level constructs such as frames and gops\n      // (group-of-pictures)\n\n\n      frames = frameUtils.groupNalsIntoFrames(nalUnits);\n      gops = frameUtils.groupFramesIntoGops(frames); // If the first frame of this fragment is not a keyframe we have\n      // a problem since MSE (on Chrome) requires a leading keyframe.\n      //\n      // We have two approaches to repairing this situation:\n      // 1) GOP-FUSION:\n      //    This is where we keep track of the GOPS (group-of-pictures)\n      //    from previous fragments and attempt to find one that we can\n      //    prepend to the current fragment in order to create a valid\n      //    fragment.\n      // 2) KEYFRAME-PULLING:\n      //    Here we search for the first keyframe in the fragment and\n      //    throw away all the frames between the start of the fragment\n      //    and that keyframe. We then extend the duration and pull the\n      //    PTS of the keyframe forward so that it covers the time range\n      //    of the frames that were disposed of.\n      //\n      // #1 is far prefereable over #2 which can cause \"stuttering\" but\n      // requires more things to be just right.\n\n      if (!gops[0][0].keyFrame) {\n        // Search for a gop for fusion from our gopCache\n        gopForFusion = this.getGopForFusion_(nalUnits[0], track);\n\n        if (gopForFusion) {\n          // in order to provide more accurate timing information about the segment, save\n          // the number of seconds prepended to the original segment due to GOP fusion\n          prependedContentDuration = gopForFusion.duration;\n          gops.unshift(gopForFusion); // Adjust Gops' metadata to account for the inclusion of the\n          // new gop at the beginning\n\n          gops.byteLength += gopForFusion.byteLength;\n          gops.nalCount += gopForFusion.nalCount;\n          gops.pts = gopForFusion.pts;\n          gops.dts = gopForFusion.dts;\n          gops.duration += gopForFusion.duration;\n        } else {\n          // If we didn't find a candidate gop fall back to keyframe-pulling\n          gops = frameUtils.extendFirstKeyFrame(gops);\n        }\n      } // Trim gops to align with gopsToAlignWith\n\n\n      if (gopsToAlignWith.length) {\n        var alignedGops;\n\n        if (options.alignGopsAtEnd) {\n          alignedGops = this.alignGopsAtEnd_(gops);\n        } else {\n          alignedGops = this.alignGopsAtStart_(gops);\n        }\n\n        if (!alignedGops) {\n          // save all the nals in the last GOP into the gop cache\n          this.gopCache_.unshift({\n            gop: gops.pop(),\n            pps: track.pps,\n            sps: track.sps\n          }); // Keep a maximum of 6 GOPs in the cache\n\n          this.gopCache_.length = Math.min(6, this.gopCache_.length); // Clear nalUnits\n\n          nalUnits = []; // return early no gops can be aligned with desired gopsToAlignWith\n\n          this.resetStream_();\n          this.trigger('done', 'VideoSegmentStream');\n          return;\n        } // Some gops were trimmed. clear dts info so minSegmentDts and pts are correct\n        // when recalculated before sending off to CoalesceStream\n\n\n        trackDecodeInfo.clearDtsInfo(track);\n        gops = alignedGops;\n      }\n\n      trackDecodeInfo.collectDtsInfo(track, gops); // First, we have to build the index from byte locations to\n      // samples (that is, frames) in the video data\n\n      track.samples = frameUtils.generateSampleTable(gops); // Concatenate the video data and construct the mdat\n\n      mdat = mp4Generator.mdat(frameUtils.concatenateNalData(gops));\n      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);\n      this.trigger('processedGopsInfo', gops.map(function (gop) {\n        return {\n          pts: gop.pts,\n          dts: gop.dts,\n          byteLength: gop.byteLength\n        };\n      }));\n      firstGop = gops[0];\n      lastGop = gops[gops.length - 1];\n      this.trigger('segmentTimingInfo', generateSegmentTimingInfo(track.baseMediaDecodeTime, firstGop.dts, firstGop.pts, lastGop.dts + lastGop.duration, lastGop.pts + lastGop.duration, prependedContentDuration));\n      this.trigger('timingInfo', {\n        start: gops[0].pts,\n        end: gops[gops.length - 1].pts + gops[gops.length - 1].duration\n      }); // save all the nals in the last GOP into the gop cache\n\n      this.gopCache_.unshift({\n        gop: gops.pop(),\n        pps: track.pps,\n        sps: track.sps\n      }); // Keep a maximum of 6 GOPs in the cache\n\n      this.gopCache_.length = Math.min(6, this.gopCache_.length); // Clear nalUnits\n\n      nalUnits = [];\n      this.trigger('baseMediaDecodeTime', track.baseMediaDecodeTime);\n      this.trigger('timelineStartInfo', track.timelineStartInfo);\n      moof = mp4Generator.moof(sequenceNumber, [track]); // it would be great to allocate this array up front instead of\n      // throwing away hundreds of media segment fragments\n\n      boxes = new Uint8Array(moof.byteLength + mdat.byteLength); // Bump the sequence number for next time\n\n      sequenceNumber++;\n      boxes.set(moof);\n      boxes.set(mdat, moof.byteLength);\n      this.trigger('data', {\n        track: track,\n        boxes: boxes\n      });\n      this.resetStream_(); // Continue with the flush process now\n\n      this.trigger('done', 'VideoSegmentStream');\n    };\n\n    this.reset = function () {\n      this.resetStream_();\n      nalUnits = [];\n      this.gopCache_.length = 0;\n      gopsToAlignWith.length = 0;\n      this.trigger('reset');\n    };\n\n    this.resetStream_ = function () {\n      trackDecodeInfo.clearDtsInfo(track); // reset config and pps because they may differ across segments\n      // for instance, when we are rendition switching\n\n      config = undefined;\n      pps = undefined;\n    }; // Search for a candidate Gop for gop-fusion from the gop cache and\n    // return it or return null if no good candidate was found\n\n\n    this.getGopForFusion_ = function (nalUnit) {\n      var halfSecond = 45000,\n          // Half-a-second in a 90khz clock\n      allowableOverlap = 10000,\n          // About 3 frames @ 30fps\n      nearestDistance = Infinity,\n          dtsDistance,\n          nearestGopObj,\n          currentGop,\n          currentGopObj,\n          i; // Search for the GOP nearest to the beginning of this nal unit\n\n      for (i = 0; i < this.gopCache_.length; i++) {\n        currentGopObj = this.gopCache_[i];\n        currentGop = currentGopObj.gop; // Reject Gops with different SPS or PPS\n\n        if (!(track.pps && arrayEquals(track.pps[0], currentGopObj.pps[0])) || !(track.sps && arrayEquals(track.sps[0], currentGopObj.sps[0]))) {\n          continue;\n        } // Reject Gops that would require a negative baseMediaDecodeTime\n\n\n        if (currentGop.dts < track.timelineStartInfo.dts) {\n          continue;\n        } // The distance between the end of the gop and the start of the nalUnit\n\n\n        dtsDistance = nalUnit.dts - currentGop.dts - currentGop.duration; // Only consider GOPS that start before the nal unit and end within\n        // a half-second of the nal unit\n\n        if (dtsDistance >= -allowableOverlap && dtsDistance <= halfSecond) {\n          // Always use the closest GOP we found if there is more than\n          // one candidate\n          if (!nearestGopObj || nearestDistance > dtsDistance) {\n            nearestGopObj = currentGopObj;\n            nearestDistance = dtsDistance;\n          }\n        }\n      }\n\n      if (nearestGopObj) {\n        return nearestGopObj.gop;\n      }\n\n      return null;\n    }; // trim gop list to the first gop found that has a matching pts with a gop in the list\n    // of gopsToAlignWith starting from the START of the list\n\n\n    this.alignGopsAtStart_ = function (gops) {\n      var alignIndex, gopIndex, align, gop, byteLength, nalCount, duration, alignedGops;\n      byteLength = gops.byteLength;\n      nalCount = gops.nalCount;\n      duration = gops.duration;\n      alignIndex = gopIndex = 0;\n\n      while (alignIndex < gopsToAlignWith.length && gopIndex < gops.length) {\n        align = gopsToAlignWith[alignIndex];\n        gop = gops[gopIndex];\n\n        if (align.pts === gop.pts) {\n          break;\n        }\n\n        if (gop.pts > align.pts) {\n          // this current gop starts after the current gop we want to align on, so increment\n          // align index\n          alignIndex++;\n          continue;\n        } // current gop starts before the current gop we want to align on. so increment gop\n        // index\n\n\n        gopIndex++;\n        byteLength -= gop.byteLength;\n        nalCount -= gop.nalCount;\n        duration -= gop.duration;\n      }\n\n      if (gopIndex === 0) {\n        // no gops to trim\n        return gops;\n      }\n\n      if (gopIndex === gops.length) {\n        // all gops trimmed, skip appending all gops\n        return null;\n      }\n\n      alignedGops = gops.slice(gopIndex);\n      alignedGops.byteLength = byteLength;\n      alignedGops.duration = duration;\n      alignedGops.nalCount = nalCount;\n      alignedGops.pts = alignedGops[0].pts;\n      alignedGops.dts = alignedGops[0].dts;\n      return alignedGops;\n    }; // trim gop list to the first gop found that has a matching pts with a gop in the list\n    // of gopsToAlignWith starting from the END of the list\n\n\n    this.alignGopsAtEnd_ = function (gops) {\n      var alignIndex, gopIndex, align, gop, alignEndIndex, matchFound;\n      alignIndex = gopsToAlignWith.length - 1;\n      gopIndex = gops.length - 1;\n      alignEndIndex = null;\n      matchFound = false;\n\n      while (alignIndex >= 0 && gopIndex >= 0) {\n        align = gopsToAlignWith[alignIndex];\n        gop = gops[gopIndex];\n\n        if (align.pts === gop.pts) {\n          matchFound = true;\n          break;\n        }\n\n        if (align.pts > gop.pts) {\n          alignIndex--;\n          continue;\n        }\n\n        if (alignIndex === gopsToAlignWith.length - 1) {\n          // gop.pts is greater than the last alignment candidate. If no match is found\n          // by the end of this loop, we still want to append gops that come after this\n          // point\n          alignEndIndex = gopIndex;\n        }\n\n        gopIndex--;\n      }\n\n      if (!matchFound && alignEndIndex === null) {\n        return null;\n      }\n\n      var trimIndex;\n\n      if (matchFound) {\n        trimIndex = gopIndex;\n      } else {\n        trimIndex = alignEndIndex;\n      }\n\n      if (trimIndex === 0) {\n        return gops;\n      }\n\n      var alignedGops = gops.slice(trimIndex);\n      var metadata = alignedGops.reduce(function (total, gop) {\n        total.byteLength += gop.byteLength;\n        total.duration += gop.duration;\n        total.nalCount += gop.nalCount;\n        return total;\n      }, {\n        byteLength: 0,\n        duration: 0,\n        nalCount: 0\n      });\n      alignedGops.byteLength = metadata.byteLength;\n      alignedGops.duration = metadata.duration;\n      alignedGops.nalCount = metadata.nalCount;\n      alignedGops.pts = alignedGops[0].pts;\n      alignedGops.dts = alignedGops[0].dts;\n      return alignedGops;\n    };\n\n    this.alignGopsWith = function (newGopsToAlignWith) {\n      gopsToAlignWith = newGopsToAlignWith;\n    };\n  };\n\n  _VideoSegmentStream$1.prototype = new stream();\n  /**\n   * A Stream that can combine multiple streams (ie. audio & video)\n   * into a single output segment for MSE. Also supports audio-only\n   * and video-only streams.\n   * @param options {object} transmuxer options object\n   * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps\n   *        in the source; false to adjust the first segment to start at media timeline start.\n   */\n\n  _CoalesceStream = function CoalesceStream(options, metadataStream) {\n    // Number of Tracks per output segment\n    // If greater than 1, we combine multiple\n    // tracks into a single segment\n    this.numberOfTracks = 0;\n    this.metadataStream = metadataStream;\n    options = options || {};\n\n    if (typeof options.remux !== 'undefined') {\n      this.remuxTracks = !!options.remux;\n    } else {\n      this.remuxTracks = true;\n    }\n\n    if (typeof options.keepOriginalTimestamps === 'boolean') {\n      this.keepOriginalTimestamps = options.keepOriginalTimestamps;\n    } else {\n      this.keepOriginalTimestamps = false;\n    }\n\n    this.pendingTracks = [];\n    this.videoTrack = null;\n    this.pendingBoxes = [];\n    this.pendingCaptions = [];\n    this.pendingMetadata = [];\n    this.pendingBytes = 0;\n    this.emittedTracks = 0;\n\n    _CoalesceStream.prototype.init.call(this); // Take output from multiple\n\n\n    this.push = function (output) {\n      // buffer incoming captions until the associated video segment\n      // finishes\n      if (output.text) {\n        return this.pendingCaptions.push(output);\n      } // buffer incoming id3 tags until the final flush\n\n\n      if (output.frames) {\n        return this.pendingMetadata.push(output);\n      } // Add this track to the list of pending tracks and store\n      // important information required for the construction of\n      // the final segment\n\n\n      this.pendingTracks.push(output.track);\n      this.pendingBytes += output.boxes.byteLength; // TODO: is there an issue for this against chrome?\n      // We unshift audio and push video because\n      // as of Chrome 75 when switching from\n      // one init segment to another if the video\n      // mdat does not appear after the audio mdat\n      // only audio will play for the duration of our transmux.\n\n      if (output.track.type === 'video') {\n        this.videoTrack = output.track;\n        this.pendingBoxes.push(output.boxes);\n      }\n\n      if (output.track.type === 'audio') {\n        this.audioTrack = output.track;\n        this.pendingBoxes.unshift(output.boxes);\n      }\n    };\n  };\n\n  _CoalesceStream.prototype = new stream();\n\n  _CoalesceStream.prototype.flush = function (flushSource) {\n    var offset = 0,\n        event = {\n      captions: [],\n      captionStreams: {},\n      metadata: [],\n      info: {}\n    },\n        caption,\n        id3,\n        initSegment,\n        timelineStartPts = 0,\n        i;\n\n    if (this.pendingTracks.length < this.numberOfTracks) {\n      if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {\n        // Return because we haven't received a flush from a data-generating\n        // portion of the segment (meaning that we have only recieved meta-data\n        // or captions.)\n        return;\n      } else if (this.remuxTracks) {\n        // Return until we have enough tracks from the pipeline to remux (if we\n        // are remuxing audio and video into a single MP4)\n        return;\n      } else if (this.pendingTracks.length === 0) {\n        // In the case where we receive a flush without any data having been\n        // received we consider it an emitted track for the purposes of coalescing\n        // `done` events.\n        // We do this for the case where there is an audio and video track in the\n        // segment but no audio data. (seen in several playlists with alternate\n        // audio tracks and no audio present in the main TS segments.)\n        this.emittedTracks++;\n\n        if (this.emittedTracks >= this.numberOfTracks) {\n          this.trigger('done');\n          this.emittedTracks = 0;\n        }\n\n        return;\n      }\n    }\n\n    if (this.videoTrack) {\n      timelineStartPts = this.videoTrack.timelineStartInfo.pts;\n      videoProperties.forEach(function (prop) {\n        event.info[prop] = this.videoTrack[prop];\n      }, this);\n    } else if (this.audioTrack) {\n      timelineStartPts = this.audioTrack.timelineStartInfo.pts;\n      audioProperties.forEach(function (prop) {\n        event.info[prop] = this.audioTrack[prop];\n      }, this);\n    }\n\n    if (this.videoTrack || this.audioTrack) {\n      if (this.pendingTracks.length === 1) {\n        event.type = this.pendingTracks[0].type;\n      } else {\n        event.type = 'combined';\n      }\n\n      this.emittedTracks += this.pendingTracks.length;\n      initSegment = mp4Generator.initSegment(this.pendingTracks); // Create a new typed array to hold the init segment\n\n      event.initSegment = new Uint8Array(initSegment.byteLength); // Create an init segment containing a moov\n      // and track definitions\n\n      event.initSegment.set(initSegment); // Create a new typed array to hold the moof+mdats\n\n      event.data = new Uint8Array(this.pendingBytes); // Append each moof+mdat (one per track) together\n\n      for (i = 0; i < this.pendingBoxes.length; i++) {\n        event.data.set(this.pendingBoxes[i], offset);\n        offset += this.pendingBoxes[i].byteLength;\n      } // Translate caption PTS times into second offsets to match the\n      // video timeline for the segment, and add track info\n\n\n      for (i = 0; i < this.pendingCaptions.length; i++) {\n        caption = this.pendingCaptions[i];\n        caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, this.keepOriginalTimestamps);\n        caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, this.keepOriginalTimestamps);\n        event.captionStreams[caption.stream] = true;\n        event.captions.push(caption);\n      } // Translate ID3 frame PTS times into second offsets to match the\n      // video timeline for the segment\n\n\n      for (i = 0; i < this.pendingMetadata.length; i++) {\n        id3 = this.pendingMetadata[i];\n        id3.cueTime = clock.metadataTsToSeconds(id3.pts, timelineStartPts, this.keepOriginalTimestamps);\n        event.metadata.push(id3);\n      } // We add this to every single emitted segment even though we only need\n      // it for the first\n\n\n      event.metadata.dispatchType = this.metadataStream.dispatchType; // Reset stream state\n\n      this.pendingTracks.length = 0;\n      this.videoTrack = null;\n      this.pendingBoxes.length = 0;\n      this.pendingCaptions.length = 0;\n      this.pendingBytes = 0;\n      this.pendingMetadata.length = 0; // Emit the built segment\n      // We include captions and ID3 tags for backwards compatibility,\n      // ideally we should send only video and audio in the data event\n\n      this.trigger('data', event); // Emit each caption to the outside world\n      // Ideally, this would happen immediately on parsing captions,\n      // but we need to ensure that video data is sent back first\n      // so that caption timing can be adjusted to match video timing\n\n      for (i = 0; i < event.captions.length; i++) {\n        caption = event.captions[i];\n        this.trigger('caption', caption);\n      } // Emit each id3 tag to the outside world\n      // Ideally, this would happen immediately on parsing the tag,\n      // but we need to ensure that video data is sent back first\n      // so that ID3 frame timing can be adjusted to match video timing\n\n\n      for (i = 0; i < event.metadata.length; i++) {\n        id3 = event.metadata[i];\n        this.trigger('id3Frame', id3);\n      }\n    } // Only emit `done` if all tracks have been flushed and emitted\n\n\n    if (this.emittedTracks >= this.numberOfTracks) {\n      this.trigger('done');\n      this.emittedTracks = 0;\n    }\n  };\n\n  _CoalesceStream.prototype.setRemux = function (val) {\n    this.remuxTracks = val;\n  };\n  /**\n   * A Stream that expects MP2T binary data as input and produces\n   * corresponding media segments, suitable for use with Media Source\n   * Extension (MSE) implementations that support the ISO BMFF byte\n   * stream format, like Chrome.\n   */\n\n\n  _Transmuxer$1 = function Transmuxer(options) {\n    var self = this,\n        hasFlushed = true,\n        videoTrack,\n        audioTrack;\n\n    _Transmuxer$1.prototype.init.call(this);\n\n    options = options || {};\n    this.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;\n    this.transmuxPipeline_ = {};\n\n    this.setupAacPipeline = function () {\n      var pipeline = {};\n      this.transmuxPipeline_ = pipeline;\n      pipeline.type = 'aac';\n      pipeline.metadataStream = new m2ts_1.MetadataStream(); // set up the parsing pipeline\n\n      pipeline.aacStream = new aac();\n      pipeline.audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');\n      pipeline.timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');\n      pipeline.adtsStream = new adts();\n      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);\n      pipeline.headOfPipeline = pipeline.aacStream;\n      pipeline.aacStream.pipe(pipeline.audioTimestampRolloverStream).pipe(pipeline.adtsStream);\n      pipeline.aacStream.pipe(pipeline.timedMetadataTimestampRolloverStream).pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);\n      pipeline.metadataStream.on('timestamp', function (frame) {\n        pipeline.aacStream.setTimestamp(frame.timeStamp);\n      });\n      pipeline.aacStream.on('data', function (data) {\n        if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {\n          return;\n        }\n\n        audioTrack = audioTrack || {\n          timelineStartInfo: {\n            baseMediaDecodeTime: self.baseMediaDecodeTime\n          },\n          codec: 'adts',\n          type: 'audio'\n        }; // hook up the audio segment stream to the first track with aac data\n\n        pipeline.coalesceStream.numberOfTracks++;\n        pipeline.audioSegmentStream = new _AudioSegmentStream$1(audioTrack, options);\n        pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));\n        pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo')); // Set up the final part of the audio pipeline\n\n        pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream); // emit pmt info\n\n        self.trigger('trackinfo', {\n          hasAudio: !!audioTrack,\n          hasVideo: !!videoTrack\n        });\n      }); // Re-emit any data coming from the coalesce stream to the outside world\n\n      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data')); // Let the consumer know we have finished flushing the entire pipeline\n\n      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));\n    };\n\n    this.setupTsPipeline = function () {\n      var pipeline = {};\n      this.transmuxPipeline_ = pipeline;\n      pipeline.type = 'ts';\n      pipeline.metadataStream = new m2ts_1.MetadataStream(); // set up the parsing pipeline\n\n      pipeline.packetStream = new m2ts_1.TransportPacketStream();\n      pipeline.parseStream = new m2ts_1.TransportParseStream();\n      pipeline.elementaryStream = new m2ts_1.ElementaryStream();\n      pipeline.timestampRolloverStream = new m2ts_1.TimestampRolloverStream();\n      pipeline.adtsStream = new adts();\n      pipeline.h264Stream = new H264Stream$1();\n      pipeline.captionStream = new m2ts_1.CaptionStream(options);\n      pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);\n      pipeline.headOfPipeline = pipeline.packetStream; // disassemble MPEG2-TS packets into elementary streams\n\n      pipeline.packetStream.pipe(pipeline.parseStream).pipe(pipeline.elementaryStream).pipe(pipeline.timestampRolloverStream); // !!THIS ORDER IS IMPORTANT!!\n      // demux the streams\n\n      pipeline.timestampRolloverStream.pipe(pipeline.h264Stream);\n      pipeline.timestampRolloverStream.pipe(pipeline.adtsStream);\n      pipeline.timestampRolloverStream.pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream); // Hook up CEA-608/708 caption stream\n\n      pipeline.h264Stream.pipe(pipeline.captionStream).pipe(pipeline.coalesceStream);\n      pipeline.elementaryStream.on('data', function (data) {\n        var i;\n\n        if (data.type === 'metadata') {\n          i = data.tracks.length; // scan the tracks listed in the metadata\n\n          while (i--) {\n            if (!videoTrack && data.tracks[i].type === 'video') {\n              videoTrack = data.tracks[i];\n              videoTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;\n            } else if (!audioTrack && data.tracks[i].type === 'audio') {\n              audioTrack = data.tracks[i];\n              audioTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;\n            }\n          } // hook up the video segment stream to the first track with h264 data\n\n\n          if (videoTrack && !pipeline.videoSegmentStream) {\n            pipeline.coalesceStream.numberOfTracks++;\n            pipeline.videoSegmentStream = new _VideoSegmentStream$1(videoTrack, options);\n            pipeline.videoSegmentStream.on('log', self.getLogTrigger_('videoSegmentStream'));\n            pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {\n              // When video emits timelineStartInfo data after a flush, we forward that\n              // info to the AudioSegmentStream, if it exists, because video timeline\n              // data takes precedence.  Do not do this if keepOriginalTimestamps is set,\n              // because this is a particularly subtle form of timestamp alteration.\n              if (audioTrack && !options.keepOriginalTimestamps) {\n                audioTrack.timelineStartInfo = timelineStartInfo; // On the first segment we trim AAC frames that exist before the\n                // very earliest DTS we have seen in video because Chrome will\n                // interpret any video track with a baseMediaDecodeTime that is\n                // non-zero as a gap.\n\n                pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - self.baseMediaDecodeTime);\n              }\n            });\n            pipeline.videoSegmentStream.on('processedGopsInfo', self.trigger.bind(self, 'gopInfo'));\n            pipeline.videoSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'videoSegmentTimingInfo'));\n            pipeline.videoSegmentStream.on('baseMediaDecodeTime', function (baseMediaDecodeTime) {\n              if (audioTrack) {\n                pipeline.audioSegmentStream.setVideoBaseMediaDecodeTime(baseMediaDecodeTime);\n              }\n            });\n            pipeline.videoSegmentStream.on('timingInfo', self.trigger.bind(self, 'videoTimingInfo')); // Set up the final part of the video pipeline\n\n            pipeline.h264Stream.pipe(pipeline.videoSegmentStream).pipe(pipeline.coalesceStream);\n          }\n\n          if (audioTrack && !pipeline.audioSegmentStream) {\n            // hook up the audio segment stream to the first track with aac data\n            pipeline.coalesceStream.numberOfTracks++;\n            pipeline.audioSegmentStream = new _AudioSegmentStream$1(audioTrack, options);\n            pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));\n            pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));\n            pipeline.audioSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'audioSegmentTimingInfo')); // Set up the final part of the audio pipeline\n\n            pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);\n          } // emit pmt info\n\n\n          self.trigger('trackinfo', {\n            hasAudio: !!audioTrack,\n            hasVideo: !!videoTrack\n          });\n        }\n      }); // Re-emit any data coming from the coalesce stream to the outside world\n\n      pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));\n      pipeline.coalesceStream.on('id3Frame', function (id3Frame) {\n        id3Frame.dispatchType = pipeline.metadataStream.dispatchType;\n        self.trigger('id3Frame', id3Frame);\n      });\n      pipeline.coalesceStream.on('caption', this.trigger.bind(this, 'caption')); // Let the consumer know we have finished flushing the entire pipeline\n\n      pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));\n    }; // hook up the segment streams once track metadata is delivered\n\n\n    this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {\n      var pipeline = this.transmuxPipeline_;\n\n      if (!options.keepOriginalTimestamps) {\n        this.baseMediaDecodeTime = baseMediaDecodeTime;\n      }\n\n      if (audioTrack) {\n        audioTrack.timelineStartInfo.dts = undefined;\n        audioTrack.timelineStartInfo.pts = undefined;\n        trackDecodeInfo.clearDtsInfo(audioTrack);\n\n        if (pipeline.audioTimestampRolloverStream) {\n          pipeline.audioTimestampRolloverStream.discontinuity();\n        }\n      }\n\n      if (videoTrack) {\n        if (pipeline.videoSegmentStream) {\n          pipeline.videoSegmentStream.gopCache_ = [];\n        }\n\n        videoTrack.timelineStartInfo.dts = undefined;\n        videoTrack.timelineStartInfo.pts = undefined;\n        trackDecodeInfo.clearDtsInfo(videoTrack);\n        pipeline.captionStream.reset();\n      }\n\n      if (pipeline.timestampRolloverStream) {\n        pipeline.timestampRolloverStream.discontinuity();\n      }\n    };\n\n    this.setAudioAppendStart = function (timestamp) {\n      if (audioTrack) {\n        this.transmuxPipeline_.audioSegmentStream.setAudioAppendStart(timestamp);\n      }\n    };\n\n    this.setRemux = function (val) {\n      var pipeline = this.transmuxPipeline_;\n      options.remux = val;\n\n      if (pipeline && pipeline.coalesceStream) {\n        pipeline.coalesceStream.setRemux(val);\n      }\n    };\n\n    this.alignGopsWith = function (gopsToAlignWith) {\n      if (videoTrack && this.transmuxPipeline_.videoSegmentStream) {\n        this.transmuxPipeline_.videoSegmentStream.alignGopsWith(gopsToAlignWith);\n      }\n    };\n\n    this.getLogTrigger_ = function (key) {\n      var self = this;\n      return function (event) {\n        event.stream = key;\n        self.trigger('log', event);\n      };\n    }; // feed incoming data to the front of the parsing pipeline\n\n\n    this.push = function (data) {\n      if (hasFlushed) {\n        var isAac = isLikelyAacData$1(data);\n\n        if (isAac && this.transmuxPipeline_.type !== 'aac') {\n          this.setupAacPipeline();\n        } else if (!isAac && this.transmuxPipeline_.type !== 'ts') {\n          this.setupTsPipeline();\n        }\n\n        if (this.transmuxPipeline_) {\n          var keys = Object.keys(this.transmuxPipeline_);\n\n          for (var i = 0; i < keys.length; i++) {\n            var key = keys[i]; // skip non-stream keys and headOfPipeline\n            // which is just a duplicate\n\n            if (key === 'headOfPipeline' || !this.transmuxPipeline_[key].on) {\n              continue;\n            }\n\n            this.transmuxPipeline_[key].on('log', this.getLogTrigger_(key));\n          }\n        }\n\n        hasFlushed = false;\n      }\n\n      this.transmuxPipeline_.headOfPipeline.push(data);\n    }; // flush any buffered data\n\n\n    this.flush = function () {\n      hasFlushed = true; // Start at the top of the pipeline and flush all pending work\n\n      this.transmuxPipeline_.headOfPipeline.flush();\n    };\n\n    this.endTimeline = function () {\n      this.transmuxPipeline_.headOfPipeline.endTimeline();\n    };\n\n    this.reset = function () {\n      if (this.transmuxPipeline_.headOfPipeline) {\n        this.transmuxPipeline_.headOfPipeline.reset();\n      }\n    }; // Caption data has to be reset when seeking outside buffered range\n\n\n    this.resetCaptions = function () {\n      if (this.transmuxPipeline_.captionStream) {\n        this.transmuxPipeline_.captionStream.reset();\n      }\n    };\n  };\n\n  _Transmuxer$1.prototype = new stream();\n  var transmuxer$2 = {\n    Transmuxer: _Transmuxer$1,\n    VideoSegmentStream: _VideoSegmentStream$1,\n    AudioSegmentStream: _AudioSegmentStream$1,\n    AUDIO_PROPERTIES: audioProperties,\n    VIDEO_PROPERTIES: videoProperties,\n    // exported for testing\n    generateSegmentTimingInfo: generateSegmentTimingInfo\n  };\n\n  var discardEmulationPreventionBytes = captionPacketParser.discardEmulationPreventionBytes;\n  var CaptionStream = captionStream.CaptionStream;\n  /**\n    * Maps an offset in the mdat to a sample based on the the size of the samples.\n    * Assumes that `parseSamples` has been called first.\n    *\n    * @param {Number} offset - The offset into the mdat\n    * @param {Object[]} samples - An array of samples, parsed using `parseSamples`\n    * @return {?Object} The matching sample, or null if no match was found.\n    *\n    * @see ISO-BMFF-12/2015, Section 8.8.8\n   **/\n\n  var mapToSample = function mapToSample(offset, samples) {\n    var approximateOffset = offset;\n\n    for (var i = 0; i < samples.length; i++) {\n      var sample = samples[i];\n\n      if (approximateOffset < sample.size) {\n        return sample;\n      }\n\n      approximateOffset -= sample.size;\n    }\n\n    return null;\n  };\n  /**\n    * Finds SEI nal units contained in a Media Data Box.\n    * Assumes that `parseSamples` has been called first.\n    *\n    * @param {Uint8Array} avcStream - The bytes of the mdat\n    * @param {Object[]} samples - The samples parsed out by `parseSamples`\n    * @param {Number} trackId - The trackId of this video track\n    * @return {Object[]} seiNals - the parsed SEI NALUs found.\n    *   The contents of the seiNal should match what is expected by\n    *   CaptionStream.push (nalUnitType, size, data, escapedRBSP, pts, dts)\n    *\n    * @see ISO-BMFF-12/2015, Section 8.1.1\n    * @see Rec. ITU-T H.264, 7.3.2.3.1\n   **/\n\n\n  var findSeiNals = function findSeiNals(avcStream, samples, trackId) {\n    var avcView = new DataView(avcStream.buffer, avcStream.byteOffset, avcStream.byteLength),\n        result = {\n      logs: [],\n      seiNals: []\n    },\n        seiNal,\n        i,\n        length,\n        lastMatchedSample;\n\n    for (i = 0; i + 4 < avcStream.length; i += length) {\n      length = avcView.getUint32(i);\n      i += 4; // Bail if this doesn't appear to be an H264 stream\n\n      if (length <= 0) {\n        continue;\n      }\n\n      switch (avcStream[i] & 0x1F) {\n        case 0x06:\n          var data = avcStream.subarray(i + 1, i + 1 + length);\n          var matchingSample = mapToSample(i, samples);\n          seiNal = {\n            nalUnitType: 'sei_rbsp',\n            size: length,\n            data: data,\n            escapedRBSP: discardEmulationPreventionBytes(data),\n            trackId: trackId\n          };\n\n          if (matchingSample) {\n            seiNal.pts = matchingSample.pts;\n            seiNal.dts = matchingSample.dts;\n            lastMatchedSample = matchingSample;\n          } else if (lastMatchedSample) {\n            // If a matching sample cannot be found, use the last\n            // sample's values as they should be as close as possible\n            seiNal.pts = lastMatchedSample.pts;\n            seiNal.dts = lastMatchedSample.dts;\n          } else {\n            result.logs.push({\n              level: 'warn',\n              message: 'We\\'ve encountered a nal unit without data at ' + i + ' for trackId ' + trackId + '. See mux.js#223.'\n            });\n            break;\n          }\n\n          result.seiNals.push(seiNal);\n          break;\n      }\n    }\n\n    return result;\n  };\n  /**\n    * Parses sample information out of Track Run Boxes and calculates\n    * the absolute presentation and decode timestamps of each sample.\n    *\n    * @param {Array<Uint8Array>} truns - The Trun Run boxes to be parsed\n    * @param {Number} baseMediaDecodeTime - base media decode time from tfdt\n        @see ISO-BMFF-12/2015, Section 8.8.12\n    * @param {Object} tfhd - The parsed Track Fragment Header\n    *   @see inspect.parseTfhd\n    * @return {Object[]} the parsed samples\n    *\n    * @see ISO-BMFF-12/2015, Section 8.8.8\n   **/\n\n\n  var parseSamples = function parseSamples(truns, baseMediaDecodeTime, tfhd) {\n    var currentDts = baseMediaDecodeTime;\n    var defaultSampleDuration = tfhd.defaultSampleDuration || 0;\n    var defaultSampleSize = tfhd.defaultSampleSize || 0;\n    var trackId = tfhd.trackId;\n    var allSamples = [];\n    truns.forEach(function (trun) {\n      // Note: We currently do not parse the sample table as well\n      // as the trun. It's possible some sources will require this.\n      // moov > trak > mdia > minf > stbl\n      var trackRun = parseTrun(trun);\n      var samples = trackRun.samples;\n      samples.forEach(function (sample) {\n        if (sample.duration === undefined) {\n          sample.duration = defaultSampleDuration;\n        }\n\n        if (sample.size === undefined) {\n          sample.size = defaultSampleSize;\n        }\n\n        sample.trackId = trackId;\n        sample.dts = currentDts;\n\n        if (sample.compositionTimeOffset === undefined) {\n          sample.compositionTimeOffset = 0;\n        }\n\n        sample.pts = currentDts + sample.compositionTimeOffset;\n        currentDts += sample.duration;\n      });\n      allSamples = allSamples.concat(samples);\n    });\n    return allSamples;\n  };\n  /**\n    * Parses out caption nals from an FMP4 segment's video tracks.\n    *\n    * @param {Uint8Array} segment - The bytes of a single segment\n    * @param {Number} videoTrackId - The trackId of a video track in the segment\n    * @return {Object.<Number, Object[]>} A mapping of video trackId to\n    *   a list of seiNals found in that track\n   **/\n\n\n  var parseCaptionNals = function parseCaptionNals(segment, videoTrackId) {\n    // To get the samples\n    var trafs = findBox_1(segment, ['moof', 'traf']); // To get SEI NAL units\n\n    var mdats = findBox_1(segment, ['mdat']);\n    var captionNals = {};\n    var mdatTrafPairs = []; // Pair up each traf with a mdat as moofs and mdats are in pairs\n\n    mdats.forEach(function (mdat, index) {\n      var matchingTraf = trafs[index];\n      mdatTrafPairs.push({\n        mdat: mdat,\n        traf: matchingTraf\n      });\n    });\n    mdatTrafPairs.forEach(function (pair) {\n      var mdat = pair.mdat;\n      var traf = pair.traf;\n      var tfhd = findBox_1(traf, ['tfhd']); // Exactly 1 tfhd per traf\n\n      var headerInfo = parseTfhd(tfhd[0]);\n      var trackId = headerInfo.trackId;\n      var tfdt = findBox_1(traf, ['tfdt']); // Either 0 or 1 tfdt per traf\n\n      var baseMediaDecodeTime = tfdt.length > 0 ? parseTfdt(tfdt[0]).baseMediaDecodeTime : 0;\n      var truns = findBox_1(traf, ['trun']);\n      var samples;\n      var result; // Only parse video data for the chosen video track\n\n      if (videoTrackId === trackId && truns.length > 0) {\n        samples = parseSamples(truns, baseMediaDecodeTime, headerInfo);\n        result = findSeiNals(mdat, samples, trackId);\n\n        if (!captionNals[trackId]) {\n          captionNals[trackId] = {\n            seiNals: [],\n            logs: []\n          };\n        }\n\n        captionNals[trackId].seiNals = captionNals[trackId].seiNals.concat(result.seiNals);\n        captionNals[trackId].logs = captionNals[trackId].logs.concat(result.logs);\n      }\n    });\n    return captionNals;\n  };\n  /**\n    * Parses out inband captions from an MP4 container and returns\n    * caption objects that can be used by WebVTT and the TextTrack API.\n    * @see https://developer.mozilla.org/en-US/docs/Web/API/VTTCue\n    * @see https://developer.mozilla.org/en-US/docs/Web/API/TextTrack\n    * Assumes that `probe.getVideoTrackIds` and `probe.timescale` have been called first\n    *\n    * @param {Uint8Array} segment - The fmp4 segment containing embedded captions\n    * @param {Number} trackId - The id of the video track to parse\n    * @param {Number} timescale - The timescale for the video track from the init segment\n    *\n    * @return {?Object[]} parsedCaptions - A list of captions or null if no video tracks\n    * @return {Number} parsedCaptions[].startTime - The time to show the caption in seconds\n    * @return {Number} parsedCaptions[].endTime - The time to stop showing the caption in seconds\n    * @return {String} parsedCaptions[].text - The visible content of the caption\n   **/\n\n\n  var parseEmbeddedCaptions = function parseEmbeddedCaptions(segment, trackId, timescale) {\n    var captionNals; // the ISO-BMFF spec says that trackId can't be zero, but there's some broken content out there\n\n    if (trackId === null) {\n      return null;\n    }\n\n    captionNals = parseCaptionNals(segment, trackId);\n    var trackNals = captionNals[trackId] || {};\n    return {\n      seiNals: trackNals.seiNals,\n      logs: trackNals.logs,\n      timescale: timescale\n    };\n  };\n  /**\n    * Converts SEI NALUs into captions that can be used by video.js\n   **/\n\n\n  var CaptionParser = function CaptionParser() {\n    var isInitialized = false;\n    var captionStream; // Stores segments seen before trackId and timescale are set\n\n    var segmentCache; // Stores video track ID of the track being parsed\n\n    var trackId; // Stores the timescale of the track being parsed\n\n    var timescale; // Stores captions parsed so far\n\n    var parsedCaptions; // Stores whether we are receiving partial data or not\n\n    var parsingPartial;\n    /**\n      * A method to indicate whether a CaptionParser has been initalized\n      * @returns {Boolean}\n     **/\n\n    this.isInitialized = function () {\n      return isInitialized;\n    };\n    /**\n      * Initializes the underlying CaptionStream, SEI NAL parsing\n      * and management, and caption collection\n     **/\n\n\n    this.init = function (options) {\n      captionStream = new CaptionStream();\n      isInitialized = true;\n      parsingPartial = options ? options.isPartial : false; // Collect dispatched captions\n\n      captionStream.on('data', function (event) {\n        // Convert to seconds in the source's timescale\n        event.startTime = event.startPts / timescale;\n        event.endTime = event.endPts / timescale;\n        parsedCaptions.captions.push(event);\n        parsedCaptions.captionStreams[event.stream] = true;\n      });\n      captionStream.on('log', function (log) {\n        parsedCaptions.logs.push(log);\n      });\n    };\n    /**\n      * Determines if a new video track will be selected\n      * or if the timescale changed\n      * @return {Boolean}\n     **/\n\n\n    this.isNewInit = function (videoTrackIds, timescales) {\n      if (videoTrackIds && videoTrackIds.length === 0 || timescales && typeof timescales === 'object' && Object.keys(timescales).length === 0) {\n        return false;\n      }\n\n      return trackId !== videoTrackIds[0] || timescale !== timescales[trackId];\n    };\n    /**\n      * Parses out SEI captions and interacts with underlying\n      * CaptionStream to return dispatched captions\n      *\n      * @param {Uint8Array} segment - The fmp4 segment containing embedded captions\n      * @param {Number[]} videoTrackIds - A list of video tracks found in the init segment\n      * @param {Object.<Number, Number>} timescales - The timescales found in the init segment\n      * @see parseEmbeddedCaptions\n      * @see m2ts/caption-stream.js\n     **/\n\n\n    this.parse = function (segment, videoTrackIds, timescales) {\n      var parsedData;\n\n      if (!this.isInitialized()) {\n        return null; // This is not likely to be a video segment\n      } else if (!videoTrackIds || !timescales) {\n        return null;\n      } else if (this.isNewInit(videoTrackIds, timescales)) {\n        // Use the first video track only as there is no\n        // mechanism to switch to other video tracks\n        trackId = videoTrackIds[0];\n        timescale = timescales[trackId]; // If an init segment has not been seen yet, hold onto segment\n        // data until we have one.\n        // the ISO-BMFF spec says that trackId can't be zero, but there's some broken content out there\n      } else if (trackId === null || !timescale) {\n        segmentCache.push(segment);\n        return null;\n      } // Now that a timescale and trackId is set, parse cached segments\n\n\n      while (segmentCache.length > 0) {\n        var cachedSegment = segmentCache.shift();\n        this.parse(cachedSegment, videoTrackIds, timescales);\n      }\n\n      parsedData = parseEmbeddedCaptions(segment, trackId, timescale);\n\n      if (parsedData && parsedData.logs) {\n        parsedCaptions.logs = parsedCaptions.logs.concat(parsedData.logs);\n      }\n\n      if (parsedData === null || !parsedData.seiNals) {\n        if (parsedCaptions.logs.length) {\n          return {\n            logs: parsedCaptions.logs,\n            captions: [],\n            captionStreams: []\n          };\n        }\n\n        return null;\n      }\n\n      this.pushNals(parsedData.seiNals); // Force the parsed captions to be dispatched\n\n      this.flushStream();\n      return parsedCaptions;\n    };\n    /**\n      * Pushes SEI NALUs onto CaptionStream\n      * @param {Object[]} nals - A list of SEI nals parsed using `parseCaptionNals`\n      * Assumes that `parseCaptionNals` has been called first\n      * @see m2ts/caption-stream.js\n      **/\n\n\n    this.pushNals = function (nals) {\n      if (!this.isInitialized() || !nals || nals.length === 0) {\n        return null;\n      }\n\n      nals.forEach(function (nal) {\n        captionStream.push(nal);\n      });\n    };\n    /**\n      * Flushes underlying CaptionStream to dispatch processed, displayable captions\n      * @see m2ts/caption-stream.js\n     **/\n\n\n    this.flushStream = function () {\n      if (!this.isInitialized()) {\n        return null;\n      }\n\n      if (!parsingPartial) {\n        captionStream.flush();\n      } else {\n        captionStream.partialFlush();\n      }\n    };\n    /**\n      * Reset caption buckets for new data\n     **/\n\n\n    this.clearParsedCaptions = function () {\n      parsedCaptions.captions = [];\n      parsedCaptions.captionStreams = {};\n      parsedCaptions.logs = [];\n    };\n    /**\n      * Resets underlying CaptionStream\n      * @see m2ts/caption-stream.js\n     **/\n\n\n    this.resetCaptionStream = function () {\n      if (!this.isInitialized()) {\n        return null;\n      }\n\n      captionStream.reset();\n    };\n    /**\n      * Convenience method to clear all captions flushed from the\n      * CaptionStream and still being parsed\n      * @see m2ts/caption-stream.js\n     **/\n\n\n    this.clearAllCaptions = function () {\n      this.clearParsedCaptions();\n      this.resetCaptionStream();\n    };\n    /**\n      * Reset caption parser\n     **/\n\n\n    this.reset = function () {\n      segmentCache = [];\n      trackId = null;\n      timescale = null;\n\n      if (!parsedCaptions) {\n        parsedCaptions = {\n          captions: [],\n          // CC1, CC2, CC3, CC4\n          captionStreams: {},\n          logs: []\n        };\n      } else {\n        this.clearParsedCaptions();\n      }\n\n      this.resetCaptionStream();\n    };\n\n    this.reset();\n  };\n\n  var captionParser = CaptionParser;\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var mp4 = {\n    generator: mp4Generator,\n    probe: probe$2,\n    Transmuxer: transmuxer$2.Transmuxer,\n    AudioSegmentStream: transmuxer$2.AudioSegmentStream,\n    VideoSegmentStream: transmuxer$2.VideoSegmentStream,\n    CaptionParser: captionParser\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   *\n   * An object that stores the bytes of an FLV tag and methods for\n   * querying and manipulating that data.\n   * @see http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf\n   */\n\n  var _FlvTag; // (type:uint, extraData:Boolean = false) extends ByteArray\n\n\n  _FlvTag = function FlvTag(type, extraData) {\n    var // Counter if this is a metadata tag, nal start marker if this is a video\n    // tag. unused if this is an audio tag\n    adHoc = 0,\n        // :uint\n    // The default size is 16kb but this is not enough to hold iframe\n    // data and the resizing algorithm costs a bit so we create a larger\n    // starting buffer for video tags\n    bufferStartSize = 16384,\n        // checks whether the FLV tag has enough capacity to accept the proposed\n    // write and re-allocates the internal buffers if necessary\n    prepareWrite = function prepareWrite(flv, count) {\n      var bytes,\n          minLength = flv.position + count;\n\n      if (minLength < flv.bytes.byteLength) {\n        // there's enough capacity so do nothing\n        return;\n      } // allocate a new buffer and copy over the data that will not be modified\n\n\n      bytes = new Uint8Array(minLength * 2);\n      bytes.set(flv.bytes.subarray(0, flv.position), 0);\n      flv.bytes = bytes;\n      flv.view = new DataView(flv.bytes.buffer);\n    },\n        // commonly used metadata properties\n    widthBytes = _FlvTag.widthBytes || new Uint8Array('width'.length),\n        heightBytes = _FlvTag.heightBytes || new Uint8Array('height'.length),\n        videocodecidBytes = _FlvTag.videocodecidBytes || new Uint8Array('videocodecid'.length),\n        i;\n\n    if (!_FlvTag.widthBytes) {\n      // calculating the bytes of common metadata names ahead of time makes the\n      // corresponding writes faster because we don't have to loop over the\n      // characters\n      // re-test with test/perf.html if you're planning on changing this\n      for (i = 0; i < 'width'.length; i++) {\n        widthBytes[i] = 'width'.charCodeAt(i);\n      }\n\n      for (i = 0; i < 'height'.length; i++) {\n        heightBytes[i] = 'height'.charCodeAt(i);\n      }\n\n      for (i = 0; i < 'videocodecid'.length; i++) {\n        videocodecidBytes[i] = 'videocodecid'.charCodeAt(i);\n      }\n\n      _FlvTag.widthBytes = widthBytes;\n      _FlvTag.heightBytes = heightBytes;\n      _FlvTag.videocodecidBytes = videocodecidBytes;\n    }\n\n    this.keyFrame = false; // :Boolean\n\n    switch (type) {\n      case _FlvTag.VIDEO_TAG:\n        this.length = 16; // Start the buffer at 256k\n\n        bufferStartSize *= 6;\n        break;\n\n      case _FlvTag.AUDIO_TAG:\n        this.length = 13;\n        this.keyFrame = true;\n        break;\n\n      case _FlvTag.METADATA_TAG:\n        this.length = 29;\n        this.keyFrame = true;\n        break;\n\n      default:\n        throw new Error('Unknown FLV tag type');\n    }\n\n    this.bytes = new Uint8Array(bufferStartSize);\n    this.view = new DataView(this.bytes.buffer);\n    this.bytes[0] = type;\n    this.position = this.length;\n    this.keyFrame = extraData; // Defaults to false\n    // presentation timestamp\n\n    this.pts = 0; // decoder timestamp\n\n    this.dts = 0; // ByteArray#writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0)\n\n    this.writeBytes = function (bytes, offset, length) {\n      var start = offset || 0,\n          end;\n      length = length || bytes.byteLength;\n      end = start + length;\n      prepareWrite(this, length);\n      this.bytes.set(bytes.subarray(start, end), this.position);\n      this.position += length;\n      this.length = Math.max(this.length, this.position);\n    }; // ByteArray#writeByte(value:int):void\n\n\n    this.writeByte = function (byte) {\n      prepareWrite(this, 1);\n      this.bytes[this.position] = byte;\n      this.position++;\n      this.length = Math.max(this.length, this.position);\n    }; // ByteArray#writeShort(value:int):void\n\n\n    this.writeShort = function (short) {\n      prepareWrite(this, 2);\n      this.view.setUint16(this.position, short);\n      this.position += 2;\n      this.length = Math.max(this.length, this.position);\n    }; // Negative index into array\n    // (pos:uint):int\n\n\n    this.negIndex = function (pos) {\n      return this.bytes[this.length - pos];\n    }; // The functions below ONLY work when this[0] == VIDEO_TAG.\n    // We are not going to check for that because we dont want the overhead\n    // (nal:ByteArray = null):int\n\n\n    this.nalUnitSize = function () {\n      if (adHoc === 0) {\n        return 0;\n      }\n\n      return this.length - (adHoc + 4);\n    };\n\n    this.startNalUnit = function () {\n      // remember position and add 4 bytes\n      if (adHoc > 0) {\n        throw new Error('Attempted to create new NAL wihout closing the old one');\n      } // reserve 4 bytes for nal unit size\n\n\n      adHoc = this.length;\n      this.length += 4;\n      this.position = this.length;\n    }; // (nal:ByteArray = null):void\n\n\n    this.endNalUnit = function (nalContainer) {\n      var nalStart, // :uint\n      nalLength; // :uint\n      // Rewind to the marker and write the size\n\n      if (this.length === adHoc + 4) {\n        // we started a nal unit, but didnt write one, so roll back the 4 byte size value\n        this.length -= 4;\n      } else if (adHoc > 0) {\n        nalStart = adHoc + 4;\n        nalLength = this.length - nalStart;\n        this.position = adHoc;\n        this.view.setUint32(this.position, nalLength);\n        this.position = this.length;\n\n        if (nalContainer) {\n          // Add the tag to the NAL unit\n          nalContainer.push(this.bytes.subarray(nalStart, nalStart + nalLength));\n        }\n      }\n\n      adHoc = 0;\n    };\n    /**\n     * Write out a 64-bit floating point valued metadata property. This method is\n     * called frequently during a typical parse and needs to be fast.\n     */\n    // (key:String, val:Number):void\n\n\n    this.writeMetaDataDouble = function (key, val) {\n      var i;\n      prepareWrite(this, 2 + key.length + 9); // write size of property name\n\n      this.view.setUint16(this.position, key.length);\n      this.position += 2; // this next part looks terrible but it improves parser throughput by\n      // 10kB/s in my testing\n      // write property name\n\n      if (key === 'width') {\n        this.bytes.set(widthBytes, this.position);\n        this.position += 5;\n      } else if (key === 'height') {\n        this.bytes.set(heightBytes, this.position);\n        this.position += 6;\n      } else if (key === 'videocodecid') {\n        this.bytes.set(videocodecidBytes, this.position);\n        this.position += 12;\n      } else {\n        for (i = 0; i < key.length; i++) {\n          this.bytes[this.position] = key.charCodeAt(i);\n          this.position++;\n        }\n      } // skip null byte\n\n\n      this.position++; // write property value\n\n      this.view.setFloat64(this.position, val);\n      this.position += 8; // update flv tag length\n\n      this.length = Math.max(this.length, this.position);\n      ++adHoc;\n    }; // (key:String, val:Boolean):void\n\n\n    this.writeMetaDataBoolean = function (key, val) {\n      var i;\n      prepareWrite(this, 2);\n      this.view.setUint16(this.position, key.length);\n      this.position += 2;\n\n      for (i = 0; i < key.length; i++) {\n        // if key.charCodeAt(i) >= 255, handle error\n        prepareWrite(this, 1);\n        this.bytes[this.position] = key.charCodeAt(i);\n        this.position++;\n      }\n\n      prepareWrite(this, 2);\n      this.view.setUint8(this.position, 0x01);\n      this.position++;\n      this.view.setUint8(this.position, val ? 0x01 : 0x00);\n      this.position++;\n      this.length = Math.max(this.length, this.position);\n      ++adHoc;\n    }; // ():ByteArray\n\n\n    this.finalize = function () {\n      var dtsDelta, // :int\n      len; // :int\n\n      switch (this.bytes[0]) {\n        // Video Data\n        case _FlvTag.VIDEO_TAG:\n          // We only support AVC, 1 = key frame (for AVC, a seekable\n          // frame), 2 = inter frame (for AVC, a non-seekable frame)\n          this.bytes[11] = (this.keyFrame || extraData ? 0x10 : 0x20) | 0x07;\n          this.bytes[12] = extraData ? 0x00 : 0x01;\n          dtsDelta = this.pts - this.dts;\n          this.bytes[13] = (dtsDelta & 0x00FF0000) >>> 16;\n          this.bytes[14] = (dtsDelta & 0x0000FF00) >>> 8;\n          this.bytes[15] = (dtsDelta & 0x000000FF) >>> 0;\n          break;\n\n        case _FlvTag.AUDIO_TAG:\n          this.bytes[11] = 0xAF; // 44 kHz, 16-bit stereo\n\n          this.bytes[12] = extraData ? 0x00 : 0x01;\n          break;\n\n        case _FlvTag.METADATA_TAG:\n          this.position = 11;\n          this.view.setUint8(this.position, 0x02); // String type\n\n          this.position++;\n          this.view.setUint16(this.position, 0x0A); // 10 Bytes\n\n          this.position += 2; // set \"onMetaData\"\n\n          this.bytes.set([0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61], this.position);\n          this.position += 10;\n          this.bytes[this.position] = 0x08; // Array type\n\n          this.position++;\n          this.view.setUint32(this.position, adHoc);\n          this.position = this.length;\n          this.bytes.set([0, 0, 9], this.position);\n          this.position += 3; // End Data Tag\n\n          this.length = this.position;\n          break;\n      }\n\n      len = this.length - 11; // write the DataSize field\n\n      this.bytes[1] = (len & 0x00FF0000) >>> 16;\n      this.bytes[2] = (len & 0x0000FF00) >>> 8;\n      this.bytes[3] = (len & 0x000000FF) >>> 0; // write the Timestamp\n\n      this.bytes[4] = (this.dts & 0x00FF0000) >>> 16;\n      this.bytes[5] = (this.dts & 0x0000FF00) >>> 8;\n      this.bytes[6] = (this.dts & 0x000000FF) >>> 0;\n      this.bytes[7] = (this.dts & 0xFF000000) >>> 24; // write the StreamID\n\n      this.bytes[8] = 0;\n      this.bytes[9] = 0;\n      this.bytes[10] = 0; // Sometimes we're at the end of the view and have one slot to write a\n      // uint32, so, prepareWrite of count 4, since, view is uint8\n\n      prepareWrite(this, 4);\n      this.view.setUint32(this.length, this.length);\n      this.length += 4;\n      this.position += 4; // trim down the byte buffer to what is actually being used\n\n      this.bytes = this.bytes.subarray(0, this.length);\n      this.frameTime = _FlvTag.frameTime(this.bytes); // if bytes.bytelength isn't equal to this.length, handle error\n\n      return this;\n    };\n  };\n\n  _FlvTag.AUDIO_TAG = 0x08; // == 8, :uint\n\n  _FlvTag.VIDEO_TAG = 0x09; // == 9, :uint\n\n  _FlvTag.METADATA_TAG = 0x12; // == 18, :uint\n  // (tag:ByteArray):Boolean {\n\n  _FlvTag.isAudioFrame = function (tag) {\n    return _FlvTag.AUDIO_TAG === tag[0];\n  }; // (tag:ByteArray):Boolean {\n\n\n  _FlvTag.isVideoFrame = function (tag) {\n    return _FlvTag.VIDEO_TAG === tag[0];\n  }; // (tag:ByteArray):Boolean {\n\n\n  _FlvTag.isMetaData = function (tag) {\n    return _FlvTag.METADATA_TAG === tag[0];\n  }; // (tag:ByteArray):Boolean {\n\n\n  _FlvTag.isKeyFrame = function (tag) {\n    if (_FlvTag.isVideoFrame(tag)) {\n      return tag[11] === 0x17;\n    }\n\n    if (_FlvTag.isAudioFrame(tag)) {\n      return true;\n    }\n\n    if (_FlvTag.isMetaData(tag)) {\n      return true;\n    }\n\n    return false;\n  }; // (tag:ByteArray):uint {\n\n\n  _FlvTag.frameTime = function (tag) {\n    var pts = tag[4] << 16; // :uint\n\n    pts |= tag[5] << 8;\n    pts |= tag[6] << 0;\n    pts |= tag[7] << 24;\n    return pts;\n  };\n\n  var flvTag = _FlvTag;\n\n  /**\n   * The final stage of the transmuxer that emits the flv tags\n   * for audio, video, and metadata. Also tranlates in time and\n   * outputs caption data and id3 cues.\n   */\n\n\n  var CoalesceStream = function CoalesceStream(options) {\n    // Number of Tracks per output segment\n    // If greater than 1, we combine multiple\n    // tracks into a single segment\n    this.numberOfTracks = 0;\n    this.metadataStream = options.metadataStream;\n    this.videoTags = [];\n    this.audioTags = [];\n    this.videoTrack = null;\n    this.audioTrack = null;\n    this.pendingCaptions = [];\n    this.pendingMetadata = [];\n    this.pendingTracks = 0;\n    this.processedTracks = 0;\n    CoalesceStream.prototype.init.call(this); // Take output from multiple\n\n    this.push = function (output) {\n      // buffer incoming captions until the associated video segment\n      // finishes\n      if (output.text) {\n        return this.pendingCaptions.push(output);\n      } // buffer incoming id3 tags until the final flush\n\n\n      if (output.frames) {\n        return this.pendingMetadata.push(output);\n      }\n\n      if (output.track.type === 'video') {\n        this.videoTrack = output.track;\n        this.videoTags = output.tags;\n        this.pendingTracks++;\n      }\n\n      if (output.track.type === 'audio') {\n        this.audioTrack = output.track;\n        this.audioTags = output.tags;\n        this.pendingTracks++;\n      }\n    };\n  };\n\n  CoalesceStream.prototype = new stream();\n\n  CoalesceStream.prototype.flush = function (flushSource) {\n    var id3,\n        caption,\n        i,\n        timelineStartPts,\n        event = {\n      tags: {},\n      captions: [],\n      captionStreams: {},\n      metadata: []\n    };\n\n    if (this.pendingTracks < this.numberOfTracks) {\n      if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {\n        // Return because we haven't received a flush from a data-generating\n        // portion of the segment (meaning that we have only recieved meta-data\n        // or captions.)\n        return;\n      } else if (this.pendingTracks === 0) {\n        // In the case where we receive a flush without any data having been\n        // received we consider it an emitted track for the purposes of coalescing\n        // `done` events.\n        // We do this for the case where there is an audio and video track in the\n        // segment but no audio data. (seen in several playlists with alternate\n        // audio tracks and no audio present in the main TS segments.)\n        this.processedTracks++;\n\n        if (this.processedTracks < this.numberOfTracks) {\n          return;\n        }\n      }\n    }\n\n    this.processedTracks += this.pendingTracks;\n    this.pendingTracks = 0;\n\n    if (this.processedTracks < this.numberOfTracks) {\n      return;\n    }\n\n    if (this.videoTrack) {\n      timelineStartPts = this.videoTrack.timelineStartInfo.pts;\n    } else if (this.audioTrack) {\n      timelineStartPts = this.audioTrack.timelineStartInfo.pts;\n    }\n\n    event.tags.videoTags = this.videoTags;\n    event.tags.audioTags = this.audioTags; // Translate caption PTS times into second offsets into the\n    // video timeline for the segment, and add track info\n\n    for (i = 0; i < this.pendingCaptions.length; i++) {\n      caption = this.pendingCaptions[i];\n      caption.startTime = caption.startPts - timelineStartPts;\n      caption.startTime /= 90e3;\n      caption.endTime = caption.endPts - timelineStartPts;\n      caption.endTime /= 90e3;\n      event.captionStreams[caption.stream] = true;\n      event.captions.push(caption);\n    } // Translate ID3 frame PTS times into second offsets into the\n    // video timeline for the segment\n\n\n    for (i = 0; i < this.pendingMetadata.length; i++) {\n      id3 = this.pendingMetadata[i];\n      id3.cueTime = id3.pts - timelineStartPts;\n      id3.cueTime /= 90e3;\n      event.metadata.push(id3);\n    } // We add this to every single emitted segment even though we only need\n    // it for the first\n\n\n    event.metadata.dispatchType = this.metadataStream.dispatchType; // Reset stream state\n\n    this.videoTrack = null;\n    this.audioTrack = null;\n    this.videoTags = [];\n    this.audioTags = [];\n    this.pendingCaptions.length = 0;\n    this.pendingMetadata.length = 0;\n    this.pendingTracks = 0;\n    this.processedTracks = 0; // Emit the final segment\n\n    this.trigger('data', event);\n    this.trigger('done');\n  };\n\n  var coalesceStream = CoalesceStream;\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var TagList = function TagList() {\n    var self = this;\n    this.list = [];\n\n    this.push = function (tag) {\n      this.list.push({\n        bytes: tag.bytes,\n        dts: tag.dts,\n        pts: tag.pts,\n        keyFrame: tag.keyFrame,\n        metaDataTag: tag.metaDataTag\n      });\n    };\n\n    Object.defineProperty(this, 'length', {\n      get: function get() {\n        return self.list.length;\n      }\n    });\n  };\n\n  var tagList = TagList;\n\n  var H264Stream = h264.H264Stream;\n\n  var _Transmuxer, _VideoSegmentStream, _AudioSegmentStream, collectTimelineInfo, metaDataTag, extraDataTag;\n  /**\n   * Store information about the start and end of the tracka and the\n   * duration for each frame/sample we process in order to calculate\n   * the baseMediaDecodeTime\n   */\n\n\n  collectTimelineInfo = function collectTimelineInfo(track, data) {\n    if (typeof data.pts === 'number') {\n      if (track.timelineStartInfo.pts === undefined) {\n        track.timelineStartInfo.pts = data.pts;\n      } else {\n        track.timelineStartInfo.pts = Math.min(track.timelineStartInfo.pts, data.pts);\n      }\n    }\n\n    if (typeof data.dts === 'number') {\n      if (track.timelineStartInfo.dts === undefined) {\n        track.timelineStartInfo.dts = data.dts;\n      } else {\n        track.timelineStartInfo.dts = Math.min(track.timelineStartInfo.dts, data.dts);\n      }\n    }\n  };\n\n  metaDataTag = function metaDataTag(track, pts) {\n    var tag = new flvTag(flvTag.METADATA_TAG); // :FlvTag\n\n    tag.dts = pts;\n    tag.pts = pts;\n    tag.writeMetaDataDouble('videocodecid', 7);\n    tag.writeMetaDataDouble('width', track.width);\n    tag.writeMetaDataDouble('height', track.height);\n    return tag;\n  };\n\n  extraDataTag = function extraDataTag(track, pts) {\n    var i,\n        tag = new flvTag(flvTag.VIDEO_TAG, true);\n    tag.dts = pts;\n    tag.pts = pts;\n    tag.writeByte(0x01); // version\n\n    tag.writeByte(track.profileIdc); // profile\n\n    tag.writeByte(track.profileCompatibility); // compatibility\n\n    tag.writeByte(track.levelIdc); // level\n\n    tag.writeByte(0xFC | 0x03); // reserved (6 bits), NULA length size - 1 (2 bits)\n\n    tag.writeByte(0xE0 | 0x01); // reserved (3 bits), num of SPS (5 bits)\n\n    tag.writeShort(track.sps[0].length); // data of SPS\n\n    tag.writeBytes(track.sps[0]); // SPS\n\n    tag.writeByte(track.pps.length); // num of PPS (will there ever be more that 1 PPS?)\n\n    for (i = 0; i < track.pps.length; ++i) {\n      tag.writeShort(track.pps[i].length); // 2 bytes for length of PPS\n\n      tag.writeBytes(track.pps[i]); // data of PPS\n    }\n\n    return tag;\n  };\n  /**\n   * Constructs a single-track, media segment from AAC data\n   * events. The output of this stream can be fed to flash.\n   */\n\n\n  _AudioSegmentStream = function AudioSegmentStream(track) {\n    var adtsFrames = [],\n        videoKeyFrames = [],\n        oldExtraData;\n\n    _AudioSegmentStream.prototype.init.call(this);\n\n    this.push = function (data) {\n      collectTimelineInfo(track, data);\n\n      if (track) {\n        track.audioobjecttype = data.audioobjecttype;\n        track.channelcount = data.channelcount;\n        track.samplerate = data.samplerate;\n        track.samplingfrequencyindex = data.samplingfrequencyindex;\n        track.samplesize = data.samplesize;\n        track.extraData = track.audioobjecttype << 11 | track.samplingfrequencyindex << 7 | track.channelcount << 3;\n      }\n\n      data.pts = Math.round(data.pts / 90);\n      data.dts = Math.round(data.dts / 90); // buffer audio data until end() is called\n\n      adtsFrames.push(data);\n    };\n\n    this.flush = function () {\n      var currentFrame,\n          adtsFrame,\n          lastMetaPts,\n          tags = new tagList(); // return early if no audio data has been observed\n\n      if (adtsFrames.length === 0) {\n        this.trigger('done', 'AudioSegmentStream');\n        return;\n      }\n\n      lastMetaPts = -Infinity;\n\n      while (adtsFrames.length) {\n        currentFrame = adtsFrames.shift(); // write out a metadata frame at every video key frame\n\n        if (videoKeyFrames.length && currentFrame.pts >= videoKeyFrames[0]) {\n          lastMetaPts = videoKeyFrames.shift();\n          this.writeMetaDataTags(tags, lastMetaPts);\n        } // also write out metadata tags every 1 second so that the decoder\n        // is re-initialized quickly after seeking into a different\n        // audio configuration.\n\n\n        if (track.extraData !== oldExtraData || currentFrame.pts - lastMetaPts >= 1000) {\n          this.writeMetaDataTags(tags, currentFrame.pts);\n          oldExtraData = track.extraData;\n          lastMetaPts = currentFrame.pts;\n        }\n\n        adtsFrame = new flvTag(flvTag.AUDIO_TAG);\n        adtsFrame.pts = currentFrame.pts;\n        adtsFrame.dts = currentFrame.dts;\n        adtsFrame.writeBytes(currentFrame.data);\n        tags.push(adtsFrame.finalize());\n      }\n\n      videoKeyFrames.length = 0;\n      oldExtraData = null;\n      this.trigger('data', {\n        track: track,\n        tags: tags.list\n      });\n      this.trigger('done', 'AudioSegmentStream');\n    };\n\n    this.writeMetaDataTags = function (tags, pts) {\n      var adtsFrame;\n      adtsFrame = new flvTag(flvTag.METADATA_TAG); // For audio, DTS is always the same as PTS. We want to set the DTS\n      // however so we can compare with video DTS to determine approximate\n      // packet order\n\n      adtsFrame.pts = pts;\n      adtsFrame.dts = pts; // AAC is always 10\n\n      adtsFrame.writeMetaDataDouble('audiocodecid', 10);\n      adtsFrame.writeMetaDataBoolean('stereo', track.channelcount === 2);\n      adtsFrame.writeMetaDataDouble('audiosamplerate', track.samplerate); // Is AAC always 16 bit?\n\n      adtsFrame.writeMetaDataDouble('audiosamplesize', 16);\n      tags.push(adtsFrame.finalize());\n      adtsFrame = new flvTag(flvTag.AUDIO_TAG, true); // For audio, DTS is always the same as PTS. We want to set the DTS\n      // however so we can compare with video DTS to determine approximate\n      // packet order\n\n      adtsFrame.pts = pts;\n      adtsFrame.dts = pts;\n      adtsFrame.view.setUint16(adtsFrame.position, track.extraData);\n      adtsFrame.position += 2;\n      adtsFrame.length = Math.max(adtsFrame.length, adtsFrame.position);\n      tags.push(adtsFrame.finalize());\n    };\n\n    this.onVideoKeyFrame = function (pts) {\n      videoKeyFrames.push(pts);\n    };\n  };\n\n  _AudioSegmentStream.prototype = new stream();\n  /**\n   * Store FlvTags for the h264 stream\n   * @param track {object} track metadata configuration\n   */\n\n  _VideoSegmentStream = function VideoSegmentStream(track) {\n    var nalUnits = [],\n        config,\n        h264Frame;\n\n    _VideoSegmentStream.prototype.init.call(this);\n\n    this.finishFrame = function (tags, frame) {\n      if (!frame) {\n        return;\n      } // Check if keyframe and the length of tags.\n      // This makes sure we write metadata on the first frame of a segment.\n\n\n      if (config && track && track.newMetadata && (frame.keyFrame || tags.length === 0)) {\n        // Push extra data on every IDR frame in case we did a stream change + seek\n        var metaTag = metaDataTag(config, frame.dts).finalize();\n        var extraTag = extraDataTag(track, frame.dts).finalize();\n        metaTag.metaDataTag = extraTag.metaDataTag = true;\n        tags.push(metaTag);\n        tags.push(extraTag);\n        track.newMetadata = false;\n        this.trigger('keyframe', frame.dts);\n      }\n\n      frame.endNalUnit();\n      tags.push(frame.finalize());\n      h264Frame = null;\n    };\n\n    this.push = function (data) {\n      collectTimelineInfo(track, data);\n      data.pts = Math.round(data.pts / 90);\n      data.dts = Math.round(data.dts / 90); // buffer video until flush() is called\n\n      nalUnits.push(data);\n    };\n\n    this.flush = function () {\n      var currentNal,\n          tags = new tagList(); // Throw away nalUnits at the start of the byte stream until we find\n      // the first AUD\n\n      while (nalUnits.length) {\n        if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {\n          break;\n        }\n\n        nalUnits.shift();\n      } // return early if no video data has been observed\n\n\n      if (nalUnits.length === 0) {\n        this.trigger('done', 'VideoSegmentStream');\n        return;\n      }\n\n      while (nalUnits.length) {\n        currentNal = nalUnits.shift(); // record the track config\n\n        if (currentNal.nalUnitType === 'seq_parameter_set_rbsp') {\n          track.newMetadata = true;\n          config = currentNal.config;\n          track.width = config.width;\n          track.height = config.height;\n          track.sps = [currentNal.data];\n          track.profileIdc = config.profileIdc;\n          track.levelIdc = config.levelIdc;\n          track.profileCompatibility = config.profileCompatibility;\n          h264Frame.endNalUnit();\n        } else if (currentNal.nalUnitType === 'pic_parameter_set_rbsp') {\n          track.newMetadata = true;\n          track.pps = [currentNal.data];\n          h264Frame.endNalUnit();\n        } else if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {\n          if (h264Frame) {\n            this.finishFrame(tags, h264Frame);\n          }\n\n          h264Frame = new flvTag(flvTag.VIDEO_TAG);\n          h264Frame.pts = currentNal.pts;\n          h264Frame.dts = currentNal.dts;\n        } else {\n          if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {\n            // the current sample is a key frame\n            h264Frame.keyFrame = true;\n          }\n\n          h264Frame.endNalUnit();\n        }\n\n        h264Frame.startNalUnit();\n        h264Frame.writeBytes(currentNal.data);\n      }\n\n      if (h264Frame) {\n        this.finishFrame(tags, h264Frame);\n      }\n\n      this.trigger('data', {\n        track: track,\n        tags: tags.list\n      }); // Continue with the flush process now\n\n      this.trigger('done', 'VideoSegmentStream');\n    };\n  };\n\n  _VideoSegmentStream.prototype = new stream();\n  /**\n   * An object that incrementally transmuxes MPEG2 Trasport Stream\n   * chunks into an FLV.\n   */\n\n  _Transmuxer = function Transmuxer(options) {\n    var self = this,\n        packetStream,\n        parseStream,\n        elementaryStream,\n        videoTimestampRolloverStream,\n        audioTimestampRolloverStream,\n        timedMetadataTimestampRolloverStream,\n        adtsStream,\n        h264Stream,\n        videoSegmentStream,\n        audioSegmentStream,\n        captionStream,\n        coalesceStream$1;\n\n    _Transmuxer.prototype.init.call(this);\n\n    options = options || {}; // expose the metadata stream\n\n    this.metadataStream = new m2ts_1.MetadataStream();\n    options.metadataStream = this.metadataStream; // set up the parsing pipeline\n\n    packetStream = new m2ts_1.TransportPacketStream();\n    parseStream = new m2ts_1.TransportParseStream();\n    elementaryStream = new m2ts_1.ElementaryStream();\n    videoTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('video');\n    audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');\n    timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');\n    adtsStream = new adts();\n    h264Stream = new H264Stream();\n    coalesceStream$1 = new coalesceStream(options); // disassemble MPEG2-TS packets into elementary streams\n\n    packetStream.pipe(parseStream).pipe(elementaryStream); // !!THIS ORDER IS IMPORTANT!!\n    // demux the streams\n\n    elementaryStream.pipe(videoTimestampRolloverStream).pipe(h264Stream);\n    elementaryStream.pipe(audioTimestampRolloverStream).pipe(adtsStream);\n    elementaryStream.pipe(timedMetadataTimestampRolloverStream).pipe(this.metadataStream).pipe(coalesceStream$1); // if CEA-708 parsing is available, hook up a caption stream\n\n    captionStream = new m2ts_1.CaptionStream(options);\n    h264Stream.pipe(captionStream).pipe(coalesceStream$1); // hook up the segment streams once track metadata is delivered\n\n    elementaryStream.on('data', function (data) {\n      var i, videoTrack, audioTrack;\n\n      if (data.type === 'metadata') {\n        i = data.tracks.length; // scan the tracks listed in the metadata\n\n        while (i--) {\n          if (data.tracks[i].type === 'video') {\n            videoTrack = data.tracks[i];\n          } else if (data.tracks[i].type === 'audio') {\n            audioTrack = data.tracks[i];\n          }\n        } // hook up the video segment stream to the first track with h264 data\n\n\n        if (videoTrack && !videoSegmentStream) {\n          coalesceStream$1.numberOfTracks++;\n          videoSegmentStream = new _VideoSegmentStream(videoTrack); // Set up the final part of the video pipeline\n\n          h264Stream.pipe(videoSegmentStream).pipe(coalesceStream$1);\n        }\n\n        if (audioTrack && !audioSegmentStream) {\n          // hook up the audio segment stream to the first track with aac data\n          coalesceStream$1.numberOfTracks++;\n          audioSegmentStream = new _AudioSegmentStream(audioTrack); // Set up the final part of the audio pipeline\n\n          adtsStream.pipe(audioSegmentStream).pipe(coalesceStream$1);\n\n          if (videoSegmentStream) {\n            videoSegmentStream.on('keyframe', audioSegmentStream.onVideoKeyFrame);\n          }\n        }\n      }\n    }); // feed incoming data to the front of the parsing pipeline\n\n    this.push = function (data) {\n      packetStream.push(data);\n    }; // flush any buffered data\n\n\n    this.flush = function () {\n      // Start at the top of the pipeline and flush all pending work\n      packetStream.flush();\n    }; // Caption data has to be reset when seeking outside buffered range\n\n\n    this.resetCaptions = function () {\n      captionStream.reset();\n    }; // Re-emit any data coming from the coalesce stream to the outside world\n\n\n    coalesceStream$1.on('data', function (event) {\n      self.trigger('data', event);\n    }); // Let the consumer know we have finished flushing the entire pipeline\n\n    coalesceStream$1.on('done', function () {\n      self.trigger('done');\n    });\n  };\n\n  _Transmuxer.prototype = new stream(); // forward compatibility\n\n  var transmuxer$1 = _Transmuxer;\n\n  // http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf.\n  // Technically, this function returns the header and a metadata FLV tag\n  // if duration is greater than zero\n  // duration in seconds\n  // @return {object} the bytes of the FLV header as a Uint8Array\n\n\n  var getFlvHeader = function getFlvHeader(duration, audio, video) {\n    // :ByteArray {\n    var headBytes = new Uint8Array(3 + 1 + 1 + 4),\n        head = new DataView(headBytes.buffer),\n        metadata,\n        result,\n        metadataLength; // default arguments\n\n    duration = duration || 0;\n    audio = audio === undefined ? true : audio;\n    video = video === undefined ? true : video; // signature\n\n    head.setUint8(0, 0x46); // 'F'\n\n    head.setUint8(1, 0x4c); // 'L'\n\n    head.setUint8(2, 0x56); // 'V'\n    // version\n\n    head.setUint8(3, 0x01); // flags\n\n    head.setUint8(4, (audio ? 0x04 : 0x00) | (video ? 0x01 : 0x00)); // data offset, should be 9 for FLV v1\n\n    head.setUint32(5, headBytes.byteLength); // init the first FLV tag\n\n    if (duration <= 0) {\n      // no duration available so just write the first field of the first\n      // FLV tag\n      result = new Uint8Array(headBytes.byteLength + 4);\n      result.set(headBytes);\n      result.set([0, 0, 0, 0], headBytes.byteLength);\n      return result;\n    } // write out the duration metadata tag\n\n\n    metadata = new flvTag(flvTag.METADATA_TAG);\n    metadata.pts = metadata.dts = 0;\n    metadata.writeMetaDataDouble('duration', duration);\n    metadataLength = metadata.finalize().length;\n    result = new Uint8Array(headBytes.byteLength + metadataLength);\n    result.set(headBytes);\n    result.set(head.byteLength, metadataLength);\n    return result;\n  };\n\n  var flvHeader = getFlvHeader;\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var flv = {\n    tag: flvTag,\n    Transmuxer: transmuxer$1,\n    getFlvHeader: flvHeader\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var m2ts = m2ts_1;\n\n  var ONE_SECOND_IN_TS$1 = clock.ONE_SECOND_IN_TS;\n  /**\n   * Constructs a single-track, ISO BMFF media segment from AAC data\n   * events. The output of this stream can be fed to a SourceBuffer\n   * configured with a suitable initialization segment.\n   */\n\n  var AudioSegmentStream = function AudioSegmentStream(track, options) {\n    var adtsFrames = [],\n        sequenceNumber = 0,\n        earliestAllowedDts = 0,\n        audioAppendStartTs = 0,\n        videoBaseMediaDecodeTime = Infinity,\n        segmentStartPts = null,\n        segmentEndPts = null;\n    options = options || {};\n    AudioSegmentStream.prototype.init.call(this);\n\n    this.push = function (data) {\n      trackDecodeInfo.collectDtsInfo(track, data);\n\n      if (track) {\n        audioProperties.forEach(function (prop) {\n          track[prop] = data[prop];\n        });\n      } // buffer audio data until end() is called\n\n\n      adtsFrames.push(data);\n    };\n\n    this.setEarliestDts = function (earliestDts) {\n      earliestAllowedDts = earliestDts;\n    };\n\n    this.setVideoBaseMediaDecodeTime = function (baseMediaDecodeTime) {\n      videoBaseMediaDecodeTime = baseMediaDecodeTime;\n    };\n\n    this.setAudioAppendStart = function (timestamp) {\n      audioAppendStartTs = timestamp;\n    };\n\n    this.processFrames_ = function () {\n      var frames, moof, mdat, boxes, timingInfo; // return early if no audio data has been observed\n\n      if (adtsFrames.length === 0) {\n        return;\n      }\n\n      frames = audioFrameUtils.trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts);\n\n      if (frames.length === 0) {\n        // return early if the frames are all after the earliest allowed DTS\n        // TODO should we clear the adtsFrames?\n        return;\n      }\n\n      track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);\n      audioFrameUtils.prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime); // we have to build the index from byte locations to\n      // samples (that is, adts frames) in the audio data\n\n      track.samples = audioFrameUtils.generateSampleTable(frames); // concatenate the audio data to constuct the mdat\n\n      mdat = mp4Generator.mdat(audioFrameUtils.concatenateFrameData(frames));\n      adtsFrames = [];\n      moof = mp4Generator.moof(sequenceNumber, [track]); // bump the sequence number for next time\n\n      sequenceNumber++;\n      track.initSegment = mp4Generator.initSegment([track]); // it would be great to allocate this array up front instead of\n      // throwing away hundreds of media segment fragments\n\n      boxes = new Uint8Array(moof.byteLength + mdat.byteLength);\n      boxes.set(moof);\n      boxes.set(mdat, moof.byteLength);\n      trackDecodeInfo.clearDtsInfo(track);\n\n      if (segmentStartPts === null) {\n        segmentEndPts = segmentStartPts = frames[0].pts;\n      }\n\n      segmentEndPts += frames.length * (ONE_SECOND_IN_TS$1 * 1024 / track.samplerate);\n      timingInfo = {\n        start: segmentStartPts\n      };\n      this.trigger('timingInfo', timingInfo);\n      this.trigger('data', {\n        track: track,\n        boxes: boxes\n      });\n    };\n\n    this.flush = function () {\n      this.processFrames_(); // trigger final timing info\n\n      this.trigger('timingInfo', {\n        start: segmentStartPts,\n        end: segmentEndPts\n      });\n      this.resetTiming_();\n      this.trigger('done', 'AudioSegmentStream');\n    };\n\n    this.partialFlush = function () {\n      this.processFrames_();\n      this.trigger('partialdone', 'AudioSegmentStream');\n    };\n\n    this.endTimeline = function () {\n      this.flush();\n      this.trigger('endedtimeline', 'AudioSegmentStream');\n    };\n\n    this.resetTiming_ = function () {\n      trackDecodeInfo.clearDtsInfo(track);\n      segmentStartPts = null;\n      segmentEndPts = null;\n    };\n\n    this.reset = function () {\n      this.resetTiming_();\n      adtsFrames = [];\n      this.trigger('reset');\n    };\n  };\n\n  AudioSegmentStream.prototype = new stream();\n  var audioSegmentStream = AudioSegmentStream;\n\n  var VideoSegmentStream = function VideoSegmentStream(track, options) {\n    var sequenceNumber = 0,\n        nalUnits = [],\n        frameCache = [],\n        // gopsToAlignWith = [],\n    config,\n        pps,\n        segmentStartPts = null,\n        segmentEndPts = null,\n        gops,\n        ensureNextFrameIsKeyFrame = true;\n    options = options || {};\n    VideoSegmentStream.prototype.init.call(this);\n\n    this.push = function (nalUnit) {\n      trackDecodeInfo.collectDtsInfo(track, nalUnit);\n\n      if (typeof track.timelineStartInfo.dts === 'undefined') {\n        track.timelineStartInfo.dts = nalUnit.dts;\n      } // record the track config\n\n\n      if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {\n        config = nalUnit.config;\n        track.sps = [nalUnit.data];\n        videoProperties.forEach(function (prop) {\n          track[prop] = config[prop];\n        }, this);\n      }\n\n      if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {\n        pps = nalUnit.data;\n        track.pps = [nalUnit.data];\n      } // buffer video until flush() is called\n\n\n      nalUnits.push(nalUnit);\n    };\n\n    this.processNals_ = function (cacheLastFrame) {\n      var i;\n      nalUnits = frameCache.concat(nalUnits); // Throw away nalUnits at the start of the byte stream until\n      // we find the first AUD\n\n      while (nalUnits.length) {\n        if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {\n          break;\n        }\n\n        nalUnits.shift();\n      } // Return early if no video data has been observed\n\n\n      if (nalUnits.length === 0) {\n        return;\n      }\n\n      var frames = frameUtils.groupNalsIntoFrames(nalUnits);\n\n      if (!frames.length) {\n        return;\n      } // note that the frame cache may also protect us from cases where we haven't\n      // pushed data for the entire first or last frame yet\n\n\n      frameCache = frames[frames.length - 1];\n\n      if (cacheLastFrame) {\n        frames.pop();\n        frames.duration -= frameCache.duration;\n        frames.nalCount -= frameCache.length;\n        frames.byteLength -= frameCache.byteLength;\n      }\n\n      if (!frames.length) {\n        nalUnits = [];\n        return;\n      }\n\n      this.trigger('timelineStartInfo', track.timelineStartInfo);\n\n      if (ensureNextFrameIsKeyFrame) {\n        gops = frameUtils.groupFramesIntoGops(frames);\n\n        if (!gops[0][0].keyFrame) {\n          gops = frameUtils.extendFirstKeyFrame(gops);\n\n          if (!gops[0][0].keyFrame) {\n            // we haven't yet gotten a key frame, so reset nal units to wait for more nal\n            // units\n            nalUnits = [].concat.apply([], frames).concat(frameCache);\n            frameCache = [];\n            return;\n          }\n\n          frames = [].concat.apply([], gops);\n          frames.duration = gops.duration;\n        }\n\n        ensureNextFrameIsKeyFrame = false;\n      }\n\n      if (segmentStartPts === null) {\n        segmentStartPts = frames[0].pts;\n        segmentEndPts = segmentStartPts;\n      }\n\n      segmentEndPts += frames.duration;\n      this.trigger('timingInfo', {\n        start: segmentStartPts,\n        end: segmentEndPts\n      });\n\n      for (i = 0; i < frames.length; i++) {\n        var frame = frames[i];\n        track.samples = frameUtils.generateSampleTableForFrame(frame);\n        var mdat = mp4Generator.mdat(frameUtils.concatenateNalDataForFrame(frame));\n        trackDecodeInfo.clearDtsInfo(track);\n        trackDecodeInfo.collectDtsInfo(track, frame);\n        track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);\n        var moof = mp4Generator.moof(sequenceNumber, [track]);\n        sequenceNumber++;\n        track.initSegment = mp4Generator.initSegment([track]);\n        var boxes = new Uint8Array(moof.byteLength + mdat.byteLength);\n        boxes.set(moof);\n        boxes.set(mdat, moof.byteLength);\n        this.trigger('data', {\n          track: track,\n          boxes: boxes,\n          sequence: sequenceNumber,\n          videoFrameDts: frame.dts,\n          videoFramePts: frame.pts\n        });\n      }\n\n      nalUnits = [];\n    };\n\n    this.resetTimingAndConfig_ = function () {\n      config = undefined;\n      pps = undefined;\n      segmentStartPts = null;\n      segmentEndPts = null;\n    };\n\n    this.partialFlush = function () {\n      this.processNals_(true);\n      this.trigger('partialdone', 'VideoSegmentStream');\n    };\n\n    this.flush = function () {\n      this.processNals_(false); // reset config and pps because they may differ across segments\n      // for instance, when we are rendition switching\n\n      this.resetTimingAndConfig_();\n      this.trigger('done', 'VideoSegmentStream');\n    };\n\n    this.endTimeline = function () {\n      this.flush();\n      this.trigger('endedtimeline', 'VideoSegmentStream');\n    };\n\n    this.reset = function () {\n      this.resetTimingAndConfig_();\n      frameCache = [];\n      nalUnits = [];\n      ensureNextFrameIsKeyFrame = true;\n      this.trigger('reset');\n    };\n  };\n\n  VideoSegmentStream.prototype = new stream();\n  var videoSegmentStream = VideoSegmentStream;\n\n  var isLikelyAacData = utils.isLikelyAacData;\n\n  var createPipeline = function createPipeline(object) {\n    object.prototype = new stream();\n    object.prototype.init.call(object);\n    return object;\n  };\n\n  var tsPipeline = function tsPipeline(options) {\n    var pipeline = {\n      type: 'ts',\n      tracks: {\n        audio: null,\n        video: null\n      },\n      packet: new m2ts_1.TransportPacketStream(),\n      parse: new m2ts_1.TransportParseStream(),\n      elementary: new m2ts_1.ElementaryStream(),\n      timestampRollover: new m2ts_1.TimestampRolloverStream(),\n      adts: new codecs.Adts(),\n      h264: new codecs.h264.H264Stream(),\n      captionStream: new m2ts_1.CaptionStream(options),\n      metadataStream: new m2ts_1.MetadataStream()\n    };\n    pipeline.headOfPipeline = pipeline.packet; // Transport Stream\n\n    pipeline.packet.pipe(pipeline.parse).pipe(pipeline.elementary).pipe(pipeline.timestampRollover); // H264\n\n    pipeline.timestampRollover.pipe(pipeline.h264); // Hook up CEA-608/708 caption stream\n\n    pipeline.h264.pipe(pipeline.captionStream);\n    pipeline.timestampRollover.pipe(pipeline.metadataStream); // ADTS\n\n    pipeline.timestampRollover.pipe(pipeline.adts);\n    pipeline.elementary.on('data', function (data) {\n      if (data.type !== 'metadata') {\n        return;\n      }\n\n      for (var i = 0; i < data.tracks.length; i++) {\n        if (!pipeline.tracks[data.tracks[i].type]) {\n          pipeline.tracks[data.tracks[i].type] = data.tracks[i];\n          pipeline.tracks[data.tracks[i].type].timelineStartInfo.baseMediaDecodeTime = options.baseMediaDecodeTime;\n        }\n      }\n\n      if (pipeline.tracks.video && !pipeline.videoSegmentStream) {\n        pipeline.videoSegmentStream = new videoSegmentStream(pipeline.tracks.video, options);\n        pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {\n          if (pipeline.tracks.audio && !options.keepOriginalTimestamps) {\n            pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - options.baseMediaDecodeTime);\n          }\n        });\n        pipeline.videoSegmentStream.on('timingInfo', pipeline.trigger.bind(pipeline, 'videoTimingInfo'));\n        pipeline.videoSegmentStream.on('data', function (data) {\n          pipeline.trigger('data', {\n            type: 'video',\n            data: data\n          });\n        });\n        pipeline.videoSegmentStream.on('done', pipeline.trigger.bind(pipeline, 'done'));\n        pipeline.videoSegmentStream.on('partialdone', pipeline.trigger.bind(pipeline, 'partialdone'));\n        pipeline.videoSegmentStream.on('endedtimeline', pipeline.trigger.bind(pipeline, 'endedtimeline'));\n        pipeline.h264.pipe(pipeline.videoSegmentStream);\n      }\n\n      if (pipeline.tracks.audio && !pipeline.audioSegmentStream) {\n        pipeline.audioSegmentStream = new audioSegmentStream(pipeline.tracks.audio, options);\n        pipeline.audioSegmentStream.on('data', function (data) {\n          pipeline.trigger('data', {\n            type: 'audio',\n            data: data\n          });\n        });\n        pipeline.audioSegmentStream.on('done', pipeline.trigger.bind(pipeline, 'done'));\n        pipeline.audioSegmentStream.on('partialdone', pipeline.trigger.bind(pipeline, 'partialdone'));\n        pipeline.audioSegmentStream.on('endedtimeline', pipeline.trigger.bind(pipeline, 'endedtimeline'));\n        pipeline.audioSegmentStream.on('timingInfo', pipeline.trigger.bind(pipeline, 'audioTimingInfo'));\n        pipeline.adts.pipe(pipeline.audioSegmentStream);\n      } // emit pmt info\n\n\n      pipeline.trigger('trackinfo', {\n        hasAudio: !!pipeline.tracks.audio,\n        hasVideo: !!pipeline.tracks.video\n      });\n    });\n    pipeline.captionStream.on('data', function (caption) {\n      var timelineStartPts;\n\n      if (pipeline.tracks.video) {\n        timelineStartPts = pipeline.tracks.video.timelineStartInfo.pts || 0;\n      } else {\n        // This will only happen if we encounter caption packets before\n        // video data in a segment. This is an unusual/unlikely scenario,\n        // so we assume the timeline starts at zero for now.\n        timelineStartPts = 0;\n      } // Translate caption PTS times into second offsets into the\n      // video timeline for the segment\n\n\n      caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, options.keepOriginalTimestamps);\n      caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, options.keepOriginalTimestamps);\n      pipeline.trigger('caption', caption);\n    });\n    pipeline = createPipeline(pipeline);\n    pipeline.metadataStream.on('data', pipeline.trigger.bind(pipeline, 'id3Frame'));\n    return pipeline;\n  };\n\n  var aacPipeline = function aacPipeline(options) {\n    var pipeline = {\n      type: 'aac',\n      tracks: {\n        audio: null\n      },\n      metadataStream: new m2ts_1.MetadataStream(),\n      aacStream: new aac(),\n      audioRollover: new m2ts_1.TimestampRolloverStream('audio'),\n      timedMetadataRollover: new m2ts_1.TimestampRolloverStream('timed-metadata'),\n      adtsStream: new adts(true)\n    }; // set up the parsing pipeline\n\n    pipeline.headOfPipeline = pipeline.aacStream;\n    pipeline.aacStream.pipe(pipeline.audioRollover).pipe(pipeline.adtsStream);\n    pipeline.aacStream.pipe(pipeline.timedMetadataRollover).pipe(pipeline.metadataStream);\n    pipeline.metadataStream.on('timestamp', function (frame) {\n      pipeline.aacStream.setTimestamp(frame.timeStamp);\n    });\n    pipeline.aacStream.on('data', function (data) {\n      if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {\n        return;\n      }\n\n      pipeline.tracks.audio = pipeline.tracks.audio || {\n        timelineStartInfo: {\n          baseMediaDecodeTime: options.baseMediaDecodeTime\n        },\n        codec: 'adts',\n        type: 'audio'\n      }; // hook up the audio segment stream to the first track with aac data\n\n      pipeline.audioSegmentStream = new audioSegmentStream(pipeline.tracks.audio, options);\n      pipeline.audioSegmentStream.on('data', function (data) {\n        pipeline.trigger('data', {\n          type: 'audio',\n          data: data\n        });\n      });\n      pipeline.audioSegmentStream.on('partialdone', pipeline.trigger.bind(pipeline, 'partialdone'));\n      pipeline.audioSegmentStream.on('done', pipeline.trigger.bind(pipeline, 'done'));\n      pipeline.audioSegmentStream.on('endedtimeline', pipeline.trigger.bind(pipeline, 'endedtimeline'));\n      pipeline.audioSegmentStream.on('timingInfo', pipeline.trigger.bind(pipeline, 'audioTimingInfo')); // Set up the final part of the audio pipeline\n\n      pipeline.adtsStream.pipe(pipeline.audioSegmentStream);\n      pipeline.trigger('trackinfo', {\n        hasAudio: !!pipeline.tracks.audio,\n        hasVideo: !!pipeline.tracks.video\n      });\n    }); // set the pipeline up as a stream before binding to get access to the trigger function\n\n    pipeline = createPipeline(pipeline);\n    pipeline.metadataStream.on('data', pipeline.trigger.bind(pipeline, 'id3Frame'));\n    return pipeline;\n  };\n\n  var setupPipelineListeners = function setupPipelineListeners(pipeline, transmuxer) {\n    pipeline.on('data', transmuxer.trigger.bind(transmuxer, 'data'));\n    pipeline.on('done', transmuxer.trigger.bind(transmuxer, 'done'));\n    pipeline.on('partialdone', transmuxer.trigger.bind(transmuxer, 'partialdone'));\n    pipeline.on('endedtimeline', transmuxer.trigger.bind(transmuxer, 'endedtimeline'));\n    pipeline.on('audioTimingInfo', transmuxer.trigger.bind(transmuxer, 'audioTimingInfo'));\n    pipeline.on('videoTimingInfo', transmuxer.trigger.bind(transmuxer, 'videoTimingInfo'));\n    pipeline.on('trackinfo', transmuxer.trigger.bind(transmuxer, 'trackinfo'));\n    pipeline.on('id3Frame', function (event) {\n      // add this to every single emitted segment even though it's only needed for the first\n      event.dispatchType = pipeline.metadataStream.dispatchType; // keep original time, can be adjusted if needed at a higher level\n\n      event.cueTime = clock.videoTsToSeconds(event.pts);\n      transmuxer.trigger('id3Frame', event);\n    });\n    pipeline.on('caption', function (event) {\n      transmuxer.trigger('caption', event);\n    });\n  };\n\n  var Transmuxer = function Transmuxer(options) {\n    var pipeline = null,\n        hasFlushed = true;\n    options = options || {};\n    Transmuxer.prototype.init.call(this);\n    options.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;\n\n    this.push = function (bytes) {\n      if (hasFlushed) {\n        var isAac = isLikelyAacData(bytes);\n\n        if (isAac && (!pipeline || pipeline.type !== 'aac')) {\n          pipeline = aacPipeline(options);\n          setupPipelineListeners(pipeline, this);\n        } else if (!isAac && (!pipeline || pipeline.type !== 'ts')) {\n          pipeline = tsPipeline(options);\n          setupPipelineListeners(pipeline, this);\n        }\n\n        hasFlushed = false;\n      }\n\n      pipeline.headOfPipeline.push(bytes);\n    };\n\n    this.flush = function () {\n      if (!pipeline) {\n        return;\n      }\n\n      hasFlushed = true;\n      pipeline.headOfPipeline.flush();\n    };\n\n    this.partialFlush = function () {\n      if (!pipeline) {\n        return;\n      }\n\n      pipeline.headOfPipeline.partialFlush();\n    };\n\n    this.endTimeline = function () {\n      if (!pipeline) {\n        return;\n      }\n\n      pipeline.headOfPipeline.endTimeline();\n    };\n\n    this.reset = function () {\n      if (!pipeline) {\n        return;\n      }\n\n      pipeline.headOfPipeline.reset();\n    };\n\n    this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {\n      if (!options.keepOriginalTimestamps) {\n        options.baseMediaDecodeTime = baseMediaDecodeTime;\n      }\n\n      if (!pipeline) {\n        return;\n      }\n\n      if (pipeline.tracks.audio) {\n        pipeline.tracks.audio.timelineStartInfo.dts = undefined;\n        pipeline.tracks.audio.timelineStartInfo.pts = undefined;\n        trackDecodeInfo.clearDtsInfo(pipeline.tracks.audio);\n\n        if (pipeline.audioRollover) {\n          pipeline.audioRollover.discontinuity();\n        }\n      }\n\n      if (pipeline.tracks.video) {\n        if (pipeline.videoSegmentStream) {\n          pipeline.videoSegmentStream.gopCache_ = [];\n        }\n\n        pipeline.tracks.video.timelineStartInfo.dts = undefined;\n        pipeline.tracks.video.timelineStartInfo.pts = undefined;\n        trackDecodeInfo.clearDtsInfo(pipeline.tracks.video); // pipeline.captionStream.reset();\n      }\n\n      if (pipeline.timestampRollover) {\n        pipeline.timestampRollover.discontinuity();\n      }\n    };\n\n    this.setRemux = function (val) {\n      options.remux = val;\n\n      if (pipeline && pipeline.coalesceStream) {\n        pipeline.coalesceStream.setRemux(val);\n      }\n    };\n\n    this.setAudioAppendStart = function (audioAppendStart) {\n      if (!pipeline || !pipeline.tracks.audio || !pipeline.audioSegmentStream) {\n        return;\n      }\n\n      pipeline.audioSegmentStream.setAudioAppendStart(audioAppendStart);\n    }; // TODO GOP alignment support\n    // Support may be a bit trickier than with full segment appends, as GOPs may be split\n    // and processed in a more granular fashion\n\n\n    this.alignGopsWith = function (gopsToAlignWith) {\n      return;\n    };\n  };\n\n  Transmuxer.prototype = new stream();\n  var transmuxer = Transmuxer;\n\n  var partial = {\n    Transmuxer: transmuxer\n  };\n\n  var MAX_UINT32$1 = Math.pow(2, 32);\n\n  var parseSidx = function parseSidx(data) {\n    var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n        result = {\n      version: data[0],\n      flags: new Uint8Array(data.subarray(1, 4)),\n      references: [],\n      referenceId: view.getUint32(4),\n      timescale: view.getUint32(8)\n    },\n        i = 12;\n\n    if (result.version === 0) {\n      result.earliestPresentationTime = view.getUint32(i);\n      result.firstOffset = view.getUint32(i + 4);\n      i += 8;\n    } else {\n      // read 64 bits\n      result.earliestPresentationTime = view.getUint32(i) * MAX_UINT32$1 + view.getUint32(i + 4);\n      result.firstOffset = view.getUint32(i + 8) * MAX_UINT32$1 + view.getUint32(i + 12);\n      i += 16;\n    }\n\n    i += 2; // reserved\n\n    var referenceCount = view.getUint16(i);\n    i += 2; // start of references\n\n    for (; referenceCount > 0; i += 12, referenceCount--) {\n      result.references.push({\n        referenceType: (data[i] & 0x80) >>> 7,\n        referencedSize: view.getUint32(i) & 0x7FFFFFFF,\n        subsegmentDuration: view.getUint32(i + 4),\n        startsWithSap: !!(data[i + 8] & 0x80),\n        sapType: (data[i + 8] & 0x70) >>> 4,\n        sapDeltaTime: view.getUint32(i + 8) & 0x0FFFFFFF\n      });\n    }\n\n    return result;\n  };\n\n  var parseSidx_1 = parseSidx;\n\n  var MAX_UINT32 = Math.pow(2, 32);\n\n  var inspectMp4,\n      _textifyMp,\n      parseMp4Date = function parseMp4Date(seconds) {\n    return new Date(seconds * 1000 - 2082844800000);\n  },\n      nalParse = function nalParse(avcStream) {\n    var avcView = new DataView(avcStream.buffer, avcStream.byteOffset, avcStream.byteLength),\n        result = [],\n        i,\n        length;\n\n    for (i = 0; i + 4 < avcStream.length; i += length) {\n      length = avcView.getUint32(i);\n      i += 4; // bail if this doesn't appear to be an H264 stream\n\n      if (length <= 0) {\n        result.push('<span style=\\'color:red;\\'>MALFORMED DATA</span>');\n        continue;\n      }\n\n      switch (avcStream[i] & 0x1F) {\n        case 0x01:\n          result.push('slice_layer_without_partitioning_rbsp');\n          break;\n\n        case 0x05:\n          result.push('slice_layer_without_partitioning_rbsp_idr');\n          break;\n\n        case 0x06:\n          result.push('sei_rbsp');\n          break;\n\n        case 0x07:\n          result.push('seq_parameter_set_rbsp');\n          break;\n\n        case 0x08:\n          result.push('pic_parameter_set_rbsp');\n          break;\n\n        case 0x09:\n          result.push('access_unit_delimiter_rbsp');\n          break;\n\n        default:\n          result.push('UNKNOWN NAL - ' + avcStream[i] & 0x1F);\n          break;\n      }\n    }\n\n    return result;\n  },\n      // registry of handlers for individual mp4 box types\n  parse = {\n    // codingname, not a first-class box type. stsd entries share the\n    // same format as real boxes so the parsing infrastructure can be\n    // shared\n    avc1: function avc1(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n      return {\n        dataReferenceIndex: view.getUint16(6),\n        width: view.getUint16(24),\n        height: view.getUint16(26),\n        horizresolution: view.getUint16(28) + view.getUint16(30) / 16,\n        vertresolution: view.getUint16(32) + view.getUint16(34) / 16,\n        frameCount: view.getUint16(40),\n        depth: view.getUint16(74),\n        config: inspectMp4(data.subarray(78, data.byteLength))\n      };\n    },\n    avcC: function avcC(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        configurationVersion: data[0],\n        avcProfileIndication: data[1],\n        profileCompatibility: data[2],\n        avcLevelIndication: data[3],\n        lengthSizeMinusOne: data[4] & 0x03,\n        sps: [],\n        pps: []\n      },\n          numOfSequenceParameterSets = data[5] & 0x1f,\n          numOfPictureParameterSets,\n          nalSize,\n          offset,\n          i; // iterate past any SPSs\n\n      offset = 6;\n\n      for (i = 0; i < numOfSequenceParameterSets; i++) {\n        nalSize = view.getUint16(offset);\n        offset += 2;\n        result.sps.push(new Uint8Array(data.subarray(offset, offset + nalSize)));\n        offset += nalSize;\n      } // iterate past any PPSs\n\n\n      numOfPictureParameterSets = data[offset];\n      offset++;\n\n      for (i = 0; i < numOfPictureParameterSets; i++) {\n        nalSize = view.getUint16(offset);\n        offset += 2;\n        result.pps.push(new Uint8Array(data.subarray(offset, offset + nalSize)));\n        offset += nalSize;\n      }\n\n      return result;\n    },\n    btrt: function btrt(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n      return {\n        bufferSizeDB: view.getUint32(0),\n        maxBitrate: view.getUint32(4),\n        avgBitrate: view.getUint32(8)\n      };\n    },\n    edts: function edts(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    elst: function elst(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        version: view.getUint8(0),\n        flags: new Uint8Array(data.subarray(1, 4)),\n        edits: []\n      },\n          entryCount = view.getUint32(4),\n          i;\n\n      for (i = 8; entryCount; entryCount--) {\n        if (result.version === 0) {\n          result.edits.push({\n            segmentDuration: view.getUint32(i),\n            mediaTime: view.getInt32(i + 4),\n            mediaRate: view.getUint16(i + 8) + view.getUint16(i + 10) / (256 * 256)\n          });\n          i += 12;\n        } else {\n          result.edits.push({\n            segmentDuration: view.getUint32(i) * MAX_UINT32 + view.getUint32(i + 4),\n            mediaTime: view.getUint32(i + 8) * MAX_UINT32 + view.getUint32(i + 12),\n            mediaRate: view.getUint16(i + 16) + view.getUint16(i + 18) / (256 * 256)\n          });\n          i += 20;\n        }\n      }\n\n      return result;\n    },\n    esds: function esds(data) {\n      return {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        esId: data[6] << 8 | data[7],\n        streamPriority: data[8] & 0x1f,\n        decoderConfig: {\n          objectProfileIndication: data[11],\n          streamType: data[12] >>> 2 & 0x3f,\n          bufferSize: data[13] << 16 | data[14] << 8 | data[15],\n          maxBitrate: data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19],\n          avgBitrate: data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23],\n          decoderConfigDescriptor: {\n            tag: data[24],\n            length: data[25],\n            audioObjectType: data[26] >>> 3 & 0x1f,\n            samplingFrequencyIndex: (data[26] & 0x07) << 1 | data[27] >>> 7 & 0x01,\n            channelConfiguration: data[27] >>> 3 & 0x0f\n          }\n        }\n      };\n    },\n    ftyp: function ftyp(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        majorBrand: parseType_1(data.subarray(0, 4)),\n        minorVersion: view.getUint32(4),\n        compatibleBrands: []\n      },\n          i = 8;\n\n      while (i < data.byteLength) {\n        result.compatibleBrands.push(parseType_1(data.subarray(i, i + 4)));\n        i += 4;\n      }\n\n      return result;\n    },\n    dinf: function dinf(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    dref: function dref(data) {\n      return {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        dataReferences: inspectMp4(data.subarray(8))\n      };\n    },\n    hdlr: function hdlr(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        version: view.getUint8(0),\n        flags: new Uint8Array(data.subarray(1, 4)),\n        handlerType: parseType_1(data.subarray(8, 12)),\n        name: ''\n      },\n          i = 8; // parse out the name field\n\n      for (i = 24; i < data.byteLength; i++) {\n        if (data[i] === 0x00) {\n          // the name field is null-terminated\n          i++;\n          break;\n        }\n\n        result.name += String.fromCharCode(data[i]);\n      } // decode UTF-8 to javascript's internal representation\n      // see http://ecmanaut.blogspot.com/2006/07/encoding-decoding-utf8-in-javascript.html\n\n\n      result.name = decodeURIComponent(escape(result.name));\n      return result;\n    },\n    mdat: function mdat(data) {\n      return {\n        byteLength: data.byteLength,\n        nals: nalParse(data)\n      };\n    },\n    mdhd: function mdhd(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          i = 4,\n          language,\n          result = {\n        version: view.getUint8(0),\n        flags: new Uint8Array(data.subarray(1, 4)),\n        language: ''\n      };\n\n      if (result.version === 1) {\n        i += 4;\n        result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n        i += 8;\n        result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n        i += 4;\n        result.timescale = view.getUint32(i);\n        i += 8;\n        result.duration = view.getUint32(i); // truncating top 4 bytes\n      } else {\n        result.creationTime = parseMp4Date(view.getUint32(i));\n        i += 4;\n        result.modificationTime = parseMp4Date(view.getUint32(i));\n        i += 4;\n        result.timescale = view.getUint32(i);\n        i += 4;\n        result.duration = view.getUint32(i);\n      }\n\n      i += 4; // language is stored as an ISO-639-2/T code in an array of three 5-bit fields\n      // each field is the packed difference between its ASCII value and 0x60\n\n      language = view.getUint16(i);\n      result.language += String.fromCharCode((language >> 10) + 0x60);\n      result.language += String.fromCharCode(((language & 0x03e0) >> 5) + 0x60);\n      result.language += String.fromCharCode((language & 0x1f) + 0x60);\n      return result;\n    },\n    mdia: function mdia(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    mfhd: function mfhd(data) {\n      return {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        sequenceNumber: data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]\n      };\n    },\n    minf: function minf(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    // codingname, not a first-class box type. stsd entries share the\n    // same format as real boxes so the parsing infrastructure can be\n    // shared\n    mp4a: function mp4a(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        // 6 bytes reserved\n        dataReferenceIndex: view.getUint16(6),\n        // 4 + 4 bytes reserved\n        channelcount: view.getUint16(16),\n        samplesize: view.getUint16(18),\n        // 2 bytes pre_defined\n        // 2 bytes reserved\n        samplerate: view.getUint16(24) + view.getUint16(26) / 65536\n      }; // if there are more bytes to process, assume this is an ISO/IEC\n      // 14496-14 MP4AudioSampleEntry and parse the ESDBox\n\n      if (data.byteLength > 28) {\n        result.streamDescriptor = inspectMp4(data.subarray(28))[0];\n      }\n\n      return result;\n    },\n    moof: function moof(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    moov: function moov(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    mvex: function mvex(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    mvhd: function mvhd(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          i = 4,\n          result = {\n        version: view.getUint8(0),\n        flags: new Uint8Array(data.subarray(1, 4))\n      };\n\n      if (result.version === 1) {\n        i += 4;\n        result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n        i += 8;\n        result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n        i += 4;\n        result.timescale = view.getUint32(i);\n        i += 8;\n        result.duration = view.getUint32(i); // truncating top 4 bytes\n      } else {\n        result.creationTime = parseMp4Date(view.getUint32(i));\n        i += 4;\n        result.modificationTime = parseMp4Date(view.getUint32(i));\n        i += 4;\n        result.timescale = view.getUint32(i);\n        i += 4;\n        result.duration = view.getUint32(i);\n      }\n\n      i += 4; // convert fixed-point, base 16 back to a number\n\n      result.rate = view.getUint16(i) + view.getUint16(i + 2) / 16;\n      i += 4;\n      result.volume = view.getUint8(i) + view.getUint8(i + 1) / 8;\n      i += 2;\n      i += 2;\n      i += 2 * 4;\n      result.matrix = new Uint32Array(data.subarray(i, i + 9 * 4));\n      i += 9 * 4;\n      i += 6 * 4;\n      result.nextTrackId = view.getUint32(i);\n      return result;\n    },\n    pdin: function pdin(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n      return {\n        version: view.getUint8(0),\n        flags: new Uint8Array(data.subarray(1, 4)),\n        rate: view.getUint32(4),\n        initialDelay: view.getUint32(8)\n      };\n    },\n    sdtp: function sdtp(data) {\n      var result = {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        samples: []\n      },\n          i;\n\n      for (i = 4; i < data.byteLength; i++) {\n        result.samples.push({\n          dependsOn: (data[i] & 0x30) >> 4,\n          isDependedOn: (data[i] & 0x0c) >> 2,\n          hasRedundancy: data[i] & 0x03\n        });\n      }\n\n      return result;\n    },\n    sidx: parseSidx_1,\n    smhd: function smhd(data) {\n      return {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        balance: data[4] + data[5] / 256\n      };\n    },\n    stbl: function stbl(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    ctts: function ctts(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        version: view.getUint8(0),\n        flags: new Uint8Array(data.subarray(1, 4)),\n        compositionOffsets: []\n      },\n          entryCount = view.getUint32(4),\n          i;\n\n      for (i = 8; entryCount; i += 8, entryCount--) {\n        result.compositionOffsets.push({\n          sampleCount: view.getUint32(i),\n          sampleOffset: view[result.version === 0 ? 'getUint32' : 'getInt32'](i + 4)\n        });\n      }\n\n      return result;\n    },\n    stss: function stss(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        version: view.getUint8(0),\n        flags: new Uint8Array(data.subarray(1, 4)),\n        syncSamples: []\n      },\n          entryCount = view.getUint32(4),\n          i;\n\n      for (i = 8; entryCount; i += 4, entryCount--) {\n        result.syncSamples.push(view.getUint32(i));\n      }\n\n      return result;\n    },\n    stco: function stco(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        chunkOffsets: []\n      },\n          entryCount = view.getUint32(4),\n          i;\n\n      for (i = 8; entryCount; i += 4, entryCount--) {\n        result.chunkOffsets.push(view.getUint32(i));\n      }\n\n      return result;\n    },\n    stsc: function stsc(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          entryCount = view.getUint32(4),\n          result = {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        sampleToChunks: []\n      },\n          i;\n\n      for (i = 8; entryCount; i += 12, entryCount--) {\n        result.sampleToChunks.push({\n          firstChunk: view.getUint32(i),\n          samplesPerChunk: view.getUint32(i + 4),\n          sampleDescriptionIndex: view.getUint32(i + 8)\n        });\n      }\n\n      return result;\n    },\n    stsd: function stsd(data) {\n      return {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        sampleDescriptions: inspectMp4(data.subarray(8))\n      };\n    },\n    stsz: function stsz(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        sampleSize: view.getUint32(4),\n        entries: []\n      },\n          i;\n\n      for (i = 12; i < data.byteLength; i += 4) {\n        result.entries.push(view.getUint32(i));\n      }\n\n      return result;\n    },\n    stts: function stts(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          result = {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        timeToSamples: []\n      },\n          entryCount = view.getUint32(4),\n          i;\n\n      for (i = 8; entryCount; i += 8, entryCount--) {\n        result.timeToSamples.push({\n          sampleCount: view.getUint32(i),\n          sampleDelta: view.getUint32(i + 4)\n        });\n      }\n\n      return result;\n    },\n    styp: function styp(data) {\n      return parse.ftyp(data);\n    },\n    tfdt: parseTfdt,\n    tfhd: parseTfhd,\n    tkhd: function tkhd(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n          i = 4,\n          result = {\n        version: view.getUint8(0),\n        flags: new Uint8Array(data.subarray(1, 4))\n      };\n\n      if (result.version === 1) {\n        i += 4;\n        result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n        i += 8;\n        result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n        i += 4;\n        result.trackId = view.getUint32(i);\n        i += 4;\n        i += 8;\n        result.duration = view.getUint32(i); // truncating top 4 bytes\n      } else {\n        result.creationTime = parseMp4Date(view.getUint32(i));\n        i += 4;\n        result.modificationTime = parseMp4Date(view.getUint32(i));\n        i += 4;\n        result.trackId = view.getUint32(i);\n        i += 4;\n        i += 4;\n        result.duration = view.getUint32(i);\n      }\n\n      i += 4;\n      i += 2 * 4;\n      result.layer = view.getUint16(i);\n      i += 2;\n      result.alternateGroup = view.getUint16(i);\n      i += 2; // convert fixed-point, base 16 back to a number\n\n      result.volume = view.getUint8(i) + view.getUint8(i + 1) / 8;\n      i += 2;\n      i += 2;\n      result.matrix = new Uint32Array(data.subarray(i, i + 9 * 4));\n      i += 9 * 4;\n      result.width = view.getUint16(i) + view.getUint16(i + 2) / 65536;\n      i += 4;\n      result.height = view.getUint16(i) + view.getUint16(i + 2) / 65536;\n      return result;\n    },\n    traf: function traf(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    trak: function trak(data) {\n      return {\n        boxes: inspectMp4(data)\n      };\n    },\n    trex: function trex(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n      return {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        trackId: view.getUint32(4),\n        defaultSampleDescriptionIndex: view.getUint32(8),\n        defaultSampleDuration: view.getUint32(12),\n        defaultSampleSize: view.getUint32(16),\n        sampleDependsOn: data[20] & 0x03,\n        sampleIsDependedOn: (data[21] & 0xc0) >> 6,\n        sampleHasRedundancy: (data[21] & 0x30) >> 4,\n        samplePaddingValue: (data[21] & 0x0e) >> 1,\n        sampleIsDifferenceSample: !!(data[21] & 0x01),\n        sampleDegradationPriority: view.getUint16(22)\n      };\n    },\n    trun: parseTrun,\n    'url ': function url(data) {\n      return {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4))\n      };\n    },\n    vmhd: function vmhd(data) {\n      var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n      return {\n        version: data[0],\n        flags: new Uint8Array(data.subarray(1, 4)),\n        graphicsmode: view.getUint16(4),\n        opcolor: new Uint16Array([view.getUint16(6), view.getUint16(8), view.getUint16(10)])\n      };\n    }\n  };\n  /**\n   * Return a javascript array of box objects parsed from an ISO base\n   * media file.\n   * @param data {Uint8Array} the binary data of the media to be inspected\n   * @return {array} a javascript array of potentially nested box objects\n   */\n\n\n  inspectMp4 = function inspectMp4(data) {\n    var i = 0,\n        result = [],\n        view,\n        size,\n        type,\n        end,\n        box; // Convert data from Uint8Array to ArrayBuffer, to follow Dataview API\n\n    var ab = new ArrayBuffer(data.length);\n    var v = new Uint8Array(ab);\n\n    for (var z = 0; z < data.length; ++z) {\n      v[z] = data[z];\n    }\n\n    view = new DataView(ab);\n\n    while (i < data.byteLength) {\n      // parse box data\n      size = view.getUint32(i);\n      type = parseType_1(data.subarray(i + 4, i + 8));\n      end = size > 1 ? i + size : data.byteLength; // parse type-specific data\n\n      box = (parse[type] || function (data) {\n        return {\n          data: data\n        };\n      })(data.subarray(i + 8, end));\n\n      box.size = size;\n      box.type = type; // store this box and move to the next\n\n      result.push(box);\n      i = end;\n    }\n\n    return result;\n  };\n  /**\n   * Returns a textual representation of the javascript represtentation\n   * of an MP4 file. You can use it as an alternative to\n   * JSON.stringify() to compare inspected MP4s.\n   * @param inspectedMp4 {array} the parsed array of boxes in an MP4\n   * file\n   * @param depth {number} (optional) the number of ancestor boxes of\n   * the elements of inspectedMp4. Assumed to be zero if unspecified.\n   * @return {string} a text representation of the parsed MP4\n   */\n\n\n  _textifyMp = function textifyMp4(inspectedMp4, depth) {\n    var indent;\n    depth = depth || 0;\n    indent = new Array(depth * 2 + 1).join(' '); // iterate over all the boxes\n\n    return inspectedMp4.map(function (box, index) {\n      // list the box type first at the current indentation level\n      return indent + box.type + '\\n' + // the type is already included and handle child boxes separately\n      Object.keys(box).filter(function (key) {\n        return key !== 'type' && key !== 'boxes'; // output all the box properties\n      }).map(function (key) {\n        var prefix = indent + '  ' + key + ': ',\n            value = box[key]; // print out raw bytes as hexademical\n\n        if (value instanceof Uint8Array || value instanceof Uint32Array) {\n          var bytes = Array.prototype.slice.call(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)).map(function (byte) {\n            return ' ' + ('00' + byte.toString(16)).slice(-2);\n          }).join('').match(/.{1,24}/g);\n\n          if (!bytes) {\n            return prefix + '<>';\n          }\n\n          if (bytes.length === 1) {\n            return prefix + '<' + bytes.join('').slice(1) + '>';\n          }\n\n          return prefix + '<\\n' + bytes.map(function (line) {\n            return indent + '  ' + line;\n          }).join('\\n') + '\\n' + indent + '  >';\n        } // stringify generic objects\n\n\n        return prefix + JSON.stringify(value, null, 2).split('\\n').map(function (line, index) {\n          if (index === 0) {\n            return line;\n          }\n\n          return indent + '  ' + line;\n        }).join('\\n');\n      }).join('\\n') + ( // recursively textify the child boxes\n      box.boxes ? '\\n' + _textifyMp(box.boxes, depth + 1) : '');\n    }).join('\\n');\n  };\n\n  var mp4Inspector = {\n    inspect: inspectMp4,\n    textify: _textifyMp,\n    parseType: parseType_1,\n    findBox: findBox_1,\n    parseTraf: parse.traf,\n    parseTfdt: parse.tfdt,\n    parseHdlr: parse.hdlr,\n    parseTfhd: parse.tfhd,\n    parseTrun: parse.trun,\n    parseSidx: parse.sidx\n  };\n\n  /**\n   * mux.js\n   *\n   * Copyright (c) Brightcove\n   * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n   */\n\n  var tagTypes = {\n    0x08: 'audio',\n    0x09: 'video',\n    0x12: 'metadata'\n  },\n      hex = function hex(val) {\n    return '0x' + ('00' + val.toString(16)).slice(-2).toUpperCase();\n  },\n      hexStringList = function hexStringList(data) {\n    var arr = [],\n        i;\n\n    while (data.byteLength > 0) {\n      i = 0;\n      arr.push(hex(data[i++]));\n      data = data.subarray(i);\n    }\n\n    return arr.join(' ');\n  },\n      parseAVCTag = function parseAVCTag(tag, obj) {\n    var avcPacketTypes = ['AVC Sequence Header', 'AVC NALU', 'AVC End-of-Sequence'],\n        compositionTime = tag[1] & parseInt('01111111', 2) << 16 | tag[2] << 8 | tag[3];\n    obj = obj || {};\n    obj.avcPacketType = avcPacketTypes[tag[0]];\n    obj.CompositionTime = tag[1] & parseInt('10000000', 2) ? -compositionTime : compositionTime;\n\n    if (tag[0] === 1) {\n      obj.nalUnitTypeRaw = hexStringList(tag.subarray(4, 100));\n    } else {\n      obj.data = hexStringList(tag.subarray(4));\n    }\n\n    return obj;\n  },\n      parseVideoTag = function parseVideoTag(tag, obj) {\n    var frameTypes = ['Unknown', 'Keyframe (for AVC, a seekable frame)', 'Inter frame (for AVC, a nonseekable frame)', 'Disposable inter frame (H.263 only)', 'Generated keyframe (reserved for server use only)', 'Video info/command frame'],\n        codecID = tag[0] & parseInt('00001111', 2);\n    obj = obj || {};\n    obj.frameType = frameTypes[(tag[0] & parseInt('11110000', 2)) >>> 4];\n    obj.codecID = codecID;\n\n    if (codecID === 7) {\n      return parseAVCTag(tag.subarray(1), obj);\n    }\n\n    return obj;\n  },\n      parseAACTag = function parseAACTag(tag, obj) {\n    var packetTypes = ['AAC Sequence Header', 'AAC Raw'];\n    obj = obj || {};\n    obj.aacPacketType = packetTypes[tag[0]];\n    obj.data = hexStringList(tag.subarray(1));\n    return obj;\n  },\n      parseAudioTag = function parseAudioTag(tag, obj) {\n    var formatTable = ['Linear PCM, platform endian', 'ADPCM', 'MP3', 'Linear PCM, little endian', 'Nellymoser 16-kHz mono', 'Nellymoser 8-kHz mono', 'Nellymoser', 'G.711 A-law logarithmic PCM', 'G.711 mu-law logarithmic PCM', 'reserved', 'AAC', 'Speex', 'MP3 8-Khz', 'Device-specific sound'],\n        samplingRateTable = ['5.5-kHz', '11-kHz', '22-kHz', '44-kHz'],\n        soundFormat = (tag[0] & parseInt('11110000', 2)) >>> 4;\n    obj = obj || {};\n    obj.soundFormat = formatTable[soundFormat];\n    obj.soundRate = samplingRateTable[(tag[0] & parseInt('00001100', 2)) >>> 2];\n    obj.soundSize = (tag[0] & parseInt('00000010', 2)) >>> 1 ? '16-bit' : '8-bit';\n    obj.soundType = tag[0] & parseInt('00000001', 2) ? 'Stereo' : 'Mono';\n\n    if (soundFormat === 10) {\n      return parseAACTag(tag.subarray(1), obj);\n    }\n\n    return obj;\n  },\n      parseGenericTag = function parseGenericTag(tag) {\n    return {\n      tagType: tagTypes[tag[0]],\n      dataSize: tag[1] << 16 | tag[2] << 8 | tag[3],\n      timestamp: tag[7] << 24 | tag[4] << 16 | tag[5] << 8 | tag[6],\n      streamID: tag[8] << 16 | tag[9] << 8 | tag[10]\n    };\n  },\n      inspectFlvTag = function inspectFlvTag(tag) {\n    var header = parseGenericTag(tag);\n\n    switch (tag[0]) {\n      case 0x08:\n        parseAudioTag(tag.subarray(11), header);\n        break;\n\n      case 0x09:\n        parseVideoTag(tag.subarray(11), header);\n        break;\n    }\n\n    return header;\n  },\n      inspectFlv = function inspectFlv(bytes) {\n    var i = 9,\n        // header\n    dataSize,\n        parsedResults = [],\n        tag; // traverse the tags\n\n    i += 4; // skip previous tag size\n\n    while (i < bytes.byteLength) {\n      dataSize = bytes[i + 1] << 16;\n      dataSize |= bytes[i + 2] << 8;\n      dataSize |= bytes[i + 3];\n      dataSize += 11;\n      tag = bytes.subarray(i, i + dataSize);\n      parsedResults.push(inspectFlvTag(tag));\n      i += dataSize + 4;\n    }\n\n    return parsedResults;\n  },\n      textifyFlv = function textifyFlv(flvTagArray) {\n    return JSON.stringify(flvTagArray, null, 2);\n  };\n\n  var flvInspector = {\n    inspectTag: inspectFlvTag,\n    inspect: inspectFlv,\n    textify: textifyFlv\n  };\n\n  var parsePid = function parsePid(packet) {\n    var pid = packet[1] & 0x1f;\n    pid <<= 8;\n    pid |= packet[2];\n    return pid;\n  };\n\n  var parsePayloadUnitStartIndicator = function parsePayloadUnitStartIndicator(packet) {\n    return !!(packet[1] & 0x40);\n  };\n\n  var parseAdaptionField = function parseAdaptionField(packet) {\n    var offset = 0; // if an adaption field is present, its length is specified by the\n    // fifth byte of the TS packet header. The adaptation field is\n    // used to add stuffing to PES packets that don't fill a complete\n    // TS packet, and to specify some forms of timing and control data\n    // that we do not currently use.\n\n    if ((packet[3] & 0x30) >>> 4 > 0x01) {\n      offset += packet[4] + 1;\n    }\n\n    return offset;\n  };\n\n  var parseType = function parseType(packet, pmtPid) {\n    var pid = parsePid(packet);\n\n    if (pid === 0) {\n      return 'pat';\n    } else if (pid === pmtPid) {\n      return 'pmt';\n    } else if (pmtPid) {\n      return 'pes';\n    }\n\n    return null;\n  };\n\n  var parsePat = function parsePat(packet) {\n    var pusi = parsePayloadUnitStartIndicator(packet);\n    var offset = 4 + parseAdaptionField(packet);\n\n    if (pusi) {\n      offset += packet[offset] + 1;\n    }\n\n    return (packet[offset + 10] & 0x1f) << 8 | packet[offset + 11];\n  };\n\n  var parsePmt = function parsePmt(packet) {\n    var programMapTable = {};\n    var pusi = parsePayloadUnitStartIndicator(packet);\n    var payloadOffset = 4 + parseAdaptionField(packet);\n\n    if (pusi) {\n      payloadOffset += packet[payloadOffset] + 1;\n    } // PMTs can be sent ahead of the time when they should actually\n    // take effect. We don't believe this should ever be the case\n    // for HLS but we'll ignore \"forward\" PMT declarations if we see\n    // them. Future PMT declarations have the current_next_indicator\n    // set to zero.\n\n\n    if (!(packet[payloadOffset + 5] & 0x01)) {\n      return;\n    }\n\n    var sectionLength, tableEnd, programInfoLength; // the mapping table ends at the end of the current section\n\n    sectionLength = (packet[payloadOffset + 1] & 0x0f) << 8 | packet[payloadOffset + 2];\n    tableEnd = 3 + sectionLength - 4; // to determine where the table is, we have to figure out how\n    // long the program info descriptors are\n\n    programInfoLength = (packet[payloadOffset + 10] & 0x0f) << 8 | packet[payloadOffset + 11]; // advance the offset to the first entry in the mapping table\n\n    var offset = 12 + programInfoLength;\n\n    while (offset < tableEnd) {\n      var i = payloadOffset + offset; // add an entry that maps the elementary_pid to the stream_type\n\n      programMapTable[(packet[i + 1] & 0x1F) << 8 | packet[i + 2]] = packet[i]; // move to the next table entry\n      // skip past the elementary stream descriptors, if present\n\n      offset += ((packet[i + 3] & 0x0F) << 8 | packet[i + 4]) + 5;\n    }\n\n    return programMapTable;\n  };\n\n  var parsePesType = function parsePesType(packet, programMapTable) {\n    var pid = parsePid(packet);\n    var type = programMapTable[pid];\n\n    switch (type) {\n      case streamTypes.H264_STREAM_TYPE:\n        return 'video';\n\n      case streamTypes.ADTS_STREAM_TYPE:\n        return 'audio';\n\n      case streamTypes.METADATA_STREAM_TYPE:\n        return 'timed-metadata';\n\n      default:\n        return null;\n    }\n  };\n\n  var parsePesTime = function parsePesTime(packet) {\n    var pusi = parsePayloadUnitStartIndicator(packet);\n\n    if (!pusi) {\n      return null;\n    }\n\n    var offset = 4 + parseAdaptionField(packet);\n\n    if (offset >= packet.byteLength) {\n      // From the H 222.0 MPEG-TS spec\n      // \"For transport stream packets carrying PES packets, stuffing is needed when there\n      //  is insufficient PES packet data to completely fill the transport stream packet\n      //  payload bytes. Stuffing is accomplished by defining an adaptation field longer than\n      //  the sum of the lengths of the data elements in it, so that the payload bytes\n      //  remaining after the adaptation field exactly accommodates the available PES packet\n      //  data.\"\n      //\n      // If the offset is >= the length of the packet, then the packet contains no data\n      // and instead is just adaption field stuffing bytes\n      return null;\n    }\n\n    var pes = null;\n    var ptsDtsFlags; // PES packets may be annotated with a PTS value, or a PTS value\n    // and a DTS value. Determine what combination of values is\n    // available to work with.\n\n    ptsDtsFlags = packet[offset + 7]; // PTS and DTS are normally stored as a 33-bit number.  Javascript\n    // performs all bitwise operations on 32-bit integers but javascript\n    // supports a much greater range (52-bits) of integer using standard\n    // mathematical operations.\n    // We construct a 31-bit value using bitwise operators over the 31\n    // most significant bits and then multiply by 4 (equal to a left-shift\n    // of 2) before we add the final 2 least significant bits of the\n    // timestamp (equal to an OR.)\n\n    if (ptsDtsFlags & 0xC0) {\n      pes = {}; // the PTS and DTS are not written out directly. For information\n      // on how they are encoded, see\n      // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html\n\n      pes.pts = (packet[offset + 9] & 0x0E) << 27 | (packet[offset + 10] & 0xFF) << 20 | (packet[offset + 11] & 0xFE) << 12 | (packet[offset + 12] & 0xFF) << 5 | (packet[offset + 13] & 0xFE) >>> 3;\n      pes.pts *= 4; // Left shift by 2\n\n      pes.pts += (packet[offset + 13] & 0x06) >>> 1; // OR by the two LSBs\n\n      pes.dts = pes.pts;\n\n      if (ptsDtsFlags & 0x40) {\n        pes.dts = (packet[offset + 14] & 0x0E) << 27 | (packet[offset + 15] & 0xFF) << 20 | (packet[offset + 16] & 0xFE) << 12 | (packet[offset + 17] & 0xFF) << 5 | (packet[offset + 18] & 0xFE) >>> 3;\n        pes.dts *= 4; // Left shift by 2\n\n        pes.dts += (packet[offset + 18] & 0x06) >>> 1; // OR by the two LSBs\n      }\n    }\n\n    return pes;\n  };\n\n  var parseNalUnitType = function parseNalUnitType(type) {\n    switch (type) {\n      case 0x05:\n        return 'slice_layer_without_partitioning_rbsp_idr';\n\n      case 0x06:\n        return 'sei_rbsp';\n\n      case 0x07:\n        return 'seq_parameter_set_rbsp';\n\n      case 0x08:\n        return 'pic_parameter_set_rbsp';\n\n      case 0x09:\n        return 'access_unit_delimiter_rbsp';\n\n      default:\n        return null;\n    }\n  };\n\n  var videoPacketContainsKeyFrame = function videoPacketContainsKeyFrame(packet) {\n    var offset = 4 + parseAdaptionField(packet);\n    var frameBuffer = packet.subarray(offset);\n    var frameI = 0;\n    var frameSyncPoint = 0;\n    var foundKeyFrame = false;\n    var nalType; // advance the sync point to a NAL start, if necessary\n\n    for (; frameSyncPoint < frameBuffer.byteLength - 3; frameSyncPoint++) {\n      if (frameBuffer[frameSyncPoint + 2] === 1) {\n        // the sync point is properly aligned\n        frameI = frameSyncPoint + 5;\n        break;\n      }\n    }\n\n    while (frameI < frameBuffer.byteLength) {\n      // look at the current byte to determine if we've hit the end of\n      // a NAL unit boundary\n      switch (frameBuffer[frameI]) {\n        case 0:\n          // skip past non-sync sequences\n          if (frameBuffer[frameI - 1] !== 0) {\n            frameI += 2;\n            break;\n          } else if (frameBuffer[frameI - 2] !== 0) {\n            frameI++;\n            break;\n          }\n\n          if (frameSyncPoint + 3 !== frameI - 2) {\n            nalType = parseNalUnitType(frameBuffer[frameSyncPoint + 3] & 0x1f);\n\n            if (nalType === 'slice_layer_without_partitioning_rbsp_idr') {\n              foundKeyFrame = true;\n            }\n          } // drop trailing zeroes\n\n\n          do {\n            frameI++;\n          } while (frameBuffer[frameI] !== 1 && frameI < frameBuffer.length);\n\n          frameSyncPoint = frameI - 2;\n          frameI += 3;\n          break;\n\n        case 1:\n          // skip past non-sync sequences\n          if (frameBuffer[frameI - 1] !== 0 || frameBuffer[frameI - 2] !== 0) {\n            frameI += 3;\n            break;\n          }\n\n          nalType = parseNalUnitType(frameBuffer[frameSyncPoint + 3] & 0x1f);\n\n          if (nalType === 'slice_layer_without_partitioning_rbsp_idr') {\n            foundKeyFrame = true;\n          }\n\n          frameSyncPoint = frameI - 2;\n          frameI += 3;\n          break;\n\n        default:\n          // the current byte isn't a one or zero, so it cannot be part\n          // of a sync sequence\n          frameI += 3;\n          break;\n      }\n    }\n\n    frameBuffer = frameBuffer.subarray(frameSyncPoint);\n    frameI -= frameSyncPoint;\n    frameSyncPoint = 0; // parse the final nal\n\n    if (frameBuffer && frameBuffer.byteLength > 3) {\n      nalType = parseNalUnitType(frameBuffer[frameSyncPoint + 3] & 0x1f);\n\n      if (nalType === 'slice_layer_without_partitioning_rbsp_idr') {\n        foundKeyFrame = true;\n      }\n    }\n\n    return foundKeyFrame;\n  };\n\n  var probe$1 = {\n    parseType: parseType,\n    parsePat: parsePat,\n    parsePmt: parsePmt,\n    parsePayloadUnitStartIndicator: parsePayloadUnitStartIndicator,\n    parsePesType: parsePesType,\n    parsePesTime: parsePesTime,\n    videoPacketContainsKeyFrame: videoPacketContainsKeyFrame\n  };\n\n  var handleRollover = timestampRolloverStream.handleRollover;\n  var probe = {};\n  probe.ts = probe$1;\n  probe.aac = utils;\n  var ONE_SECOND_IN_TS = clock.ONE_SECOND_IN_TS;\n  var MP2T_PACKET_LENGTH = 188,\n      // bytes\n  SYNC_BYTE = 0x47;\n  /**\n   * walks through segment data looking for pat and pmt packets to parse out\n   * program map table information\n   */\n\n  var parsePsi_ = function parsePsi_(bytes, pmt) {\n    var startIndex = 0,\n        endIndex = MP2T_PACKET_LENGTH,\n        packet,\n        type;\n\n    while (endIndex < bytes.byteLength) {\n      // Look for a pair of start and end sync bytes in the data..\n      if (bytes[startIndex] === SYNC_BYTE && bytes[endIndex] === SYNC_BYTE) {\n        // We found a packet\n        packet = bytes.subarray(startIndex, endIndex);\n        type = probe.ts.parseType(packet, pmt.pid);\n\n        switch (type) {\n          case 'pat':\n            pmt.pid = probe.ts.parsePat(packet);\n            break;\n\n          case 'pmt':\n            var table = probe.ts.parsePmt(packet);\n            pmt.table = pmt.table || {};\n            Object.keys(table).forEach(function (key) {\n              pmt.table[key] = table[key];\n            });\n            break;\n        }\n\n        startIndex += MP2T_PACKET_LENGTH;\n        endIndex += MP2T_PACKET_LENGTH;\n        continue;\n      } // If we get here, we have somehow become de-synchronized and we need to step\n      // forward one byte at a time until we find a pair of sync bytes that denote\n      // a packet\n\n\n      startIndex++;\n      endIndex++;\n    }\n  };\n  /**\n   * walks through the segment data from the start and end to get timing information\n   * for the first and last audio pes packets\n   */\n\n\n  var parseAudioPes_ = function parseAudioPes_(bytes, pmt, result) {\n    var startIndex = 0,\n        endIndex = MP2T_PACKET_LENGTH,\n        packet,\n        type,\n        pesType,\n        pusi,\n        parsed;\n    var endLoop = false; // Start walking from start of segment to get first audio packet\n\n    while (endIndex <= bytes.byteLength) {\n      // Look for a pair of start and end sync bytes in the data..\n      if (bytes[startIndex] === SYNC_BYTE && (bytes[endIndex] === SYNC_BYTE || endIndex === bytes.byteLength)) {\n        // We found a packet\n        packet = bytes.subarray(startIndex, endIndex);\n        type = probe.ts.parseType(packet, pmt.pid);\n\n        switch (type) {\n          case 'pes':\n            pesType = probe.ts.parsePesType(packet, pmt.table);\n            pusi = probe.ts.parsePayloadUnitStartIndicator(packet);\n\n            if (pesType === 'audio' && pusi) {\n              parsed = probe.ts.parsePesTime(packet);\n\n              if (parsed) {\n                parsed.type = 'audio';\n                result.audio.push(parsed);\n                endLoop = true;\n              }\n            }\n\n            break;\n        }\n\n        if (endLoop) {\n          break;\n        }\n\n        startIndex += MP2T_PACKET_LENGTH;\n        endIndex += MP2T_PACKET_LENGTH;\n        continue;\n      } // If we get here, we have somehow become de-synchronized and we need to step\n      // forward one byte at a time until we find a pair of sync bytes that denote\n      // a packet\n\n\n      startIndex++;\n      endIndex++;\n    } // Start walking from end of segment to get last audio packet\n\n\n    endIndex = bytes.byteLength;\n    startIndex = endIndex - MP2T_PACKET_LENGTH;\n    endLoop = false;\n\n    while (startIndex >= 0) {\n      // Look for a pair of start and end sync bytes in the data..\n      if (bytes[startIndex] === SYNC_BYTE && (bytes[endIndex] === SYNC_BYTE || endIndex === bytes.byteLength)) {\n        // We found a packet\n        packet = bytes.subarray(startIndex, endIndex);\n        type = probe.ts.parseType(packet, pmt.pid);\n\n        switch (type) {\n          case 'pes':\n            pesType = probe.ts.parsePesType(packet, pmt.table);\n            pusi = probe.ts.parsePayloadUnitStartIndicator(packet);\n\n            if (pesType === 'audio' && pusi) {\n              parsed = probe.ts.parsePesTime(packet);\n\n              if (parsed) {\n                parsed.type = 'audio';\n                result.audio.push(parsed);\n                endLoop = true;\n              }\n            }\n\n            break;\n        }\n\n        if (endLoop) {\n          break;\n        }\n\n        startIndex -= MP2T_PACKET_LENGTH;\n        endIndex -= MP2T_PACKET_LENGTH;\n        continue;\n      } // If we get here, we have somehow become de-synchronized and we need to step\n      // forward one byte at a time until we find a pair of sync bytes that denote\n      // a packet\n\n\n      startIndex--;\n      endIndex--;\n    }\n  };\n  /**\n   * walks through the segment data from the start and end to get timing information\n   * for the first and last video pes packets as well as timing information for the first\n   * key frame.\n   */\n\n\n  var parseVideoPes_ = function parseVideoPes_(bytes, pmt, result) {\n    var startIndex = 0,\n        endIndex = MP2T_PACKET_LENGTH,\n        packet,\n        type,\n        pesType,\n        pusi,\n        parsed,\n        frame,\n        i,\n        pes;\n    var endLoop = false;\n    var currentFrame = {\n      data: [],\n      size: 0\n    }; // Start walking from start of segment to get first video packet\n\n    while (endIndex < bytes.byteLength) {\n      // Look for a pair of start and end sync bytes in the data..\n      if (bytes[startIndex] === SYNC_BYTE && bytes[endIndex] === SYNC_BYTE) {\n        // We found a packet\n        packet = bytes.subarray(startIndex, endIndex);\n        type = probe.ts.parseType(packet, pmt.pid);\n\n        switch (type) {\n          case 'pes':\n            pesType = probe.ts.parsePesType(packet, pmt.table);\n            pusi = probe.ts.parsePayloadUnitStartIndicator(packet);\n\n            if (pesType === 'video') {\n              if (pusi && !endLoop) {\n                parsed = probe.ts.parsePesTime(packet);\n\n                if (parsed) {\n                  parsed.type = 'video';\n                  result.video.push(parsed);\n                  endLoop = true;\n                }\n              }\n\n              if (!result.firstKeyFrame) {\n                if (pusi) {\n                  if (currentFrame.size !== 0) {\n                    frame = new Uint8Array(currentFrame.size);\n                    i = 0;\n\n                    while (currentFrame.data.length) {\n                      pes = currentFrame.data.shift();\n                      frame.set(pes, i);\n                      i += pes.byteLength;\n                    }\n\n                    if (probe.ts.videoPacketContainsKeyFrame(frame)) {\n                      var firstKeyFrame = probe.ts.parsePesTime(frame); // PTS/DTS may not be available. Simply *not* setting\n                      // the keyframe seems to work fine with HLS playback\n                      // and definitely preferable to a crash with TypeError...\n\n                      if (firstKeyFrame) {\n                        result.firstKeyFrame = firstKeyFrame;\n                        result.firstKeyFrame.type = 'video';\n                      } else {\n                        // eslint-disable-next-line\n                        console.warn('Failed to extract PTS/DTS from PES at first keyframe. ' + 'This could be an unusual TS segment, or else mux.js did not ' + 'parse your TS segment correctly. If you know your TS ' + 'segments do contain PTS/DTS on keyframes please file a bug ' + 'report! You can try ffprobe to double check for yourself.');\n                      }\n                    }\n\n                    currentFrame.size = 0;\n                  }\n                }\n\n                currentFrame.data.push(packet);\n                currentFrame.size += packet.byteLength;\n              }\n            }\n\n            break;\n        }\n\n        if (endLoop && result.firstKeyFrame) {\n          break;\n        }\n\n        startIndex += MP2T_PACKET_LENGTH;\n        endIndex += MP2T_PACKET_LENGTH;\n        continue;\n      } // If we get here, we have somehow become de-synchronized and we need to step\n      // forward one byte at a time until we find a pair of sync bytes that denote\n      // a packet\n\n\n      startIndex++;\n      endIndex++;\n    } // Start walking from end of segment to get last video packet\n\n\n    endIndex = bytes.byteLength;\n    startIndex = endIndex - MP2T_PACKET_LENGTH;\n    endLoop = false;\n\n    while (startIndex >= 0) {\n      // Look for a pair of start and end sync bytes in the data..\n      if (bytes[startIndex] === SYNC_BYTE && bytes[endIndex] === SYNC_BYTE) {\n        // We found a packet\n        packet = bytes.subarray(startIndex, endIndex);\n        type = probe.ts.parseType(packet, pmt.pid);\n\n        switch (type) {\n          case 'pes':\n            pesType = probe.ts.parsePesType(packet, pmt.table);\n            pusi = probe.ts.parsePayloadUnitStartIndicator(packet);\n\n            if (pesType === 'video' && pusi) {\n              parsed = probe.ts.parsePesTime(packet);\n\n              if (parsed) {\n                parsed.type = 'video';\n                result.video.push(parsed);\n                endLoop = true;\n              }\n            }\n\n            break;\n        }\n\n        if (endLoop) {\n          break;\n        }\n\n        startIndex -= MP2T_PACKET_LENGTH;\n        endIndex -= MP2T_PACKET_LENGTH;\n        continue;\n      } // If we get here, we have somehow become de-synchronized and we need to step\n      // forward one byte at a time until we find a pair of sync bytes that denote\n      // a packet\n\n\n      startIndex--;\n      endIndex--;\n    }\n  };\n  /**\n   * Adjusts the timestamp information for the segment to account for\n   * rollover and convert to seconds based on pes packet timescale (90khz clock)\n   */\n\n\n  var adjustTimestamp_ = function adjustTimestamp_(segmentInfo, baseTimestamp) {\n    if (segmentInfo.audio && segmentInfo.audio.length) {\n      var audioBaseTimestamp = baseTimestamp;\n\n      if (typeof audioBaseTimestamp === 'undefined' || isNaN(audioBaseTimestamp)) {\n        audioBaseTimestamp = segmentInfo.audio[0].dts;\n      }\n\n      segmentInfo.audio.forEach(function (info) {\n        info.dts = handleRollover(info.dts, audioBaseTimestamp);\n        info.pts = handleRollover(info.pts, audioBaseTimestamp); // time in seconds\n\n        info.dtsTime = info.dts / ONE_SECOND_IN_TS;\n        info.ptsTime = info.pts / ONE_SECOND_IN_TS;\n      });\n    }\n\n    if (segmentInfo.video && segmentInfo.video.length) {\n      var videoBaseTimestamp = baseTimestamp;\n\n      if (typeof videoBaseTimestamp === 'undefined' || isNaN(videoBaseTimestamp)) {\n        videoBaseTimestamp = segmentInfo.video[0].dts;\n      }\n\n      segmentInfo.video.forEach(function (info) {\n        info.dts = handleRollover(info.dts, videoBaseTimestamp);\n        info.pts = handleRollover(info.pts, videoBaseTimestamp); // time in seconds\n\n        info.dtsTime = info.dts / ONE_SECOND_IN_TS;\n        info.ptsTime = info.pts / ONE_SECOND_IN_TS;\n      });\n\n      if (segmentInfo.firstKeyFrame) {\n        var frame = segmentInfo.firstKeyFrame;\n        frame.dts = handleRollover(frame.dts, videoBaseTimestamp);\n        frame.pts = handleRollover(frame.pts, videoBaseTimestamp); // time in seconds\n\n        frame.dtsTime = frame.dts / ONE_SECOND_IN_TS;\n        frame.ptsTime = frame.pts / ONE_SECOND_IN_TS;\n      }\n    }\n  };\n  /**\n   * inspects the aac data stream for start and end time information\n   */\n\n\n  var inspectAac_ = function inspectAac_(bytes) {\n    var endLoop = false,\n        audioCount = 0,\n        sampleRate = null,\n        timestamp = null,\n        frameSize = 0,\n        byteIndex = 0,\n        packet;\n\n    while (bytes.length - byteIndex >= 3) {\n      var type = probe.aac.parseType(bytes, byteIndex);\n\n      switch (type) {\n        case 'timed-metadata':\n          // Exit early because we don't have enough to parse\n          // the ID3 tag header\n          if (bytes.length - byteIndex < 10) {\n            endLoop = true;\n            break;\n          }\n\n          frameSize = probe.aac.parseId3TagSize(bytes, byteIndex); // Exit early if we don't have enough in the buffer\n          // to emit a full packet\n\n          if (frameSize > bytes.length) {\n            endLoop = true;\n            break;\n          }\n\n          if (timestamp === null) {\n            packet = bytes.subarray(byteIndex, byteIndex + frameSize);\n            timestamp = probe.aac.parseAacTimestamp(packet);\n          }\n\n          byteIndex += frameSize;\n          break;\n\n        case 'audio':\n          // Exit early because we don't have enough to parse\n          // the ADTS frame header\n          if (bytes.length - byteIndex < 7) {\n            endLoop = true;\n            break;\n          }\n\n          frameSize = probe.aac.parseAdtsSize(bytes, byteIndex); // Exit early if we don't have enough in the buffer\n          // to emit a full packet\n\n          if (frameSize > bytes.length) {\n            endLoop = true;\n            break;\n          }\n\n          if (sampleRate === null) {\n            packet = bytes.subarray(byteIndex, byteIndex + frameSize);\n            sampleRate = probe.aac.parseSampleRate(packet);\n          }\n\n          audioCount++;\n          byteIndex += frameSize;\n          break;\n\n        default:\n          byteIndex++;\n          break;\n      }\n\n      if (endLoop) {\n        return null;\n      }\n    }\n\n    if (sampleRate === null || timestamp === null) {\n      return null;\n    }\n\n    var audioTimescale = ONE_SECOND_IN_TS / sampleRate;\n    var result = {\n      audio: [{\n        type: 'audio',\n        dts: timestamp,\n        pts: timestamp\n      }, {\n        type: 'audio',\n        dts: timestamp + audioCount * 1024 * audioTimescale,\n        pts: timestamp + audioCount * 1024 * audioTimescale\n      }]\n    };\n    return result;\n  };\n  /**\n   * inspects the transport stream segment data for start and end time information\n   * of the audio and video tracks (when present) as well as the first key frame's\n   * start time.\n   */\n\n\n  var inspectTs_ = function inspectTs_(bytes) {\n    var pmt = {\n      pid: null,\n      table: null\n    };\n    var result = {};\n    parsePsi_(bytes, pmt);\n\n    for (var pid in pmt.table) {\n      if (pmt.table.hasOwnProperty(pid)) {\n        var type = pmt.table[pid];\n\n        switch (type) {\n          case streamTypes.H264_STREAM_TYPE:\n            result.video = [];\n            parseVideoPes_(bytes, pmt, result);\n\n            if (result.video.length === 0) {\n              delete result.video;\n            }\n\n            break;\n\n          case streamTypes.ADTS_STREAM_TYPE:\n            result.audio = [];\n            parseAudioPes_(bytes, pmt, result);\n\n            if (result.audio.length === 0) {\n              delete result.audio;\n            }\n\n            break;\n        }\n      }\n    }\n\n    return result;\n  };\n  /**\n   * Inspects segment byte data and returns an object with start and end timing information\n   *\n   * @param {Uint8Array} bytes The segment byte data\n   * @param {Number} baseTimestamp Relative reference timestamp used when adjusting frame\n   *  timestamps for rollover. This value must be in 90khz clock.\n   * @return {Object} Object containing start and end frame timing info of segment.\n   */\n\n\n  var inspect = function inspect(bytes, baseTimestamp) {\n    var isAacData = probe.aac.isLikelyAacData(bytes);\n    var result;\n\n    if (isAacData) {\n      result = inspectAac_(bytes);\n    } else {\n      result = inspectTs_(bytes);\n    }\n\n    if (!result || !result.audio && !result.video) {\n      return null;\n    }\n\n    adjustTimestamp_(result, baseTimestamp);\n    return result;\n  };\n\n  var tsInspector = {\n    inspect: inspect,\n    parseAudioPes_: parseAudioPes_\n  };\n\n  var muxjs = {\n    codecs: codecs,\n    mp4: mp4,\n    flv: flv,\n    mp2t: m2ts,\n    partial: partial\n  }; // include all the tools when the full library is required\n\n  muxjs.mp4.tools = mp4Inspector;\n  muxjs.flv.tools = flvInspector;\n  muxjs.mp2t.tools = tsInspector;\n  var lib = muxjs;\n\n  return lib;\n\n})));\n","<template>\n    <div v-if=\"video && isEmbed\" style=\"position: absolute; top: 0; left: 0; width: 100%; height: 100%; z-index: 999\">\n        <Player\n            ref=\"videoPlayer\"\n            :video=\"video\"\n            :sponsors=\"sponsors\"\n            :selected-auto-play=\"false\"\n            :selected-auto-loop=\"selectedAutoLoop\"\n            :is-embed=\"isEmbed\"\n        />\n    </div>\n\n    <div v-if=\"video && !isEmbed\" class=\"uk-container uk-container-xlarge\">\n        <ErrorHandler v-if=\"video && video.error\" :message=\"video.message\" :error=\"video.error\" />\n\n        <div v-show=\"!video.error\">\n            <Player\n                ref=\"videoPlayer\"\n                :video=\"video\"\n                :sponsors=\"sponsors\"\n                :selected-auto-play=\"selectedAutoPlay\"\n                :selected-auto-loop=\"selectedAutoLoop\"\n            />\n            <div class=\"uk-text-bold uk-margin-small-top uk-text-large uk-text-emphasis uk-text-break\">\n                {{ video.title }}\n            </div>\n\n            <div class=\"uk-flex uk-flex-middle\">\n                <div class=\"uk-margin-small-right\">{{ addCommas(video.views) }} views</div>\n                <div class=\"uk-margin-small-right\">{{ uploadDate }}</div>\n                <div class=\"uk-flex-1\"></div>\n                <div class=\"uk-margin-small-left\">\n                    <font-awesome-icon class=\"uk-margin-small-right\" icon=\"thumbs-up\"></font-awesome-icon>\n                    <b>{{ addCommas(video.likes) }}</b>\n                </div>\n                <div class=\"uk-margin-small-left\">\n                    <font-awesome-icon class=\"uk-margin-small-right\" icon=\"thumbs-down\"></font-awesome-icon>\n                    <b>{{ addCommas(video.dislikes) }}</b>\n                </div>\n                <a\n                    :href=\"'https://youtu.be/' + getVideoId()\"\n                    class=\"uk-margin-small-left uk-button uk-button-small\"\n                    style=\"background: #222\"\n                >\n                    <b>{{ $t(\"player.watch_on\") }}&nbsp;</b>\n                    <font-awesome-icon class=\"uk-margin-small-right\" :icon=\"['fab', 'youtube']\"></font-awesome-icon>\n                </a>\n                <a\n                    v-if=\"video.lbryId\"\n                    :href=\"'https://odysee.com/' + video.lbryId\"\n                    class=\"uk-margin-small-left uk-button uk-button-small\"\n                    style=\"background: #222\"\n                >\n                    <b>{{ $t(\"player.watch_on\") }} LBRY</b>\n                </a>\n                <router-link\n                    :to=\"toggleListenUrl\"\n                    :aria-label=\"(isListening ? 'Watch ' : 'Listen to ') + video.title\"\n                    :title=\"(isListening ? 'Watch ' : 'Listen to ') + video.title\"\n                    class=\"uk-margin-small-left uk-button uk-button-small\"\n                >\n                    <font-awesome-icon icon=\"headphones\"></font-awesome-icon>\n                </router-link>\n            </div>\n\n            <div class=\"uk-flex uk-flex-middle uk-margin-small-top\">\n                <img :src=\"video.uploaderAvatar\" alt=\"\" loading=\"lazy\" class=\"uk-border-circle\" />\n                <router-link v-if=\"video.uploaderUrl\" class=\"uk-link uk-margin-small-left\" :to=\"video.uploaderUrl\">\n                    {{ video.uploader }} </router-link\n                >&thinsp;<font-awesome-icon v-if=\"video.uploaderVerified\" icon=\"check\"></font-awesome-icon>\n                <div class=\"uk-flex-1\"></div>\n                <button\n                    v-if=\"authenticated\"\n                    class=\"uk-button uk-button-small\"\n                    style=\"background: #222\"\n                    type=\"button\"\n                    @click=\"subscribeHandler\"\n                >\n                    {{ subscribed ? $t(\"actions.unsubscribe\") : $t(\"actions.subscribe\") }}\n                </button>\n            </div>\n\n            <hr />\n\n            <a class=\"uk-button uk-button-small\" style=\"background: #222\" @click=\"showDesc = !showDesc\">\n                {{ showDesc ? $t(\"actions.minimize_description\") : $t(\"actions.show_description\") }}\n            </a>\n            <!-- eslint-disable-next-line vue/no-v-html -->\n            <p v-show=\"showDesc\" :style=\"[{ colour: foregroundColor }]\" v-html=\"purifyHTML(video.description)\"></p>\n            <div v-if=\"showDesc && sponsors && sponsors.segments\">\n                {{ $t(\"video.sponsor_segments\") }}: {{ sponsors.segments.length }}\n            </div>\n        </div>\n\n        <hr />\n\n        <label for=\"chkAutoLoop\"\n            ><b>{{ $t(\"actions.loop_this_video\") }}:</b></label\n        >&nbsp;\n        <input\n            id=\"chkAutoLoop\"\n            v-model=\"selectedAutoLoop\"\n            class=\"uk-checkbox\"\n            type=\"checkbox\"\n            @change=\"onChange($event)\"\n        />\n        <br />\n        <label for=\"chkAutoPlay\"\n            ><b>{{ $t(\"actions.auto_play_next_video\") }}:</b></label\n        >&nbsp;\n        <input\n            id=\"chkAutoPlay\"\n            v-model=\"selectedAutoPlay\"\n            class=\"uk-checkbox\"\n            type=\"checkbox\"\n            @change=\"onChange($event)\"\n        />\n\n        <hr />\n\n        <div uk-grid>\n            <div v-if=\"comments\" ref=\"comments\" class=\"uk-width-4-5@xl uk-width-3-4@s uk-width-1\">\n                <div\n                    v-for=\"comment in comments.comments\"\n                    :key=\"comment.commentId\"\n                    class=\"uk-tile-default uk-align-left uk-width-expand\"\n                    :style=\"[{ background: backgroundColor }]\"\n                >\n                    <Comment :comment=\"comment\" :uploader=\"video.uploader\" />\n                </div>\n            </div>\n\n            <div v-if=\"video\" class=\"uk-width-1-5@xl uk-width-1-4@s uk-width-1 uk-flex-last@s uk-flex-first\">\n                <a\n                    class=\"uk-button uk-button-small uk-margin-small-bottom uk-hidden@s\"\n                    style=\"background: #222\"\n                    @click=\"showRecs = !showRecs\"\n                >\n                    {{ showRecs ? $t(\"actions.minimize_recommendations\") : $t(\"actions.show_recommendations\") }}\n                </a>\n                <div\n                    v-for=\"related in video.relatedStreams\"\n                    v-show=\"showRecs || !smallView\"\n                    :key=\"related.url\"\n                    class=\"uk-tile-default uk-width-auto\"\n                    :style=\"[{ background: backgroundColor }]\"\n                >\n                    <VideoItem :video=\"related\" height=\"94\" width=\"168\" />\n                </div>\n                <hr class=\"uk-hidden@s\" />\n            </div>\n        </div>\n    </div>\n</template>\n\n<script>\nimport Player from \"@/components/Player.vue\";\nimport VideoItem from \"@/components/VideoItem.vue\";\nimport ErrorHandler from \"@/components/ErrorHandler.vue\";\nimport Comment from \"@/components/Comment.vue\";\n\nexport default {\n    name: \"App\",\n    components: {\n        Player,\n        VideoItem,\n        ErrorHandler,\n        Comment,\n    },\n    data() {\n        const smallViewQuery = window.matchMedia(\"(max-width: 640px)\");\n        return {\n            video: {\n                title: \"Loading...\",\n            },\n            sponsors: null,\n            selectedAutoLoop: false,\n            selectedAutoPlay: null,\n            showDesc: true,\n            showRecs: true,\n            comments: null,\n            subscribed: false,\n            channelId: null,\n            active: true,\n            smallViewQuery: smallViewQuery,\n            smallView: smallViewQuery.matches,\n        };\n    },\n    computed: {\n        isListening(_this) {\n            return _this.getPreferenceBoolean(\"listen\", false);\n        },\n        toggleListenUrl(_this) {\n            const url = new URL(window.location.href);\n            url.searchParams.set(\"listen\", _this.isListening ? \"0\" : \"1\");\n            return url.href;\n        },\n        isEmbed(_this) {\n            return String(_this.$route.path).indexOf(\"/embed/\") == 0;\n        },\n        uploadDate(_this) {\n            return new Date(_this.video.uploadDate).toLocaleString(undefined, {\n                month: \"short\",\n                day: \"numeric\",\n                year: \"numeric\",\n            });\n        },\n    },\n    mounted() {\n        this.getVideoData().then(() => {\n            (async () => {\n                if (window.db) {\n                    var tx = window.db.transaction(\"watch_history\", \"readwrite\");\n                    var store = tx.objectStore(\"watch_history\");\n                    var video = {\n                        videoId: this.getVideoId(),\n                        title: this.video.title,\n                        duration: this.video.duration,\n                        thumbnail: this.video.thumbnailUrl,\n                        uploaderUrl: this.video.uploaderUrl,\n                        uploaderName: this.video.uploader,\n                        watchedAt: Date.now(),\n                    };\n                    store.add(video);\n                }\n            })();\n            if (this.active) this.$refs.videoPlayer.loadVideo();\n        });\n        this.getSponsors();\n        if (!this.isEmbed && this.getPreferenceBoolean(\"comments\", true)) this.getComments();\n        window.addEventListener(\"resize\", () => {\n            this.smallView = this.smallViewQuery.matches;\n        });\n    },\n    activated() {\n        this.active = true;\n        this.selectedAutoPlay = this.getPreferenceBoolean(\"autoplay\", false);\n        this.showDesc = !this.getPreferenceBoolean(\"minimizeDescription\", false);\n        if (this.video.duration) {\n            document.title = this.video.title + \" - Piped\";\n            this.$refs.videoPlayer.loadVideo();\n        }\n        window.addEventListener(\"scroll\", this.handleScroll);\n    },\n    deactivated() {\n        this.active = false;\n        window.removeEventListener(\"scroll\", this.handleScroll);\n    },\n    unmounted() {\n        window.removeEventListener(\"scroll\", this.handleScroll);\n    },\n    methods: {\n        fetchVideo() {\n            return this.fetchJson(this.apiUrl() + \"/streams/\" + this.getVideoId());\n        },\n        async fetchSponsors() {\n            return await this.fetchJson(this.apiUrl() + \"/sponsors/\" + this.getVideoId(), {\n                category:\n                    '[\"' +\n                    this.getPreferenceString(\"selectedSkip\", \"sponsor,interaction,selfpromo,music_offtopic\").replaceAll(\n                        \",\",\n                        '\",\"',\n                    ) +\n                    '\"]',\n            });\n        },\n        fetchComments() {\n            return this.fetchJson(this.apiUrl() + \"/comments/\" + this.getVideoId());\n        },\n        onChange() {\n            this.setPreference(\"autoplay\", this.selectedAutoPlay);\n        },\n        async getVideoData() {\n            await this.fetchVideo()\n                .then(data => {\n                    this.video = data;\n                })\n                .then(() => {\n                    if (!this.video.error) {\n                        document.title = this.video.title + \" - Piped\";\n                        this.channelId = this.video.uploaderUrl.split(\"/\")[2];\n                        if (!this.isEmbed) this.fetchSubscribedStatus();\n\n                        this.video.description = this.video.description\n                            .replaceAll(\"http://www.youtube.com\", \"\")\n                            .replaceAll(\"https://www.youtube.com\", \"\")\n                            .replaceAll(\"\\n\", \"<br>\");\n                    }\n                });\n        },\n        async getSponsors() {\n            if (this.getPreferenceBoolean(\"sponsorblock\", true))\n                this.fetchSponsors().then(data => (this.sponsors = data));\n        },\n        async getComments() {\n            this.fetchComments().then(data => (this.comments = data));\n        },\n        async fetchSubscribedStatus() {\n            if (!this.channelId || !this.authenticated) return;\n\n            this.fetchJson(\n                this.apiUrl() + \"/subscribed\",\n                {\n                    channelId: this.channelId,\n                },\n                {\n                    headers: {\n                        Authorization: this.getAuthToken(),\n                    },\n                },\n            ).then(json => {\n                this.subscribed = json.subscribed;\n            });\n        },\n        subscribeHandler() {\n            this.fetchJson(this.apiUrl() + (this.subscribed ? \"/unsubscribe\" : \"/subscribe\"), null, {\n                method: \"POST\",\n                body: JSON.stringify({\n                    channelId: this.channelId,\n                }),\n                headers: {\n                    Authorization: this.getAuthToken(),\n                    \"Content-Type\": \"application/json\",\n                },\n            });\n            this.subscribed = !this.subscribed;\n        },\n        handleScroll() {\n            if (this.loading || !this.comments || !this.comments.nextpage) return;\n            if (window.innerHeight + window.scrollY >= this.$refs.comments.offsetHeight - window.innerHeight) {\n                this.loading = true;\n                this.fetchJson(this.apiUrl() + \"/nextpage/comments/\" + this.getVideoId(), {\n                    nextpage: this.comments.nextpage,\n                }).then(json => {\n                    this.comments.nextpage = json.nextpage;\n                    this.loading = false;\n                    json.comments.map(comment => this.comments.comments.push(comment));\n                });\n            }\n        },\n        getVideoId() {\n            return this.$route.query.v || this.$route.params.v;\n        },\n    },\n};\n</script>\n","<template>\n    <div class=\"uk-container-expand\">\n        <div\n            ref=\"container\"\n            data-shaka-player-container\n            style=\"width: 100%; height: 100%; background: #000\"\n            :style=\"!isEmbed ? { 'max-height': '75vh', 'min-height': '250px' } : {}\"\n        >\n            <video\n                ref=\"videoEl\"\n                data-shaka-player\n                class=\"uk-width-expand\"\n                :autoplay=\"shouldAutoPlay\"\n                :loop=\"selectedAutoLoop\"\n            ></video>\n        </div>\n    </div>\n</template>\n\n<script>\nimport(\"shaka-player/dist/controls.css\");\nconst shaka = import(\"shaka-player/dist/shaka-player.ui.js\");\nimport muxjs from \"mux.js\";\nwindow.muxjs = muxjs;\n\nexport default {\n    props: {\n        video: {\n            type: Object,\n            default: () => {\n                return {};\n            },\n        },\n        sponsors: {\n            type: Object,\n            default: () => {\n                return {};\n            },\n        },\n        selectedAutoPlay: Boolean,\n        selectedAutoLoop: Boolean,\n        isEmbed: Boolean,\n    },\n    data() {\n        return {\n            $player: null,\n            $ui: null,\n        };\n    },\n    computed: {\n        shouldAutoPlay: _this => {\n            return _this.getPreferenceBoolean(\"playerAutoPlay\", true);\n        },\n        preferredVideoCodecs: _this => {\n            var preferredVideoCodecs = [];\n            const enabledCodecs = _this.getPreferenceString(\"enabledCodecs\", \"av1,vp9,avc\").split(\",\");\n\n            if (\n                _this.$refs.videoEl.canPlayType('video/mp4; codecs=\"av01.0.08M.08\"') !== \"\" &&\n                enabledCodecs.includes(\"av1\")\n            )\n                preferredVideoCodecs.push(\"av01\");\n            if (_this.$refs.videoEl.canPlayType('video/webm; codecs=\"vp9\"') !== \"\" && enabledCodecs.includes(\"vp9\"))\n                preferredVideoCodecs.push(\"vp9\");\n            if (\n                _this.$refs.videoEl.canPlayType('video/mp4; codecs=\"avc1.4d401f\"') !== \"\" &&\n                enabledCodecs.includes(\"avc\")\n            )\n                preferredVideoCodecs.push(\"avc1\");\n\n            return preferredVideoCodecs;\n        },\n    },\n    mounted() {\n        if (!this.shaka) this.shakaPromise = shaka.then(shaka => shaka.default).then(shaka => (this.shaka = shaka));\n    },\n    activated() {\n        import(\"hotkeys-js\")\n            .then(mod => mod.default)\n            .then(hotkeys => {\n                this.hotkeys = hotkeys;\n                var self = this;\n                hotkeys(\"f,m,j,k,l,space,up,down,left,right\", function(e, handler) {\n                    const videoEl = self.$refs.videoEl;\n                    switch (handler.key) {\n                        case \"f\":\n                            self.$ui.getControls().toggleFullScreen();\n                            e.preventDefault();\n                            break;\n                        case \"m\":\n                            videoEl.muted = !videoEl.muted;\n                            e.preventDefault();\n                            break;\n                        case \"j\":\n                            videoEl.currentTime = Math.max(videoEl.currentTime - 15, 0);\n                            e.preventDefault();\n                            break;\n                        case \"l\":\n                            videoEl.currentTime = videoEl.currentTime + 15;\n                            e.preventDefault();\n                            break;\n                        case \"k\":\n                        case \"space\":\n                            if (videoEl.paused) videoEl.play();\n                            else videoEl.pause();\n                            e.preventDefault();\n                            break;\n                        case \"up\":\n                            videoEl.volume = Math.min(videoEl.volume + 0.05, 1);\n                            e.preventDefault();\n                            break;\n                        case \"down\":\n                            videoEl.volume = Math.max(videoEl.volume - 0.05, 0);\n                            e.preventDefault();\n                            break;\n                        case \"left\":\n                            videoEl.currentTime = Math.max(videoEl.currentTime - 5, 0);\n                            e.preventDefault();\n                            break;\n                        case \"right\":\n                            videoEl.currentTime = videoEl.currentTime + 5;\n                            e.preventDefault();\n                            break;\n                    }\n                });\n            });\n    },\n    deactivated() {\n        this.destroy();\n    },\n    unmounted() {\n        this.destroy();\n    },\n    methods: {\n        async loadVideo() {\n            const component = this;\n            const videoEl = this.$refs.videoEl;\n\n            videoEl.setAttribute(\"poster\", this.video.thumbnailUrl);\n\n            if (this.$route.query.t) videoEl.currentTime = this.$route.query.t;\n\n            const noPrevPlayer = !this.$player;\n\n            var streams = [];\n\n            streams.push(...this.video.audioStreams);\n            streams.push(...this.video.videoStreams);\n\n            const MseSupport = window.MediaSource !== undefined;\n\n            const lbry = this.getPreferenceBoolean(\"disableLBRY\", false)\n                ? null\n                : this.video.videoStreams.filter(stream => stream.quality === \"LBRY\")[0];\n\n            var uri;\n            var mime;\n\n            if (this.video.livestream) {\n                uri = this.video.hls;\n                mime = \"application/x-mpegURL\";\n            } else if (this.video.audioStreams.length > 0 && !lbry && MseSupport) {\n                if (!this.video.dash) {\n                    const dash = require(\"@/utils/DashUtils.js\").default.generate_dash_file_from_formats(\n                        streams,\n                        this.video.duration,\n                    );\n\n                    uri = \"data:application/dash+xml;charset=utf-8;base64,\" + btoa(dash);\n                } else uri = this.video.dash;\n                mime = \"application/dash+xml\";\n            } else if (lbry) {\n                uri = lbry.url;\n                if (this.getPreferenceBoolean(\"proxyLBRY\", false)) {\n                    const url = new URL(uri);\n                    url.searchParams.set(\"host\", url.host);\n                    url.host = new URL(this.video.proxyUrl).host;\n                    uri = url.toString();\n                }\n                const contentType = await fetch(uri, {\n                    method: \"HEAD\",\n                }).then(response => response.headers.get(\"Content-Type\"));\n                mime = contentType;\n            } else {\n                uri = this.video.videoStreams.filter(stream => stream.codec == null).slice(-1)[0].url;\n                mime = \"video/mp4\";\n            }\n\n            if (noPrevPlayer)\n                this.shakaPromise.then(() => {\n                    this.shaka.polyfill.installAll();\n\n                    const localPlayer = new this.shaka.Player(videoEl);\n                    const proxyHost = new URL(component.video.proxyUrl).host;\n\n                    localPlayer.getNetworkingEngine().registerRequestFilter((_type, request) => {\n                        const uri = request.uris[0];\n                        var url = new URL(uri);\n                        const headers = request.headers;\n                        if (\n                            url.host.endsWith(\".googlevideo.com\") ||\n                            (url.host.endsWith(\".lbryplayer.xyz\") &&\n                                (component.getPreferenceBoolean(\"proxyLBRY\", false) || headers.Range))\n                        ) {\n                            url.searchParams.set(\"host\", url.host);\n                            url.host = proxyHost;\n                            request.uris[0] = url.toString();\n                        }\n                        if (url.pathname === \"/videoplayback\") {\n                            if (headers.Range) {\n                                url.searchParams.set(\"range\", headers.Range.split(\"=\")[1]);\n                                request.headers = {};\n                                request.uris[0] = url.toString();\n                            }\n                        }\n                    });\n\n                    localPlayer.configure(\n                        \"streaming.bufferingGoal\",\n                        Math.max(this.getPreferenceNumber(\"bufferGoal\", 10), 10),\n                    );\n\n                    this.setPlayerAttrs(localPlayer, videoEl, uri, mime, this.shaka);\n                });\n            else this.setPlayerAttrs(this.$player, videoEl, uri, mime, this.shaka);\n\n            if (noPrevPlayer) {\n                videoEl.addEventListener(\"timeupdate\", () => {\n                    if (this.sponsors && this.sponsors.segments) {\n                        const time = videoEl.currentTime;\n                        this.sponsors.segments.map(segment => {\n                            if (!segment.skipped || this.selectedAutoLoop) {\n                                const end = segment.segment[1];\n                                if (time >= segment.segment[0] && time < end) {\n                                    console.log(\"Skipped segment at \" + time);\n                                    videoEl.currentTime = end;\n                                    segment.skipped = true;\n                                    return;\n                                }\n                            }\n                        });\n                    }\n                });\n\n                videoEl.addEventListener(\"volumechange\", () => {\n                    this.setPreference(\"volume\", videoEl.volume);\n                });\n\n                videoEl.addEventListener(\"ratechange\", () => {\n                    this.setPreference(\"rate\", videoEl.playbackRate);\n                });\n\n                videoEl.addEventListener(\"ended\", () => {\n                    if (!this.selectedAutoLoop && this.selectedAutoPlay && this.video.relatedStreams.length > 0) {\n                        const params = this.$route.query;\n                        let url = this.video.relatedStreams[0].url;\n                        const searchParams = new URLSearchParams();\n                        for (var param in params)\n                            switch (param) {\n                                case \"v\":\n                                case \"t\":\n                                    break;\n                                default:\n                                    searchParams.set(param, params[param]);\n                                    break;\n                            }\n                        const paramStr = searchParams.toString();\n                        if (paramStr.length > 0) url += \"&\" + paramStr;\n                        this.$router.push(url);\n                    }\n                });\n            }\n\n            //TODO: Add sponsors on seekbar: https://github.com/ajayyy/SponsorBlock/blob/e39de9fd852adb9196e0358ed827ad38d9933e29/src/js-components/previewBar.ts#L12\n        },\n        setPlayerAttrs(localPlayer, videoEl, uri, mime, shaka) {\n            if (!this.$ui) {\n                this.$ui = new shaka.ui.Overlay(localPlayer, this.$refs.container, videoEl);\n\n                const config = {\n                    overflowMenuButtons: [\"quality\", \"captions\", \"picture_in_picture\", \"playback_rate\", \"airplay\"],\n                    seekBarColors: {\n                        base: \"rgba(255, 255, 255, 0.3)\",\n                        buffered: \"rgba(255, 255, 255, 0.54)\",\n                        played: \"rgb(255, 0, 0)\",\n                    },\n                };\n\n                this.$ui.configure(config);\n            }\n\n            const player = this.$ui.getControls().getPlayer();\n\n            this.$player = player;\n\n            const disableVideo = this.getPreferenceBoolean(\"listen\", false) && !this.video.livestream;\n\n            this.$player.configure({\n                preferredVideoCodecs: this.preferredVideoCodecs,\n                preferredAudioCodecs: [\"opus\", \"mp4a\"],\n                manifest: {\n                    disableVideo: disableVideo,\n                },\n            });\n\n            const quality = this.getPreferenceNumber(\"quality\", 0);\n            const qualityConds =\n                quality > 0 && (this.video.audioStreams.length > 0 || this.video.livestream) && !disableVideo;\n            if (qualityConds) this.$player.configure(\"abr.enabled\", false);\n\n            player.load(uri, 0, mime).then(() => {\n                if (qualityConds) {\n                    var leastDiff = Number.MAX_VALUE;\n                    var bestStream = null;\n                    player\n                        .getVariantTracks()\n                        .sort((a, b) => a.bandwidth - b.bandwidth)\n                        .forEach(stream => {\n                            const diff = Math.abs(quality - stream.height);\n                            if (diff < leastDiff) {\n                                leastDiff = diff;\n                                bestStream = stream;\n                            }\n                        });\n                    player.selectVariantTrack(bestStream);\n                }\n\n                this.video.subtitles.map(subtitle => {\n                    player.addTextTrackAsync(\n                        subtitle.url,\n                        subtitle.code,\n                        \"SUBTITLE\",\n                        subtitle.mimeType,\n                        null,\n                        subtitle.name,\n                    );\n                });\n                videoEl.volume = this.getPreferenceNumber(\"volume\", 1);\n                videoEl.playbackRate = this.getPreferenceNumber(\"rate\", 1);\n            });\n        },\n        destroy() {\n            if (this.$ui) {\n                this.$ui.destroy();\n                this.$ui = undefined;\n                this.$player = undefined;\n            }\n            if (this.$player) {\n                this.$player.destroy();\n                this.$player = undefined;\n            }\n            if (this.hotkeys) this.hotkeys.unbind();\n            if (this.$refs.container) this.$refs.container.querySelectorAll(\"div\").forEach(node => node.remove());\n        },\n    },\n};\n</script>\n\n<style>\n.shaka-text-container > div {\n    height: auto !important;\n    width: auto !important;\n    top: auto !important;\n    left: auto !important;\n}\n\n.shaka-text-container * {\n    background-color: rgba(8, 8, 8, 0.75) !important;\n    color: white !important;\n}\n\n.shaka-video-container:-webkit-full-screen {\n    max-height: none !important;\n}\n</style>\n","import { render } from \"./Player.vue?vue&type=template&id=53107514\"\nimport script from \"./Player.vue?vue&type=script&lang=js\"\nexport * from \"./Player.vue?vue&type=script&lang=js\"\n\nimport \"./Player.vue?vue&type=style&index=0&id=53107514&lang=css\"\nscript.render = render\n\nexport default script","<template>\n    <div class=\"comment uk-flex\">\n        <img\n            :src=\"comment.thumbnail\"\n            class=\"comment-avatar uk-border-circle uk-margin-right\"\n            style=\"width: 48px; height: 48px;\"\n            loading=\"lazy\"\n            alt=\"Avatar\"\n        />\n\n        <div class=\"comment-content\">\n            <div class=\"comment-header\">\n                <div v-if=\"comment.pinned\" class=\"comment-pinned uk-text-meta\">\n                    <font-awesome-icon icon=\"thumbtack\"></font-awesome-icon>&nbsp; {{ $t(\"comment.pinned_by\") }}\n                    {{ uploader }}\n                </div>\n\n                <div class=\"comment-author\">\n                    <router-link class=\"uk-text-bold uk-text-small\" :to=\"comment.commentorUrl\">\n                        {{ comment.author }} </router-link\n                    >&thinsp;<font-awesome-icon v-if=\"comment.verified\" icon=\"check\"></font-awesome-icon>\n                </div>\n                <div class=\"comment-meta uk-text-meta uk-margin-small-bottom\">\n                    {{ comment.commentedTime }}\n                </div>\n            </div>\n            <div class=\"comment-body\" style=\"white-space: pre-wrap\">\n                {{ comment.commentText }}\n            </div>\n            <div class=\"comment-footer uk-margin-small-top uk-text-meta\">\n                <font-awesome-icon icon=\"thumbs-up\" style=\"margin-right: 4px;\"></font-awesome-icon>\n                <span>{{ numberFormat(comment.likeCount) }}</span>\n                &nbsp;\n                <font-awesome-icon v-if=\"comment.hearted\" icon=\"heart\"></font-awesome-icon>\n            </div>\n        </div>\n    </div>\n</template>\n\n<script>\nexport default {\n    props: {\n        comment: {\n            type: Object,\n            default: () => {\n                return {};\n            },\n        },\n        uploader: { type: String, default: null },\n    },\n};\n</script>\n","import { render } from \"./Comment.vue?vue&type=template&id=78a80119\"\nimport script from \"./Comment.vue?vue&type=script&lang=js\"\nexport * from \"./Comment.vue?vue&type=script&lang=js\"\nscript.render = render\n\nexport default script","import { render } from \"./WatchVideo.vue?vue&type=template&id=270155ac\"\nimport script from \"./WatchVideo.vue?vue&type=script&lang=js\"\nexport * from \"./WatchVideo.vue?vue&type=script&lang=js\"\nscript.render = render\n\nexport default script","// 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":""}