{"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?9ab2","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?2847","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:///./src/components/Player.vue?96e0","webpack:///./node_modules/global/window.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?d697","webpack:///./src/components/Comment.vue","webpack:///./src/components/Comment.vue?30b7","webpack:///./src/components/WatchVideo.vue?182a","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","toggleTrace","class","type","$t","ref","style","hidden","props","default","methods","$refs","stacktrace","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","id","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","_","win","window","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","_interopDefaultLegacy","window__default","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","MAX_UINT32$1","getUint64$4","dv","getBigUint64","MAX_SAFE_INTEGER","numbers","getUint64","MAX_UINT32","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","getUint64$3","parseTfdt","getUint64$2","traks","fragment","trafs","lowestTime","acc","baseTime","scale","BigInt","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","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","map","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","retriggerForStream","addPipelineLogRetriggers","transmuxer","pipeline","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","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","audioAppendStart","inspectMp4","_textifyMp","partial","getUint64$1","parseSidx","references","referenceId","earliestPresentationTime","firstOffset","referenceCount","getUint16","referenceType","referencedSize","subsegmentDuration","startsWithSap","sapType","sapDeltaTime","parseSidx_1","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","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","video-id","showRecs","relatedStreams","related","smallView","data-shaka-player-container","data-shaka-player","autoplay","shouldAutoPlay","loop","shaka","$player","$ui","lastUpdate","getTime","computed","getPreferenceBoolean","preferredVideoCodecs","enabledCodecs","getPreferenceString","videoEl","canPlayType","shakaPromise","then","mod","hotkeys","getControls","toggleFullScreen","preventDefault","muted","currentTime","setTextTrackVisibility","isTextTrackVisible","play","component","setAttribute","thumbnailUrl","$route","query","db","tx","transaction","store","objectStore","request","onsuccess","noPrevPlayer","streams","audioStreams","videoStreams","MseSupport","MediaSource","lbry","quality","mime","livestream","hls","dash","btoa","URL","proxyURL","proxyUrl","proxyPath","pathname","searchParams","host","protocol","contentType","fetch","response","headers","polyfill","installAll","localPlayer","Player","getNetworkingEngine","registerRequestFilter","_type","uris","endsWith","Range","configure","getPreferenceNumber","setPlayerAttrs","addEventListener","time","updateProgressDatabase","skipped","setPreference","playbackRate","params","URLSearchParams","param","paramStr","$router","OpenButton","ui","Element","controls","super","newTabButton_","document","createElement","classList","add","ariaPressed","newTabIcon_","textContent","appendChild","label","newTabNameSpan_","innerText","eventManager","listen","open","Factory","rootElement","OverflowMenu","registerElement","Overlay","container","overflowMenuButtons","seekBarColors","base","buffered","played","player","getPlayer","disableVideo","preferredAudioCodecs","manifest","useFullSegmentsForStartTime","qualityConds","load","leastDiff","MAX_VALUE","bestStream","getVariantTracks","diff","selectVariantTrack","subtitles","subtitle","addTextTrackAsync","trickPlay","put","unbind","querySelectorAll","node","remove","pinned","commentorUrl","author","verified","commentedTime","commentText","likeCount","hearted","repliesPage","loadingReplies","showingReplies","loadReplies","hideReplies","replies","reply","videoId","nextpage","fetchJson","apiUrl","components","VideoItem","ErrorHandler","Comment","smallViewQuery","matchMedia","channelId","active","matches","location","toLocaleString","month","day","year","getVideoData","watchedAt","now","videoPlayer","loadVideo","getSponsors","getComments","handleScroll","removeEventListener","category","replaceAll","fetchVideo","fetchSubscribedStatus","fetchSponsors","fetchComments","Authorization","getAuthToken","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-69b9ab2e.b0ca8a7b.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 @click=\"toggleTrace\" class=\"uk-button uk-button-small\" type=\"button\">\n        {{ $t(\"actions.show_more\") }}\n    </button>\n    <p ref=\"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    methods: {\n        toggleTrace() {\n            this.$refs.stacktrace.hidden = !this.$refs.stacktrace.hidden;\n        },\n    },\n};\n</script>\n","import { render } from \"./ErrorHandler.vue?vue&type=template&id=e25db53c\"\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","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, 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, 0.75); color: white; padding: 0 5px\"\n                    >{{ $t(\"video.watched\") }}</span\n                >\n            </div>\n\n            <div>\n                <p\n                    style=\"\n                        padding-top: 0.5rem;\n                        margin-bottom: 0.5rem;\n                        display: -webkit-box;\n                        -webkit-line-clamp: 2;\n                        -webkit-box-orient: vertical;\n                        overflow: hidden;\n                    \"\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=5524002a\"\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","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--7-oneOf-1-0!../../node_modules/@vue/cli-service/node_modules/css-loader/dist/cjs.js??ref--7-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--7-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--1-0!../../node_modules/vue-loader-v16/dist/index.js??ref--1-1!./Player.vue?vue&type=style&index=0&id=84fdece2&lang=css\"","var win;\n\nif (typeof window !== \"undefined\") {\n    win = window;\n} else if (typeof global !== \"undefined\") {\n    win = global;\n} else if (typeof self !== \"undefined\"){\n    win = self;\n} else {\n    win = {};\n}\n\nmodule.exports = win;\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 6.0.0 @license Apache-2.0 */\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('global/window')) :\n  typeof define === 'function' && define.amd ? define(['global/window'], factory) :\n  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.muxjs = factory(global.window));\n}(this, (function (window) { 'use strict';\n\n  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\n  var window__default = /*#__PURE__*/_interopDefaultLegacy(window);\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  var MAX_UINT32$1 = Math.pow(2, 32);\n\n  var getUint64$4 = function getUint64(uint8) {\n    var dv = new DataView(uint8.buffer, uint8.byteOffset, uint8.byteLength);\n    var value;\n\n    if (dv.getBigUint64) {\n      value = dv.getBigUint64(0);\n\n      if (value < Number.MAX_SAFE_INTEGER) {\n        return Number(value);\n      }\n\n      return value;\n    }\n\n    return dv.getUint32(0) * MAX_UINT32$1 + dv.getUint32(4);\n  };\n\n  var numbers = {\n    getUint64: getUint64$4,\n    MAX_UINT32: MAX_UINT32$1\n  };\n\n  var MAX_UINT32 = numbers.MAX_UINT32;\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 / MAX_UINT32);\n    lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % MAX_UINT32);\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  var getUint64$3 = numbers.getUint64;\n\n  var tfdt = function tfdt(data) {\n    var result = {\n      version: data[0],\n      flags: new Uint8Array(data.subarray(1, 4))\n    };\n\n    if (result.version === 1) {\n      result.baseMediaDecodeTime = getUint64$3(data.subarray(4));\n    } else {\n      result.baseMediaDecodeTime = toUnsigned$1(data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]);\n    }\n\n    return result;\n  };\n\n  var parseTfdt = tfdt;\n\n  var toUnsigned = bin.toUnsigned;\n  var toHexString = bin.toHexString;\n  var getUint64$2 = numbers.getUint64;\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; // 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    var lowestTime = trafs.reduce(function (acc, traf) {\n      var tfhd = findBox_1(traf, ['tfhd'])[0]; // get the track id from the tfhd\n\n      var id = toUnsigned(tfhd[4] << 24 | tfhd[5] << 16 | tfhd[6] << 8 | tfhd[7]); // assume a 90kHz clock if no timescale was specified\n\n      var scale = timescale[id] || 90e3; // get the base media decode time from the tfdt\n\n      var tfdt = findBox_1(traf, ['tfdt'])[0];\n      var dv = new DataView(tfdt.buffer, tfdt.byteOffset, tfdt.byteLength);\n      var baseTime; // version 1 is 64 bit\n\n      if (tfdt[0] === 1) {\n        baseTime = getUint64$2(tfdt.subarray(4, 12));\n      } else {\n        baseTime = dv.getUint32(4);\n      } // convert base time to seconds if it is a valid number.\n\n\n      var seconds;\n\n      if (typeof baseTime === 'bigint') {\n        seconds = baseTime / window__default['default'].BigInt(scale);\n      } else if (typeof baseTime === 'number' && !isNaN(baseTime)) {\n        seconds = baseTime / scale;\n      }\n\n      if (seconds < Number.MAX_SAFE_INTEGER) {\n        seconds = Number(seconds);\n      }\n\n      if (seconds < acc) {\n        acc = seconds;\n      }\n\n      return acc;\n    }, Infinity);\n    return typeof lowestTime === 'bigint' || isFinite(lowestTime) ? lowestTime : 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    if (typeof baseMediaDecodeTime === 'bigint') {\n      compositionTimeOffset = window__default['default'].BigInt(compositionTimeOffset);\n      timescale = window__default['default'].BigInt(timescale);\n    }\n\n    var result = (baseMediaDecodeTime + compositionTimeOffset) / timescale;\n\n    if (typeof result === 'bigint' && result < Number.MAX_SAFE_INTEGER) {\n      result = Number(result);\n    }\n\n    return result;\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 (/^[asm]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  var retriggerForStream = function retriggerForStream(key, event) {\n    event.stream = key;\n    this.trigger('log', event);\n  };\n\n  var addPipelineLogRetriggers = function addPipelineLogRetriggers(transmuxer, pipeline) {\n    var keys = Object.keys(pipeline);\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' || !pipeline[key].on) {\n        continue;\n      }\n\n      pipeline[key].on('log', retriggerForStream.bind(transmuxer, key));\n    }\n  };\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      addPipelineLogRetriggers(this, pipeline);\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      addPipelineLogRetriggers(this, pipeline);\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        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|BigInt} 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        if (typeof currentDts === 'bigint') {\n          sample.pts = currentDts + window__default['default'].BigInt(sample.compositionTimeOffset);\n          currentDts += window__default['default'].BigInt(sample.duration);\n        } else {\n          sample.pts = currentDts + sample.compositionTimeOffset;\n          currentDts += sample.duration;\n        }\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 getUint64$1 = numbers.getUint64;\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 = getUint64$1(data.subarray(i));\n      result.firstOffset = getUint64$1(data.subarray(i + 8));\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 getUint64 = numbers.getUint64;\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: getUint64(data.subarray(i)),\n            mediaTime: getUint64(data.subarray(i + 8)),\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-expand\">\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                <template v-if=\"video.likes >= 0\">\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>{{ video.dislikes >= 0 ? addCommas(video.dislikes) : \"?\" }}</b>\n                    </div>\n                </template>\n                <template v-if=\"video.likes < 0\">\n                    <div class=\"uk-margin-small-left\">\n                        <b v-t=\"'video.ratings_disabled'\" />\n                    </div>\n                </template>\n                <a :href=\"'https://youtu.be/' + getVideoId()\" class=\"uk-margin-small-left uk-button uk-button-small\">\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                >\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=\"isListening ? 'tv' : '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 v-if=\"authenticated\" class=\"uk-button uk-button-small\" type=\"button\" @click=\"subscribeHandler\">\n                    {{ subscribed ? $t(\"actions.unsubscribe\") : $t(\"actions.subscribe\") }}\n                </button>\n            </div>\n\n            <hr />\n\n            <a class=\"uk-button uk-button-small\" @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 class=\"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\" :video-id=\"getVideoId()\" />\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 class=\"uk-button uk-button-small uk-margin-small-bottom uk-hidden@s\" @click=\"showRecs = !showRecs\">\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                const videoId = this.getVideoId();\n                const instance = this;\n                if (window.db && !this.video.error) {\n                    var tx = window.db.transaction(\"watch_history\", \"readwrite\");\n                    var store = tx.objectStore(\"watch_history\");\n                    var request = store.get(videoId);\n                    request.onsuccess = function(event) {\n                        var video = event.target.result;\n                        if (video) {\n                            video.watchedAt = Date.now();\n                        } else {\n                            video = {\n                                videoId: videoId,\n                                title: instance.video.title,\n                                duration: instance.video.duration,\n                                thumbnail: instance.video.thumbnailUrl,\n                                uploaderUrl: instance.video.uploaderUrl,\n                                uploaderName: instance.video.uploader,\n                                watchedAt: Date.now(),\n                            };\n                        }\n                        store.put(video);\n                    };\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                    this.video.id = this.getVideoId();\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            lastUpdate: new Date().getTime(),\n        };\n    },\n    computed: {\n        shouldAutoPlay: _this => {\n            return _this.getPreferenceBoolean(\"playerAutoPlay\", true) && !_this.isEmbed;\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,c,space,up,down,left,right,0,1,2,3,4,5,6,7,8,9\", 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 \"c\":\n                            self.$player.setTextTrackVisibility(!self.$player.isTextTrackVisible());\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                        case \"0\":\n                            videoEl.currentTime = 0;\n                            e.preventDefault();\n                            break;\n                        case \"1\":\n                            videoEl.currentTime = videoEl.duration * 0.1;\n                            e.preventDefault();\n                            break;\n                        case \"2\":\n                            videoEl.currentTime = videoEl.duration * 0.2;\n                            e.preventDefault();\n                            break;\n                        case \"3\":\n                            videoEl.currentTime = videoEl.duration * 0.3;\n                            e.preventDefault();\n                            break;\n                        case \"4\":\n                            videoEl.currentTime = videoEl.duration * 0.4;\n                            e.preventDefault();\n                            break;\n                        case \"5\":\n                            videoEl.currentTime = videoEl.duration * 0.5;\n                            e.preventDefault();\n                            break;\n                        case \"6\":\n                            videoEl.currentTime = videoEl.duration * 0.6;\n                            e.preventDefault();\n                            break;\n                        case \"7\":\n                            videoEl.currentTime = videoEl.duration * 0.7;\n                            e.preventDefault();\n                            break;\n                        case \"8\":\n                            videoEl.currentTime = videoEl.duration * 0.8;\n                            e.preventDefault();\n                            break;\n                        case \"9\":\n                            videoEl.currentTime = videoEl.duration * 0.9;\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) {\n                videoEl.currentTime = this.$route.query.t;\n            } else if (window.db) {\n                var tx = window.db.transaction(\"watch_history\", \"readonly\");\n                var store = tx.objectStore(\"watch_history\");\n                var request = store.get(this.video.id);\n                request.onsuccess = function(event) {\n                    var video = event.target.result;\n                    if (video && video.currentTime) {\n                        videoEl.currentTime = video.currentTime;\n                    }\n                };\n            }\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                    const proxyURL = new URL(this.video.proxyUrl);\n                    let proxyPath = proxyURL.pathname;\n                    if (proxyPath.lastIndexOf(\"/\") === proxyPath.length - 1) {\n                        proxyPath = proxyPath.substring(0, proxyPath.length - 1);\n                    }\n\n                    url.searchParams.set(\"host\", url.host);\n                    url.protocol = proxyURL.protocol;\n                    url.host = proxyURL.host;\n                    url.pathname = proxyPath + url.pathname;\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 if (this.video.hls) {\n                uri = this.video.hls;\n                mime = \"application/x-mpegURL\";\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 proxyURL = new URL(component.video.proxyUrl);\n                    let proxyPath = proxyURL.pathname;\n                    if (proxyPath.lastIndexOf(\"/\") === proxyPath.length - 1) {\n                        proxyPath = proxyPath.substring(0, proxyPath.length - 1);\n                    }\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.protocol = proxyURL.protocol;\n                            url.host = proxyURL.host;\n                            url.pathname = proxyPath + url.pathname;\n                            request.uris[0] = url.toString();\n                        }\n                        if (url.pathname === proxyPath + \"/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                    const time = videoEl.currentTime;\n                    this.updateProgressDatabase(time);\n                    if (this.sponsors && this.sponsors.segments) {\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            const url = \"/watch?v=\" + this.video.id;\n\n            if (!this.$ui) {\n                const OpenButton = class extends shaka.ui.Element {\n                    constructor(parent, controls) {\n                        super(parent, controls);\n\n                        this.newTabButton_ = document.createElement(\"button\");\n                        this.newTabButton_.classList.add(\"shaka-cast-button\");\n                        this.newTabButton_.classList.add(\"shaka-tooltip\");\n                        this.newTabButton_.ariaPressed = \"false\";\n\n                        this.newTabIcon_ = document.createElement(\"i\");\n                        this.newTabIcon_.classList.add(\"material-icons-round\");\n                        this.newTabIcon_.textContent = \"launch\";\n                        this.newTabButton_.appendChild(this.newTabIcon_);\n\n                        const label = document.createElement(\"label\");\n                        label.classList.add(\"shaka-overflow-button-label\");\n                        label.classList.add(\"shaka-overflow-menu-only\");\n                        this.newTabNameSpan_ = document.createElement(\"span\");\n                        this.newTabNameSpan_.innerText = \"Open in new tab\";\n                        label.appendChild(this.newTabNameSpan_);\n\n                        this.newTabButton_.appendChild(label);\n                        this.parent.appendChild(this.newTabButton_);\n\n                        this.eventManager.listen(this.newTabButton_, \"click\", () => {\n                            this.video.pause();\n                            window.open(url);\n                        });\n                    }\n                };\n\n                OpenButton.Factory = class {\n                    create(rootElement, controls) {\n                        return new OpenButton(rootElement, controls);\n                    }\n                };\n\n                shaka.ui.OverflowMenu.registerElement(\"open_new_tab\", new OpenButton.Factory());\n\n                this.$ui = new shaka.ui.Overlay(localPlayer, this.$refs.container, videoEl);\n\n                const overflowMenuButtons = [\"quality\", \"captions\", \"picture_in_picture\", \"playback_rate\", \"airplay\"];\n\n                if (this.isEmbed) {\n                    overflowMenuButtons.push(\"open_new_tab\");\n                }\n\n                const config = {\n                    overflowMenuButtons: overflowMenuButtons,\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                    hls: {\n                        useFullSegmentsForStartTime: true,\n                    },\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                player.trickPlay(this.getPreferenceNumber(\"rate\", 1));\n            });\n        },\n        async updateProgressDatabase(time) {\n            // debounce\n            if (new Date().getTime() - this.lastUpdate < 500) return;\n            this.lastUpdate = new Date().getTime();\n\n            if (!this.video.id || !window.db) return;\n\n            var tx = window.db.transaction(\"watch_history\", \"readwrite\");\n            var store = tx.objectStore(\"watch_history\");\n            var request = store.get(this.video.id);\n            request.onsuccess = function(event) {\n                var video = event.target.result;\n                if (video) {\n                    video.currentTime = time;\n                    store.put(video);\n                }\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=84fdece2\"\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=84fdece2&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            height=\"48\"\n            width=\"48\"\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            <template v-if=\"comment.repliesPage && (!loadingReplies || !showingReplies)\">\n                <div @click=\"loadReplies\">\n                    <a class=\"uk-link-text\" v-t=\"'actions.show_replies'\" />\n                    &nbsp;\n                    <font-awesome-icon icon=\"level-down-alt\" />\n                </div>\n            </template>\n            <template v-if=\"showingReplies\">\n                <div @click=\"hideReplies\">\n                    <a class=\"uk-link-text\" v-t=\"'actions.hide_replies'\" />\n                    &nbsp;\n                    <font-awesome-icon icon=\"level-up-alt\" />\n                </div>\n            </template>\n            <div v-show=\"showingReplies\" v-if=\"replies\" class=\"replies uk-width-4-5@xl uk-width-3-4@s uk-width-1\">\n                <div\n                    v-for=\"reply in replies\"\n                    :key=\"reply.commentId\"\n                    class=\"uk-tile-default uk-align-left uk-width-expand\"\n                    :style=\"[{ background: backgroundColor }]\"\n                >\n                    <Comment :comment=\"reply\" :uploader=\"uploader\" :video-id=\"videoId\" />\n                </div>\n                <div v-if=\"nextpage\" @click=\"loadReplies\">\n                    <a class=\"uk-link-text\" v-t=\"'actions.load_more_replies'\" />\n                    &nbsp;\n                    <font-awesome-icon icon=\"level-down-alt\" />\n                </div>\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        videoId: { type: String, default: null },\n    },\n    data() {\n        return {\n            loadingReplies: false,\n            showingReplies: false,\n            replies: [],\n            nextpage: null,\n        };\n    },\n    methods: {\n        async loadReplies() {\n            if (!this.showingReplies && this.loadingReplies) {\n                this.showingReplies = true;\n                return;\n            }\n\n            this.loadingReplies = true;\n            this.showingReplies = true;\n            this.fetchJson(this.apiUrl() + \"/nextpage/comments/\" + this.videoId, {\n                nextpage: this.nextpage || this.comment.repliesPage,\n            }).then(json => {\n                this.replies = this.replies.concat(json.comments);\n                this.nextpage = json.nextpage;\n            });\n        },\n        async hideReplies() {\n            this.showingReplies = false;\n        },\n    },\n};\n</script>\n","import { render } from \"./Comment.vue?vue&type=template&id=24afeebc\"\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=05fa8f06\"\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":""}