{"version":3,"sources":["webpack:///./node_modules/xml-js/lib/xml2json.js","webpack:///./node_modules/readable-stream/duplex-browser.js","webpack:///./node_modules/base64-js/index.js","webpack:///./node_modules/readable-stream/lib/_stream_transform.js","webpack:///./node_modules/readable-stream/writable-browser.js","webpack:///./node_modules/sax/lib/sax.js","webpack:///./node_modules/core-util-is/lib/util.js","webpack:///./src/components/ErrorHandler.vue","webpack:///./src/components/ErrorHandler.vue?1beb","webpack:///./node_modules/inherits/inherits_browser.js","webpack:///./node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack:///./node_modules/node-libs-browser/mock/process.js","webpack:///./node_modules/readable-stream/lib/internal/streams/destroy.js","webpack:///./node_modules/xml-js/lib/json2xml.js","webpack:///./node_modules/readable-stream/lib/internal/streams/BufferList.js","webpack:///./src/components/VideoItem.vue","webpack:///./src/components/VideoItem.vue?5c02","webpack:///./node_modules/readable-stream/lib/_stream_passthrough.js","webpack:///./node_modules/string_decoder/lib/string_decoder.js","webpack:///./src/utils/DashUtils.js","webpack:///./node_modules/xml-js/lib/xml2js.js","webpack:///./node_modules/safe-buffer/index.js","webpack:///./node_modules/ieee754/index.js","webpack:///./src/components/Player.vue?0985","webpack:///./node_modules/process-nextick-args/index.js","webpack:///./node_modules/xml-js/lib/options-helper.js","webpack:///./node_modules/xml-js/lib/array-helper.js","webpack:///./node_modules/readable-stream/node_modules/safe-buffer/index.js","webpack:///./node_modules/readable-stream/lib/_stream_readable.js","webpack:///./node_modules/readable-stream/lib/_stream_duplex.js","webpack:///./node_modules/buffer/index.js","webpack:///./node_modules/util-deprecate/browser.js","webpack:///./node_modules/readable-stream/passthrough.js","webpack:///./node_modules/xml-js/lib/index.js","webpack:///./node_modules/xml-js/lib/js2xml.js","webpack:///./node_modules/readable-stream/transform.js","webpack:///./node_modules/stream-browserify/index.js","webpack:///./node_modules/readable-stream/lib/_stream_writable.js","webpack:///./node_modules/path-browserify/index.js","webpack:///./node_modules/readable-stream/readable-browser.js","webpack:///./node_modules/isarray/index.js","webpack:///./node_modules/mux.js/dist/mux.js","webpack:///./src/components/WatchVideo.vue","webpack:///./src/components/Player.vue","webpack:///./src/components/Player.vue?68a3","webpack:///./src/components/Comment.vue","webpack:///./src/components/Comment.vue?cd81","webpack:///./src/components/WatchVideo.vue?a6c1","webpack:///./node_modules/events/events.js"],"names":["helper","xml2js","validateOptions","userOptions","options","copyOptions","ensureSpacesExists","module","exports","xml","js","json","parentKey","compact","addParent","JSON","stringify","k","v","spaces","replace","byteLength","toByteArray","fromByteArray","lookup","revLookup","Arr","Uint8Array","Array","code","i","len","length","charCodeAt","getLens","b64","Error","validLen","indexOf","placeHoldersLen","lens","_byteLength","tmp","arr","curByte","tripletToBase64","num","encodeChunk","uint8","start","end","output","push","join","extraBytes","parts","maxChunkLength","len2","Transform","Duplex","util","Object","create","afterTransform","er","data","ts","this","_transformState","transforming","cb","writecb","emit","writechunk","rs","_readableState","reading","needReadable","highWaterMark","_read","call","bind","needTransform","writeencoding","sync","transform","_transform","flush","_flush","on","prefinish","_this","done","stream","_writableState","inherits","prototype","chunk","encoding","_write","n","_destroy","err","_this2","err2","sax","parser","strict","opt","SAXParser","SAXStream","createStream","MAX_BUFFER_LENGTH","Stream","buffers","clearBuffers","q","c","bufferCheckPosition","lowercase","lowercasetags","looseCase","tags","closed","closedRoot","sawRoot","tag","error","noscript","state","S","BEGIN","strictEntities","ENTITIES","XML_ENTITIES","attribList","xmlns","ns","rootNS","trackPosition","position","line","column","checkBufferLength","maxAllowed","Math","max","maxActual","l","closeText","emitNode","cdata","script","m","flushBuffers","EVENTS","o","F","newf","keys","a","hasOwnProperty","write","resume","close","ex","streamWraps","filter","ev","apply","_parser","writable","readable","me","onend","onerror","_decoder","forEach","defineProperty","get","set","h","removeAllListeners","enumerable","configurable","constructor","value","Buffer","isBuffer","SD","StringDecoder","toString","handler","args","arguments","splice","CDATA","DOCTYPE","XML_NAMESPACE","XMLNS_NAMESPACE","nameStart","nameBody","entityStart","entityBody","isWhitespace","isQuote","isAttribEnd","isMatch","regex","test","notMatch","s","STATE","BEGIN_WHITESPACE","TEXT","TEXT_ENTITY","OPEN_WAKA","SGML_DECL","SGML_DECL_QUOTED","DOCTYPE_QUOTED","DOCTYPE_DTD","DOCTYPE_DTD_QUOTED","COMMENT_STARTING","COMMENT","COMMENT_ENDING","COMMENT_ENDED","CDATA_ENDING","CDATA_ENDING_2","PROC_INST","PROC_INST_BODY","PROC_INST_ENDING","OPEN_TAG","OPEN_TAG_SLASH","ATTRIB","ATTRIB_NAME","ATTRIB_NAME_SAW_WHITE","ATTRIB_VALUE","ATTRIB_VALUE_QUOTED","ATTRIB_VALUE_CLOSED","ATTRIB_VALUE_UNQUOTED","ATTRIB_VALUE_ENTITY_Q","ATTRIB_VALUE_ENTITY_U","CLOSE_TAG","CLOSE_TAG_SAW_WHITE","SCRIPT","SCRIPT_ENDING","key","e","String","fromCharCode","event","nodeType","textNode","textopts","text","trim","normalize","strictFail","message","newTag","tagName","parent","name","attributes","qname","attribute","qualName","split","prefix","local","attrib","attribName","attribValue","qn","openTag","selfClosing","uri","p","nv","isSelfClosing","toLowerCase","closeTag","t","closeTo","pop","x","parseEntity","entity","entityLC","numStr","charAt","slice","parseInt","isNaN","fromCodePoint","beginWhiteSpace","startTagPosition","result","starti","substring","sgmlDecl","procInstName","procInstBody","pad","toUpperCase","comment","doctype","body","returnState","buffer","stringFromCharCode","floor","highSurrogate","lowSurrogate","MAX_SIZE","codeUnits","index","codePoint","Number","isFinite","RangeError","isArray","arg","objectToString","isBoolean","isNull","isNullOrUndefined","isNumber","isString","isSymbol","isUndefined","isRegExp","re","isObject","isDate","d","isError","isFunction","isPrimitive","uk-toggle","class","style","type","id","hidden","props","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","views","uploadedDate","uploaderUrl","uploaderName","hideChannel","icon","numberFormat","uploaded","timeAgo","Boolean","PassThrough","isEncoding","_normalizeEncoding","enc","retried","normalizeEncoding","nenc","nb","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckIncomplete","buf","j","utf8CheckExtraBytes","r","undefined","utf8Text","total","utf8End","require","DashUtils","generate_dash_file_from_formats","VideoFormats","VideoLength","generatedJSON","generate_xmljs_json_from_data","json2xml","VideoFormatArray","convertJSON","declaration","version","elements","profiles","minBufferTime","mediaPresentationDuration","generate_adaptation_set","adaptationSets","mimeTypes","mimeObjects","videoFormat","mimeType","videoOnly","mimeTypeIndex","isVideoFormat","adapSet","startWithSAP","subsegmentAlignment","includes","scanType","format","generate_representation_video","generate_representation_audio","Format","representation","itag","codecs","codec","bandwidth","bitrate","schemeIdUri","indexRange","indexStart","indexEnd","range","initStart","initEnd","maxPlayoutRate","frameRate","fps","currentElement","expat","pureJsParser","ensureFlagExists","ensureAlwaysArrayExists","ensureKeyExists","checkFnExists","nativeType","nValue","bValue","addField","alwaysArray","instructionFn","temp","instructionNameFn","elementsKey","element","typeKey","nameKey","instructionHasAttributes","attributesKey","instructionKey","manipulateAttributes","attributesFn","nativeTypeAttributes","attributeValueFn","attributeNameFn","onInstruction","instruction","match","attrsRegExp","exec","ignoreDeclaration","declarationKey","ignoreInstruction","onStartElement","elementNameFn","ignoreAttributes","alwaysChildren","onText","ignoreText","captureSpacesBetweenElements","sanitize","onComment","ignoreComment","onEndElement","parentElement","onCdata","ignoreCdata","onDoctype","ignoreDoctype","onError","note","Parser","onopentag","ontext","oncomment","onclosetag","oncdata","ondoctype","onprocessinginstruction","getError","copyProps","dst","SafeBuffer","encodingOrOffset","from","allocUnsafeSlow","size","fill","SlowBuffer","read","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","Infinity","pow","rt","abs","log","LN2","arg1","arg2","arg3","process","item","Readable","ReadableState","EElistenerCount","emitter","listeners","OurUint8Array","global","_uint8ArrayToBuffer","_isUint8Array","debugUtil","debug","debuglog","destroyImpl","kProxyEvents","prependListener","_events","isDuplex","objectMode","readableObjectMode","hwm","readableHwm","readableHighWaterMark","defaultHwm","pipes","pipesCount","flowing","emittedReadable","readableListening","resumeScheduled","defaultEncoding","awaitDrain","readingMore","decoder","readableAddChunk","addToFront","skipChunkCheck","onEofChunk","chunkInvalid","getPrototypeOf","addChunk","maybeReadMore","needMoreData","emitReadable","_undestroy","isPaused","setEncoding","MAX_HWM","computeNewHighWaterMark","howMuchToRead","emitReadable_","flow","maybeReadMore_","pipeOnDrain","nReadingNextTick","resume_","fromList","fromListPartial","list","hasStrings","copyFromBufferString","copyFromBuffer","str","endReadable","endReadableNT","xs","nOrig","doRead","pipe","dest","pipeOpts","doEnd","stdout","stderr","endFn","unpipe","onunpipe","unpipeInfo","hasUnpiped","cleanup","once","ondrain","cleanedUp","removeListener","onclose","onfinish","ondata","needDrain","increasedAwaitDrain","pause","dests","res","addListener","wrap","paused","method","_fromList","objectKeys","Writable","allowHalfOpen","onEndNT","base64","ieee754","typedArraySupport","__proto__","foo","subarray","kMaxLength","TYPED_ARRAY_SUPPORT","createBuffer","that","ArrayBuffer","fromArrayBuffer","fromString","fromObject","assertSize","checked","string","actual","fromArrayLike","array","byteOffset","isnan","isView","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","bidirectionalIndexOf","val","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","readUInt16BE","foundIndex","found","hexWrite","remaining","strLen","parsed","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","min","secondByte","thirdByte","fourthByte","tempCodePoint","firstByte","bytesPerSequence","decodeCodePointsArray","INSPECT_MAX_BYTES","poolSize","_augment","Symbol","species","_isBuffer","compare","y","pos","swap16","swap32","swap64","equals","thisStart","thisEnd","thisCopy","targetCopy","toJSON","_arr","MAX_ARGUMENTS_LENGTH","codePoints","out","toHex","bytes","checkOffset","ext","checkInt","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","writeDouble","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","INVALID_BASE64_RE","base64clean","stringtrim","units","leadSurrogate","byteArray","hi","lo","deprecate","msg","config","warned","deprecated","console","trace","warn","localStorage","_","xml2json","currentElementName","writeIndentation","depth","firstLine","writeAttributes","attr","attrName","quote","noQuotesForNativeAttributes","indentAttributes","writeDeclaration","writeInstruction","instructionName","instructionValue","writeComment","commentFn","writeCdata","cdataFn","writeDoctype","doctypeFn","writeText","textFn","hasContent","indentText","indentCdata","indentInstruction","writeElement","elementName","withClosingTag","fullTagEmptyElementFn","fullTagEmptyElement","writeElements","reduce","indent","commentKey","doctypeKey","cdataKey","textKey","hasContentCompact","anyContent","writeElementCompact","writeElementsCompact","nodes","EE","source","_isStdio","didOnEnd","listenerCount","CorkedRequest","finish","onCorkedFinish","asyncWrite","setImmediate","WritableState","internalUtil","realHasInstance","nop","writableObjectMode","writableHwm","writableHighWaterMark","finalCalled","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","bufferedRequest","lastBufferedRequest","pendingcb","prefinished","bufferedRequestCount","corkedRequestsFree","writev","_writev","final","_final","writeAfterEnd","validChunk","valid","decodeChunk","writeOrBuffer","isBuf","newChunk","last","callback","doWrite","onwriteError","finishMaybe","onwriteStateUpdate","needFinish","clearBuffer","afterWrite","onwriteDrain","holder","count","allBuffers","callFinal","need","endWritable","corkReq","getBuffer","current","hasInstance","Function","object","cork","uncork","setDefaultEncoding","normalizeArray","allowAboveRoot","up","basename","matchedSlash","f","resolvedPath","resolvedAbsolute","isAbsolute","trailingSlash","paths","relative","fromParts","toParts","samePartsLength","outputParts","sep","delimiter","dirname","hasRoot","extname","startDot","startPart","preDotState","factory","init","listener","off","trigger","callbacks","dispose","destination","flushSource","partialFlush","endTimeline","reset","secondsToVideoTs","secondsToAudioTs","videoTsToSeconds","audioTsToSeconds","audioTsToVideoTs","videoTsToAudioTs","metadataTsToSeconds","ONE_SECOND_IN_TS$5","seconds","sampleRate","timestamp","timelineStartPts","keepOriginalTimestamps","_AdtsStream","clock","ONE_SECOND_IN_TS","ONE_SECOND_IN_TS$4","ADTS_SAMPLING_FREQUENCIES$1","handlePartialSegments","frameNum","skipWarn_","level","packet","frameLength","protectionSkipBytes","oldBuffer","sampleCount","adtsFrameDuration","skip","pts","dts","audioobjecttype","channelcount","samplerate","samplingfrequencyindex","samplesize","ExpGolomb","adts","workingData","workingBytesAvailable","workingWord","workingBitsAvailable","bitsAvailable","loadWord","workingBytes","availableBytes","DataView","getUint32","skipBits","skipBytes","readBits","bits","valu","skipLeadingZeros","leadingZeroCount","skipUnsignedExpGolomb","skipExpGolomb","readUnsignedExpGolomb","clz","readExpGolomb","readBoolean","readUnsignedByte","_H264Stream","_NalByteStream","PROFILES_WITH_OPTIONAL_SPS_DATA","expGolomb","syncPoint","swapBuffer","100","110","122","244","44","83","86","118","128","138","139","134","trackId","currentPts","currentDts","discardEmulationPreventionBytes","readSequenceParameterSet","skipScalingList","nalByteStream","nalUnitTypeCode","nalUnitType","escapedRBSP","expGolombDecoder","deltaScale","lastScale","nextScale","newLength","newData","emulationPreventionBytesPositions","sourceIndex","profileIdc","levelIdc","profileCompatibility","chromaFormatIdc","picOrderCntType","numRefFramesInPicOrderCntCycle","picWidthInMbsMinus1","picHeightInMapUnitsMinus1","frameMbsOnlyFlag","scalingListCount","aspectRatioIdc","frameCropLeftOffset","frameCropRightOffset","frameCropTopOffset","frameCropBottomOffset","sarRatio","box","dinf","esds","ftyp","mdat","mfhd","minf","moof","moov","mvex","mvhd","trak","tkhd","mdia","mdhd","hdlr","sdtp","stbl","stsd","traf","trex","trun$1","types","MAJOR_BRAND","MINOR_VERSION","AVC1_BRAND","VIDEO_HDLR","AUDIO_HDLR","HDLR_TYPES","VMHD","SMHD","DREF","STCO","STSC","STSZ","STTS","h264","H264Stream","NalByteStream","Adts","UINT32_MAX","avc1","avcC","btrt","dref","mp4a","pasp","smhd","stco","stsc","stsz","stts","styp","tfdt","tfhd","trun","vmhd","audio","view","payload","setUint32","track","sequenceNumber","tracks","trackFragments","boxes","flags","samples","dependsOn","isDependedOn","hasRedundancy","videoSample","audioSample","avc1Box","sps","pps","sequenceParameterSets","pictureParameterSets","hSpacing","vSpacing","trackFragmentHeader","trackFragmentDecodeTime","trackFragmentRun","sampleDependencyTable","dataOffset","upperWordBaseMediaDecodeTime","lowerWordBaseMediaDecodeTime","baseMediaDecodeTime","audioTrun","videoTrun","trunHeader","durationPresent","sizePresent","flagsPresent","compositionTimeOffset","bytesOffest","header","sample","isLeading","paddingValue","isNonSyncSample","degradationPriority","timescale","startTime","compositionStartTime","getVideoTrackIds","getTracks","getTimescaleFromMediaHeader","mp4Generator","initSegment","fileType","movie","toUnsigned$3","toHexString$1","bin","toUnsigned","toHexString","parseType$2","parseType_1","toUnsigned$2","findBox","subresults","results","findBox_1","baseDataOffsetPresent","sampleDescriptionIndexPresent","defaultSampleDurationPresent","defaultSampleSizePresent","defaultSampleFlagsPresent","durationIsEmpty","defaultBaseIsMoof","baseDataOffset","sampleDescriptionIndex","defaultSampleDuration","defaultSampleSize","defaultSampleFlags","baseDataOffsetIsMoof","parseTfhd","parseSampleFlags","parseSampleFlags_1","dataOffsetPresent","firstSampleFlagsPresent","sampleDurationPresent","sampleSizePresent","sampleFlagsPresent","sampleCompositionTimeOffsetPresent","getInt32","parseTrun","toUnsigned$1","parseTfdt","traks","fragment","trafs","baseTimes","map","scale","baseTime","timescales","trafBoxes","parsedTfhd","parsedTfdt","parsedTrun","videoTrackIds","hdlrs","tkhds","handlerType","getUint8","tkhdVersion","sampleDescriptions","codecConfig","codecConfigType","codecBox","silence","probe$2","parseType","groupNalsIntoFrames","nalUnits","currentNal","currentFrame","frames","nalCount","keyFrame","groupFramesIntoGops","currentGop","gops","extendFirstKeyFrame","createDefaultSample","sampleForFrame","frame","generateSampleTable$1","concatenateNalData","nalsByteLength","numberOfNals","totalByteLength","generateSampleTableForFrame","concatenateNalDataForFrame","frameUtils","generateSampleTable","highPrefix","lowPrefix","zeroFill","makeTable","metaTable","part","silence_1","coneOfSilence","96000","88200","64000","48000","44100","32000","24000","16000","12000","11025","8000","sumFrameByteLengths","currentObj","sum","prefixWithSilence","audioAppendStartTs","videoBaseMediaDecodeTime","baseMediaDecodeTimeTs","silentFrame","firstFrame","frameDuration","audioGapDuration","audioFillFrameCount","audioFillDuration","ceil","trimAdtsFramesByEarliestDts","adtsFrames","earliestAllowedDts","minSegmentDts","minSegmentPts","concatenateFrameData","audioFrameUtils","ONE_SECOND_IN_TS$3","collectDtsInfo","timelineStartInfo","maxSegmentPts","maxSegmentDts","clearDtsInfo","calculateTrackBaseMediaDecodeTime","trackDecodeInfo","USER_DATA_REGISTERED_ITU_T_T35","RBSP_TRAILING_BITS","parseSei","payloadType","payloadSize","userIdentifier","parseUserData","sei","parseCaptionPackets","userData","ccData","discardEmulationPreventionBytes$1","captionPacketParser","CaptionStream$1","CaptionStream","parse708captions_","parse708captions","captionPackets_","ccStreams_","Cea608Stream","cc708Stream_","Cea708Stream","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","startPts","win","setCurrentWindow","current708Packet","services","new708Packet","add708Bytes","push708Packet","ptsVals","byte0","byte1","packet708","packetData","blockSize","seq","sizeCode","pushServiceBlock","service","initService","handleText","extendedCommands","defineWindow","clearWindows","deleteWindows","displayWindows","hideWindows","toggleWindows","setWindowAttributes","setPenAttributes","setPenColor","setPenLocation","getPts","byteIndex","flushDisplayed","isExtended","extended","char","fillOpacity","fillRed","fillGreen","fillBlue","borderType","borderRed","borderGreen","borderBlue","wordWrap","printDirection","scrollDirection","justify","effectSpeed","effectDirection","displayEffect","displayedText","winId","endPts","pushCaption","textTag","penSize","italics","underline","edgeType","fontStyle","fgOpacity","fgRed","fgGreen","fgBlue","bgOpacity","bgRed","bgGreen","bgBlue","edgeRed","edgeGreen","edgeBlue","CHARACTER_TRANSLATION","getCharFromCode","BOTTOM_ROW","ROWS","createDisplayBuffer","field","dataChannel","field_","dataChannel_","name_","setConstants","char0","char1","lastControlCode_","PADDING_","RESUME_CAPTION_LOADING_","mode_","END_OF_CAPTION_","clearFormatting","displayed_","nonDisplayed_","startPts_","ROLL_UP_2_ROWS_","rollUpRows_","setRollUp","ROLL_UP_3_ROWS_","ROLL_UP_4_ROWS_","CARRIAGE_RETURN_","shiftRowsUp_","BACKSPACE_","row_","ERASE_DISPLAYED_MEMORY_","ERASE_NON_DISPLAYED_MEMORY_","RESUME_DIRECT_CAPTIONING_","isSpecialCharacter","column_","isExtCharacter","isMidRowCode","addFormatting","isOffsetControlCode","isPAC","formatting_","isColorPAC","isNormalChar","content","topRow_","BASE_","EXT_","CONTROL_","OFFSET_","newBaseRow","reverse","popOn","baseRow","rollUp","paintOn","captionStream","streamTypes","H264_STREAM_TYPE","ADTS_STREAM_TYPE","METADATA_STREAM_TYPE","MAX_TS","RO_THRESH","TYPE_SHARED","handleRollover$1","reference","direction","TimestampRolloverStream$1","TimestampRolloverStream","lastDTS","referenceDTS","type_","discontinuity","_MetadataStream","timestampRolloverStream","handleRollover","percentEncode$1","parseUtf8","decodeURIComponent","parseIso88591$1","unescape","parseSyncSafeInteger$1","tagParsers","TXXX","description","WXXX","PRIV","owner","privateData","settings","descriptor","tagSize","bufferSize","dispatchType","frameStart","frameSize","frameHeader","dataAlignmentIndicator","timeStamp","_TransportPacketStream","_TransportParseStream","_ElementaryStream","metadataStream","MP2T_PACKET_LENGTH$1","SYNC_BYTE$1","bytesInBuffer","everything","startIndex","endIndex","parsePsi","parsePat","parsePmt","packetsWaitingForPmt","programMapTable","psi","payloadUnitStartIndicator","pat","section_number","last_section_number","pmtPid","pmt","sectionLength","tableEnd","programInfoLength","streamType","processPes_","STREAM_TYPES","segmentHadPmt","timedMetadata","parsePes","pes","ptsDtsFlags","startPrefix","packetLength","forceFlush","packetFlushable","flushStreams_","m2ts$1","PAT_PID","MP2T_PACKET_LENGTH","TransportPacketStream","TransportParseStream","ElementaryStream","MetadataStream","_AacStream","m2ts_1","ADTS_SAMPLING_FREQUENCIES","parseId3TagSize","returnSize","footerPresent","getId3Offset","isLikelyAacData$2","parseSyncSafeInteger","percentEncode","parseIso88591","parseAdtsSize","lowThree","middle","highTwo","parseType$1","parseSampleRate","parseAacTimestamp","utils","isLikelyAacData","setTimestamp","bytesLeft","tempLength","_VideoSegmentStream$1","_AudioSegmentStream$1","_Transmuxer$1","_CoalesceStream","aac","AUDIO_PROPERTIES","audioProperties","VIDEO_PROPERTIES","videoProperties","H264Stream$1","isLikelyAacData$1","ONE_SECOND_IN_TS$2","arrayEquals","generateSegmentTimingInfo","startDts","endDts","prependedContentDuration","ptsOffsetFromDts","decodeDuration","presentationDuration","prop","setEarliestDts","earliestDts","setVideoBaseMediaDecodeTime","setAudioAppendStart","segmentDuration","videoClockCyclesOfSilencePrefixed","gopsToAlignWith","minPTS","gopCache_","nalUnit","gopForFusion","firstGop","lastGop","resetStream_","getGopForFusion_","alignedGops","alignGopsAtEnd","alignGopsAtEnd_","alignGopsAtStart_","gop","dtsDistance","nearestGopObj","currentGopObj","halfSecond","allowableOverlap","nearestDistance","alignIndex","gopIndex","align","alignEndIndex","matchFound","trimIndex","metadata","alignGopsWith","newGopsToAlignWith","numberOfTracks","remux","remuxTracks","pendingTracks","videoTrack","pendingBoxes","pendingCaptions","pendingMetadata","pendingBytes","emittedTracks","audioTrack","caption","id3","captions","captionStreams","info","endTime","cueTime","setRemux","hasFlushed","transmuxPipeline_","setupAacPipeline","pipeline","aacStream","audioTimestampRolloverStream","timedMetadataTimestampRolloverStream","adtsStream","coalesceStream","headOfPipeline","audioSegmentStream","getLogTrigger_","hasAudio","hasVideo","setupTsPipeline","packetStream","parseStream","elementaryStream","h264Stream","videoSegmentStream","id3Frame","setBaseMediaDecodeTime","isAac","resetCaptions","_FlvTag","transmuxer$2","Transmuxer","VideoSegmentStream","AudioSegmentStream","mapToSample","approximateOffset","findSeiNals","avcStream","seiNal","lastMatchedSample","avcView","logs","seiNals","matchingSample","parseSamples","truns","allSamples","trackRun","parseCaptionNals","segment","videoTrackId","mdats","captionNals","mdatTrafPairs","matchingTraf","pair","headerInfo","parseEmbeddedCaptions","trackNals","CaptionParser","segmentCache","parsedCaptions","parsingPartial","isInitialized","isPartial","isNewInit","parsedData","cachedSegment","pushNals","nals","nal","clearParsedCaptions","resetCaptionStream","clearAllCaptions","captionParser","mp4","generator","probe","extraData","adHoc","bufferStartSize","prepareWrite","flv","minLength","widthBytes","heightBytes","videocodecidBytes","VIDEO_TAG","AUDIO_TAG","METADATA_TAG","writeBytes","writeByte","writeShort","short","setUint16","negIndex","nalUnitSize","startNalUnit","endNalUnit","nalContainer","nalStart","nalLength","writeMetaDataDouble","setFloat64","writeMetaDataBoolean","setUint8","finalize","dtsDelta","frameTime","isAudioFrame","isVideoFrame","isMetaData","isKeyFrame","flvTag","CoalesceStream","videoTags","audioTags","processedTracks","_Transmuxer","_VideoSegmentStream","_AudioSegmentStream","collectTimelineInfo","metaDataTag","extraDataTag","TagList","tagList","oldExtraData","videoKeyFrames","round","adtsFrame","lastMetaPts","writeMetaDataTags","onVideoKeyFrame","h264Frame","finishFrame","newMetadata","metaTag","extraTag","videoTimestampRolloverStream","coalesceStream$1","transmuxer$1","getFlvHeader","metadataLength","headBytes","flvHeader","m2ts","ONE_SECOND_IN_TS$1","segmentStartPts","segmentEndPts","processFrames_","timingInfo","resetTiming_","frameCache","ensureNextFrameIsKeyFrame","processNals_","cacheLastFrame","sequence","videoFrameDts","videoFramePts","resetTimingAndConfig_","createPipeline","tsPipeline","elementary","timestampRollover","aacPipeline","audioRollover","timedMetadataRollover","setupPipelineListeners","transmuxer","audioAppendStart","inspectMp4","_textifyMp","partial","MAX_UINT32$1","parseSidx","references","referenceId","earliestPresentationTime","firstOffset","referenceCount","getUint16","referenceType","referencedSize","subsegmentDuration","startsWithSap","sapType","sapDeltaTime","parseSidx_1","MAX_UINT32","parseMp4Date","Date","nalParse","dataReferenceIndex","horizresolution","vertresolution","frameCount","numOfPictureParameterSets","nalSize","configurationVersion","avcProfileIndication","avcLevelIndication","lengthSizeMinusOne","numOfSequenceParameterSets","bufferSizeDB","maxBitrate","avgBitrate","edts","elst","edits","entryCount","mediaTime","mediaRate","esId","streamPriority","decoderConfig","objectProfileIndication","decoderConfigDescriptor","audioObjectType","samplingFrequencyIndex","channelConfiguration","majorBrand","minorVersion","compatibleBrands","dataReferences","escape","language","creationTime","modificationTime","streamDescriptor","rate","volume","matrix","Uint32Array","nextTrackId","pdin","initialDelay","sidx","balance","ctts","compositionOffsets","sampleOffset","stss","syncSamples","chunkOffsets","sampleToChunks","firstChunk","samplesPerChunk","sampleSize","entries","timeToSamples","sampleDelta","layer","alternateGroup","defaultSampleDescriptionIndex","sampleDependsOn","sampleIsDependedOn","sampleHasRedundancy","samplePaddingValue","sampleIsDifferenceSample","sampleDegradationPriority","graphicsmode","opcolor","Uint16Array","ab","z","inspectedMp4","mp4Inspector","textify","parseTraf","parseHdlr","tagTypes","hex","hexStringList","parseAVCTag","avcPacketTypes","compositionTime","avcPacketType","CompositionTime","nalUnitTypeRaw","parseVideoTag","frameTypes","codecID","frameType","parseAACTag","packetTypes","aacPacketType","parseAudioTag","formatTable","samplingRateTable","soundFormat","soundRate","soundSize","soundType","parseGenericTag","tagType","dataSize","streamID","inspectFlvTag","inspectFlv","parsedResults","textifyFlv","flvTagArray","flvInspector","inspectTag","parsePid","parsePayloadUnitStartIndicator","parseAdaptionField","pusi","payloadOffset","parsePesType","parsePesTime","parseNalUnitType","videoPacketContainsKeyFrame","nalType","frameBuffer","frameI","frameSyncPoint","foundKeyFrame","probe$1","SYNC_BYTE","parsePsi_","table","parseAudioPes_","pesType","endLoop","parseVideoPes_","firstKeyFrame","adjustTimestamp_","segmentInfo","baseTimestamp","audioBaseTimestamp","dtsTime","ptsTime","videoBaseTimestamp","inspectAac_","audioCount","audioTimescale","inspectTs_","isAacData","tsInspector","muxjs","mp2t","tools","lib","uk-grid","ref","isEmbed","sponsors","selectedAutoPlay","selectedAutoLoop","addCommas","uploadDate","likes","dislikes","href","getVideoId","lbryId","uploaderAvatar","uploader","authenticated","subscribeHandler","subscribed","showDesc","foregroundColor","segments","onChange","$event","comments","commentId","relatedStreams","related","data-shaka-player-container","data-shaka-player","autoplay","shouldAutoPlay","loop","shaka","window","player","computed","getPreferenceBoolean","preferredVideoCodecs","$refs","videoEl","canPlayType","shakaPromise","then","default","methods","component","setAttribute","thumbnailUrl","$route","query","currentTime","noPrevPlayer","streams","audioStreams","videoStreams","MseSupport","MediaSource","lbry","quality","livestream","hls","dash","btoa","polyfill","installAll","localPlayer","Player","getNetworkingEngine","registerRequestFilter","_type","request","uris","URL","host","endsWith","searchParams","proxyUrl","configure","getPreferenceNumber","setPlayerAttrs","addEventListener","time","skipped","setPreference","params","URLSearchParams","param","paramStr","$router","ui","Overlay","container","overflowMenuButtons","seekBarColors","base","buffered","played","getControls","getPlayer","disableVideo","preferredAudioCodecs","manifest","qualityConds","load","leastDiff","MAX_VALUE","bestStream","getVariantTracks","diff","selectVariantTrack","subtitles","subtitle","addTextTrackAsync","mod","hotkeys","document","fullscreenElement","exitFullscreen","requestFullscreen","preventDefault","muted","play","unbind","querySelectorAll","node","remove","pinned","commentorUrl","author","verified","commentedTime","commentText","likeCount","hearted","channelId","active","getVideoData","videoPlayer","loadVideo","getSponsors","getComments","handleScroll","removeEventListener","watch","scrollTo","fetchJson","apiUrl","category","getPreferenceString","replaceAll","fetchVideo","fetchSubscribedStatus","purifyHTML","fetchSponsors","fetchComments","headers","Authorization","getAuthToken","nextpage","innerHeight","scrollY","offsetHeight","components","VideoItem","ErrorHandler","Comment","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","eventListener","errorListener","setMaxListeners","getMaxListeners","doError","context","prependOnceListener","originalListener","rawListeners","eventNames"],"mappings":"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","file":"js/chunk-11ee9ad9.d8934979.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/**/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/**/\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++, // & and such.\n OPEN_WAKA: S++, // <\n SGML_DECL: S++, // \n SCRIPT: S++, // \n","import { render } from \"./ErrorHandler.vue?vue&type=template&id=827cf3e0\"\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/**/\n\nvar pna = require('process-nextick-args');\n/**/\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}","\n\n\n","import { render } from \"./VideoItem.vue?vue&type=template&id=791e1b02\"\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/**/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/**/\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/**/\n\nvar Buffer = require('safe-buffer').Buffer;\n/**/\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, '&').replace(//g, '>');\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 */\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 */\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","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--6-oneOf-1-0!../../node_modules/@vue/cli-service/node_modules/css-loader/dist/cjs.js??ref--6-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--6-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader-v16/dist/index.js??ref--0-1!./Player.vue?vue&type=style&index=0&id=406694ae&lang=css\"","'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/**/\n\nvar pna = require('process-nextick-args');\n/**/\n\nmodule.exports = Readable;\n\n/**/\nvar isArray = require('isarray');\n/**/\n\n/**/\nvar Duplex;\n/**/\n\nReadable.ReadableState = ReadableState;\n\n/**/\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function (emitter, type) {\n return emitter.listeners(type).length;\n};\n/**/\n\n/**/\nvar Stream = require('./internal/streams/stream');\n/**/\n\n/**/\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/**/\n\n/**/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/**/\n\n/**/\nvar debugUtil = require('util');\nvar debug = void 0;\nif (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog('stream');\n} else {\n debug = function () {};\n}\n/**/\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/**/\n\nvar pna = require('process-nextick-args');\n/**/\n\n/**/\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n for (var key in obj) {\n keys.push(key);\n }return keys;\n};\n/**/\n\nmodule.exports = Duplex;\n\n/**/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/**/\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 \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 ''\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (!Buffer.isBuffer(target)) {\n throw new TypeError('Argument must be a Buffer')\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (isNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (Buffer.TYPED_ARRAY_SUPPORT &&\n typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n // must be an even number of digits\n var strLen = string.length\n if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (isNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset | 0\n if (isFinite(length)) {\n length = length | 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n // legacy write(string, encoding, offset, length) - remove in v0.13\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += toHex(buf[i])\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n newBuf = this.subarray(start, end)\n newBuf.__proto__ = Buffer.prototype\n } else {\n var sliceLen = end - start\n newBuf = new Buffer(sliceLen, undefined)\n for (var i = 0; i < sliceLen; ++i) {\n newBuf[i] = this[i + start]\n }\n }\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n byteLength = byteLength | 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n (littleEndian ? i : 1 - i) * 8\n }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n if (value < 0) value = 0xffffffff + value + 1\n for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) {\n var limit = Math.pow(2, 8 * byteLength - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n } else {\n objectWriteUInt16(this, value, offset, true)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n } else {\n objectWriteUInt16(this, value, offset, false)\n }\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n } else {\n objectWriteUInt32(this, value, offset, true)\n }\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset | 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n if (Buffer.TYPED_ARRAY_SUPPORT) {\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n } else {\n objectWriteUInt32(this, value, offset, false)\n }\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n var i\n\n if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n // ascending copy from start\n for (i = 0; i < len; ++i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, start + len),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if (code < 256) {\n val = code\n }\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n } else if (typeof val === 'number') {\n val = val & 255\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : utf8ToBytes(new Buffer(val, encoding).toString())\n var len = bytes.length\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction stringtrim (str) {\n if (str.trim) return str.trim()\n return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n if (n < 16) return '0' + n.toString(16)\n return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\nfunction isnan (val) {\n return val !== val // eslint-disable-line no-self-compare\n}\n","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n if (config('noDeprecation')) {\n return fn;\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (config('throwDeprecation')) {\n throw new Error(msg);\n } else if (config('traceDeprecation')) {\n console.trace(msg);\n } else {\n console.warn(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n try {\n if (!global.localStorage) return false;\n } catch (_) {\n return false;\n }\n var val = global.localStorage[name];\n if (null == val) return false;\n return String(val).toLowerCase() === 'true';\n}\n","module.exports = require('./readable').PassThrough\n","/*jslint node:true */\r\n\r\nvar xml2js = require('./xml2js');\r\nvar xml2json = require('./xml2json');\r\nvar js2xml = require('./js2xml');\r\nvar json2xml = require('./json2xml');\r\n\r\nmodule.exports = {\r\n xml2js: xml2js,\r\n xml2json: xml2json,\r\n js2xml: js2xml,\r\n json2xml: json2xml\r\n};\r\n","var helper = require('./options-helper');\nvar isArray = require('./array-helper').isArray;\n\nvar currentElement, currentElementName;\n\nfunction validateOptions(userOptions) {\n var options = helper.copyOptions(userOptions);\n helper.ensureFlagExists('ignoreDeclaration', options);\n helper.ensureFlagExists('ignoreInstruction', options);\n helper.ensureFlagExists('ignoreAttributes', options);\n helper.ensureFlagExists('ignoreText', options);\n helper.ensureFlagExists('ignoreComment', options);\n helper.ensureFlagExists('ignoreCdata', options);\n helper.ensureFlagExists('ignoreDoctype', options);\n helper.ensureFlagExists('compact', options);\n helper.ensureFlagExists('indentText', options);\n helper.ensureFlagExists('indentCdata', options);\n helper.ensureFlagExists('indentAttributes', options);\n helper.ensureFlagExists('indentInstruction', options);\n helper.ensureFlagExists('fullTagEmptyElement', options);\n helper.ensureFlagExists('noQuotesForNativeAttributes', options);\n helper.ensureSpacesExists(options);\n if (typeof options.spaces === 'number') {\n options.spaces = Array(options.spaces + 1).join(' ');\n }\n helper.ensureKeyExists('declaration', options);\n helper.ensureKeyExists('instruction', options);\n helper.ensureKeyExists('attributes', options);\n helper.ensureKeyExists('text', options);\n helper.ensureKeyExists('comment', options);\n helper.ensureKeyExists('cdata', options);\n helper.ensureKeyExists('doctype', options);\n helper.ensureKeyExists('type', options);\n helper.ensureKeyExists('name', options);\n helper.ensureKeyExists('elements', options);\n helper.checkFnExists('doctype', options);\n helper.checkFnExists('instruction', options);\n helper.checkFnExists('cdata', options);\n helper.checkFnExists('comment', options);\n helper.checkFnExists('text', options);\n helper.checkFnExists('instructionName', options);\n helper.checkFnExists('elementName', options);\n helper.checkFnExists('attributeName', options);\n helper.checkFnExists('attributeValue', options);\n helper.checkFnExists('attributes', options);\n helper.checkFnExists('fullTagEmptyElement', options);\n return options;\n}\n\nfunction writeIndentation(options, depth, firstLine) {\n return (!firstLine && options.spaces ? '\\n' : '') + Array(depth + 1).join(options.spaces);\n}\n\nfunction writeAttributes(attributes, options, depth) {\n if (options.ignoreAttributes) {\n return '';\n }\n if ('attributesFn' in options) {\n attributes = options.attributesFn(attributes, currentElementName, currentElement);\n }\n var key, attr, attrName, quote, result = [];\n for (key in attributes) {\n if (attributes.hasOwnProperty(key) && attributes[key] !== null && attributes[key] !== undefined) {\n quote = options.noQuotesForNativeAttributes && typeof attributes[key] !== 'string' ? '' : '\"';\n attr = '' + attributes[key]; // ensure number and boolean are converted to String\n attr = attr.replace(/\"/g, '"');\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 ? '' : '';\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 '';\n } else {\n var instructionValue = instruction[key] ? instruction[key] : '';\n if ('instructionFn' in options) instructionValue = options.instructionFn(instructionValue, key, currentElementName, currentElement);\n return '';\n }\n}\n\nfunction writeComment(comment, options) {\n return options.ignoreComment ? '' : '';\n}\n\nfunction writeCdata(cdata, options) {\n return options.ignoreCdata ? '' : '', ']]]]>')) + ']]>';\n}\n\nfunction writeDoctype(doctype, options) {\n return options.ignoreDoctype ? '' : '';\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(/&/g, '&'); // desanitize to avoid double sanitization\n text = text.replace(/&/g, '&').replace(//g, '>');\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('');\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 + '/>';\n }\n var xml = [];\n if (name) {\n xml.push('<' + elementName);\n if (typeof element !== 'object') {\n xml.push('>' + writeText(element,options) + '');\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) : '') + '');\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/**/\n\nvar pna = require('process-nextick-args');\n/**/\n\nmodule.exports = Writable;\n\n/* */\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/* */\n\n/**/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/**/\n\n/**/\nvar Duplex;\n/**/\n\nWritable.WritableState = WritableState;\n\n/**/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/**/\n\n/**/\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/**/\n\n/**/\nvar Stream = require('./internal/streams/stream');\n/**/\n\n/**/\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/**/\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 /**/\n asyncWrite(afterWrite, stream, state, finished, cb);\n /**/\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n if (!finished) onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n}\n\n// Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n}\n\n// if there's something in the buffer waiting, then process it\nfunction clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n\n if (stream._writev && entry && entry.next) {\n // Fast case, write everything using _writev()\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n\n var count = 0;\n var allBuffers = true;\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n buffer.allBuffers = allBuffers;\n\n doWrite(stream, state, true, state.length, buffer, '', holder.finish);\n\n // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n state.pendingcb++;\n state.lastBufferedRequest = null;\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n state.bufferedRequestCount = 0;\n } else {\n // Slow case, write chunks one-by-one\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n state.bufferedRequestCount--;\n // if we didn't call the onwrite immediately, then\n // it means that we need to wait until it does.\n // also, that means that the chunk and cb are currently\n // being processed, so move the buffer counter past them.\n if (state.writing) {\n break;\n }\n }\n\n if (entry === null) state.lastBufferedRequest = null;\n }\n\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n cb(new Error('_write() is not implemented'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n var state = this._writableState;\n\n if (typeof chunk === 'function') {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);\n\n // .end() fully uncorks\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n }\n\n // ignore unnecessary end() calls.\n if (!state.ending && !state.finished) endWritable(this, state, cb);\n};\n\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n if (err) {\n stream.emit('error', err);\n }\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function') {\n state.pendingcb++;\n state.finalCalled = true;\n pna.nextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit('prefinish');\n }\n }\n}\n\nfunction finishMaybe(stream, state) {\n var need = needFinish(state);\n if (need) {\n prefinish(stream, state);\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n }\n }\n return need;\n}\n\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n if (cb) {\n if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);\n }\n state.ended = true;\n stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n }\n if (state.corkedRequestsFree) {\n state.corkedRequestsFree.next = corkReq;\n } else {\n state.corkedRequestsFree = corkReq;\n }\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n get: function () {\n if (this._writableState === undefined) {\n return false;\n }\n return this._writableState.destroyed;\n },\n set: function (value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n }\n\n // backward compatibility, the user is explicitly\n // managing destroyed\n this._writableState.destroyed = value;\n }\n});\n\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\nWritable.prototype._destroy = function (err, cb) {\n this.end();\n cb(err);\n};","// .dirname, .basename, and .extname methods are extracted from Node.js v8.11.1,\n// backported and transplited with Babel, with backwards-compat fixes\n\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// resolves . and .. elements in a path array with directory names there\n// must be no slashes, empty elements, or device names (c:\\) in the array\n// (so also no leading and trailing slashes - it does not distinguish\n// relative and absolute paths)\nfunction normalizeArray(parts, allowAboveRoot) {\n // if the path tries to go above the root, `up` ends up > 0\n var up = 0;\n for (var i = parts.length - 1; i >= 0; i--) {\n var last = parts[i];\n if (last === '.') {\n parts.splice(i, 1);\n } else if (last === '..') {\n parts.splice(i, 1);\n up++;\n } else if (up) {\n parts.splice(i, 1);\n up--;\n }\n }\n\n // if the path is allowed to go above the root, restore leading ..s\n if (allowAboveRoot) {\n for (; up--; up) {\n parts.unshift('..');\n }\n }\n\n return parts;\n}\n\n// path.resolve([from ...], to)\n// posix version\nexports.resolve = function() {\n var resolvedPath = '',\n resolvedAbsolute = false;\n\n for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {\n var path = (i >= 0) ? arguments[i] : process.cwd();\n\n // Skip empty and invalid entries\n if (typeof path !== 'string') {\n throw new TypeError('Arguments to path.resolve must be strings');\n } else if (!path) {\n continue;\n }\n\n resolvedPath = path + '/' + resolvedPath;\n resolvedAbsolute = path.charAt(0) === '/';\n }\n\n // At this point the path should be resolved to a full absolute path, but\n // handle relative paths to be safe (might happen when process.cwd() fails)\n\n // Normalize the path\n resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {\n return !!p;\n }), !resolvedAbsolute).join('/');\n\n return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';\n};\n\n// path.normalize(path)\n// posix version\nexports.normalize = function(path) {\n var isAbsolute = exports.isAbsolute(path),\n trailingSlash = substr(path, -1) === '/';\n\n // Normalize the path\n path = normalizeArray(filter(path.split('/'), function(p) {\n return !!p;\n }), !isAbsolute).join('/');\n\n if (!path && !isAbsolute) {\n path = '.';\n }\n if (path && trailingSlash) {\n path += '/';\n }\n\n return (isAbsolute ? '/' : '') + path;\n};\n\n// posix version\nexports.isAbsolute = function(path) {\n return path.charAt(0) === '/';\n};\n\n// posix version\nexports.join = function() {\n var paths = Array.prototype.slice.call(arguments, 0);\n return exports.normalize(filter(paths, function(p, index) {\n if (typeof p !== 'string') {\n throw new TypeError('Arguments to path.join must be strings');\n }\n return p;\n }).join('/'));\n};\n\n\n// path.relative(from, to)\n// posix version\nexports.relative = function(from, to) {\n from = exports.resolve(from).substr(1);\n to = exports.resolve(to).substr(1);\n\n function trim(arr) {\n var start = 0;\n for (; start < arr.length; start++) {\n if (arr[start] !== '') break;\n }\n\n var end = arr.length - 1;\n for (; end >= 0; end--) {\n if (arr[end] !== '') break;\n }\n\n if (start > end) return [];\n return arr.slice(start, end - start + 1);\n }\n\n var fromParts = trim(from.split('/'));\n var toParts = trim(to.split('/'));\n\n var length = Math.min(fromParts.length, toParts.length);\n var samePartsLength = length;\n for (var i = 0; i < length; i++) {\n if (fromParts[i] !== toParts[i]) {\n samePartsLength = i;\n break;\n }\n }\n\n var outputParts = [];\n for (var i = samePartsLength; i < fromParts.length; i++) {\n outputParts.push('..');\n }\n\n outputParts = outputParts.concat(toParts.slice(samePartsLength));\n\n return outputParts.join('/');\n};\n\nexports.sep = '/';\nexports.delimiter = ':';\n\nexports.dirname = function (path) {\n if (typeof path !== 'string') path = path + '';\n if (path.length === 0) return '.';\n var code = path.charCodeAt(0);\n var hasRoot = code === 47 /*/*/;\n var end = -1;\n var matchedSlash = true;\n for (var i = path.length - 1; i >= 1; --i) {\n code = path.charCodeAt(i);\n if (code === 47 /*/*/) {\n if (!matchedSlash) {\n end = i;\n break;\n }\n } else {\n // We saw the first non-path separator\n matchedSlash = false;\n }\n }\n\n if (end === -1) return hasRoot ? '/' : '.';\n if (hasRoot && end === 1) {\n // return '//';\n // Backwards-compat fix:\n return '/';\n }\n return path.slice(0, end);\n};\n\nfunction basename(path) {\n if (typeof path !== 'string') path = path + '';\n\n var start = 0;\n var end = -1;\n var matchedSlash = true;\n var i;\n\n for (i = path.length - 1; i >= 0; --i) {\n if (path.charCodeAt(i) === 47 /*/*/) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n start = i + 1;\n break;\n }\n } else if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // path component\n matchedSlash = false;\n end = i + 1;\n }\n }\n\n if (end === -1) return '';\n return path.slice(start, end);\n}\n\n// Uses a mixed approach for backwards-compatibility, as ext behavior changed\n// in new Node.js versions, so only basename() above is backported here\nexports.basename = function (path, ext) {\n var f = basename(path);\n if (ext && f.substr(-1 * ext.length) === ext) {\n f = f.substr(0, f.length - ext.length);\n }\n return f;\n};\n\nexports.extname = function (path) {\n if (typeof path !== 'string') path = path + '';\n var startDot = -1;\n var startPart = 0;\n var end = -1;\n var matchedSlash = true;\n // Track the state of characters (if any) we see before our first dot and\n // after any path separator we find\n var preDotState = 0;\n for (var i = path.length - 1; i >= 0; --i) {\n var code = path.charCodeAt(i);\n if (code === 47 /*/*/) {\n // If we reached a path separator that was not part of a set of path\n // separators at the end of the string, stop now\n if (!matchedSlash) {\n startPart = i + 1;\n break;\n }\n continue;\n }\n if (end === -1) {\n // We saw the first non-path separator, mark this as the end of our\n // extension\n matchedSlash = false;\n end = i + 1;\n }\n if (code === 46 /*.*/) {\n // If this is our first dot, mark it as the start of our extension\n if (startDot === -1)\n startDot = i;\n else if (preDotState !== 1)\n preDotState = 1;\n } else if (startDot !== -1) {\n // We saw a non-dot and non-path separator before our dot, so we should\n // have a good chance at having a non-empty extension\n preDotState = -1;\n }\n }\n\n if (startDot === -1 || end === -1 ||\n // We saw a non-dot character immediately before the dot\n preDotState === 0 ||\n // The (right-most) trimmed path component is exactly '..'\n preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n return '';\n }\n return path.slice(startDot, end);\n};\n\nfunction filter (xs, f) {\n if (xs.filter) return xs.filter(f);\n var res = [];\n for (var i = 0; i < xs.length; i++) {\n if (f(xs[i], i, xs)) res.push(xs[i]);\n }\n return res;\n}\n\n// String.prototype.substr - negative index don't work in IE8\nvar substr = 'ab'.substr(-1) === 'b'\n ? function (str, start, len) { return str.substr(start, len) }\n : function (str, start, len) {\n if (start < 0) start = str.length + start;\n return str.substr(start, len);\n }\n;\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n return toString.call(arr) == '[object Array]';\n};\n","/*! @name mux.js @version 5.12.2 @license Apache-2.0 */\n(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n typeof define === 'function' && define.amd ? define(factory) :\n (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.muxjs = factory());\n}(this, (function () { 'use strict';\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n *\n * A lightweight readable stream implemention that handles event dispatching.\n * Objects that inherit from streams should call init in their constructors.\n */\n\n var Stream = function Stream() {\n this.init = function () {\n var listeners = {};\n /**\n * Add a listener for a specified event type.\n * @param type {string} the event name\n * @param listener {function} the callback to be invoked when an event of\n * the specified type occurs\n */\n\n this.on = function (type, listener) {\n if (!listeners[type]) {\n listeners[type] = [];\n }\n\n listeners[type] = listeners[type].concat(listener);\n };\n /**\n * Remove a listener for a specified event type.\n * @param type {string} the event name\n * @param listener {function} a function previously registered for this\n * type of event through `on`\n */\n\n\n this.off = function (type, listener) {\n var index;\n\n if (!listeners[type]) {\n return false;\n }\n\n index = listeners[type].indexOf(listener);\n listeners[type] = listeners[type].slice();\n listeners[type].splice(index, 1);\n return index > -1;\n };\n /**\n * Trigger an event of the specified type on this stream. Any additional\n * arguments to this function are passed as parameters to event listeners.\n * @param type {string} the event name\n */\n\n\n this.trigger = function (type) {\n var callbacks, i, length, args;\n callbacks = listeners[type];\n\n if (!callbacks) {\n return;\n } // Slicing the arguments on every invocation of this method\n // can add a significant amount of overhead. Avoid the\n // intermediate object creation for the common case of a\n // single callback argument\n\n\n if (arguments.length === 2) {\n length = callbacks.length;\n\n for (i = 0; i < length; ++i) {\n callbacks[i].call(this, arguments[1]);\n }\n } else {\n args = [];\n i = arguments.length;\n\n for (i = 1; i < arguments.length; ++i) {\n args.push(arguments[i]);\n }\n\n length = callbacks.length;\n\n for (i = 0; i < length; ++i) {\n callbacks[i].apply(this, args);\n }\n }\n };\n /**\n * Destroys the stream and cleans up.\n */\n\n\n this.dispose = function () {\n listeners = {};\n };\n };\n };\n /**\n * Forwards all `data` events on this stream to the destination stream. The\n * destination stream should provide a method `push` to receive the data\n * events as they arrive.\n * @param destination {stream} the stream that will receive all `data` events\n * @param autoFlush {boolean} if false, we will not call `flush` on the destination\n * when the current stream emits a 'done' event\n * @see http://nodejs.org/api/stream.html#stream_readable_pipe_destination_options\n */\n\n\n Stream.prototype.pipe = function (destination) {\n this.on('data', function (data) {\n destination.push(data);\n });\n this.on('done', function (flushSource) {\n destination.flush(flushSource);\n });\n this.on('partialdone', function (flushSource) {\n destination.partialFlush(flushSource);\n });\n this.on('endedtimeline', function (flushSource) {\n destination.endTimeline(flushSource);\n });\n this.on('reset', function (flushSource) {\n destination.reset(flushSource);\n });\n return destination;\n }; // Default stream functions that are expected to be overridden to perform\n // actual work. These are provided by the prototype as a sort of no-op\n // implementation so that we don't have to check for their existence in the\n // `pipe` function above.\n\n\n Stream.prototype.push = function (data) {\n this.trigger('data', data);\n };\n\n Stream.prototype.flush = function (flushSource) {\n this.trigger('done', flushSource);\n };\n\n Stream.prototype.partialFlush = function (flushSource) {\n this.trigger('partialdone', flushSource);\n };\n\n Stream.prototype.endTimeline = function (flushSource) {\n this.trigger('endedtimeline', flushSource);\n };\n\n Stream.prototype.reset = function (flushSource) {\n this.trigger('reset', flushSource);\n };\n\n var stream = Stream;\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n var ONE_SECOND_IN_TS$5 = 90000,\n // 90kHz clock\n secondsToVideoTs,\n secondsToAudioTs,\n videoTsToSeconds,\n audioTsToSeconds,\n audioTsToVideoTs,\n videoTsToAudioTs,\n metadataTsToSeconds;\n\n secondsToVideoTs = function secondsToVideoTs(seconds) {\n return seconds * ONE_SECOND_IN_TS$5;\n };\n\n secondsToAudioTs = function secondsToAudioTs(seconds, sampleRate) {\n return seconds * sampleRate;\n };\n\n videoTsToSeconds = function videoTsToSeconds(timestamp) {\n return timestamp / ONE_SECOND_IN_TS$5;\n };\n\n audioTsToSeconds = function audioTsToSeconds(timestamp, sampleRate) {\n return timestamp / sampleRate;\n };\n\n audioTsToVideoTs = function audioTsToVideoTs(timestamp, sampleRate) {\n return secondsToVideoTs(audioTsToSeconds(timestamp, sampleRate));\n };\n\n videoTsToAudioTs = function videoTsToAudioTs(timestamp, sampleRate) {\n return secondsToAudioTs(videoTsToSeconds(timestamp), sampleRate);\n };\n /**\n * Adjust ID3 tag or caption timing information by the timeline pts values\n * (if keepOriginalTimestamps is false) and convert to seconds\n */\n\n\n metadataTsToSeconds = function metadataTsToSeconds(timestamp, timelineStartPts, keepOriginalTimestamps) {\n return videoTsToSeconds(keepOriginalTimestamps ? timestamp : timestamp - timelineStartPts);\n };\n\n var clock = {\n ONE_SECOND_IN_TS: ONE_SECOND_IN_TS$5,\n secondsToVideoTs: secondsToVideoTs,\n secondsToAudioTs: secondsToAudioTs,\n videoTsToSeconds: videoTsToSeconds,\n audioTsToSeconds: audioTsToSeconds,\n audioTsToVideoTs: audioTsToVideoTs,\n videoTsToAudioTs: videoTsToAudioTs,\n metadataTsToSeconds: metadataTsToSeconds\n };\n\n var ONE_SECOND_IN_TS$4 = clock.ONE_SECOND_IN_TS;\n\n var _AdtsStream;\n\n var ADTS_SAMPLING_FREQUENCIES$1 = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];\n /*\n * Accepts a ElementaryStream and emits data events with parsed\n * AAC Audio Frames of the individual packets. Input audio in ADTS\n * format is unpacked and re-emitted as AAC frames.\n *\n * @see http://wiki.multimedia.cx/index.php?title=ADTS\n * @see http://wiki.multimedia.cx/?title=Understanding_AAC\n */\n\n _AdtsStream = function AdtsStream(handlePartialSegments) {\n var buffer,\n frameNum = 0;\n\n _AdtsStream.prototype.init.call(this);\n\n this.skipWarn_ = function (start, end) {\n this.trigger('log', {\n level: 'warn',\n message: \"adts skiping bytes \" + start + \" to \" + end + \" in frame \" + frameNum + \" outside syncword\"\n });\n };\n\n this.push = function (packet) {\n var i = 0,\n frameLength,\n protectionSkipBytes,\n oldBuffer,\n sampleCount,\n adtsFrameDuration;\n\n if (!handlePartialSegments) {\n frameNum = 0;\n }\n\n if (packet.type !== 'audio') {\n // ignore non-audio data\n return;\n } // Prepend any data in the buffer to the input data so that we can parse\n // aac frames the cross a PES packet boundary\n\n\n if (buffer && buffer.length) {\n oldBuffer = buffer;\n buffer = new Uint8Array(oldBuffer.byteLength + packet.data.byteLength);\n buffer.set(oldBuffer);\n buffer.set(packet.data, oldBuffer.byteLength);\n } else {\n buffer = packet.data;\n } // unpack any ADTS frames which have been fully received\n // for details on the ADTS header, see http://wiki.multimedia.cx/index.php?title=ADTS\n\n\n var skip; // We use i + 7 here because we want to be able to parse the entire header.\n // If we don't have enough bytes to do that, then we definitely won't have a full frame.\n\n while (i + 7 < buffer.length) {\n // Look for the start of an ADTS header..\n if (buffer[i] !== 0xFF || (buffer[i + 1] & 0xF6) !== 0xF0) {\n if (typeof skip !== 'number') {\n skip = i;\n } // If a valid header was not found, jump one forward and attempt to\n // find a valid ADTS header starting at the next byte\n\n\n i++;\n continue;\n }\n\n if (typeof skip === 'number') {\n this.skipWarn_(skip, i);\n skip = null;\n } // The protection skip bit tells us if we have 2 bytes of CRC data at the\n // end of the ADTS header\n\n\n protectionSkipBytes = (~buffer[i + 1] & 0x01) * 2; // Frame length is a 13 bit integer starting 16 bits from the\n // end of the sync sequence\n // NOTE: frame length includes the size of the header\n\n frameLength = (buffer[i + 3] & 0x03) << 11 | buffer[i + 4] << 3 | (buffer[i + 5] & 0xe0) >> 5;\n sampleCount = ((buffer[i + 6] & 0x03) + 1) * 1024;\n adtsFrameDuration = sampleCount * ONE_SECOND_IN_TS$4 / ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2]; // If we don't have enough data to actually finish this ADTS frame,\n // then we have to wait for more data\n\n if (buffer.byteLength - i < frameLength) {\n break;\n } // Otherwise, deliver the complete AAC frame\n\n\n this.trigger('data', {\n pts: packet.pts + frameNum * adtsFrameDuration,\n dts: packet.dts + frameNum * adtsFrameDuration,\n sampleCount: sampleCount,\n audioobjecttype: (buffer[i + 2] >>> 6 & 0x03) + 1,\n channelcount: (buffer[i + 2] & 1) << 2 | (buffer[i + 3] & 0xc0) >>> 6,\n samplerate: ADTS_SAMPLING_FREQUENCIES$1[(buffer[i + 2] & 0x3c) >>> 2],\n samplingfrequencyindex: (buffer[i + 2] & 0x3c) >>> 2,\n // assume ISO/IEC 14496-12 AudioSampleEntry default of 16\n samplesize: 16,\n // data is the frame without it's header\n data: buffer.subarray(i + 7 + protectionSkipBytes, i + frameLength)\n });\n frameNum++;\n i += frameLength;\n }\n\n if (typeof skip === 'number') {\n this.skipWarn_(skip, i);\n skip = null;\n } // remove processed bytes from the buffer.\n\n\n buffer = buffer.subarray(i);\n };\n\n this.flush = function () {\n frameNum = 0;\n this.trigger('done');\n };\n\n this.reset = function () {\n buffer = void 0;\n this.trigger('reset');\n };\n\n this.endTimeline = function () {\n buffer = void 0;\n this.trigger('endedtimeline');\n };\n };\n\n _AdtsStream.prototype = new stream();\n var adts = _AdtsStream;\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var ExpGolomb;\n /**\n * Parser for exponential Golomb codes, a variable-bitwidth number encoding\n * scheme used by h264.\n */\n\n ExpGolomb = function ExpGolomb(workingData) {\n var // the number of bytes left to examine in workingData\n workingBytesAvailable = workingData.byteLength,\n // the current word being examined\n workingWord = 0,\n // :uint\n // the number of bits left to examine in the current word\n workingBitsAvailable = 0; // :uint;\n // ():uint\n\n this.length = function () {\n return 8 * workingBytesAvailable;\n }; // ():uint\n\n\n this.bitsAvailable = function () {\n return 8 * workingBytesAvailable + workingBitsAvailable;\n }; // ():void\n\n\n this.loadWord = function () {\n var position = workingData.byteLength - workingBytesAvailable,\n workingBytes = new Uint8Array(4),\n availableBytes = Math.min(4, workingBytesAvailable);\n\n if (availableBytes === 0) {\n throw new Error('no bytes available');\n }\n\n workingBytes.set(workingData.subarray(position, position + availableBytes));\n workingWord = new DataView(workingBytes.buffer).getUint32(0); // track the amount of workingData that has been processed\n\n workingBitsAvailable = availableBytes * 8;\n workingBytesAvailable -= availableBytes;\n }; // (count:int):void\n\n\n this.skipBits = function (count) {\n var skipBytes; // :int\n\n if (workingBitsAvailable > count) {\n workingWord <<= count;\n workingBitsAvailable -= count;\n } else {\n count -= workingBitsAvailable;\n skipBytes = Math.floor(count / 8);\n count -= skipBytes * 8;\n workingBytesAvailable -= skipBytes;\n this.loadWord();\n workingWord <<= count;\n workingBitsAvailable -= count;\n }\n }; // (size:int):uint\n\n\n this.readBits = function (size) {\n var bits = Math.min(workingBitsAvailable, size),\n // :uint\n valu = workingWord >>> 32 - bits; // :uint\n // if size > 31, handle error\n\n workingBitsAvailable -= bits;\n\n if (workingBitsAvailable > 0) {\n workingWord <<= bits;\n } else if (workingBytesAvailable > 0) {\n this.loadWord();\n }\n\n bits = size - bits;\n\n if (bits > 0) {\n return valu << bits | this.readBits(bits);\n }\n\n return valu;\n }; // ():uint\n\n\n this.skipLeadingZeros = function () {\n var leadingZeroCount; // :uint\n\n for (leadingZeroCount = 0; leadingZeroCount < workingBitsAvailable; ++leadingZeroCount) {\n if ((workingWord & 0x80000000 >>> leadingZeroCount) !== 0) {\n // the first bit of working word is 1\n workingWord <<= leadingZeroCount;\n workingBitsAvailable -= leadingZeroCount;\n return leadingZeroCount;\n }\n } // we exhausted workingWord and still have not found a 1\n\n\n this.loadWord();\n return leadingZeroCount + this.skipLeadingZeros();\n }; // ():void\n\n\n this.skipUnsignedExpGolomb = function () {\n this.skipBits(1 + this.skipLeadingZeros());\n }; // ():void\n\n\n this.skipExpGolomb = function () {\n this.skipBits(1 + this.skipLeadingZeros());\n }; // ():uint\n\n\n this.readUnsignedExpGolomb = function () {\n var clz = this.skipLeadingZeros(); // :uint\n\n return this.readBits(clz + 1) - 1;\n }; // ():int\n\n\n this.readExpGolomb = function () {\n var valu = this.readUnsignedExpGolomb(); // :int\n\n if (0x01 & valu) {\n // the number is odd if the low order bit is set\n return 1 + valu >>> 1; // add 1 to make it even, and divide by 2\n }\n\n return -1 * (valu >>> 1); // divide by two then make it negative\n }; // Some convenience functions\n // :Boolean\n\n\n this.readBoolean = function () {\n return this.readBits(1) === 1;\n }; // ():int\n\n\n this.readUnsignedByte = function () {\n return this.readBits(8);\n };\n\n this.loadWord();\n };\n\n var expGolomb = ExpGolomb;\n\n var _H264Stream, _NalByteStream;\n\n var PROFILES_WITH_OPTIONAL_SPS_DATA;\n /**\n * Accepts a NAL unit byte stream and unpacks the embedded NAL units.\n */\n\n _NalByteStream = function NalByteStream() {\n var syncPoint = 0,\n i,\n buffer;\n\n _NalByteStream.prototype.init.call(this);\n /*\n * Scans a byte stream and triggers a data event with the NAL units found.\n * @param {Object} data Event received from H264Stream\n * @param {Uint8Array} data.data The h264 byte stream to be scanned\n *\n * @see H264Stream.push\n */\n\n\n this.push = function (data) {\n var swapBuffer;\n\n if (!buffer) {\n buffer = data.data;\n } else {\n swapBuffer = new Uint8Array(buffer.byteLength + data.data.byteLength);\n swapBuffer.set(buffer);\n swapBuffer.set(data.data, buffer.byteLength);\n buffer = swapBuffer;\n }\n\n var len = buffer.byteLength; // Rec. ITU-T H.264, Annex B\n // scan for NAL unit boundaries\n // a match looks like this:\n // 0 0 1 .. NAL .. 0 0 1\n // ^ sync point ^ i\n // or this:\n // 0 0 1 .. NAL .. 0 0 0\n // ^ sync point ^ i\n // advance the sync point to a NAL start, if necessary\n\n for (; syncPoint < len - 3; syncPoint++) {\n if (buffer[syncPoint + 2] === 1) {\n // the sync point is properly aligned\n i = syncPoint + 5;\n break;\n }\n }\n\n while (i < len) {\n // look at the current byte to determine if we've hit the end of\n // a NAL unit boundary\n switch (buffer[i]) {\n case 0:\n // skip past non-sync sequences\n if (buffer[i - 1] !== 0) {\n i += 2;\n break;\n } else if (buffer[i - 2] !== 0) {\n i++;\n break;\n } // deliver the NAL unit if it isn't empty\n\n\n if (syncPoint + 3 !== i - 2) {\n this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));\n } // drop trailing zeroes\n\n\n do {\n i++;\n } while (buffer[i] !== 1 && i < len);\n\n syncPoint = i - 2;\n i += 3;\n break;\n\n case 1:\n // skip past non-sync sequences\n if (buffer[i - 1] !== 0 || buffer[i - 2] !== 0) {\n i += 3;\n break;\n } // deliver the NAL unit\n\n\n this.trigger('data', buffer.subarray(syncPoint + 3, i - 2));\n syncPoint = i - 2;\n i += 3;\n break;\n\n default:\n // the current byte isn't a one or zero, so it cannot be part\n // of a sync sequence\n i += 3;\n break;\n }\n } // filter out the NAL units that were delivered\n\n\n buffer = buffer.subarray(syncPoint);\n i -= syncPoint;\n syncPoint = 0;\n };\n\n this.reset = function () {\n buffer = null;\n syncPoint = 0;\n this.trigger('reset');\n };\n\n this.flush = function () {\n // deliver the last buffered NAL unit\n if (buffer && buffer.byteLength > 3) {\n this.trigger('data', buffer.subarray(syncPoint + 3));\n } // reset the stream state\n\n\n buffer = null;\n syncPoint = 0;\n this.trigger('done');\n };\n\n this.endTimeline = function () {\n this.flush();\n this.trigger('endedtimeline');\n };\n };\n\n _NalByteStream.prototype = new stream(); // values of profile_idc that indicate additional fields are included in the SPS\n // see Recommendation ITU-T H.264 (4/2013),\n // 7.3.2.1.1 Sequence parameter set data syntax\n\n PROFILES_WITH_OPTIONAL_SPS_DATA = {\n 100: true,\n 110: true,\n 122: true,\n 244: true,\n 44: true,\n 83: true,\n 86: true,\n 118: true,\n 128: true,\n // TODO: the three profiles below don't\n // appear to have sps data in the specificiation anymore?\n 138: true,\n 139: true,\n 134: true\n };\n /**\n * Accepts input from a ElementaryStream and produces H.264 NAL unit data\n * events.\n */\n\n _H264Stream = function H264Stream() {\n var nalByteStream = new _NalByteStream(),\n self,\n trackId,\n currentPts,\n currentDts,\n discardEmulationPreventionBytes,\n readSequenceParameterSet,\n skipScalingList;\n\n _H264Stream.prototype.init.call(this);\n\n self = this;\n /*\n * Pushes a packet from a stream onto the NalByteStream\n *\n * @param {Object} packet - A packet received from a stream\n * @param {Uint8Array} packet.data - The raw bytes of the packet\n * @param {Number} packet.dts - Decode timestamp of the packet\n * @param {Number} packet.pts - Presentation timestamp of the packet\n * @param {Number} packet.trackId - The id of the h264 track this packet came from\n * @param {('video'|'audio')} packet.type - The type of packet\n *\n */\n\n this.push = function (packet) {\n if (packet.type !== 'video') {\n return;\n }\n\n trackId = packet.trackId;\n currentPts = packet.pts;\n currentDts = packet.dts;\n nalByteStream.push(packet);\n };\n /*\n * Identify NAL unit types and pass on the NALU, trackId, presentation and decode timestamps\n * for the NALUs to the next stream component.\n * Also, preprocess caption and sequence parameter NALUs.\n *\n * @param {Uint8Array} data - A NAL unit identified by `NalByteStream.push`\n * @see NalByteStream.push\n */\n\n\n nalByteStream.on('data', function (data) {\n var event = {\n trackId: trackId,\n pts: currentPts,\n dts: currentDts,\n data: data,\n nalUnitTypeCode: data[0] & 0x1f\n };\n\n switch (event.nalUnitTypeCode) {\n case 0x05:\n event.nalUnitType = 'slice_layer_without_partitioning_rbsp_idr';\n break;\n\n case 0x06:\n event.nalUnitType = 'sei_rbsp';\n event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));\n break;\n\n case 0x07:\n event.nalUnitType = 'seq_parameter_set_rbsp';\n event.escapedRBSP = discardEmulationPreventionBytes(data.subarray(1));\n event.config = readSequenceParameterSet(event.escapedRBSP);\n break;\n\n case 0x08:\n event.nalUnitType = 'pic_parameter_set_rbsp';\n break;\n\n case 0x09:\n event.nalUnitType = 'access_unit_delimiter_rbsp';\n break;\n } // This triggers data on the H264Stream\n\n\n self.trigger('data', event);\n });\n nalByteStream.on('done', function () {\n self.trigger('done');\n });\n nalByteStream.on('partialdone', function () {\n self.trigger('partialdone');\n });\n nalByteStream.on('reset', function () {\n self.trigger('reset');\n });\n nalByteStream.on('endedtimeline', function () {\n self.trigger('endedtimeline');\n });\n\n this.flush = function () {\n nalByteStream.flush();\n };\n\n this.partialFlush = function () {\n nalByteStream.partialFlush();\n };\n\n this.reset = function () {\n nalByteStream.reset();\n };\n\n this.endTimeline = function () {\n nalByteStream.endTimeline();\n };\n /**\n * Advance the ExpGolomb decoder past a scaling list. The scaling\n * list is optionally transmitted as part of a sequence parameter\n * set and is not relevant to transmuxing.\n * @param count {number} the number of entries in this scaling list\n * @param expGolombDecoder {object} an ExpGolomb pointed to the\n * start of a scaling list\n * @see Recommendation ITU-T H.264, Section 7.3.2.1.1.1\n */\n\n\n skipScalingList = function skipScalingList(count, expGolombDecoder) {\n var lastScale = 8,\n nextScale = 8,\n j,\n deltaScale;\n\n for (j = 0; j < count; j++) {\n if (nextScale !== 0) {\n deltaScale = expGolombDecoder.readExpGolomb();\n nextScale = (lastScale + deltaScale + 256) % 256;\n }\n\n lastScale = nextScale === 0 ? lastScale : nextScale;\n }\n };\n /**\n * Expunge any \"Emulation Prevention\" bytes from a \"Raw Byte\n * Sequence Payload\"\n * @param data {Uint8Array} the bytes of a RBSP from a NAL\n * unit\n * @return {Uint8Array} the RBSP without any Emulation\n * Prevention Bytes\n */\n\n\n discardEmulationPreventionBytes = function discardEmulationPreventionBytes(data) {\n var length = data.byteLength,\n emulationPreventionBytesPositions = [],\n i = 1,\n newLength,\n newData; // Find all `Emulation Prevention Bytes`\n\n while (i < length - 2) {\n if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {\n emulationPreventionBytesPositions.push(i + 2);\n i += 2;\n } else {\n i++;\n }\n } // If no Emulation Prevention Bytes were found just return the original\n // array\n\n\n if (emulationPreventionBytesPositions.length === 0) {\n return data;\n } // Create a new array to hold the NAL unit data\n\n\n newLength = length - emulationPreventionBytesPositions.length;\n newData = new Uint8Array(newLength);\n var sourceIndex = 0;\n\n for (i = 0; i < newLength; sourceIndex++, i++) {\n if (sourceIndex === emulationPreventionBytesPositions[0]) {\n // Skip this byte\n sourceIndex++; // Remove this position index\n\n emulationPreventionBytesPositions.shift();\n }\n\n newData[i] = data[sourceIndex];\n }\n\n return newData;\n };\n /**\n * Read a sequence parameter set and return some interesting video\n * properties. A sequence parameter set is the H264 metadata that\n * describes the properties of upcoming video frames.\n * @param data {Uint8Array} the bytes of a sequence parameter set\n * @return {object} an object with configuration parsed from the\n * sequence parameter set, including the dimensions of the\n * associated video frames.\n */\n\n\n readSequenceParameterSet = function readSequenceParameterSet(data) {\n var frameCropLeftOffset = 0,\n frameCropRightOffset = 0,\n frameCropTopOffset = 0,\n frameCropBottomOffset = 0,\n expGolombDecoder,\n profileIdc,\n levelIdc,\n profileCompatibility,\n chromaFormatIdc,\n picOrderCntType,\n numRefFramesInPicOrderCntCycle,\n picWidthInMbsMinus1,\n picHeightInMapUnitsMinus1,\n frameMbsOnlyFlag,\n scalingListCount,\n sarRatio = [1, 1],\n aspectRatioIdc,\n i;\n expGolombDecoder = new expGolomb(data);\n profileIdc = expGolombDecoder.readUnsignedByte(); // profile_idc\n\n profileCompatibility = expGolombDecoder.readUnsignedByte(); // constraint_set[0-5]_flag\n\n levelIdc = expGolombDecoder.readUnsignedByte(); // level_idc u(8)\n\n expGolombDecoder.skipUnsignedExpGolomb(); // seq_parameter_set_id\n // some profiles have more optional data we don't need\n\n if (PROFILES_WITH_OPTIONAL_SPS_DATA[profileIdc]) {\n chromaFormatIdc = expGolombDecoder.readUnsignedExpGolomb();\n\n if (chromaFormatIdc === 3) {\n expGolombDecoder.skipBits(1); // separate_colour_plane_flag\n }\n\n expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_luma_minus8\n\n expGolombDecoder.skipUnsignedExpGolomb(); // bit_depth_chroma_minus8\n\n expGolombDecoder.skipBits(1); // qpprime_y_zero_transform_bypass_flag\n\n if (expGolombDecoder.readBoolean()) {\n // seq_scaling_matrix_present_flag\n scalingListCount = chromaFormatIdc !== 3 ? 8 : 12;\n\n for (i = 0; i < scalingListCount; i++) {\n if (expGolombDecoder.readBoolean()) {\n // seq_scaling_list_present_flag[ i ]\n if (i < 6) {\n skipScalingList(16, expGolombDecoder);\n } else {\n skipScalingList(64, expGolombDecoder);\n }\n }\n }\n }\n }\n\n expGolombDecoder.skipUnsignedExpGolomb(); // log2_max_frame_num_minus4\n\n picOrderCntType = expGolombDecoder.readUnsignedExpGolomb();\n\n if (picOrderCntType === 0) {\n expGolombDecoder.readUnsignedExpGolomb(); // log2_max_pic_order_cnt_lsb_minus4\n } else if (picOrderCntType === 1) {\n expGolombDecoder.skipBits(1); // delta_pic_order_always_zero_flag\n\n expGolombDecoder.skipExpGolomb(); // offset_for_non_ref_pic\n\n expGolombDecoder.skipExpGolomb(); // offset_for_top_to_bottom_field\n\n numRefFramesInPicOrderCntCycle = expGolombDecoder.readUnsignedExpGolomb();\n\n for (i = 0; i < numRefFramesInPicOrderCntCycle; i++) {\n expGolombDecoder.skipExpGolomb(); // offset_for_ref_frame[ i ]\n }\n }\n\n expGolombDecoder.skipUnsignedExpGolomb(); // max_num_ref_frames\n\n expGolombDecoder.skipBits(1); // gaps_in_frame_num_value_allowed_flag\n\n picWidthInMbsMinus1 = expGolombDecoder.readUnsignedExpGolomb();\n picHeightInMapUnitsMinus1 = expGolombDecoder.readUnsignedExpGolomb();\n frameMbsOnlyFlag = expGolombDecoder.readBits(1);\n\n if (frameMbsOnlyFlag === 0) {\n expGolombDecoder.skipBits(1); // mb_adaptive_frame_field_flag\n }\n\n expGolombDecoder.skipBits(1); // direct_8x8_inference_flag\n\n if (expGolombDecoder.readBoolean()) {\n // frame_cropping_flag\n frameCropLeftOffset = expGolombDecoder.readUnsignedExpGolomb();\n frameCropRightOffset = expGolombDecoder.readUnsignedExpGolomb();\n frameCropTopOffset = expGolombDecoder.readUnsignedExpGolomb();\n frameCropBottomOffset = expGolombDecoder.readUnsignedExpGolomb();\n }\n\n if (expGolombDecoder.readBoolean()) {\n // vui_parameters_present_flag\n if (expGolombDecoder.readBoolean()) {\n // aspect_ratio_info_present_flag\n aspectRatioIdc = expGolombDecoder.readUnsignedByte();\n\n switch (aspectRatioIdc) {\n case 1:\n sarRatio = [1, 1];\n break;\n\n case 2:\n sarRatio = [12, 11];\n break;\n\n case 3:\n sarRatio = [10, 11];\n break;\n\n case 4:\n sarRatio = [16, 11];\n break;\n\n case 5:\n sarRatio = [40, 33];\n break;\n\n case 6:\n sarRatio = [24, 11];\n break;\n\n case 7:\n sarRatio = [20, 11];\n break;\n\n case 8:\n sarRatio = [32, 11];\n break;\n\n case 9:\n sarRatio = [80, 33];\n break;\n\n case 10:\n sarRatio = [18, 11];\n break;\n\n case 11:\n sarRatio = [15, 11];\n break;\n\n case 12:\n sarRatio = [64, 33];\n break;\n\n case 13:\n sarRatio = [160, 99];\n break;\n\n case 14:\n sarRatio = [4, 3];\n break;\n\n case 15:\n sarRatio = [3, 2];\n break;\n\n case 16:\n sarRatio = [2, 1];\n break;\n\n case 255:\n {\n sarRatio = [expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte(), expGolombDecoder.readUnsignedByte() << 8 | expGolombDecoder.readUnsignedByte()];\n break;\n }\n }\n\n if (sarRatio) {\n sarRatio[0] / sarRatio[1];\n }\n }\n }\n\n return {\n profileIdc: profileIdc,\n levelIdc: levelIdc,\n profileCompatibility: profileCompatibility,\n width: (picWidthInMbsMinus1 + 1) * 16 - frameCropLeftOffset * 2 - frameCropRightOffset * 2,\n height: (2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16 - frameCropTopOffset * 2 - frameCropBottomOffset * 2,\n // sar is sample aspect ratio\n sarRatio: sarRatio\n };\n };\n };\n\n _H264Stream.prototype = new stream();\n var h264 = {\n H264Stream: _H264Stream,\n NalByteStream: _NalByteStream\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var codecs = {\n Adts: adts,\n h264: h264\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n *\n * Functions that generate fragmented MP4s suitable for use with Media\n * Source Extensions.\n */\n\n var UINT32_MAX = Math.pow(2, 32) - 1;\n var box, dinf, esds, ftyp, mdat, mfhd, minf, moof, moov, mvex, mvhd, trak, tkhd, mdia, mdhd, hdlr, sdtp, stbl, stsd, traf, trex, trun$1, types, MAJOR_BRAND, MINOR_VERSION, AVC1_BRAND, VIDEO_HDLR, AUDIO_HDLR, HDLR_TYPES, VMHD, SMHD, DREF, STCO, STSC, STSZ, STTS; // pre-calculate constants\n\n (function () {\n var i;\n types = {\n avc1: [],\n // codingname\n avcC: [],\n btrt: [],\n dinf: [],\n dref: [],\n esds: [],\n ftyp: [],\n hdlr: [],\n mdat: [],\n mdhd: [],\n mdia: [],\n mfhd: [],\n minf: [],\n moof: [],\n moov: [],\n mp4a: [],\n // codingname\n mvex: [],\n mvhd: [],\n pasp: [],\n sdtp: [],\n smhd: [],\n stbl: [],\n stco: [],\n stsc: [],\n stsd: [],\n stsz: [],\n stts: [],\n styp: [],\n tfdt: [],\n tfhd: [],\n traf: [],\n trak: [],\n trun: [],\n trex: [],\n tkhd: [],\n vmhd: []\n }; // In environments where Uint8Array is undefined (e.g., IE8), skip set up so that we\n // don't throw an error\n\n if (typeof Uint8Array === 'undefined') {\n return;\n }\n\n for (i in types) {\n if (types.hasOwnProperty(i)) {\n types[i] = [i.charCodeAt(0), i.charCodeAt(1), i.charCodeAt(2), i.charCodeAt(3)];\n }\n }\n\n MAJOR_BRAND = new Uint8Array(['i'.charCodeAt(0), 's'.charCodeAt(0), 'o'.charCodeAt(0), 'm'.charCodeAt(0)]);\n AVC1_BRAND = new Uint8Array(['a'.charCodeAt(0), 'v'.charCodeAt(0), 'c'.charCodeAt(0), '1'.charCodeAt(0)]);\n MINOR_VERSION = new Uint8Array([0, 0, 0, 1]);\n VIDEO_HDLR = new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, 0x00, 0x00, // pre_defined\n 0x76, 0x69, 0x64, 0x65, // handler_type: 'vide'\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x56, 0x69, 0x64, 0x65, 0x6f, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'VideoHandler'\n ]);\n AUDIO_HDLR = new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, 0x00, 0x00, // pre_defined\n 0x73, 0x6f, 0x75, 0x6e, // handler_type: 'soun'\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x53, 0x6f, 0x75, 0x6e, 0x64, 0x48, 0x61, 0x6e, 0x64, 0x6c, 0x65, 0x72, 0x00 // name: 'SoundHandler'\n ]);\n HDLR_TYPES = {\n video: VIDEO_HDLR,\n audio: AUDIO_HDLR\n };\n DREF = new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, 0x00, 0x01, // entry_count\n 0x00, 0x00, 0x00, 0x0c, // entry_size\n 0x75, 0x72, 0x6c, 0x20, // 'url' type\n 0x00, // version 0\n 0x00, 0x00, 0x01 // entry_flags\n ]);\n SMHD = new Uint8Array([0x00, // version\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, // balance, 0 means centered\n 0x00, 0x00 // reserved\n ]);\n STCO = new Uint8Array([0x00, // version\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, 0x00, 0x00 // entry_count\n ]);\n STSC = STCO;\n STSZ = new Uint8Array([0x00, // version\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, 0x00, 0x00, // sample_size\n 0x00, 0x00, 0x00, 0x00 // sample_count\n ]);\n STTS = STCO;\n VMHD = new Uint8Array([0x00, // version\n 0x00, 0x00, 0x01, // flags\n 0x00, 0x00, // graphicsmode\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // opcolor\n ]);\n })();\n\n box = function box(type) {\n var payload = [],\n size = 0,\n i,\n result,\n view;\n\n for (i = 1; i < arguments.length; i++) {\n payload.push(arguments[i]);\n }\n\n i = payload.length; // calculate the total size we need to allocate\n\n while (i--) {\n size += payload[i].byteLength;\n }\n\n result = new Uint8Array(size + 8);\n view = new DataView(result.buffer, result.byteOffset, result.byteLength);\n view.setUint32(0, result.byteLength);\n result.set(type, 4); // copy the payload into the result\n\n for (i = 0, size = 8; i < payload.length; i++) {\n result.set(payload[i], size);\n size += payload[i].byteLength;\n }\n\n return result;\n };\n\n dinf = function dinf() {\n return box(types.dinf, box(types.dref, DREF));\n };\n\n esds = function esds(track) {\n return box(types.esds, new Uint8Array([0x00, // version\n 0x00, 0x00, 0x00, // flags\n // ES_Descriptor\n 0x03, // tag, ES_DescrTag\n 0x19, // length\n 0x00, 0x00, // ES_ID\n 0x00, // streamDependenceFlag, URL_flag, reserved, streamPriority\n // DecoderConfigDescriptor\n 0x04, // tag, DecoderConfigDescrTag\n 0x11, // length\n 0x40, // object type\n 0x15, // streamType\n 0x00, 0x06, 0x00, // bufferSizeDB\n 0x00, 0x00, 0xda, 0xc0, // maxBitrate\n 0x00, 0x00, 0xda, 0xc0, // avgBitrate\n // DecoderSpecificInfo\n 0x05, // tag, DecoderSpecificInfoTag\n 0x02, // length\n // ISO/IEC 14496-3, AudioSpecificConfig\n // for samplingFrequencyIndex see ISO/IEC 13818-7:2006, 8.1.3.2.2, Table 35\n track.audioobjecttype << 3 | track.samplingfrequencyindex >>> 1, track.samplingfrequencyindex << 7 | track.channelcount << 3, 0x06, 0x01, 0x02 // GASpecificConfig\n ]));\n };\n\n ftyp = function ftyp() {\n return box(types.ftyp, MAJOR_BRAND, MINOR_VERSION, MAJOR_BRAND, AVC1_BRAND);\n };\n\n hdlr = function hdlr(type) {\n return box(types.hdlr, HDLR_TYPES[type]);\n };\n\n mdat = function mdat(data) {\n return box(types.mdat, data);\n };\n\n mdhd = function mdhd(track) {\n var result = new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, 0x00, 0x02, // creation_time\n 0x00, 0x00, 0x00, 0x03, // modification_time\n 0x00, 0x01, 0x5f, 0x90, // timescale, 90,000 \"ticks\" per second\n track.duration >>> 24 & 0xFF, track.duration >>> 16 & 0xFF, track.duration >>> 8 & 0xFF, track.duration & 0xFF, // duration\n 0x55, 0xc4, // 'und' language (undetermined)\n 0x00, 0x00]); // Use the sample rate from the track metadata, when it is\n // defined. The sample rate can be parsed out of an ADTS header, for\n // instance.\n\n if (track.samplerate) {\n result[12] = track.samplerate >>> 24 & 0xFF;\n result[13] = track.samplerate >>> 16 & 0xFF;\n result[14] = track.samplerate >>> 8 & 0xFF;\n result[15] = track.samplerate & 0xFF;\n }\n\n return box(types.mdhd, result);\n };\n\n mdia = function mdia(track) {\n return box(types.mdia, mdhd(track), hdlr(track.type), minf(track));\n };\n\n mfhd = function mfhd(sequenceNumber) {\n return box(types.mfhd, new Uint8Array([0x00, 0x00, 0x00, 0x00, // flags\n (sequenceNumber & 0xFF000000) >> 24, (sequenceNumber & 0xFF0000) >> 16, (sequenceNumber & 0xFF00) >> 8, sequenceNumber & 0xFF // sequence_number\n ]));\n };\n\n minf = function minf(track) {\n return box(types.minf, track.type === 'video' ? box(types.vmhd, VMHD) : box(types.smhd, SMHD), dinf(), stbl(track));\n };\n\n moof = function moof(sequenceNumber, tracks) {\n var trackFragments = [],\n i = tracks.length; // build traf boxes for each track fragment\n\n while (i--) {\n trackFragments[i] = traf(tracks[i]);\n }\n\n return box.apply(null, [types.moof, mfhd(sequenceNumber)].concat(trackFragments));\n };\n /**\n * Returns a movie box.\n * @param tracks {array} the tracks associated with this movie\n * @see ISO/IEC 14496-12:2012(E), section 8.2.1\n */\n\n\n moov = function moov(tracks) {\n var i = tracks.length,\n boxes = [];\n\n while (i--) {\n boxes[i] = trak(tracks[i]);\n }\n\n return box.apply(null, [types.moov, mvhd(0xffffffff)].concat(boxes).concat(mvex(tracks)));\n };\n\n mvex = function mvex(tracks) {\n var i = tracks.length,\n boxes = [];\n\n while (i--) {\n boxes[i] = trex(tracks[i]);\n }\n\n return box.apply(null, [types.mvex].concat(boxes));\n };\n\n mvhd = function mvhd(duration) {\n var bytes = new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, 0x00, 0x01, // creation_time\n 0x00, 0x00, 0x00, 0x02, // modification_time\n 0x00, 0x01, 0x5f, 0x90, // timescale, 90,000 \"ticks\" per second\n (duration & 0xFF000000) >> 24, (duration & 0xFF0000) >> 16, (duration & 0xFF00) >> 8, duration & 0xFF, // duration\n 0x00, 0x01, 0x00, 0x00, // 1.0 rate\n 0x01, 0x00, // 1.0 volume\n 0x00, 0x00, // reserved\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // transformation: unity matrix\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined\n 0xff, 0xff, 0xff, 0xff // next_track_ID\n ]);\n return box(types.mvhd, bytes);\n };\n\n sdtp = function sdtp(track) {\n var samples = track.samples || [],\n bytes = new Uint8Array(4 + samples.length),\n flags,\n i; // leave the full box header (4 bytes) all zero\n // write the sample table\n\n for (i = 0; i < samples.length; i++) {\n flags = samples[i].flags;\n bytes[i + 4] = flags.dependsOn << 4 | flags.isDependedOn << 2 | flags.hasRedundancy;\n }\n\n return box(types.sdtp, bytes);\n };\n\n stbl = function stbl(track) {\n return box(types.stbl, stsd(track), box(types.stts, STTS), box(types.stsc, STSC), box(types.stsz, STSZ), box(types.stco, STCO));\n };\n\n (function () {\n var videoSample, audioSample;\n\n stsd = function stsd(track) {\n return box(types.stsd, new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x00, // flags\n 0x00, 0x00, 0x00, 0x01]), track.type === 'video' ? videoSample(track) : audioSample(track));\n };\n\n videoSample = function videoSample(track) {\n var sps = track.sps || [],\n pps = track.pps || [],\n sequenceParameterSets = [],\n pictureParameterSets = [],\n i,\n avc1Box; // assemble the SPSs\n\n for (i = 0; i < sps.length; i++) {\n sequenceParameterSets.push((sps[i].byteLength & 0xFF00) >>> 8);\n sequenceParameterSets.push(sps[i].byteLength & 0xFF); // sequenceParameterSetLength\n\n sequenceParameterSets = sequenceParameterSets.concat(Array.prototype.slice.call(sps[i])); // SPS\n } // assemble the PPSs\n\n\n for (i = 0; i < pps.length; i++) {\n pictureParameterSets.push((pps[i].byteLength & 0xFF00) >>> 8);\n pictureParameterSets.push(pps[i].byteLength & 0xFF);\n pictureParameterSets = pictureParameterSets.concat(Array.prototype.slice.call(pps[i]));\n }\n\n avc1Box = [types.avc1, new Uint8Array([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x01, // data_reference_index\n 0x00, 0x00, // pre_defined\n 0x00, 0x00, // reserved\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // pre_defined\n (track.width & 0xff00) >> 8, track.width & 0xff, // width\n (track.height & 0xff00) >> 8, track.height & 0xff, // height\n 0x00, 0x48, 0x00, 0x00, // horizresolution\n 0x00, 0x48, 0x00, 0x00, // vertresolution\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x01, // frame_count\n 0x13, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6a, 0x73, 0x2d, 0x63, 0x6f, 0x6e, 0x74, 0x72, 0x69, 0x62, 0x2d, 0x68, 0x6c, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // compressorname\n 0x00, 0x18, // depth = 24\n 0x11, 0x11 // pre_defined = -1\n ]), box(types.avcC, new Uint8Array([0x01, // configurationVersion\n track.profileIdc, // AVCProfileIndication\n track.profileCompatibility, // profile_compatibility\n track.levelIdc, // AVCLevelIndication\n 0xff // lengthSizeMinusOne, hard-coded to 4 bytes\n ].concat([sps.length], // numOfSequenceParameterSets\n sequenceParameterSets, // \"SPS\"\n [pps.length], // numOfPictureParameterSets\n pictureParameterSets // \"PPS\"\n ))), box(types.btrt, new Uint8Array([0x00, 0x1c, 0x9c, 0x80, // bufferSizeDB\n 0x00, 0x2d, 0xc6, 0xc0, // maxBitrate\n 0x00, 0x2d, 0xc6, 0xc0 // avgBitrate\n ]))];\n\n if (track.sarRatio) {\n var hSpacing = track.sarRatio[0],\n vSpacing = track.sarRatio[1];\n avc1Box.push(box(types.pasp, new Uint8Array([(hSpacing & 0xFF000000) >> 24, (hSpacing & 0xFF0000) >> 16, (hSpacing & 0xFF00) >> 8, hSpacing & 0xFF, (vSpacing & 0xFF000000) >> 24, (vSpacing & 0xFF0000) >> 16, (vSpacing & 0xFF00) >> 8, vSpacing & 0xFF])));\n }\n\n return box.apply(null, avc1Box);\n };\n\n audioSample = function audioSample(track) {\n return box(types.mp4a, new Uint8Array([// SampleEntry, ISO/IEC 14496-12\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x01, // data_reference_index\n // AudioSampleEntry, ISO/IEC 14496-12\n 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x00, 0x00, 0x00, // reserved\n (track.channelcount & 0xff00) >> 8, track.channelcount & 0xff, // channelcount\n (track.samplesize & 0xff00) >> 8, track.samplesize & 0xff, // samplesize\n 0x00, 0x00, // pre_defined\n 0x00, 0x00, // reserved\n (track.samplerate & 0xff00) >> 8, track.samplerate & 0xff, 0x00, 0x00 // samplerate, 16.16\n // MP4AudioSampleEntry, ISO/IEC 14496-14\n ]), esds(track));\n };\n })();\n\n tkhd = function tkhd(track) {\n var result = new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x07, // flags\n 0x00, 0x00, 0x00, 0x00, // creation_time\n 0x00, 0x00, 0x00, 0x00, // modification_time\n (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF, // track_ID\n 0x00, 0x00, 0x00, 0x00, // reserved\n (track.duration & 0xFF000000) >> 24, (track.duration & 0xFF0000) >> 16, (track.duration & 0xFF00) >> 8, track.duration & 0xFF, // duration\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // reserved\n 0x00, 0x00, // layer\n 0x00, 0x00, // alternate_group\n 0x01, 0x00, // non-audio track volume\n 0x00, 0x00, // reserved\n 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, // transformation: unity matrix\n (track.width & 0xFF00) >> 8, track.width & 0xFF, 0x00, 0x00, // width\n (track.height & 0xFF00) >> 8, track.height & 0xFF, 0x00, 0x00 // height\n ]);\n return box(types.tkhd, result);\n };\n /**\n * Generate a track fragment (traf) box. A traf box collects metadata\n * about tracks in a movie fragment (moof) box.\n */\n\n\n traf = function traf(track) {\n var trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable, dataOffset, upperWordBaseMediaDecodeTime, lowerWordBaseMediaDecodeTime;\n trackFragmentHeader = box(types.tfhd, new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x3a, // flags\n (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF, // track_ID\n 0x00, 0x00, 0x00, 0x01, // sample_description_index\n 0x00, 0x00, 0x00, 0x00, // default_sample_duration\n 0x00, 0x00, 0x00, 0x00, // default_sample_size\n 0x00, 0x00, 0x00, 0x00 // default_sample_flags\n ]));\n upperWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime / (UINT32_MAX + 1));\n lowerWordBaseMediaDecodeTime = Math.floor(track.baseMediaDecodeTime % (UINT32_MAX + 1));\n trackFragmentDecodeTime = box(types.tfdt, new Uint8Array([0x01, // version 1\n 0x00, 0x00, 0x00, // flags\n // baseMediaDecodeTime\n upperWordBaseMediaDecodeTime >>> 24 & 0xFF, upperWordBaseMediaDecodeTime >>> 16 & 0xFF, upperWordBaseMediaDecodeTime >>> 8 & 0xFF, upperWordBaseMediaDecodeTime & 0xFF, lowerWordBaseMediaDecodeTime >>> 24 & 0xFF, lowerWordBaseMediaDecodeTime >>> 16 & 0xFF, lowerWordBaseMediaDecodeTime >>> 8 & 0xFF, lowerWordBaseMediaDecodeTime & 0xFF])); // the data offset specifies the number of bytes from the start of\n // the containing moof to the first payload byte of the associated\n // mdat\n\n dataOffset = 32 + // tfhd\n 20 + // tfdt\n 8 + // traf header\n 16 + // mfhd\n 8 + // moof header\n 8; // mdat header\n // audio tracks require less metadata\n\n if (track.type === 'audio') {\n trackFragmentRun = trun$1(track, dataOffset);\n return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun);\n } // video tracks should contain an independent and disposable samples\n // box (sdtp)\n // generate one and adjust offsets to match\n\n\n sampleDependencyTable = sdtp(track);\n trackFragmentRun = trun$1(track, sampleDependencyTable.length + dataOffset);\n return box(types.traf, trackFragmentHeader, trackFragmentDecodeTime, trackFragmentRun, sampleDependencyTable);\n };\n /**\n * Generate a track box.\n * @param track {object} a track definition\n * @return {Uint8Array} the track box\n */\n\n\n trak = function trak(track) {\n track.duration = track.duration || 0xffffffff;\n return box(types.trak, tkhd(track), mdia(track));\n };\n\n trex = function trex(track) {\n var result = new Uint8Array([0x00, // version 0\n 0x00, 0x00, 0x00, // flags\n (track.id & 0xFF000000) >> 24, (track.id & 0xFF0000) >> 16, (track.id & 0xFF00) >> 8, track.id & 0xFF, // track_ID\n 0x00, 0x00, 0x00, 0x01, // default_sample_description_index\n 0x00, 0x00, 0x00, 0x00, // default_sample_duration\n 0x00, 0x00, 0x00, 0x00, // default_sample_size\n 0x00, 0x01, 0x00, 0x01 // default_sample_flags\n ]); // the last two bytes of default_sample_flags is the sample\n // degradation priority, a hint about the importance of this sample\n // relative to others. Lower the degradation priority for all sample\n // types other than video.\n\n if (track.type !== 'video') {\n result[result.length - 1] = 0x00;\n }\n\n return box(types.trex, result);\n };\n\n (function () {\n var audioTrun, videoTrun, trunHeader; // This method assumes all samples are uniform. That is, if a\n // duration is present for the first sample, it will be present for\n // all subsequent samples.\n // see ISO/IEC 14496-12:2012, Section 8.8.8.1\n\n trunHeader = function trunHeader(samples, offset) {\n var durationPresent = 0,\n sizePresent = 0,\n flagsPresent = 0,\n compositionTimeOffset = 0; // trun flag constants\n\n if (samples.length) {\n if (samples[0].duration !== undefined) {\n durationPresent = 0x1;\n }\n\n if (samples[0].size !== undefined) {\n sizePresent = 0x2;\n }\n\n if (samples[0].flags !== undefined) {\n flagsPresent = 0x4;\n }\n\n if (samples[0].compositionTimeOffset !== undefined) {\n compositionTimeOffset = 0x8;\n }\n }\n\n return [0x00, // version 0\n 0x00, durationPresent | sizePresent | flagsPresent | compositionTimeOffset, 0x01, // flags\n (samples.length & 0xFF000000) >>> 24, (samples.length & 0xFF0000) >>> 16, (samples.length & 0xFF00) >>> 8, samples.length & 0xFF, // sample_count\n (offset & 0xFF000000) >>> 24, (offset & 0xFF0000) >>> 16, (offset & 0xFF00) >>> 8, offset & 0xFF // data_offset\n ];\n };\n\n videoTrun = function videoTrun(track, offset) {\n var bytesOffest, bytes, header, samples, sample, i;\n samples = track.samples || [];\n offset += 8 + 12 + 16 * samples.length;\n header = trunHeader(samples, offset);\n bytes = new Uint8Array(header.length + samples.length * 16);\n bytes.set(header);\n bytesOffest = header.length;\n\n for (i = 0; i < samples.length; i++) {\n sample = samples[i];\n bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;\n bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;\n bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;\n bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration\n\n bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;\n bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;\n bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;\n bytes[bytesOffest++] = sample.size & 0xFF; // sample_size\n\n bytes[bytesOffest++] = sample.flags.isLeading << 2 | sample.flags.dependsOn;\n bytes[bytesOffest++] = sample.flags.isDependedOn << 6 | sample.flags.hasRedundancy << 4 | sample.flags.paddingValue << 1 | sample.flags.isNonSyncSample;\n bytes[bytesOffest++] = sample.flags.degradationPriority & 0xF0 << 8;\n bytes[bytesOffest++] = sample.flags.degradationPriority & 0x0F; // sample_flags\n\n bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF000000) >>> 24;\n bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF0000) >>> 16;\n bytes[bytesOffest++] = (sample.compositionTimeOffset & 0xFF00) >>> 8;\n bytes[bytesOffest++] = sample.compositionTimeOffset & 0xFF; // sample_composition_time_offset\n }\n\n return box(types.trun, bytes);\n };\n\n audioTrun = function audioTrun(track, offset) {\n var bytes, bytesOffest, header, samples, sample, i;\n samples = track.samples || [];\n offset += 8 + 12 + 8 * samples.length;\n header = trunHeader(samples, offset);\n bytes = new Uint8Array(header.length + samples.length * 8);\n bytes.set(header);\n bytesOffest = header.length;\n\n for (i = 0; i < samples.length; i++) {\n sample = samples[i];\n bytes[bytesOffest++] = (sample.duration & 0xFF000000) >>> 24;\n bytes[bytesOffest++] = (sample.duration & 0xFF0000) >>> 16;\n bytes[bytesOffest++] = (sample.duration & 0xFF00) >>> 8;\n bytes[bytesOffest++] = sample.duration & 0xFF; // sample_duration\n\n bytes[bytesOffest++] = (sample.size & 0xFF000000) >>> 24;\n bytes[bytesOffest++] = (sample.size & 0xFF0000) >>> 16;\n bytes[bytesOffest++] = (sample.size & 0xFF00) >>> 8;\n bytes[bytesOffest++] = sample.size & 0xFF; // sample_size\n }\n\n return box(types.trun, bytes);\n };\n\n trun$1 = function trun(track, offset) {\n if (track.type === 'audio') {\n return audioTrun(track, offset);\n }\n\n return videoTrun(track, offset);\n };\n })();\n\n var mp4Generator = {\n ftyp: ftyp,\n mdat: mdat,\n moof: moof,\n moov: moov,\n initSegment: function initSegment(tracks) {\n var fileType = ftyp(),\n movie = moov(tracks),\n result;\n result = new Uint8Array(fileType.byteLength + movie.byteLength);\n result.set(fileType);\n result.set(movie, fileType.byteLength);\n return result;\n }\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n var toUnsigned$3 = function toUnsigned(value) {\n return value >>> 0;\n };\n\n var toHexString$1 = function toHexString(value) {\n return ('00' + value.toString(16)).slice(-2);\n };\n\n var bin = {\n toUnsigned: toUnsigned$3,\n toHexString: toHexString$1\n };\n\n var parseType$2 = function parseType(buffer) {\n var result = '';\n result += String.fromCharCode(buffer[0]);\n result += String.fromCharCode(buffer[1]);\n result += String.fromCharCode(buffer[2]);\n result += String.fromCharCode(buffer[3]);\n return result;\n };\n\n var parseType_1 = parseType$2;\n\n var toUnsigned$2 = bin.toUnsigned;\n\n var findBox = function findBox(data, path) {\n var results = [],\n i,\n size,\n type,\n end,\n subresults;\n\n if (!path.length) {\n // short-circuit the search for empty paths\n return null;\n }\n\n for (i = 0; i < data.byteLength;) {\n size = toUnsigned$2(data[i] << 24 | data[i + 1] << 16 | data[i + 2] << 8 | data[i + 3]);\n type = parseType_1(data.subarray(i + 4, i + 8));\n end = size > 1 ? i + size : data.byteLength;\n\n if (type === path[0]) {\n if (path.length === 1) {\n // this is the end of the path and we've found the box we were\n // looking for\n results.push(data.subarray(i + 8, end));\n } else {\n // recursively search for the next box along the path\n subresults = findBox(data.subarray(i + 8, end), path.slice(1));\n\n if (subresults.length) {\n results = results.concat(subresults);\n }\n }\n }\n\n i = end;\n } // we've finished searching all of data\n\n\n return results;\n };\n\n var findBox_1 = findBox;\n\n var tfhd = function tfhd(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n trackId: view.getUint32(4)\n },\n baseDataOffsetPresent = result.flags[2] & 0x01,\n sampleDescriptionIndexPresent = result.flags[2] & 0x02,\n defaultSampleDurationPresent = result.flags[2] & 0x08,\n defaultSampleSizePresent = result.flags[2] & 0x10,\n defaultSampleFlagsPresent = result.flags[2] & 0x20,\n durationIsEmpty = result.flags[0] & 0x010000,\n defaultBaseIsMoof = result.flags[0] & 0x020000,\n i;\n i = 8;\n\n if (baseDataOffsetPresent) {\n i += 4; // truncate top 4 bytes\n // FIXME: should we read the full 64 bits?\n\n result.baseDataOffset = view.getUint32(12);\n i += 4;\n }\n\n if (sampleDescriptionIndexPresent) {\n result.sampleDescriptionIndex = view.getUint32(i);\n i += 4;\n }\n\n if (defaultSampleDurationPresent) {\n result.defaultSampleDuration = view.getUint32(i);\n i += 4;\n }\n\n if (defaultSampleSizePresent) {\n result.defaultSampleSize = view.getUint32(i);\n i += 4;\n }\n\n if (defaultSampleFlagsPresent) {\n result.defaultSampleFlags = view.getUint32(i);\n }\n\n if (durationIsEmpty) {\n result.durationIsEmpty = true;\n }\n\n if (!baseDataOffsetPresent && defaultBaseIsMoof) {\n result.baseDataOffsetIsMoof = true;\n }\n\n return result;\n };\n\n var parseTfhd = tfhd;\n\n var parseSampleFlags = function parseSampleFlags(flags) {\n return {\n isLeading: (flags[0] & 0x0c) >>> 2,\n dependsOn: flags[0] & 0x03,\n isDependedOn: (flags[1] & 0xc0) >>> 6,\n hasRedundancy: (flags[1] & 0x30) >>> 4,\n paddingValue: (flags[1] & 0x0e) >>> 1,\n isNonSyncSample: flags[1] & 0x01,\n degradationPriority: flags[2] << 8 | flags[3]\n };\n };\n\n var parseSampleFlags_1 = parseSampleFlags;\n\n var trun = function trun(data) {\n var result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n samples: []\n },\n view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n // Flag interpretation\n dataOffsetPresent = result.flags[2] & 0x01,\n // compare with 2nd byte of 0x1\n firstSampleFlagsPresent = result.flags[2] & 0x04,\n // compare with 2nd byte of 0x4\n sampleDurationPresent = result.flags[1] & 0x01,\n // compare with 2nd byte of 0x100\n sampleSizePresent = result.flags[1] & 0x02,\n // compare with 2nd byte of 0x200\n sampleFlagsPresent = result.flags[1] & 0x04,\n // compare with 2nd byte of 0x400\n sampleCompositionTimeOffsetPresent = result.flags[1] & 0x08,\n // compare with 2nd byte of 0x800\n sampleCount = view.getUint32(4),\n offset = 8,\n sample;\n\n if (dataOffsetPresent) {\n // 32 bit signed integer\n result.dataOffset = view.getInt32(offset);\n offset += 4;\n } // Overrides the flags for the first sample only. The order of\n // optional values will be: duration, size, compositionTimeOffset\n\n\n if (firstSampleFlagsPresent && sampleCount) {\n sample = {\n flags: parseSampleFlags_1(data.subarray(offset, offset + 4))\n };\n offset += 4;\n\n if (sampleDurationPresent) {\n sample.duration = view.getUint32(offset);\n offset += 4;\n }\n\n if (sampleSizePresent) {\n sample.size = view.getUint32(offset);\n offset += 4;\n }\n\n if (sampleCompositionTimeOffsetPresent) {\n if (result.version === 1) {\n sample.compositionTimeOffset = view.getInt32(offset);\n } else {\n sample.compositionTimeOffset = view.getUint32(offset);\n }\n\n offset += 4;\n }\n\n result.samples.push(sample);\n sampleCount--;\n }\n\n while (sampleCount--) {\n sample = {};\n\n if (sampleDurationPresent) {\n sample.duration = view.getUint32(offset);\n offset += 4;\n }\n\n if (sampleSizePresent) {\n sample.size = view.getUint32(offset);\n offset += 4;\n }\n\n if (sampleFlagsPresent) {\n sample.flags = parseSampleFlags_1(data.subarray(offset, offset + 4));\n offset += 4;\n }\n\n if (sampleCompositionTimeOffsetPresent) {\n if (result.version === 1) {\n sample.compositionTimeOffset = view.getInt32(offset);\n } else {\n sample.compositionTimeOffset = view.getUint32(offset);\n }\n\n offset += 4;\n }\n\n result.samples.push(sample);\n }\n\n return result;\n };\n\n var parseTrun = trun;\n\n var toUnsigned$1 = bin.toUnsigned;\n\n var tfdt = function tfdt(data) {\n var result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n baseMediaDecodeTime: toUnsigned$1(data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7])\n };\n\n if (result.version === 1) {\n result.baseMediaDecodeTime *= Math.pow(2, 32);\n result.baseMediaDecodeTime += toUnsigned$1(data[8] << 24 | data[9] << 16 | data[10] << 8 | data[11]);\n }\n\n return result;\n };\n\n var parseTfdt = tfdt;\n\n var toUnsigned = bin.toUnsigned;\n var toHexString = bin.toHexString;\n var timescale, startTime, compositionStartTime, getVideoTrackIds, getTracks, getTimescaleFromMediaHeader;\n /**\n * Parses an MP4 initialization segment and extracts the timescale\n * values for any declared tracks. Timescale values indicate the\n * number of clock ticks per second to assume for time-based values\n * elsewhere in the MP4.\n *\n * To determine the start time of an MP4, you need two pieces of\n * information: the timescale unit and the earliest base media decode\n * time. Multiple timescales can be specified within an MP4 but the\n * base media decode time is always expressed in the timescale from\n * the media header box for the track:\n * ```\n * moov > trak > mdia > mdhd.timescale\n * ```\n * @param init {Uint8Array} the bytes of the init segment\n * @return {object} a hash of track ids to timescale values or null if\n * the init segment is malformed.\n */\n\n timescale = function timescale(init) {\n var result = {},\n traks = findBox_1(init, ['moov', 'trak']); // mdhd timescale\n\n return traks.reduce(function (result, trak) {\n var tkhd, version, index, id, mdhd;\n tkhd = findBox_1(trak, ['tkhd'])[0];\n\n if (!tkhd) {\n return null;\n }\n\n version = tkhd[0];\n index = version === 0 ? 12 : 20;\n id = toUnsigned(tkhd[index] << 24 | tkhd[index + 1] << 16 | tkhd[index + 2] << 8 | tkhd[index + 3]);\n mdhd = findBox_1(trak, ['mdia', 'mdhd'])[0];\n\n if (!mdhd) {\n return null;\n }\n\n version = mdhd[0];\n index = version === 0 ? 12 : 20;\n result[id] = toUnsigned(mdhd[index] << 24 | mdhd[index + 1] << 16 | mdhd[index + 2] << 8 | mdhd[index + 3]);\n return result;\n }, result);\n };\n /**\n * Determine the base media decode start time, in seconds, for an MP4\n * fragment. If multiple fragments are specified, the earliest time is\n * returned.\n *\n * The base media decode time can be parsed from track fragment\n * metadata:\n * ```\n * moof > traf > tfdt.baseMediaDecodeTime\n * ```\n * It requires the timescale value from the mdhd to interpret.\n *\n * @param timescale {object} a hash of track ids to timescale values.\n * @return {number} the earliest base media decode start time for the\n * fragment, in seconds\n */\n\n\n startTime = function startTime(timescale, fragment) {\n var trafs, baseTimes, result; // we need info from two childrend of each track fragment box\n\n trafs = findBox_1(fragment, ['moof', 'traf']); // determine the start times for each track\n\n baseTimes = [].concat.apply([], trafs.map(function (traf) {\n return findBox_1(traf, ['tfhd']).map(function (tfhd) {\n var id, scale, baseTime; // get the track id from the tfhd\n\n id = toUnsigned(tfhd[4] << 24 | tfhd[5] << 16 | tfhd[6] << 8 | tfhd[7]); // assume a 90kHz clock if no timescale was specified\n\n scale = timescale[id] || 90e3; // get the base media decode time from the tfdt\n\n baseTime = findBox_1(traf, ['tfdt']).map(function (tfdt) {\n var version, result;\n version = tfdt[0];\n result = toUnsigned(tfdt[4] << 24 | tfdt[5] << 16 | tfdt[6] << 8 | tfdt[7]);\n\n if (version === 1) {\n result *= Math.pow(2, 32);\n result += toUnsigned(tfdt[8] << 24 | tfdt[9] << 16 | tfdt[10] << 8 | tfdt[11]);\n }\n\n return result;\n })[0];\n baseTime = typeof baseTime === 'number' && !isNaN(baseTime) ? baseTime : Infinity; // convert base time to seconds\n\n return baseTime / scale;\n });\n })); // return the minimum\n\n result = Math.min.apply(null, baseTimes);\n return isFinite(result) ? result : 0;\n };\n /**\n * Determine the composition start, in seconds, for an MP4\n * fragment.\n *\n * The composition start time of a fragment can be calculated using the base\n * media decode time, composition time offset, and timescale, as follows:\n *\n * compositionStartTime = (baseMediaDecodeTime + compositionTimeOffset) / timescale\n *\n * All of the aforementioned information is contained within a media fragment's\n * `traf` box, except for timescale info, which comes from the initialization\n * segment, so a track id (also contained within a `traf`) is also necessary to\n * associate it with a timescale\n *\n *\n * @param timescales {object} - a hash of track ids to timescale values.\n * @param fragment {Unit8Array} - the bytes of a media segment\n * @return {number} the composition start time for the fragment, in seconds\n **/\n\n\n compositionStartTime = function compositionStartTime(timescales, fragment) {\n var trafBoxes = findBox_1(fragment, ['moof', 'traf']);\n var baseMediaDecodeTime = 0;\n var compositionTimeOffset = 0;\n var trackId;\n\n if (trafBoxes && trafBoxes.length) {\n // The spec states that track run samples contained within a `traf` box are contiguous, but\n // it does not explicitly state whether the `traf` boxes themselves are contiguous.\n // We will assume that they are, so we only need the first to calculate start time.\n var tfhd = findBox_1(trafBoxes[0], ['tfhd'])[0];\n var trun = findBox_1(trafBoxes[0], ['trun'])[0];\n var tfdt = findBox_1(trafBoxes[0], ['tfdt'])[0];\n\n if (tfhd) {\n var parsedTfhd = parseTfhd(tfhd);\n trackId = parsedTfhd.trackId;\n }\n\n if (tfdt) {\n var parsedTfdt = parseTfdt(tfdt);\n baseMediaDecodeTime = parsedTfdt.baseMediaDecodeTime;\n }\n\n if (trun) {\n var parsedTrun = parseTrun(trun);\n\n if (parsedTrun.samples && parsedTrun.samples.length) {\n compositionTimeOffset = parsedTrun.samples[0].compositionTimeOffset || 0;\n }\n }\n } // Get timescale for this specific track. Assume a 90kHz clock if no timescale was\n // specified.\n\n\n var timescale = timescales[trackId] || 90e3; // return the composition start time, in seconds\n\n return (baseMediaDecodeTime + compositionTimeOffset) / timescale;\n };\n /**\n * Find the trackIds of the video tracks in this source.\n * Found by parsing the Handler Reference and Track Header Boxes:\n * moov > trak > mdia > hdlr\n * moov > trak > tkhd\n *\n * @param {Uint8Array} init - The bytes of the init segment for this source\n * @return {Number[]} A list of trackIds\n *\n * @see ISO-BMFF-12/2015, Section 8.4.3\n **/\n\n\n getVideoTrackIds = function getVideoTrackIds(init) {\n var traks = findBox_1(init, ['moov', 'trak']);\n var videoTrackIds = [];\n traks.forEach(function (trak) {\n var hdlrs = findBox_1(trak, ['mdia', 'hdlr']);\n var tkhds = findBox_1(trak, ['tkhd']);\n hdlrs.forEach(function (hdlr, index) {\n var handlerType = parseType_1(hdlr.subarray(8, 12));\n var tkhd = tkhds[index];\n var view;\n var version;\n var trackId;\n\n if (handlerType === 'vide') {\n view = new DataView(tkhd.buffer, tkhd.byteOffset, tkhd.byteLength);\n version = view.getUint8(0);\n trackId = version === 0 ? view.getUint32(12) : view.getUint32(20);\n videoTrackIds.push(trackId);\n }\n });\n });\n return videoTrackIds;\n };\n\n getTimescaleFromMediaHeader = function getTimescaleFromMediaHeader(mdhd) {\n // mdhd is a FullBox, meaning it will have its own version as the first byte\n var version = mdhd[0];\n var index = version === 0 ? 12 : 20;\n return toUnsigned(mdhd[index] << 24 | mdhd[index + 1] << 16 | mdhd[index + 2] << 8 | mdhd[index + 3]);\n };\n /**\n * Get all the video, audio, and hint tracks from a non fragmented\n * mp4 segment\n */\n\n\n getTracks = function getTracks(init) {\n var traks = findBox_1(init, ['moov', 'trak']);\n var tracks = [];\n traks.forEach(function (trak) {\n var track = {};\n var tkhd = findBox_1(trak, ['tkhd'])[0];\n var view, tkhdVersion; // id\n\n if (tkhd) {\n view = new DataView(tkhd.buffer, tkhd.byteOffset, tkhd.byteLength);\n tkhdVersion = view.getUint8(0);\n track.id = tkhdVersion === 0 ? view.getUint32(12) : view.getUint32(20);\n }\n\n var hdlr = findBox_1(trak, ['mdia', 'hdlr'])[0]; // type\n\n if (hdlr) {\n var type = parseType_1(hdlr.subarray(8, 12));\n\n if (type === 'vide') {\n track.type = 'video';\n } else if (type === 'soun') {\n track.type = 'audio';\n } else {\n track.type = type;\n }\n } // codec\n\n\n var stsd = findBox_1(trak, ['mdia', 'minf', 'stbl', 'stsd'])[0];\n\n if (stsd) {\n var sampleDescriptions = stsd.subarray(8); // gives the codec type string\n\n track.codec = parseType_1(sampleDescriptions.subarray(4, 8));\n var codecBox = findBox_1(sampleDescriptions, [track.codec])[0];\n var codecConfig, codecConfigType;\n\n if (codecBox) {\n // https://tools.ietf.org/html/rfc6381#section-3.3\n if (/^[a-z]vc[1-9]$/i.test(track.codec)) {\n // we don't need anything but the \"config\" parameter of the\n // avc1 codecBox\n codecConfig = codecBox.subarray(78);\n codecConfigType = parseType_1(codecConfig.subarray(4, 8));\n\n if (codecConfigType === 'avcC' && codecConfig.length > 11) {\n track.codec += '.'; // left padded with zeroes for single digit hex\n // profile idc\n\n track.codec += toHexString(codecConfig[9]); // the byte containing the constraint_set flags\n\n track.codec += toHexString(codecConfig[10]); // level idc\n\n track.codec += toHexString(codecConfig[11]);\n } else {\n // TODO: show a warning that we couldn't parse the codec\n // and are using the default\n track.codec = 'avc1.4d400d';\n }\n } else if (/^mp4[a,v]$/i.test(track.codec)) {\n // we do not need anything but the streamDescriptor of the mp4a codecBox\n codecConfig = codecBox.subarray(28);\n codecConfigType = parseType_1(codecConfig.subarray(4, 8));\n\n if (codecConfigType === 'esds' && codecConfig.length > 20 && codecConfig[19] !== 0) {\n track.codec += '.' + toHexString(codecConfig[19]); // this value is only a single digit\n\n track.codec += '.' + toHexString(codecConfig[20] >>> 2 & 0x3f).replace(/^0/, '');\n } else {\n // TODO: show a warning that we couldn't parse the codec\n // and are using the default\n track.codec = 'mp4a.40.2';\n }\n } else {\n // flac, opus, etc\n track.codec = track.codec.toLowerCase();\n }\n }\n }\n\n var mdhd = findBox_1(trak, ['mdia', 'mdhd'])[0];\n\n if (mdhd) {\n track.timescale = getTimescaleFromMediaHeader(mdhd);\n }\n\n tracks.push(track);\n });\n return tracks;\n };\n\n var probe$2 = {\n // export mp4 inspector's findBox and parseType for backwards compatibility\n findBox: findBox_1,\n parseType: parseType_1,\n timescale: timescale,\n startTime: startTime,\n compositionStartTime: compositionStartTime,\n videoTrackIds: getVideoTrackIds,\n tracks: getTracks,\n getTimescaleFromMediaHeader: getTimescaleFromMediaHeader\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n // Convert an array of nal units into an array of frames with each frame being\n // composed of the nal units that make up that frame\n // Also keep track of cummulative data about the frame from the nal units such\n // as the frame duration, starting pts, etc.\n var groupNalsIntoFrames = function groupNalsIntoFrames(nalUnits) {\n var i,\n currentNal,\n currentFrame = [],\n frames = []; // TODO added for LHLS, make sure this is OK\n\n frames.byteLength = 0;\n frames.nalCount = 0;\n frames.duration = 0;\n currentFrame.byteLength = 0;\n\n for (i = 0; i < nalUnits.length; i++) {\n currentNal = nalUnits[i]; // Split on 'aud'-type nal units\n\n if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {\n // Since the very first nal unit is expected to be an AUD\n // only push to the frames array when currentFrame is not empty\n if (currentFrame.length) {\n currentFrame.duration = currentNal.dts - currentFrame.dts; // TODO added for LHLS, make sure this is OK\n\n frames.byteLength += currentFrame.byteLength;\n frames.nalCount += currentFrame.length;\n frames.duration += currentFrame.duration;\n frames.push(currentFrame);\n }\n\n currentFrame = [currentNal];\n currentFrame.byteLength = currentNal.data.byteLength;\n currentFrame.pts = currentNal.pts;\n currentFrame.dts = currentNal.dts;\n } else {\n // Specifically flag key frames for ease of use later\n if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {\n currentFrame.keyFrame = true;\n }\n\n currentFrame.duration = currentNal.dts - currentFrame.dts;\n currentFrame.byteLength += currentNal.data.byteLength;\n currentFrame.push(currentNal);\n }\n } // For the last frame, use the duration of the previous frame if we\n // have nothing better to go on\n\n\n if (frames.length && (!currentFrame.duration || currentFrame.duration <= 0)) {\n currentFrame.duration = frames[frames.length - 1].duration;\n } // Push the final frame\n // TODO added for LHLS, make sure this is OK\n\n\n frames.byteLength += currentFrame.byteLength;\n frames.nalCount += currentFrame.length;\n frames.duration += currentFrame.duration;\n frames.push(currentFrame);\n return frames;\n }; // Convert an array of frames into an array of Gop with each Gop being composed\n // of the frames that make up that Gop\n // Also keep track of cummulative data about the Gop from the frames such as the\n // Gop duration, starting pts, etc.\n\n\n var groupFramesIntoGops = function groupFramesIntoGops(frames) {\n var i,\n currentFrame,\n currentGop = [],\n gops = []; // We must pre-set some of the values on the Gop since we\n // keep running totals of these values\n\n currentGop.byteLength = 0;\n currentGop.nalCount = 0;\n currentGop.duration = 0;\n currentGop.pts = frames[0].pts;\n currentGop.dts = frames[0].dts; // store some metadata about all the Gops\n\n gops.byteLength = 0;\n gops.nalCount = 0;\n gops.duration = 0;\n gops.pts = frames[0].pts;\n gops.dts = frames[0].dts;\n\n for (i = 0; i < frames.length; i++) {\n currentFrame = frames[i];\n\n if (currentFrame.keyFrame) {\n // Since the very first frame is expected to be an keyframe\n // only push to the gops array when currentGop is not empty\n if (currentGop.length) {\n gops.push(currentGop);\n gops.byteLength += currentGop.byteLength;\n gops.nalCount += currentGop.nalCount;\n gops.duration += currentGop.duration;\n }\n\n currentGop = [currentFrame];\n currentGop.nalCount = currentFrame.length;\n currentGop.byteLength = currentFrame.byteLength;\n currentGop.pts = currentFrame.pts;\n currentGop.dts = currentFrame.dts;\n currentGop.duration = currentFrame.duration;\n } else {\n currentGop.duration += currentFrame.duration;\n currentGop.nalCount += currentFrame.length;\n currentGop.byteLength += currentFrame.byteLength;\n currentGop.push(currentFrame);\n }\n }\n\n if (gops.length && currentGop.duration <= 0) {\n currentGop.duration = gops[gops.length - 1].duration;\n }\n\n gops.byteLength += currentGop.byteLength;\n gops.nalCount += currentGop.nalCount;\n gops.duration += currentGop.duration; // push the final Gop\n\n gops.push(currentGop);\n return gops;\n };\n /*\n * Search for the first keyframe in the GOPs and throw away all frames\n * until that keyframe. Then extend the duration of the pulled keyframe\n * and pull the PTS and DTS of the keyframe so that it covers the time\n * range of the frames that were disposed.\n *\n * @param {Array} gops video GOPs\n * @returns {Array} modified video GOPs\n */\n\n\n var extendFirstKeyFrame = function extendFirstKeyFrame(gops) {\n var currentGop;\n\n if (!gops[0][0].keyFrame && gops.length > 1) {\n // Remove the first GOP\n currentGop = gops.shift();\n gops.byteLength -= currentGop.byteLength;\n gops.nalCount -= currentGop.nalCount; // Extend the first frame of what is now the\n // first gop to cover the time period of the\n // frames we just removed\n\n gops[0][0].dts = currentGop.dts;\n gops[0][0].pts = currentGop.pts;\n gops[0][0].duration += currentGop.duration;\n }\n\n return gops;\n };\n /**\n * Default sample object\n * see ISO/IEC 14496-12:2012, section 8.6.4.3\n */\n\n\n var createDefaultSample = function createDefaultSample() {\n return {\n size: 0,\n flags: {\n isLeading: 0,\n dependsOn: 1,\n isDependedOn: 0,\n hasRedundancy: 0,\n degradationPriority: 0,\n isNonSyncSample: 1\n }\n };\n };\n /*\n * Collates information from a video frame into an object for eventual\n * entry into an MP4 sample table.\n *\n * @param {Object} frame the video frame\n * @param {Number} dataOffset the byte offset to position the sample\n * @return {Object} object containing sample table info for a frame\n */\n\n\n var sampleForFrame = function sampleForFrame(frame, dataOffset) {\n var sample = createDefaultSample();\n sample.dataOffset = dataOffset;\n sample.compositionTimeOffset = frame.pts - frame.dts;\n sample.duration = frame.duration;\n sample.size = 4 * frame.length; // Space for nal unit size\n\n sample.size += frame.byteLength;\n\n if (frame.keyFrame) {\n sample.flags.dependsOn = 2;\n sample.flags.isNonSyncSample = 0;\n }\n\n return sample;\n }; // generate the track's sample table from an array of gops\n\n\n var generateSampleTable$1 = function generateSampleTable(gops, baseDataOffset) {\n var h,\n i,\n sample,\n currentGop,\n currentFrame,\n dataOffset = baseDataOffset || 0,\n samples = [];\n\n for (h = 0; h < gops.length; h++) {\n currentGop = gops[h];\n\n for (i = 0; i < currentGop.length; i++) {\n currentFrame = currentGop[i];\n sample = sampleForFrame(currentFrame, dataOffset);\n dataOffset += sample.size;\n samples.push(sample);\n }\n }\n\n return samples;\n }; // generate the track's raw mdat data from an array of gops\n\n\n var concatenateNalData = function concatenateNalData(gops) {\n var h,\n i,\n j,\n currentGop,\n currentFrame,\n currentNal,\n dataOffset = 0,\n nalsByteLength = gops.byteLength,\n numberOfNals = gops.nalCount,\n totalByteLength = nalsByteLength + 4 * numberOfNals,\n data = new Uint8Array(totalByteLength),\n view = new DataView(data.buffer); // For each Gop..\n\n for (h = 0; h < gops.length; h++) {\n currentGop = gops[h]; // For each Frame..\n\n for (i = 0; i < currentGop.length; i++) {\n currentFrame = currentGop[i]; // For each NAL..\n\n for (j = 0; j < currentFrame.length; j++) {\n currentNal = currentFrame[j];\n view.setUint32(dataOffset, currentNal.data.byteLength);\n dataOffset += 4;\n data.set(currentNal.data, dataOffset);\n dataOffset += currentNal.data.byteLength;\n }\n }\n }\n\n return data;\n }; // generate the track's sample table from a frame\n\n\n var generateSampleTableForFrame = function generateSampleTableForFrame(frame, baseDataOffset) {\n var sample,\n dataOffset = baseDataOffset || 0,\n samples = [];\n sample = sampleForFrame(frame, dataOffset);\n samples.push(sample);\n return samples;\n }; // generate the track's raw mdat data from a frame\n\n\n var concatenateNalDataForFrame = function concatenateNalDataForFrame(frame) {\n var i,\n currentNal,\n dataOffset = 0,\n nalsByteLength = frame.byteLength,\n numberOfNals = frame.length,\n totalByteLength = nalsByteLength + 4 * numberOfNals,\n data = new Uint8Array(totalByteLength),\n view = new DataView(data.buffer); // For each NAL..\n\n for (i = 0; i < frame.length; i++) {\n currentNal = frame[i];\n view.setUint32(dataOffset, currentNal.data.byteLength);\n dataOffset += 4;\n data.set(currentNal.data, dataOffset);\n dataOffset += currentNal.data.byteLength;\n }\n\n return data;\n };\n\n var frameUtils = {\n groupNalsIntoFrames: groupNalsIntoFrames,\n groupFramesIntoGops: groupFramesIntoGops,\n extendFirstKeyFrame: extendFirstKeyFrame,\n generateSampleTable: generateSampleTable$1,\n concatenateNalData: concatenateNalData,\n generateSampleTableForFrame: generateSampleTableForFrame,\n concatenateNalDataForFrame: concatenateNalDataForFrame\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n var highPrefix = [33, 16, 5, 32, 164, 27];\n var lowPrefix = [33, 65, 108, 84, 1, 2, 4, 8, 168, 2, 4, 8, 17, 191, 252];\n\n var zeroFill = function zeroFill(count) {\n var a = [];\n\n while (count--) {\n a.push(0);\n }\n\n return a;\n };\n\n var makeTable = function makeTable(metaTable) {\n return Object.keys(metaTable).reduce(function (obj, key) {\n obj[key] = new Uint8Array(metaTable[key].reduce(function (arr, part) {\n return arr.concat(part);\n }, []));\n return obj;\n }, {});\n };\n\n var silence;\n\n var silence_1 = function silence_1() {\n if (!silence) {\n // Frames-of-silence to use for filling in missing AAC frames\n var coneOfSilence = {\n 96000: [highPrefix, [227, 64], zeroFill(154), [56]],\n 88200: [highPrefix, [231], zeroFill(170), [56]],\n 64000: [highPrefix, [248, 192], zeroFill(240), [56]],\n 48000: [highPrefix, [255, 192], zeroFill(268), [55, 148, 128], zeroFill(54), [112]],\n 44100: [highPrefix, [255, 192], zeroFill(268), [55, 163, 128], zeroFill(84), [112]],\n 32000: [highPrefix, [255, 192], zeroFill(268), [55, 234], zeroFill(226), [112]],\n 24000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 112], zeroFill(126), [224]],\n 16000: [highPrefix, [255, 192], zeroFill(268), [55, 255, 128], zeroFill(268), [111, 255], zeroFill(269), [223, 108], zeroFill(195), [1, 192]],\n 12000: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 253, 128], zeroFill(259), [56]],\n 11025: [lowPrefix, zeroFill(268), [3, 127, 248], zeroFill(268), [6, 255, 240], zeroFill(268), [13, 255, 224], zeroFill(268), [27, 255, 192], zeroFill(268), [55, 175, 128], zeroFill(108), [112]],\n 8000: [lowPrefix, zeroFill(268), [3, 121, 16], zeroFill(47), [7]]\n };\n silence = makeTable(coneOfSilence);\n }\n\n return silence;\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n /**\n * Sum the `byteLength` properties of the data in each AAC frame\n */\n\n var sumFrameByteLengths = function sumFrameByteLengths(array) {\n var i,\n currentObj,\n sum = 0; // sum the byteLength's all each nal unit in the frame\n\n for (i = 0; i < array.length; i++) {\n currentObj = array[i];\n sum += currentObj.data.byteLength;\n }\n\n return sum;\n }; // Possibly pad (prefix) the audio track with silence if appending this track\n // would lead to the introduction of a gap in the audio buffer\n\n\n var prefixWithSilence = function prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime) {\n var baseMediaDecodeTimeTs,\n frameDuration = 0,\n audioGapDuration = 0,\n audioFillFrameCount = 0,\n audioFillDuration = 0,\n silentFrame,\n i,\n firstFrame;\n\n if (!frames.length) {\n return;\n }\n\n baseMediaDecodeTimeTs = clock.audioTsToVideoTs(track.baseMediaDecodeTime, track.samplerate); // determine frame clock duration based on sample rate, round up to avoid overfills\n\n frameDuration = Math.ceil(clock.ONE_SECOND_IN_TS / (track.samplerate / 1024));\n\n if (audioAppendStartTs && videoBaseMediaDecodeTime) {\n // insert the shortest possible amount (audio gap or audio to video gap)\n audioGapDuration = baseMediaDecodeTimeTs - Math.max(audioAppendStartTs, videoBaseMediaDecodeTime); // number of full frames in the audio gap\n\n audioFillFrameCount = Math.floor(audioGapDuration / frameDuration);\n audioFillDuration = audioFillFrameCount * frameDuration;\n } // don't attempt to fill gaps smaller than a single frame or larger\n // than a half second\n\n\n if (audioFillFrameCount < 1 || audioFillDuration > clock.ONE_SECOND_IN_TS / 2) {\n return;\n }\n\n silentFrame = silence_1()[track.samplerate];\n\n if (!silentFrame) {\n // we don't have a silent frame pregenerated for the sample rate, so use a frame\n // from the content instead\n silentFrame = frames[0].data;\n }\n\n for (i = 0; i < audioFillFrameCount; i++) {\n firstFrame = frames[0];\n frames.splice(0, 0, {\n data: silentFrame,\n dts: firstFrame.dts - frameDuration,\n pts: firstFrame.pts - frameDuration\n });\n }\n\n track.baseMediaDecodeTime -= Math.floor(clock.videoTsToAudioTs(audioFillDuration, track.samplerate));\n return audioFillDuration;\n }; // If the audio segment extends before the earliest allowed dts\n // value, remove AAC frames until starts at or after the earliest\n // allowed DTS so that we don't end up with a negative baseMedia-\n // DecodeTime for the audio track\n\n\n var trimAdtsFramesByEarliestDts = function trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts) {\n if (track.minSegmentDts >= earliestAllowedDts) {\n return adtsFrames;\n } // We will need to recalculate the earliest segment Dts\n\n\n track.minSegmentDts = Infinity;\n return adtsFrames.filter(function (currentFrame) {\n // If this is an allowed frame, keep it and record it's Dts\n if (currentFrame.dts >= earliestAllowedDts) {\n track.minSegmentDts = Math.min(track.minSegmentDts, currentFrame.dts);\n track.minSegmentPts = track.minSegmentDts;\n return true;\n } // Otherwise, discard it\n\n\n return false;\n });\n }; // generate the track's raw mdat data from an array of frames\n\n\n var generateSampleTable = function generateSampleTable(frames) {\n var i,\n currentFrame,\n samples = [];\n\n for (i = 0; i < frames.length; i++) {\n currentFrame = frames[i];\n samples.push({\n size: currentFrame.data.byteLength,\n duration: 1024 // For AAC audio, all samples contain 1024 samples\n\n });\n }\n\n return samples;\n }; // generate the track's sample table from an array of frames\n\n\n var concatenateFrameData = function concatenateFrameData(frames) {\n var i,\n currentFrame,\n dataOffset = 0,\n data = new Uint8Array(sumFrameByteLengths(frames));\n\n for (i = 0; i < frames.length; i++) {\n currentFrame = frames[i];\n data.set(currentFrame.data, dataOffset);\n dataOffset += currentFrame.data.byteLength;\n }\n\n return data;\n };\n\n var audioFrameUtils = {\n prefixWithSilence: prefixWithSilence,\n trimAdtsFramesByEarliestDts: trimAdtsFramesByEarliestDts,\n generateSampleTable: generateSampleTable,\n concatenateFrameData: concatenateFrameData\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var ONE_SECOND_IN_TS$3 = clock.ONE_SECOND_IN_TS;\n /**\n * Store information about the start and end of the track and the\n * duration for each frame/sample we process in order to calculate\n * the baseMediaDecodeTime\n */\n\n var collectDtsInfo = function collectDtsInfo(track, data) {\n if (typeof data.pts === 'number') {\n if (track.timelineStartInfo.pts === undefined) {\n track.timelineStartInfo.pts = data.pts;\n }\n\n if (track.minSegmentPts === undefined) {\n track.minSegmentPts = data.pts;\n } else {\n track.minSegmentPts = Math.min(track.minSegmentPts, data.pts);\n }\n\n if (track.maxSegmentPts === undefined) {\n track.maxSegmentPts = data.pts;\n } else {\n track.maxSegmentPts = Math.max(track.maxSegmentPts, data.pts);\n }\n }\n\n if (typeof data.dts === 'number') {\n if (track.timelineStartInfo.dts === undefined) {\n track.timelineStartInfo.dts = data.dts;\n }\n\n if (track.minSegmentDts === undefined) {\n track.minSegmentDts = data.dts;\n } else {\n track.minSegmentDts = Math.min(track.minSegmentDts, data.dts);\n }\n\n if (track.maxSegmentDts === undefined) {\n track.maxSegmentDts = data.dts;\n } else {\n track.maxSegmentDts = Math.max(track.maxSegmentDts, data.dts);\n }\n }\n };\n /**\n * Clear values used to calculate the baseMediaDecodeTime between\n * tracks\n */\n\n\n var clearDtsInfo = function clearDtsInfo(track) {\n delete track.minSegmentDts;\n delete track.maxSegmentDts;\n delete track.minSegmentPts;\n delete track.maxSegmentPts;\n };\n /**\n * Calculate the track's baseMediaDecodeTime based on the earliest\n * DTS the transmuxer has ever seen and the minimum DTS for the\n * current track\n * @param track {object} track metadata configuration\n * @param keepOriginalTimestamps {boolean} If true, keep the timestamps\n * in the source; false to adjust the first segment to start at 0.\n */\n\n\n var calculateTrackBaseMediaDecodeTime = function calculateTrackBaseMediaDecodeTime(track, keepOriginalTimestamps) {\n var baseMediaDecodeTime,\n scale,\n minSegmentDts = track.minSegmentDts; // Optionally adjust the time so the first segment starts at zero.\n\n if (!keepOriginalTimestamps) {\n minSegmentDts -= track.timelineStartInfo.dts;\n } // track.timelineStartInfo.baseMediaDecodeTime is the location, in time, where\n // we want the start of the first segment to be placed\n\n\n baseMediaDecodeTime = track.timelineStartInfo.baseMediaDecodeTime; // Add to that the distance this segment is from the very first\n\n baseMediaDecodeTime += minSegmentDts; // baseMediaDecodeTime must not become negative\n\n baseMediaDecodeTime = Math.max(0, baseMediaDecodeTime);\n\n if (track.type === 'audio') {\n // Audio has a different clock equal to the sampling_rate so we need to\n // scale the PTS values into the clock rate of the track\n scale = track.samplerate / ONE_SECOND_IN_TS$3;\n baseMediaDecodeTime *= scale;\n baseMediaDecodeTime = Math.floor(baseMediaDecodeTime);\n }\n\n return baseMediaDecodeTime;\n };\n\n var trackDecodeInfo = {\n clearDtsInfo: clearDtsInfo,\n calculateTrackBaseMediaDecodeTime: calculateTrackBaseMediaDecodeTime,\n collectDtsInfo: collectDtsInfo\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n *\n * Reads in-band caption information from a video elementary\n * stream. Captions must follow the CEA-708 standard for injection\n * into an MPEG-2 transport streams.\n * @see https://en.wikipedia.org/wiki/CEA-708\n * @see https://www.gpo.gov/fdsys/pkg/CFR-2007-title47-vol1/pdf/CFR-2007-title47-vol1-sec15-119.pdf\n */\n // payload type field to indicate how they are to be\n // interpreted. CEAS-708 caption content is always transmitted with\n // payload type 0x04.\n\n var USER_DATA_REGISTERED_ITU_T_T35 = 4,\n RBSP_TRAILING_BITS = 128;\n /**\n * Parse a supplemental enhancement information (SEI) NAL unit.\n * Stops parsing once a message of type ITU T T35 has been found.\n *\n * @param bytes {Uint8Array} the bytes of a SEI NAL unit\n * @return {object} the parsed SEI payload\n * @see Rec. ITU-T H.264, 7.3.2.3.1\n */\n\n var parseSei = function parseSei(bytes) {\n var i = 0,\n result = {\n payloadType: -1,\n payloadSize: 0\n },\n payloadType = 0,\n payloadSize = 0; // go through the sei_rbsp parsing each each individual sei_message\n\n while (i < bytes.byteLength) {\n // stop once we have hit the end of the sei_rbsp\n if (bytes[i] === RBSP_TRAILING_BITS) {\n break;\n } // Parse payload type\n\n\n while (bytes[i] === 0xFF) {\n payloadType += 255;\n i++;\n }\n\n payloadType += bytes[i++]; // Parse payload size\n\n while (bytes[i] === 0xFF) {\n payloadSize += 255;\n i++;\n }\n\n payloadSize += bytes[i++]; // this sei_message is a 608/708 caption so save it and break\n // there can only ever be one caption message in a frame's sei\n\n if (!result.payload && payloadType === USER_DATA_REGISTERED_ITU_T_T35) {\n var userIdentifier = String.fromCharCode(bytes[i + 3], bytes[i + 4], bytes[i + 5], bytes[i + 6]);\n\n if (userIdentifier === 'GA94') {\n result.payloadType = payloadType;\n result.payloadSize = payloadSize;\n result.payload = bytes.subarray(i, i + payloadSize);\n break;\n } else {\n result.payload = void 0;\n }\n } // skip the payload and parse the next message\n\n\n i += payloadSize;\n payloadType = 0;\n payloadSize = 0;\n }\n\n return result;\n }; // see ANSI/SCTE 128-1 (2013), section 8.1\n\n\n var parseUserData = function parseUserData(sei) {\n // itu_t_t35_contry_code must be 181 (United States) for\n // captions\n if (sei.payload[0] !== 181) {\n return null;\n } // itu_t_t35_provider_code should be 49 (ATSC) for captions\n\n\n if ((sei.payload[1] << 8 | sei.payload[2]) !== 49) {\n return null;\n } // the user_identifier should be \"GA94\" to indicate ATSC1 data\n\n\n if (String.fromCharCode(sei.payload[3], sei.payload[4], sei.payload[5], sei.payload[6]) !== 'GA94') {\n return null;\n } // finally, user_data_type_code should be 0x03 for caption data\n\n\n if (sei.payload[7] !== 0x03) {\n return null;\n } // return the user_data_type_structure and strip the trailing\n // marker bits\n\n\n return sei.payload.subarray(8, sei.payload.length - 1);\n }; // see CEA-708-D, section 4.4\n\n\n var parseCaptionPackets = function parseCaptionPackets(pts, userData) {\n var results = [],\n i,\n count,\n offset,\n data; // if this is just filler, return immediately\n\n if (!(userData[0] & 0x40)) {\n return results;\n } // parse out the cc_data_1 and cc_data_2 fields\n\n\n count = userData[0] & 0x1f;\n\n for (i = 0; i < count; i++) {\n offset = i * 3;\n data = {\n type: userData[offset + 2] & 0x03,\n pts: pts\n }; // capture cc data when cc_valid is 1\n\n if (userData[offset + 2] & 0x04) {\n data.ccData = userData[offset + 3] << 8 | userData[offset + 4];\n results.push(data);\n }\n }\n\n return results;\n };\n\n var discardEmulationPreventionBytes$1 = function discardEmulationPreventionBytes(data) {\n var length = data.byteLength,\n emulationPreventionBytesPositions = [],\n i = 1,\n newLength,\n newData; // Find all `Emulation Prevention Bytes`\n\n while (i < length - 2) {\n if (data[i] === 0 && data[i + 1] === 0 && data[i + 2] === 0x03) {\n emulationPreventionBytesPositions.push(i + 2);\n i += 2;\n } else {\n i++;\n }\n } // If no Emulation Prevention Bytes were found just return the original\n // array\n\n\n if (emulationPreventionBytesPositions.length === 0) {\n return data;\n } // Create a new array to hold the NAL unit data\n\n\n newLength = length - emulationPreventionBytesPositions.length;\n newData = new Uint8Array(newLength);\n var sourceIndex = 0;\n\n for (i = 0; i < newLength; sourceIndex++, i++) {\n if (sourceIndex === emulationPreventionBytesPositions[0]) {\n // Skip this byte\n sourceIndex++; // Remove this position index\n\n emulationPreventionBytesPositions.shift();\n }\n\n newData[i] = data[sourceIndex];\n }\n\n return newData;\n }; // exports\n\n\n var captionPacketParser = {\n parseSei: parseSei,\n parseUserData: parseUserData,\n parseCaptionPackets: parseCaptionPackets,\n discardEmulationPreventionBytes: discardEmulationPreventionBytes$1,\n USER_DATA_REGISTERED_ITU_T_T35: USER_DATA_REGISTERED_ITU_T_T35\n };\n\n // Link To Transport\n // -----------------\n\n\n var CaptionStream$1 = function CaptionStream(options) {\n options = options || {};\n CaptionStream.prototype.init.call(this); // parse708captions flag, default to true\n\n this.parse708captions_ = typeof options.parse708captions === 'boolean' ? options.parse708captions : true;\n this.captionPackets_ = [];\n this.ccStreams_ = [new Cea608Stream(0, 0), // eslint-disable-line no-use-before-define\n new Cea608Stream(0, 1), // eslint-disable-line no-use-before-define\n new Cea608Stream(1, 0), // eslint-disable-line no-use-before-define\n new Cea608Stream(1, 1) // eslint-disable-line no-use-before-define\n ];\n\n if (this.parse708captions_) {\n this.cc708Stream_ = new Cea708Stream(); // 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) {\n this.serviceNum = serviceNum;\n this.text = '';\n this.currentWindow = new Cea708Window(-1);\n this.windows = [];\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 var Cea708Stream = function Cea708Stream() {\n Cea708Stream.prototype.init.call(this);\n var self = this;\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 === 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, true);\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 self = this;\n this.services[serviceNum] = new Cea708Service(serviceNum);\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, isExtended) {\n var packetData = this.current708Packet.data;\n var b = packetData[i];\n var extended = isExtended ? 0x1000 : 0x0000;\n var char = get708CharFromCode(extended | b);\n var win = service.currentWindow;\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 * 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 + '';\n }, '');\n this.formatting_ = [];\n this[this.mode_](pts, text);\n }; // Mode Implementations\n\n\n Cea608Stream.prototype.popOn = function (pts, text) {\n var baseRow = this.nonDisplayed_[this.row_]; // buffer characters\n\n baseRow += text;\n this.nonDisplayed_[this.row_] = baseRow;\n };\n\n Cea608Stream.prototype.rollUp = function (pts, text) {\n var baseRow = this.displayed_[this.row_];\n baseRow += text;\n this.displayed_[this.row_] = baseRow;\n };\n\n Cea608Stream.prototype.shiftRowsUp_ = function () {\n var i; // clear out inactive rows\n\n for (i = 0; i < this.topRow_; i++) {\n this.displayed_[i] = '';\n }\n\n for (i = this.row_ + 1; i < BOTTOM_ROW + 1; i++) {\n this.displayed_[i] = '';\n } // shift displayed rows up\n\n\n for (i = this.topRow_; i < this.row_; i++) {\n this.displayed_[i] = this.displayed_[i + 1];\n } // clear out the bottom row\n\n\n this.displayed_[this.row_] = '';\n };\n\n Cea608Stream.prototype.paintOn = function (pts, text) {\n var baseRow = this.displayed_[this.row_];\n baseRow += text;\n this.displayed_[this.row_] = baseRow;\n }; // exports\n\n\n var captionStream = {\n CaptionStream: CaptionStream$1,\n Cea608Stream: Cea608Stream,\n Cea708Stream: Cea708Stream\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var streamTypes = {\n H264_STREAM_TYPE: 0x1B,\n ADTS_STREAM_TYPE: 0x0F,\n METADATA_STREAM_TYPE: 0x15\n };\n\n var MAX_TS = 8589934592;\n var RO_THRESH = 4294967296;\n var TYPE_SHARED = 'shared';\n\n var handleRollover$1 = function handleRollover(value, reference) {\n var direction = 1;\n\n if (value > reference) {\n // If the current timestamp value is greater than our reference timestamp and we detect a\n // timestamp rollover, this means the roll over is happening in the opposite direction.\n // Example scenario: Enter a long stream/video just after a rollover occurred. The reference\n // point will be set to a small number, e.g. 1. The user then seeks backwards over the\n // rollover point. In loading this segment, the timestamp values will be very large,\n // e.g. 2^33 - 1. Since this comes before the data we loaded previously, we want to adjust\n // the time stamp to be `value - 2^33`.\n direction = -1;\n } // Note: A seek forwards or back that is greater than the RO_THRESH (2^32, ~13 hours) will\n // cause an incorrect adjustment.\n\n\n while (Math.abs(reference - value) > RO_THRESH) {\n value += direction * MAX_TS;\n }\n\n return value;\n };\n\n var TimestampRolloverStream$1 = function TimestampRolloverStream(type) {\n var lastDTS, referenceDTS;\n TimestampRolloverStream.prototype.init.call(this); // The \"shared\" type is used in cases where a stream will contain muxed\n // video and audio. We could use `undefined` here, but having a string\n // makes debugging a little clearer.\n\n this.type_ = type || TYPE_SHARED;\n\n this.push = function (data) {\n // Any \"shared\" rollover streams will accept _all_ data. Otherwise,\n // streams will only accept data that matches their type.\n if (this.type_ !== TYPE_SHARED && data.type !== this.type_) {\n return;\n }\n\n if (referenceDTS === undefined) {\n referenceDTS = data.dts;\n }\n\n data.dts = handleRollover$1(data.dts, referenceDTS);\n data.pts = handleRollover$1(data.pts, referenceDTS);\n lastDTS = data.dts;\n this.trigger('data', data);\n };\n\n this.flush = function () {\n referenceDTS = lastDTS;\n this.trigger('done');\n };\n\n this.endTimeline = function () {\n this.flush();\n this.trigger('endedtimeline');\n };\n\n this.discontinuity = function () {\n referenceDTS = void 0;\n lastDTS = void 0;\n };\n\n this.reset = function () {\n this.discontinuity();\n this.trigger('reset');\n };\n };\n\n TimestampRolloverStream$1.prototype = new stream();\n var timestampRolloverStream = {\n TimestampRolloverStream: TimestampRolloverStream$1,\n handleRollover: handleRollover$1\n };\n\n var percentEncode$1 = function percentEncode(bytes, start, end) {\n var i,\n result = '';\n\n for (i = start; i < end; i++) {\n result += '%' + ('00' + bytes[i].toString(16)).slice(-2);\n }\n\n return result;\n },\n // return the string representation of the specified byte range,\n // interpreted as UTf-8.\n parseUtf8 = function parseUtf8(bytes, start, end) {\n return decodeURIComponent(percentEncode$1(bytes, start, end));\n },\n // return the string representation of the specified byte range,\n // interpreted as ISO-8859-1.\n parseIso88591$1 = function parseIso88591(bytes, start, end) {\n return unescape(percentEncode$1(bytes, start, end)); // jshint ignore:line\n },\n parseSyncSafeInteger$1 = function parseSyncSafeInteger(data) {\n return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];\n },\n tagParsers = {\n TXXX: function TXXX(tag) {\n var i;\n\n if (tag.data[0] !== 3) {\n // ignore frames with unrecognized character encodings\n return;\n }\n\n for (i = 1; i < tag.data.length; i++) {\n if (tag.data[i] === 0) {\n // parse the text fields\n tag.description = parseUtf8(tag.data, 1, i); // do not include the null terminator in the tag value\n\n tag.value = parseUtf8(tag.data, i + 1, tag.data.length).replace(/\\0*$/, '');\n break;\n }\n }\n\n tag.data = tag.value;\n },\n WXXX: function WXXX(tag) {\n var i;\n\n if (tag.data[0] !== 3) {\n // ignore frames with unrecognized character encodings\n return;\n }\n\n for (i = 1; i < tag.data.length; i++) {\n if (tag.data[i] === 0) {\n // parse the description and URL fields\n tag.description = parseUtf8(tag.data, 1, i);\n tag.url = parseUtf8(tag.data, i + 1, tag.data.length);\n break;\n }\n }\n },\n PRIV: function PRIV(tag) {\n var i;\n\n for (i = 0; i < tag.data.length; i++) {\n if (tag.data[i] === 0) {\n // parse the description and URL fields\n tag.owner = parseIso88591$1(tag.data, 0, i);\n break;\n }\n }\n\n tag.privateData = tag.data.subarray(i + 1);\n tag.data = tag.privateData;\n }\n },\n _MetadataStream;\n\n _MetadataStream = function MetadataStream(options) {\n var settings = {\n // the bytes of the program-level descriptor field in MP2T\n // see ISO/IEC 13818-1:2013 (E), section 2.6 \"Program and\n // program element descriptors\"\n descriptor: options && options.descriptor\n },\n // the total size in bytes of the ID3 tag being parsed\n tagSize = 0,\n // tag data that is not complete enough to be parsed\n buffer = [],\n // the total number of bytes currently in the buffer\n bufferSize = 0,\n i;\n\n _MetadataStream.prototype.init.call(this); // calculate the text track in-band metadata track dispatch type\n // https://html.spec.whatwg.org/multipage/embedded-content.html#steps-to-expose-a-media-resource-specific-text-track\n\n\n this.dispatchType = streamTypes.METADATA_STREAM_TYPE.toString(16);\n\n if (settings.descriptor) {\n for (i = 0; i < settings.descriptor.length; i++) {\n this.dispatchType += ('00' + settings.descriptor[i].toString(16)).slice(-2);\n }\n }\n\n this.push = function (chunk) {\n var tag, frameStart, frameSize, frame, i, frameHeader;\n\n if (chunk.type !== 'timed-metadata') {\n return;\n } // if data_alignment_indicator is set in the PES header,\n // we must have the start of a new ID3 tag. Assume anything\n // remaining in the buffer was malformed and throw it out\n\n\n if (chunk.dataAlignmentIndicator) {\n bufferSize = 0;\n buffer.length = 0;\n } // ignore events that don't look like ID3 data\n\n\n if (buffer.length === 0 && (chunk.data.length < 10 || chunk.data[0] !== 'I'.charCodeAt(0) || chunk.data[1] !== 'D'.charCodeAt(0) || chunk.data[2] !== '3'.charCodeAt(0))) {\n this.trigger('log', {\n level: 'warn',\n message: 'Skipping unrecognized metadata packet'\n });\n return;\n } // add this chunk to the data we've collected so far\n\n\n buffer.push(chunk);\n bufferSize += chunk.data.byteLength; // grab the size of the entire frame from the ID3 header\n\n if (buffer.length === 1) {\n // the frame size is transmitted as a 28-bit integer in the\n // last four bytes of the ID3 header.\n // The most significant bit of each byte is dropped and the\n // results concatenated to recover the actual value.\n tagSize = parseSyncSafeInteger$1(chunk.data.subarray(6, 10)); // ID3 reports the tag size excluding the header but it's more\n // convenient for our comparisons to include it\n\n tagSize += 10;\n } // if the entire frame has not arrived, wait for more data\n\n\n if (bufferSize < tagSize) {\n return;\n } // collect the entire frame so it can be parsed\n\n\n tag = {\n data: new Uint8Array(tagSize),\n frames: [],\n pts: buffer[0].pts,\n dts: buffer[0].dts\n };\n\n for (i = 0; i < tagSize;) {\n tag.data.set(buffer[0].data.subarray(0, tagSize - i), i);\n i += buffer[0].data.byteLength;\n bufferSize -= buffer[0].data.byteLength;\n buffer.shift();\n } // find the start of the first frame and the end of the tag\n\n\n frameStart = 10;\n\n if (tag.data[5] & 0x40) {\n // advance the frame start past the extended header\n frameStart += 4; // header size field\n\n frameStart += parseSyncSafeInteger$1(tag.data.subarray(10, 14)); // clip any padding off the end\n\n tagSize -= parseSyncSafeInteger$1(tag.data.subarray(16, 20));\n } // parse one or more ID3 frames\n // http://id3.org/id3v2.3.0#ID3v2_frame_overview\n\n\n do {\n // determine the number of bytes in this frame\n frameSize = parseSyncSafeInteger$1(tag.data.subarray(frameStart + 4, frameStart + 8));\n\n if (frameSize < 1) {\n this.trigger('log', {\n level: 'warn',\n message: 'Malformed ID3 frame encountered. Skipping metadata parsing.'\n });\n return;\n }\n\n frameHeader = String.fromCharCode(tag.data[frameStart], tag.data[frameStart + 1], tag.data[frameStart + 2], tag.data[frameStart + 3]);\n frame = {\n id: frameHeader,\n data: tag.data.subarray(frameStart + 10, frameStart + frameSize + 10)\n };\n frame.key = frame.id;\n\n if (tagParsers[frame.id]) {\n tagParsers[frame.id](frame); // handle the special PRIV frame used to indicate the start\n // time for raw AAC data\n\n if (frame.owner === 'com.apple.streaming.transportStreamTimestamp') {\n var d = frame.data,\n size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;\n size *= 4;\n size += d[7] & 0x03;\n frame.timeStamp = size; // in raw AAC, all subsequent data will be timestamped based\n // on the value of this frame\n // we couldn't have known the appropriate pts and dts before\n // parsing this ID3 tag so set those values now\n\n if (tag.pts === undefined && tag.dts === undefined) {\n tag.pts = frame.timeStamp;\n tag.dts = frame.timeStamp;\n }\n\n this.trigger('timestamp', frame);\n }\n }\n\n tag.frames.push(frame);\n frameStart += 10; // advance past the frame header\n\n frameStart += frameSize; // advance past the frame body\n } while (frameStart < tagSize);\n\n this.trigger('data', tag);\n };\n };\n\n _MetadataStream.prototype = new stream();\n var metadataStream = _MetadataStream;\n\n var TimestampRolloverStream = timestampRolloverStream.TimestampRolloverStream; // object types\n\n var _TransportPacketStream, _TransportParseStream, _ElementaryStream; // constants\n\n\n var MP2T_PACKET_LENGTH$1 = 188,\n // bytes\n SYNC_BYTE$1 = 0x47;\n /**\n * Splits an incoming stream of binary data into MPEG-2 Transport\n * Stream packets.\n */\n\n _TransportPacketStream = function TransportPacketStream() {\n var buffer = new Uint8Array(MP2T_PACKET_LENGTH$1),\n bytesInBuffer = 0;\n\n _TransportPacketStream.prototype.init.call(this); // Deliver new bytes to the stream.\n\n /**\n * Split a stream of data into M2TS packets\n **/\n\n\n this.push = function (bytes) {\n var startIndex = 0,\n endIndex = MP2T_PACKET_LENGTH$1,\n everything; // If there are bytes remaining from the last segment, prepend them to the\n // bytes that were pushed in\n\n if (bytesInBuffer) {\n everything = new Uint8Array(bytes.byteLength + bytesInBuffer);\n everything.set(buffer.subarray(0, bytesInBuffer));\n everything.set(bytes, bytesInBuffer);\n bytesInBuffer = 0;\n } else {\n everything = bytes;\n } // While we have enough data for a packet\n\n\n while (endIndex < everything.byteLength) {\n // Look for a pair of start and end sync bytes in the data..\n if (everything[startIndex] === SYNC_BYTE$1 && everything[endIndex] === SYNC_BYTE$1) {\n // We found a packet so emit it and jump one whole packet forward in\n // the stream\n this.trigger('data', everything.subarray(startIndex, endIndex));\n startIndex += MP2T_PACKET_LENGTH$1;\n endIndex += MP2T_PACKET_LENGTH$1;\n continue;\n } // If we get here, we have somehow become de-synchronized and we need to step\n // forward one byte at a time until we find a pair of sync bytes that denote\n // a packet\n\n\n startIndex++;\n endIndex++;\n } // If there was some data left over at the end of the segment that couldn't\n // possibly be a whole packet, keep it because it might be the start of a packet\n // that continues in the next segment\n\n\n if (startIndex < everything.byteLength) {\n buffer.set(everything.subarray(startIndex), 0);\n bytesInBuffer = everything.byteLength - startIndex;\n }\n };\n /**\n * Passes identified M2TS packets to the TransportParseStream to be parsed\n **/\n\n\n this.flush = function () {\n // If the buffer contains a whole packet when we are being flushed, emit it\n // and empty the buffer. Otherwise hold onto the data because it may be\n // important for decoding the next segment\n if (bytesInBuffer === MP2T_PACKET_LENGTH$1 && buffer[0] === SYNC_BYTE$1) {\n this.trigger('data', buffer);\n bytesInBuffer = 0;\n }\n\n this.trigger('done');\n };\n\n this.endTimeline = function () {\n this.flush();\n this.trigger('endedtimeline');\n };\n\n this.reset = function () {\n bytesInBuffer = 0;\n this.trigger('reset');\n };\n };\n\n _TransportPacketStream.prototype = new stream();\n /**\n * Accepts an MP2T TransportPacketStream and emits data events with parsed\n * forms of the individual transport stream packets.\n */\n\n _TransportParseStream = function TransportParseStream() {\n var parsePsi, parsePat, parsePmt, self;\n\n _TransportParseStream.prototype.init.call(this);\n\n self = this;\n this.packetsWaitingForPmt = [];\n this.programMapTable = undefined;\n\n parsePsi = function parsePsi(payload, psi) {\n var offset = 0; // PSI packets may be split into multiple sections and those\n // sections may be split into multiple packets. If a PSI\n // section starts in this packet, the payload_unit_start_indicator\n // will be true and the first byte of the payload will indicate\n // the offset from the current position to the start of the\n // section.\n\n if (psi.payloadUnitStartIndicator) {\n offset += payload[offset] + 1;\n }\n\n if (psi.type === 'pat') {\n parsePat(payload.subarray(offset), psi);\n } else {\n parsePmt(payload.subarray(offset), psi);\n }\n };\n\n parsePat = function parsePat(payload, pat) {\n pat.section_number = payload[7]; // eslint-disable-line camelcase\n\n pat.last_section_number = payload[8]; // eslint-disable-line camelcase\n // skip the PSI header and parse the first PMT entry\n\n self.pmtPid = (payload[10] & 0x1F) << 8 | payload[11];\n pat.pmtPid = self.pmtPid;\n };\n /**\n * Parse out the relevant fields of a Program Map Table (PMT).\n * @param payload {Uint8Array} the PMT-specific portion of an MP2T\n * packet. The first byte in this array should be the table_id\n * field.\n * @param pmt {object} the object that should be decorated with\n * fields parsed from the PMT.\n */\n\n\n parsePmt = function parsePmt(payload, pmt) {\n var sectionLength, tableEnd, programInfoLength, offset; // PMTs can be sent ahead of the time when they should actually\n // take effect. We don't believe this should ever be the case\n // for HLS but we'll ignore \"forward\" PMT declarations if we see\n // them. Future PMT declarations have the current_next_indicator\n // set to zero.\n\n if (!(payload[5] & 0x01)) {\n return;\n } // overwrite any existing program map table\n\n\n self.programMapTable = {\n video: null,\n audio: null,\n 'timed-metadata': {}\n }; // the mapping table ends at the end of the current section\n\n sectionLength = (payload[1] & 0x0f) << 8 | payload[2];\n tableEnd = 3 + sectionLength - 4; // to determine where the table is, we have to figure out how\n // long the program info descriptors are\n\n programInfoLength = (payload[10] & 0x0f) << 8 | payload[11]; // advance the offset to the first entry in the mapping table\n\n offset = 12 + programInfoLength;\n\n while (offset < tableEnd) {\n var streamType = payload[offset];\n var pid = (payload[offset + 1] & 0x1F) << 8 | payload[offset + 2]; // only map a single elementary_pid for audio and video stream types\n // TODO: should this be done for metadata too? for now maintain behavior of\n // multiple metadata streams\n\n if (streamType === streamTypes.H264_STREAM_TYPE && self.programMapTable.video === null) {\n self.programMapTable.video = pid;\n } else if (streamType === streamTypes.ADTS_STREAM_TYPE && self.programMapTable.audio === null) {\n self.programMapTable.audio = pid;\n } else if (streamType === streamTypes.METADATA_STREAM_TYPE) {\n // map pid to stream type for metadata streams\n self.programMapTable['timed-metadata'][pid] = streamType;\n } // move to the next table entry\n // skip past the elementary stream descriptors, if present\n\n\n offset += ((payload[offset + 3] & 0x0F) << 8 | payload[offset + 4]) + 5;\n } // record the map on the packet as well\n\n\n pmt.programMapTable = self.programMapTable;\n };\n /**\n * Deliver a new MP2T packet to the next stream in the pipeline.\n */\n\n\n this.push = function (packet) {\n var result = {},\n offset = 4;\n result.payloadUnitStartIndicator = !!(packet[1] & 0x40); // pid is a 13-bit field starting at the last bit of packet[1]\n\n result.pid = packet[1] & 0x1f;\n result.pid <<= 8;\n result.pid |= packet[2]; // if an adaption field is present, its length is specified by the\n // fifth byte of the TS packet header. The adaptation field is\n // used to add stuffing to PES packets that don't fill a complete\n // TS packet, and to specify some forms of timing and control data\n // that we do not currently use.\n\n if ((packet[3] & 0x30) >>> 4 > 0x01) {\n offset += packet[offset] + 1;\n } // parse the rest of the packet based on the type\n\n\n if (result.pid === 0) {\n result.type = 'pat';\n parsePsi(packet.subarray(offset), result);\n this.trigger('data', result);\n } else if (result.pid === this.pmtPid) {\n result.type = 'pmt';\n parsePsi(packet.subarray(offset), result);\n this.trigger('data', result); // if there are any packets waiting for a PMT to be found, process them now\n\n while (this.packetsWaitingForPmt.length) {\n this.processPes_.apply(this, this.packetsWaitingForPmt.shift());\n }\n } else if (this.programMapTable === undefined) {\n // When we have not seen a PMT yet, defer further processing of\n // PES packets until one has been parsed\n this.packetsWaitingForPmt.push([packet, offset, result]);\n } else {\n this.processPes_(packet, offset, result);\n }\n };\n\n this.processPes_ = function (packet, offset, result) {\n // set the appropriate stream type\n if (result.pid === this.programMapTable.video) {\n result.streamType = streamTypes.H264_STREAM_TYPE;\n } else if (result.pid === this.programMapTable.audio) {\n result.streamType = streamTypes.ADTS_STREAM_TYPE;\n } else {\n // if not video or audio, it is timed-metadata or unknown\n // if unknown, streamType will be undefined\n result.streamType = this.programMapTable['timed-metadata'][result.pid];\n }\n\n result.type = 'pes';\n result.data = packet.subarray(offset);\n this.trigger('data', result);\n };\n };\n\n _TransportParseStream.prototype = new stream();\n _TransportParseStream.STREAM_TYPES = {\n h264: 0x1b,\n adts: 0x0f\n };\n /**\n * Reconsistutes program elementary stream (PES) packets from parsed\n * transport stream packets. That is, if you pipe an\n * mp2t.TransportParseStream into a mp2t.ElementaryStream, the output\n * events will be events which capture the bytes for individual PES\n * packets plus relevant metadata that has been extracted from the\n * container.\n */\n\n _ElementaryStream = function ElementaryStream() {\n var self = this,\n segmentHadPmt = false,\n // PES packet fragments\n video = {\n data: [],\n size: 0\n },\n audio = {\n data: [],\n size: 0\n },\n timedMetadata = {\n data: [],\n size: 0\n },\n programMapTable,\n parsePes = function parsePes(payload, pes) {\n var ptsDtsFlags;\n var startPrefix = payload[0] << 16 | payload[1] << 8 | payload[2]; // default to an empty array\n\n pes.data = new Uint8Array(); // In certain live streams, the start of a TS fragment has ts packets\n // that are frame data that is continuing from the previous fragment. This\n // is to check that the pes data is the start of a new pes payload\n\n if (startPrefix !== 1) {\n return;\n } // get the packet length, this will be 0 for video\n\n\n pes.packetLength = 6 + (payload[4] << 8 | payload[5]); // find out if this packets starts a new keyframe\n\n pes.dataAlignmentIndicator = (payload[6] & 0x04) !== 0; // PES packets may be annotated with a PTS value, or a PTS value\n // and a DTS value. Determine what combination of values is\n // available to work with.\n\n ptsDtsFlags = payload[7]; // PTS and DTS are normally stored as a 33-bit number. Javascript\n // performs all bitwise operations on 32-bit integers but javascript\n // supports a much greater range (52-bits) of integer using standard\n // mathematical operations.\n // We construct a 31-bit value using bitwise operators over the 31\n // most significant bits and then multiply by 4 (equal to a left-shift\n // of 2) before we add the final 2 least significant bits of the\n // timestamp (equal to an OR.)\n\n if (ptsDtsFlags & 0xC0) {\n // the PTS and DTS are not written out directly. For information\n // on how they are encoded, see\n // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html\n pes.pts = (payload[9] & 0x0E) << 27 | (payload[10] & 0xFF) << 20 | (payload[11] & 0xFE) << 12 | (payload[12] & 0xFF) << 5 | (payload[13] & 0xFE) >>> 3;\n pes.pts *= 4; // Left shift by 2\n\n pes.pts += (payload[13] & 0x06) >>> 1; // OR by the two LSBs\n\n pes.dts = pes.pts;\n\n if (ptsDtsFlags & 0x40) {\n pes.dts = (payload[14] & 0x0E) << 27 | (payload[15] & 0xFF) << 20 | (payload[16] & 0xFE) << 12 | (payload[17] & 0xFF) << 5 | (payload[18] & 0xFE) >>> 3;\n pes.dts *= 4; // Left shift by 2\n\n pes.dts += (payload[18] & 0x06) >>> 1; // OR by the two LSBs\n }\n } // the data section starts immediately after the PES header.\n // pes_header_data_length specifies the number of header bytes\n // that follow the last byte of the field.\n\n\n pes.data = payload.subarray(9 + payload[8]);\n },\n\n /**\n * Pass completely parsed PES packets to the next stream in the pipeline\n **/\n flushStream = function flushStream(stream, type, forceFlush) {\n var packetData = new Uint8Array(stream.size),\n event = {\n type: type\n },\n i = 0,\n offset = 0,\n packetFlushable = false,\n fragment; // do nothing if there is not enough buffered data for a complete\n // PES header\n\n if (!stream.data.length || stream.size < 9) {\n return;\n }\n\n event.trackId = stream.data[0].pid; // reassemble the packet\n\n for (i = 0; i < stream.data.length; i++) {\n fragment = stream.data[i];\n packetData.set(fragment.data, offset);\n offset += fragment.data.byteLength;\n } // parse assembled packet's PES header\n\n\n parsePes(packetData, event); // non-video PES packets MUST have a non-zero PES_packet_length\n // check that there is enough stream data to fill the packet\n\n packetFlushable = type === 'video' || event.packetLength <= stream.size; // flush pending packets if the conditions are right\n\n if (forceFlush || packetFlushable) {\n stream.size = 0;\n stream.data.length = 0;\n } // only emit packets that are complete. this is to avoid assembling\n // incomplete PES packets due to poor segmentation\n\n\n if (packetFlushable) {\n self.trigger('data', event);\n }\n };\n\n _ElementaryStream.prototype.init.call(this);\n /**\n * Identifies M2TS packet types and parses PES packets using metadata\n * parsed from the PMT\n **/\n\n\n this.push = function (data) {\n ({\n pat: function pat() {// we have to wait for the PMT to arrive as well before we\n // have any meaningful metadata\n },\n pes: function pes() {\n var stream, streamType;\n\n switch (data.streamType) {\n case streamTypes.H264_STREAM_TYPE:\n stream = video;\n streamType = 'video';\n break;\n\n case streamTypes.ADTS_STREAM_TYPE:\n stream = audio;\n streamType = 'audio';\n break;\n\n case streamTypes.METADATA_STREAM_TYPE:\n stream = timedMetadata;\n streamType = 'timed-metadata';\n break;\n\n default:\n // ignore unknown stream types\n return;\n } // if a new packet is starting, we can flush the completed\n // packet\n\n\n if (data.payloadUnitStartIndicator) {\n flushStream(stream, streamType, true);\n } // buffer this fragment until we are sure we've received the\n // complete payload\n\n\n stream.data.push(data);\n stream.size += data.data.byteLength;\n },\n pmt: function pmt() {\n var event = {\n type: 'metadata',\n tracks: []\n };\n programMapTable = data.programMapTable; // translate audio and video streams to tracks\n\n if (programMapTable.video !== null) {\n event.tracks.push({\n timelineStartInfo: {\n baseMediaDecodeTime: 0\n },\n id: +programMapTable.video,\n codec: 'avc',\n type: 'video'\n });\n }\n\n if (programMapTable.audio !== null) {\n event.tracks.push({\n timelineStartInfo: {\n baseMediaDecodeTime: 0\n },\n id: +programMapTable.audio,\n codec: 'adts',\n type: 'audio'\n });\n }\n\n segmentHadPmt = true;\n self.trigger('data', event);\n }\n })[data.type]();\n };\n\n this.reset = function () {\n video.size = 0;\n video.data.length = 0;\n audio.size = 0;\n audio.data.length = 0;\n this.trigger('reset');\n };\n /**\n * Flush any remaining input. Video PES packets may be of variable\n * length. Normally, the start of a new video packet can trigger the\n * finalization of the previous packet. That is not possible if no\n * more video is forthcoming, however. In that case, some other\n * mechanism (like the end of the file) has to be employed. When it is\n * clear that no additional data is forthcoming, calling this method\n * will flush the buffered packets.\n */\n\n\n this.flushStreams_ = function () {\n // !!THIS ORDER IS IMPORTANT!!\n // video first then audio\n flushStream(video, 'video');\n flushStream(audio, 'audio');\n flushStream(timedMetadata, 'timed-metadata');\n };\n\n this.flush = function () {\n // if on flush we haven't had a pmt emitted\n // and we have a pmt to emit. emit the pmt\n // so that we trigger a trackinfo downstream.\n if (!segmentHadPmt && programMapTable) {\n var pmt = {\n type: 'metadata',\n tracks: []\n }; // translate audio and video streams to tracks\n\n if (programMapTable.video !== null) {\n pmt.tracks.push({\n timelineStartInfo: {\n baseMediaDecodeTime: 0\n },\n id: +programMapTable.video,\n codec: 'avc',\n type: 'video'\n });\n }\n\n if (programMapTable.audio !== null) {\n pmt.tracks.push({\n timelineStartInfo: {\n baseMediaDecodeTime: 0\n },\n id: +programMapTable.audio,\n codec: 'adts',\n type: 'audio'\n });\n }\n\n self.trigger('data', pmt);\n }\n\n segmentHadPmt = false;\n this.flushStreams_();\n this.trigger('done');\n };\n };\n\n _ElementaryStream.prototype = new stream();\n var m2ts$1 = {\n PAT_PID: 0x0000,\n MP2T_PACKET_LENGTH: MP2T_PACKET_LENGTH$1,\n TransportPacketStream: _TransportPacketStream,\n TransportParseStream: _TransportParseStream,\n ElementaryStream: _ElementaryStream,\n TimestampRolloverStream: TimestampRolloverStream,\n CaptionStream: captionStream.CaptionStream,\n Cea608Stream: captionStream.Cea608Stream,\n Cea708Stream: captionStream.Cea708Stream,\n MetadataStream: metadataStream\n };\n\n for (var type in streamTypes) {\n if (streamTypes.hasOwnProperty(type)) {\n m2ts$1[type] = streamTypes[type];\n }\n }\n\n var m2ts_1 = m2ts$1;\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n *\n * Utilities to detect basic properties and metadata about Aac data.\n */\n\n var ADTS_SAMPLING_FREQUENCIES = [96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, 7350];\n\n var parseId3TagSize = function parseId3TagSize(header, byteIndex) {\n var returnSize = header[byteIndex + 6] << 21 | header[byteIndex + 7] << 14 | header[byteIndex + 8] << 7 | header[byteIndex + 9],\n flags = header[byteIndex + 5],\n footerPresent = (flags & 16) >> 4; // if we get a negative returnSize clamp it to 0\n\n returnSize = returnSize >= 0 ? returnSize : 0;\n\n if (footerPresent) {\n return returnSize + 20;\n }\n\n return returnSize + 10;\n };\n\n var getId3Offset = function getId3Offset(data, offset) {\n if (data.length - offset < 10 || data[offset] !== 'I'.charCodeAt(0) || data[offset + 1] !== 'D'.charCodeAt(0) || data[offset + 2] !== '3'.charCodeAt(0)) {\n return offset;\n }\n\n offset += parseId3TagSize(data, offset);\n return getId3Offset(data, offset);\n }; // TODO: use vhs-utils\n\n\n var isLikelyAacData$2 = function isLikelyAacData(data) {\n var offset = getId3Offset(data, 0);\n return data.length >= offset + 2 && (data[offset] & 0xFF) === 0xFF && (data[offset + 1] & 0xF0) === 0xF0 && // verify that the 2 layer bits are 0, aka this\n // is not mp3 data but aac data.\n (data[offset + 1] & 0x16) === 0x10;\n };\n\n var parseSyncSafeInteger = function parseSyncSafeInteger(data) {\n return data[0] << 21 | data[1] << 14 | data[2] << 7 | data[3];\n }; // return a percent-encoded representation of the specified byte range\n // @see http://en.wikipedia.org/wiki/Percent-encoding\n\n\n var percentEncode = function percentEncode(bytes, start, end) {\n var i,\n result = '';\n\n for (i = start; i < end; i++) {\n result += '%' + ('00' + bytes[i].toString(16)).slice(-2);\n }\n\n return result;\n }; // return the string representation of the specified byte range,\n // interpreted as ISO-8859-1.\n\n\n var parseIso88591 = function parseIso88591(bytes, start, end) {\n return unescape(percentEncode(bytes, start, end)); // jshint ignore:line\n };\n\n var parseAdtsSize = function parseAdtsSize(header, byteIndex) {\n var lowThree = (header[byteIndex + 5] & 0xE0) >> 5,\n middle = header[byteIndex + 4] << 3,\n highTwo = header[byteIndex + 3] & 0x3 << 11;\n return highTwo | middle | lowThree;\n };\n\n var parseType$1 = function parseType(header, byteIndex) {\n if (header[byteIndex] === 'I'.charCodeAt(0) && header[byteIndex + 1] === 'D'.charCodeAt(0) && header[byteIndex + 2] === '3'.charCodeAt(0)) {\n return 'timed-metadata';\n } else if (header[byteIndex] & 0xff === 0xff && (header[byteIndex + 1] & 0xf0) === 0xf0) {\n return 'audio';\n }\n\n return null;\n };\n\n var parseSampleRate = function parseSampleRate(packet) {\n var i = 0;\n\n while (i + 5 < packet.length) {\n if (packet[i] !== 0xFF || (packet[i + 1] & 0xF6) !== 0xF0) {\n // If a valid header was not found, jump one forward and attempt to\n // find a valid ADTS header starting at the next byte\n i++;\n continue;\n }\n\n return ADTS_SAMPLING_FREQUENCIES[(packet[i + 2] & 0x3c) >>> 2];\n }\n\n return null;\n };\n\n var parseAacTimestamp = function parseAacTimestamp(packet) {\n var frameStart, frameSize, frame, frameHeader; // find the start of the first frame and the end of the tag\n\n frameStart = 10;\n\n if (packet[5] & 0x40) {\n // advance the frame start past the extended header\n frameStart += 4; // header size field\n\n frameStart += parseSyncSafeInteger(packet.subarray(10, 14));\n } // parse one or more ID3 frames\n // http://id3.org/id3v2.3.0#ID3v2_frame_overview\n\n\n do {\n // determine the number of bytes in this frame\n frameSize = parseSyncSafeInteger(packet.subarray(frameStart + 4, frameStart + 8));\n\n if (frameSize < 1) {\n return null;\n }\n\n frameHeader = String.fromCharCode(packet[frameStart], packet[frameStart + 1], packet[frameStart + 2], packet[frameStart + 3]);\n\n if (frameHeader === 'PRIV') {\n frame = packet.subarray(frameStart + 10, frameStart + frameSize + 10);\n\n for (var i = 0; i < frame.byteLength; i++) {\n if (frame[i] === 0) {\n var owner = parseIso88591(frame, 0, i);\n\n if (owner === 'com.apple.streaming.transportStreamTimestamp') {\n var d = frame.subarray(i + 1);\n var size = (d[3] & 0x01) << 30 | d[4] << 22 | d[5] << 14 | d[6] << 6 | d[7] >>> 2;\n size *= 4;\n size += d[7] & 0x03;\n return size;\n }\n\n break;\n }\n }\n }\n\n frameStart += 10; // advance past the frame header\n\n frameStart += frameSize; // advance past the frame body\n } while (frameStart < packet.byteLength);\n\n return null;\n };\n\n var utils = {\n isLikelyAacData: isLikelyAacData$2,\n parseId3TagSize: parseId3TagSize,\n parseAdtsSize: parseAdtsSize,\n parseType: parseType$1,\n parseSampleRate: parseSampleRate,\n parseAacTimestamp: parseAacTimestamp\n };\n\n var _AacStream;\n /**\n * Splits an incoming stream of binary data into ADTS and ID3 Frames.\n */\n\n\n _AacStream = function AacStream() {\n var everything = new Uint8Array(),\n timeStamp = 0;\n\n _AacStream.prototype.init.call(this);\n\n this.setTimestamp = function (timestamp) {\n timeStamp = timestamp;\n };\n\n this.push = function (bytes) {\n var frameSize = 0,\n byteIndex = 0,\n bytesLeft,\n chunk,\n packet,\n tempLength; // If there are bytes remaining from the last segment, prepend them to the\n // bytes that were pushed in\n\n if (everything.length) {\n tempLength = everything.length;\n everything = new Uint8Array(bytes.byteLength + tempLength);\n everything.set(everything.subarray(0, tempLength));\n everything.set(bytes, tempLength);\n } else {\n everything = bytes;\n }\n\n while (everything.length - byteIndex >= 3) {\n if (everything[byteIndex] === 'I'.charCodeAt(0) && everything[byteIndex + 1] === 'D'.charCodeAt(0) && everything[byteIndex + 2] === '3'.charCodeAt(0)) {\n // Exit early because we don't have enough to parse\n // the ID3 tag header\n if (everything.length - byteIndex < 10) {\n break;\n } // check framesize\n\n\n frameSize = utils.parseId3TagSize(everything, byteIndex); // Exit early if we don't have enough in the buffer\n // to emit a full packet\n // Add to byteIndex to support multiple ID3 tags in sequence\n\n if (byteIndex + frameSize > everything.length) {\n break;\n }\n\n chunk = {\n type: 'timed-metadata',\n data: everything.subarray(byteIndex, byteIndex + frameSize)\n };\n this.trigger('data', chunk);\n byteIndex += frameSize;\n continue;\n } else if ((everything[byteIndex] & 0xff) === 0xff && (everything[byteIndex + 1] & 0xf0) === 0xf0) {\n // Exit early because we don't have enough to parse\n // the ADTS frame header\n if (everything.length - byteIndex < 7) {\n break;\n }\n\n frameSize = utils.parseAdtsSize(everything, byteIndex); // Exit early if we don't have enough in the buffer\n // to emit a full packet\n\n if (byteIndex + frameSize > everything.length) {\n break;\n }\n\n packet = {\n type: 'audio',\n data: everything.subarray(byteIndex, byteIndex + frameSize),\n pts: timeStamp,\n dts: timeStamp\n };\n this.trigger('data', packet);\n byteIndex += frameSize;\n continue;\n }\n\n byteIndex++;\n }\n\n bytesLeft = everything.length - byteIndex;\n\n if (bytesLeft > 0) {\n everything = everything.subarray(byteIndex);\n } else {\n everything = new Uint8Array();\n }\n };\n\n this.reset = function () {\n everything = new Uint8Array();\n this.trigger('reset');\n };\n\n this.endTimeline = function () {\n everything = new Uint8Array();\n this.trigger('endedtimeline');\n };\n };\n\n _AacStream.prototype = new stream();\n var aac = _AacStream;\n\n // constants\n var AUDIO_PROPERTIES = ['audioobjecttype', 'channelcount', 'samplerate', 'samplingfrequencyindex', 'samplesize'];\n var audioProperties = AUDIO_PROPERTIES;\n\n var VIDEO_PROPERTIES = ['width', 'height', 'profileIdc', 'levelIdc', 'profileCompatibility', 'sarRatio'];\n var videoProperties = VIDEO_PROPERTIES;\n\n var H264Stream$1 = h264.H264Stream;\n var isLikelyAacData$1 = utils.isLikelyAacData;\n var ONE_SECOND_IN_TS$2 = clock.ONE_SECOND_IN_TS; // object types\n\n var _VideoSegmentStream$1, _AudioSegmentStream$1, _Transmuxer$1, _CoalesceStream;\n /**\n * Compare two arrays (even typed) for same-ness\n */\n\n\n var arrayEquals = function arrayEquals(a, b) {\n var i;\n\n if (a.length !== b.length) {\n return false;\n } // compare the value of each element in the array\n\n\n for (i = 0; i < a.length; i++) {\n if (a[i] !== b[i]) {\n return false;\n }\n }\n\n return true;\n };\n\n var generateSegmentTimingInfo = function generateSegmentTimingInfo(baseMediaDecodeTime, startDts, startPts, endDts, endPts, prependedContentDuration) {\n var ptsOffsetFromDts = startPts - startDts,\n decodeDuration = endDts - startDts,\n presentationDuration = endPts - startPts; // The PTS and DTS values are based on the actual stream times from the segment,\n // however, the player time values will reflect a start from the baseMediaDecodeTime.\n // In order to provide relevant values for the player times, base timing info on the\n // baseMediaDecodeTime and the DTS and PTS durations of the segment.\n\n return {\n start: {\n dts: baseMediaDecodeTime,\n pts: baseMediaDecodeTime + ptsOffsetFromDts\n },\n end: {\n dts: baseMediaDecodeTime + decodeDuration,\n pts: baseMediaDecodeTime + presentationDuration\n },\n prependedContentDuration: prependedContentDuration,\n baseMediaDecodeTime: baseMediaDecodeTime\n };\n };\n /**\n * Constructs a single-track, ISO BMFF media segment from AAC data\n * events. The output of this stream can be fed to a SourceBuffer\n * configured with a suitable initialization segment.\n * @param track {object} track metadata configuration\n * @param options {object} transmuxer options object\n * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps\n * in the source; false to adjust the first segment to start at 0.\n */\n\n\n _AudioSegmentStream$1 = function AudioSegmentStream(track, options) {\n var adtsFrames = [],\n sequenceNumber = 0,\n earliestAllowedDts = 0,\n audioAppendStartTs = 0,\n videoBaseMediaDecodeTime = Infinity;\n options = options || {};\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 = 0,\n nalUnits = [],\n gopsToAlignWith = [],\n config,\n pps;\n options = options || {};\n\n _VideoSegmentStream$1.prototype.init.call(this);\n\n delete track.minPTS;\n this.gopCache_ = [];\n /**\n * Constructs a ISO BMFF segment given H264 nalUnits\n * @param {Object} nalUnit A data event representing a nalUnit\n * @param {String} nalUnit.nalUnitType\n * @param {Object} nalUnit.config Properties for a mp4 track\n * @param {Uint8Array} nalUnit.data The nalUnit bytes\n * @see lib/codecs/h264.js\n **/\n\n this.push = function (nalUnit) {\n trackDecodeInfo.collectDtsInfo(track, nalUnit); // record the track config\n\n if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {\n config = nalUnit.config;\n track.sps = [nalUnit.data];\n videoProperties.forEach(function (prop) {\n track[prop] = config[prop];\n }, this);\n }\n\n if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {\n pps = nalUnit.data;\n track.pps = [nalUnit.data];\n } // buffer video until flush() is called\n\n\n nalUnits.push(nalUnit);\n };\n /**\n * Pass constructed ISO BMFF track and boxes on to the\n * next stream in the pipeline\n **/\n\n\n this.flush = function () {\n var frames,\n gopForFusion,\n gops,\n moof,\n mdat,\n boxes,\n prependedContentDuration = 0,\n firstGop,\n lastGop; // Throw away nalUnits at the start of the byte stream until\n // we find the first AUD\n\n while (nalUnits.length) {\n if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {\n break;\n }\n\n nalUnits.shift();\n } // Return early if no video data has been observed\n\n\n if (nalUnits.length === 0) {\n this.resetStream_();\n this.trigger('done', 'VideoSegmentStream');\n return;\n } // Organize the raw nal-units into arrays that represent\n // higher-level constructs such as frames and gops\n // (group-of-pictures)\n\n\n frames = frameUtils.groupNalsIntoFrames(nalUnits);\n gops = frameUtils.groupFramesIntoGops(frames); // If the first frame of this fragment is not a keyframe we have\n // a problem since MSE (on Chrome) requires a leading keyframe.\n //\n // We have two approaches to repairing this situation:\n // 1) GOP-FUSION:\n // This is where we keep track of the GOPS (group-of-pictures)\n // from previous fragments and attempt to find one that we can\n // prepend to the current fragment in order to create a valid\n // fragment.\n // 2) KEYFRAME-PULLING:\n // Here we search for the first keyframe in the fragment and\n // throw away all the frames between the start of the fragment\n // and that keyframe. We then extend the duration and pull the\n // PTS of the keyframe forward so that it covers the time range\n // of the frames that were disposed of.\n //\n // #1 is far prefereable over #2 which can cause \"stuttering\" but\n // requires more things to be just right.\n\n if (!gops[0][0].keyFrame) {\n // Search for a gop for fusion from our gopCache\n gopForFusion = this.getGopForFusion_(nalUnits[0], track);\n\n if (gopForFusion) {\n // in order to provide more accurate timing information about the segment, save\n // the number of seconds prepended to the original segment due to GOP fusion\n prependedContentDuration = gopForFusion.duration;\n gops.unshift(gopForFusion); // Adjust Gops' metadata to account for the inclusion of the\n // new gop at the beginning\n\n gops.byteLength += gopForFusion.byteLength;\n gops.nalCount += gopForFusion.nalCount;\n gops.pts = gopForFusion.pts;\n gops.dts = gopForFusion.dts;\n gops.duration += gopForFusion.duration;\n } else {\n // If we didn't find a candidate gop fall back to keyframe-pulling\n gops = frameUtils.extendFirstKeyFrame(gops);\n }\n } // Trim gops to align with gopsToAlignWith\n\n\n if (gopsToAlignWith.length) {\n var alignedGops;\n\n if (options.alignGopsAtEnd) {\n alignedGops = this.alignGopsAtEnd_(gops);\n } else {\n alignedGops = this.alignGopsAtStart_(gops);\n }\n\n if (!alignedGops) {\n // save all the nals in the last GOP into the gop cache\n this.gopCache_.unshift({\n gop: gops.pop(),\n pps: track.pps,\n sps: track.sps\n }); // Keep a maximum of 6 GOPs in the cache\n\n this.gopCache_.length = Math.min(6, this.gopCache_.length); // Clear nalUnits\n\n nalUnits = []; // return early no gops can be aligned with desired gopsToAlignWith\n\n this.resetStream_();\n this.trigger('done', 'VideoSegmentStream');\n return;\n } // Some gops were trimmed. clear dts info so minSegmentDts and pts are correct\n // when recalculated before sending off to CoalesceStream\n\n\n trackDecodeInfo.clearDtsInfo(track);\n gops = alignedGops;\n }\n\n trackDecodeInfo.collectDtsInfo(track, gops); // First, we have to build the index from byte locations to\n // samples (that is, frames) in the video data\n\n track.samples = frameUtils.generateSampleTable(gops); // Concatenate the video data and construct the mdat\n\n mdat = mp4Generator.mdat(frameUtils.concatenateNalData(gops));\n track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);\n this.trigger('processedGopsInfo', gops.map(function (gop) {\n return {\n pts: gop.pts,\n dts: gop.dts,\n byteLength: gop.byteLength\n };\n }));\n firstGop = gops[0];\n lastGop = gops[gops.length - 1];\n this.trigger('segmentTimingInfo', generateSegmentTimingInfo(track.baseMediaDecodeTime, firstGop.dts, firstGop.pts, lastGop.dts + lastGop.duration, lastGop.pts + lastGop.duration, prependedContentDuration));\n this.trigger('timingInfo', {\n start: gops[0].pts,\n end: gops[gops.length - 1].pts + gops[gops.length - 1].duration\n }); // save all the nals in the last GOP into the gop cache\n\n this.gopCache_.unshift({\n gop: gops.pop(),\n pps: track.pps,\n sps: track.sps\n }); // Keep a maximum of 6 GOPs in the cache\n\n this.gopCache_.length = Math.min(6, this.gopCache_.length); // Clear nalUnits\n\n nalUnits = [];\n this.trigger('baseMediaDecodeTime', track.baseMediaDecodeTime);\n this.trigger('timelineStartInfo', track.timelineStartInfo);\n moof = mp4Generator.moof(sequenceNumber, [track]); // it would be great to allocate this array up front instead of\n // throwing away hundreds of media segment fragments\n\n boxes = new Uint8Array(moof.byteLength + mdat.byteLength); // Bump the sequence number for next time\n\n sequenceNumber++;\n boxes.set(moof);\n boxes.set(mdat, moof.byteLength);\n this.trigger('data', {\n track: track,\n boxes: boxes\n });\n this.resetStream_(); // Continue with the flush process now\n\n this.trigger('done', 'VideoSegmentStream');\n };\n\n this.reset = function () {\n this.resetStream_();\n nalUnits = [];\n this.gopCache_.length = 0;\n gopsToAlignWith.length = 0;\n this.trigger('reset');\n };\n\n this.resetStream_ = function () {\n trackDecodeInfo.clearDtsInfo(track); // reset config and pps because they may differ across segments\n // for instance, when we are rendition switching\n\n config = undefined;\n pps = undefined;\n }; // Search for a candidate Gop for gop-fusion from the gop cache and\n // return it or return null if no good candidate was found\n\n\n this.getGopForFusion_ = function (nalUnit) {\n var halfSecond = 45000,\n // Half-a-second in a 90khz clock\n allowableOverlap = 10000,\n // About 3 frames @ 30fps\n nearestDistance = Infinity,\n dtsDistance,\n nearestGopObj,\n currentGop,\n currentGopObj,\n i; // Search for the GOP nearest to the beginning of this nal unit\n\n for (i = 0; i < this.gopCache_.length; i++) {\n currentGopObj = this.gopCache_[i];\n currentGop = currentGopObj.gop; // Reject Gops with different SPS or PPS\n\n if (!(track.pps && arrayEquals(track.pps[0], currentGopObj.pps[0])) || !(track.sps && arrayEquals(track.sps[0], currentGopObj.sps[0]))) {\n continue;\n } // Reject Gops that would require a negative baseMediaDecodeTime\n\n\n if (currentGop.dts < track.timelineStartInfo.dts) {\n continue;\n } // The distance between the end of the gop and the start of the nalUnit\n\n\n dtsDistance = nalUnit.dts - currentGop.dts - currentGop.duration; // Only consider GOPS that start before the nal unit and end within\n // a half-second of the nal unit\n\n if (dtsDistance >= -allowableOverlap && dtsDistance <= halfSecond) {\n // Always use the closest GOP we found if there is more than\n // one candidate\n if (!nearestGopObj || nearestDistance > dtsDistance) {\n nearestGopObj = currentGopObj;\n nearestDistance = dtsDistance;\n }\n }\n }\n\n if (nearestGopObj) {\n return nearestGopObj.gop;\n }\n\n return null;\n }; // trim gop list to the first gop found that has a matching pts with a gop in the list\n // of gopsToAlignWith starting from the START of the list\n\n\n this.alignGopsAtStart_ = function (gops) {\n var alignIndex, gopIndex, align, gop, byteLength, nalCount, duration, alignedGops;\n byteLength = gops.byteLength;\n nalCount = gops.nalCount;\n duration = gops.duration;\n alignIndex = gopIndex = 0;\n\n while (alignIndex < gopsToAlignWith.length && gopIndex < gops.length) {\n align = gopsToAlignWith[alignIndex];\n gop = gops[gopIndex];\n\n if (align.pts === gop.pts) {\n break;\n }\n\n if (gop.pts > align.pts) {\n // this current gop starts after the current gop we want to align on, so increment\n // align index\n alignIndex++;\n continue;\n } // current gop starts before the current gop we want to align on. so increment gop\n // index\n\n\n gopIndex++;\n byteLength -= gop.byteLength;\n nalCount -= gop.nalCount;\n duration -= gop.duration;\n }\n\n if (gopIndex === 0) {\n // no gops to trim\n return gops;\n }\n\n if (gopIndex === gops.length) {\n // all gops trimmed, skip appending all gops\n return null;\n }\n\n alignedGops = gops.slice(gopIndex);\n alignedGops.byteLength = byteLength;\n alignedGops.duration = duration;\n alignedGops.nalCount = nalCount;\n alignedGops.pts = alignedGops[0].pts;\n alignedGops.dts = alignedGops[0].dts;\n return alignedGops;\n }; // trim gop list to the first gop found that has a matching pts with a gop in the list\n // of gopsToAlignWith starting from the END of the list\n\n\n this.alignGopsAtEnd_ = function (gops) {\n var alignIndex, gopIndex, align, gop, alignEndIndex, matchFound;\n alignIndex = gopsToAlignWith.length - 1;\n gopIndex = gops.length - 1;\n alignEndIndex = null;\n matchFound = false;\n\n while (alignIndex >= 0 && gopIndex >= 0) {\n align = gopsToAlignWith[alignIndex];\n gop = gops[gopIndex];\n\n if (align.pts === gop.pts) {\n matchFound = true;\n break;\n }\n\n if (align.pts > gop.pts) {\n alignIndex--;\n continue;\n }\n\n if (alignIndex === gopsToAlignWith.length - 1) {\n // gop.pts is greater than the last alignment candidate. If no match is found\n // by the end of this loop, we still want to append gops that come after this\n // point\n alignEndIndex = gopIndex;\n }\n\n gopIndex--;\n }\n\n if (!matchFound && alignEndIndex === null) {\n return null;\n }\n\n var trimIndex;\n\n if (matchFound) {\n trimIndex = gopIndex;\n } else {\n trimIndex = alignEndIndex;\n }\n\n if (trimIndex === 0) {\n return gops;\n }\n\n var alignedGops = gops.slice(trimIndex);\n var metadata = alignedGops.reduce(function (total, gop) {\n total.byteLength += gop.byteLength;\n total.duration += gop.duration;\n total.nalCount += gop.nalCount;\n return total;\n }, {\n byteLength: 0,\n duration: 0,\n nalCount: 0\n });\n alignedGops.byteLength = metadata.byteLength;\n alignedGops.duration = metadata.duration;\n alignedGops.nalCount = metadata.nalCount;\n alignedGops.pts = alignedGops[0].pts;\n alignedGops.dts = alignedGops[0].dts;\n return alignedGops;\n };\n\n this.alignGopsWith = function (newGopsToAlignWith) {\n gopsToAlignWith = newGopsToAlignWith;\n };\n };\n\n _VideoSegmentStream$1.prototype = new stream();\n /**\n * A Stream that can combine multiple streams (ie. audio & video)\n * into a single output segment for MSE. Also supports audio-only\n * and video-only streams.\n * @param options {object} transmuxer options object\n * @param options.keepOriginalTimestamps {boolean} If true, keep the timestamps\n * in the source; false to adjust the first segment to start at media timeline start.\n */\n\n _CoalesceStream = function CoalesceStream(options, metadataStream) {\n // Number of Tracks per output segment\n // If greater than 1, we combine multiple\n // tracks into a single segment\n this.numberOfTracks = 0;\n this.metadataStream = metadataStream;\n options = options || {};\n\n if (typeof options.remux !== 'undefined') {\n this.remuxTracks = !!options.remux;\n } else {\n this.remuxTracks = true;\n }\n\n if (typeof options.keepOriginalTimestamps === 'boolean') {\n this.keepOriginalTimestamps = options.keepOriginalTimestamps;\n } else {\n this.keepOriginalTimestamps = false;\n }\n\n this.pendingTracks = [];\n this.videoTrack = null;\n this.pendingBoxes = [];\n this.pendingCaptions = [];\n this.pendingMetadata = [];\n this.pendingBytes = 0;\n this.emittedTracks = 0;\n\n _CoalesceStream.prototype.init.call(this); // Take output from multiple\n\n\n this.push = function (output) {\n // buffer incoming captions until the associated video segment\n // finishes\n if (output.text) {\n return this.pendingCaptions.push(output);\n } // buffer incoming id3 tags until the final flush\n\n\n if (output.frames) {\n return this.pendingMetadata.push(output);\n } // Add this track to the list of pending tracks and store\n // important information required for the construction of\n // the final segment\n\n\n this.pendingTracks.push(output.track);\n this.pendingBytes += output.boxes.byteLength; // TODO: is there an issue for this against chrome?\n // We unshift audio and push video because\n // as of Chrome 75 when switching from\n // one init segment to another if the video\n // mdat does not appear after the audio mdat\n // only audio will play for the duration of our transmux.\n\n if (output.track.type === 'video') {\n this.videoTrack = output.track;\n this.pendingBoxes.push(output.boxes);\n }\n\n if (output.track.type === 'audio') {\n this.audioTrack = output.track;\n this.pendingBoxes.unshift(output.boxes);\n }\n };\n };\n\n _CoalesceStream.prototype = new stream();\n\n _CoalesceStream.prototype.flush = function (flushSource) {\n var offset = 0,\n event = {\n captions: [],\n captionStreams: {},\n metadata: [],\n info: {}\n },\n caption,\n id3,\n initSegment,\n timelineStartPts = 0,\n i;\n\n if (this.pendingTracks.length < this.numberOfTracks) {\n if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {\n // Return because we haven't received a flush from a data-generating\n // portion of the segment (meaning that we have only recieved meta-data\n // or captions.)\n return;\n } else if (this.remuxTracks) {\n // Return until we have enough tracks from the pipeline to remux (if we\n // are remuxing audio and video into a single MP4)\n return;\n } else if (this.pendingTracks.length === 0) {\n // In the case where we receive a flush without any data having been\n // received we consider it an emitted track for the purposes of coalescing\n // `done` events.\n // We do this for the case where there is an audio and video track in the\n // segment but no audio data. (seen in several playlists with alternate\n // audio tracks and no audio present in the main TS segments.)\n this.emittedTracks++;\n\n if (this.emittedTracks >= this.numberOfTracks) {\n this.trigger('done');\n this.emittedTracks = 0;\n }\n\n return;\n }\n }\n\n if (this.videoTrack) {\n timelineStartPts = this.videoTrack.timelineStartInfo.pts;\n videoProperties.forEach(function (prop) {\n event.info[prop] = this.videoTrack[prop];\n }, this);\n } else if (this.audioTrack) {\n timelineStartPts = this.audioTrack.timelineStartInfo.pts;\n audioProperties.forEach(function (prop) {\n event.info[prop] = this.audioTrack[prop];\n }, this);\n }\n\n if (this.videoTrack || this.audioTrack) {\n if (this.pendingTracks.length === 1) {\n event.type = this.pendingTracks[0].type;\n } else {\n event.type = 'combined';\n }\n\n this.emittedTracks += this.pendingTracks.length;\n initSegment = mp4Generator.initSegment(this.pendingTracks); // Create a new typed array to hold the init segment\n\n event.initSegment = new Uint8Array(initSegment.byteLength); // Create an init segment containing a moov\n // and track definitions\n\n event.initSegment.set(initSegment); // Create a new typed array to hold the moof+mdats\n\n event.data = new Uint8Array(this.pendingBytes); // Append each moof+mdat (one per track) together\n\n for (i = 0; i < this.pendingBoxes.length; i++) {\n event.data.set(this.pendingBoxes[i], offset);\n offset += this.pendingBoxes[i].byteLength;\n } // Translate caption PTS times into second offsets to match the\n // video timeline for the segment, and add track info\n\n\n for (i = 0; i < this.pendingCaptions.length; i++) {\n caption = this.pendingCaptions[i];\n caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, this.keepOriginalTimestamps);\n caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, this.keepOriginalTimestamps);\n event.captionStreams[caption.stream] = true;\n event.captions.push(caption);\n } // Translate ID3 frame PTS times into second offsets to match the\n // video timeline for the segment\n\n\n for (i = 0; i < this.pendingMetadata.length; i++) {\n id3 = this.pendingMetadata[i];\n id3.cueTime = clock.metadataTsToSeconds(id3.pts, timelineStartPts, this.keepOriginalTimestamps);\n event.metadata.push(id3);\n } // We add this to every single emitted segment even though we only need\n // it for the first\n\n\n event.metadata.dispatchType = this.metadataStream.dispatchType; // Reset stream state\n\n this.pendingTracks.length = 0;\n this.videoTrack = null;\n this.pendingBoxes.length = 0;\n this.pendingCaptions.length = 0;\n this.pendingBytes = 0;\n this.pendingMetadata.length = 0; // Emit the built segment\n // We include captions and ID3 tags for backwards compatibility,\n // ideally we should send only video and audio in the data event\n\n this.trigger('data', event); // Emit each caption to the outside world\n // Ideally, this would happen immediately on parsing captions,\n // but we need to ensure that video data is sent back first\n // so that caption timing can be adjusted to match video timing\n\n for (i = 0; i < event.captions.length; i++) {\n caption = event.captions[i];\n this.trigger('caption', caption);\n } // Emit each id3 tag to the outside world\n // Ideally, this would happen immediately on parsing the tag,\n // but we need to ensure that video data is sent back first\n // so that ID3 frame timing can be adjusted to match video timing\n\n\n for (i = 0; i < event.metadata.length; i++) {\n id3 = event.metadata[i];\n this.trigger('id3Frame', id3);\n }\n } // Only emit `done` if all tracks have been flushed and emitted\n\n\n if (this.emittedTracks >= this.numberOfTracks) {\n this.trigger('done');\n this.emittedTracks = 0;\n }\n };\n\n _CoalesceStream.prototype.setRemux = function (val) {\n this.remuxTracks = val;\n };\n /**\n * A Stream that expects MP2T binary data as input and produces\n * corresponding media segments, suitable for use with Media Source\n * Extension (MSE) implementations that support the ISO BMFF byte\n * stream format, like Chrome.\n */\n\n\n _Transmuxer$1 = function Transmuxer(options) {\n var self = this,\n hasFlushed = true,\n videoTrack,\n audioTrack;\n\n _Transmuxer$1.prototype.init.call(this);\n\n options = options || {};\n this.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;\n this.transmuxPipeline_ = {};\n\n this.setupAacPipeline = function () {\n var pipeline = {};\n this.transmuxPipeline_ = pipeline;\n pipeline.type = 'aac';\n pipeline.metadataStream = new m2ts_1.MetadataStream(); // set up the parsing pipeline\n\n pipeline.aacStream = new aac();\n pipeline.audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');\n pipeline.timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');\n pipeline.adtsStream = new adts();\n pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);\n pipeline.headOfPipeline = pipeline.aacStream;\n pipeline.aacStream.pipe(pipeline.audioTimestampRolloverStream).pipe(pipeline.adtsStream);\n pipeline.aacStream.pipe(pipeline.timedMetadataTimestampRolloverStream).pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream);\n pipeline.metadataStream.on('timestamp', function (frame) {\n pipeline.aacStream.setTimestamp(frame.timeStamp);\n });\n pipeline.aacStream.on('data', function (data) {\n if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {\n return;\n }\n\n audioTrack = audioTrack || {\n timelineStartInfo: {\n baseMediaDecodeTime: self.baseMediaDecodeTime\n },\n codec: 'adts',\n type: 'audio'\n }; // hook up the audio segment stream to the first track with aac data\n\n pipeline.coalesceStream.numberOfTracks++;\n pipeline.audioSegmentStream = new _AudioSegmentStream$1(audioTrack, options);\n pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));\n pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo')); // Set up the final part of the audio pipeline\n\n pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream); // emit pmt info\n\n self.trigger('trackinfo', {\n hasAudio: !!audioTrack,\n hasVideo: !!videoTrack\n });\n }); // Re-emit any data coming from the coalesce stream to the outside world\n\n pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data')); // Let the consumer know we have finished flushing the entire pipeline\n\n pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));\n };\n\n this.setupTsPipeline = function () {\n var pipeline = {};\n this.transmuxPipeline_ = pipeline;\n pipeline.type = 'ts';\n pipeline.metadataStream = new m2ts_1.MetadataStream(); // set up the parsing pipeline\n\n pipeline.packetStream = new m2ts_1.TransportPacketStream();\n pipeline.parseStream = new m2ts_1.TransportParseStream();\n pipeline.elementaryStream = new m2ts_1.ElementaryStream();\n pipeline.timestampRolloverStream = new m2ts_1.TimestampRolloverStream();\n pipeline.adtsStream = new adts();\n pipeline.h264Stream = new H264Stream$1();\n pipeline.captionStream = new m2ts_1.CaptionStream(options);\n pipeline.coalesceStream = new _CoalesceStream(options, pipeline.metadataStream);\n pipeline.headOfPipeline = pipeline.packetStream; // disassemble MPEG2-TS packets into elementary streams\n\n pipeline.packetStream.pipe(pipeline.parseStream).pipe(pipeline.elementaryStream).pipe(pipeline.timestampRolloverStream); // !!THIS ORDER IS IMPORTANT!!\n // demux the streams\n\n pipeline.timestampRolloverStream.pipe(pipeline.h264Stream);\n pipeline.timestampRolloverStream.pipe(pipeline.adtsStream);\n pipeline.timestampRolloverStream.pipe(pipeline.metadataStream).pipe(pipeline.coalesceStream); // Hook up CEA-608/708 caption stream\n\n pipeline.h264Stream.pipe(pipeline.captionStream).pipe(pipeline.coalesceStream);\n pipeline.elementaryStream.on('data', function (data) {\n var i;\n\n if (data.type === 'metadata') {\n i = data.tracks.length; // scan the tracks listed in the metadata\n\n while (i--) {\n if (!videoTrack && data.tracks[i].type === 'video') {\n videoTrack = data.tracks[i];\n videoTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;\n } else if (!audioTrack && data.tracks[i].type === 'audio') {\n audioTrack = data.tracks[i];\n audioTrack.timelineStartInfo.baseMediaDecodeTime = self.baseMediaDecodeTime;\n }\n } // hook up the video segment stream to the first track with h264 data\n\n\n if (videoTrack && !pipeline.videoSegmentStream) {\n pipeline.coalesceStream.numberOfTracks++;\n pipeline.videoSegmentStream = new _VideoSegmentStream$1(videoTrack, options);\n pipeline.videoSegmentStream.on('log', self.getLogTrigger_('videoSegmentStream'));\n pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {\n // When video emits timelineStartInfo data after a flush, we forward that\n // info to the AudioSegmentStream, if it exists, because video timeline\n // data takes precedence. Do not do this if keepOriginalTimestamps is set,\n // because this is a particularly subtle form of timestamp alteration.\n if (audioTrack && !options.keepOriginalTimestamps) {\n audioTrack.timelineStartInfo = timelineStartInfo; // On the first segment we trim AAC frames that exist before the\n // very earliest DTS we have seen in video because Chrome will\n // interpret any video track with a baseMediaDecodeTime that is\n // non-zero as a gap.\n\n pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - self.baseMediaDecodeTime);\n }\n });\n pipeline.videoSegmentStream.on('processedGopsInfo', self.trigger.bind(self, 'gopInfo'));\n pipeline.videoSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'videoSegmentTimingInfo'));\n pipeline.videoSegmentStream.on('baseMediaDecodeTime', function (baseMediaDecodeTime) {\n if (audioTrack) {\n pipeline.audioSegmentStream.setVideoBaseMediaDecodeTime(baseMediaDecodeTime);\n }\n });\n pipeline.videoSegmentStream.on('timingInfo', self.trigger.bind(self, 'videoTimingInfo')); // Set up the final part of the video pipeline\n\n pipeline.h264Stream.pipe(pipeline.videoSegmentStream).pipe(pipeline.coalesceStream);\n }\n\n if (audioTrack && !pipeline.audioSegmentStream) {\n // hook up the audio segment stream to the first track with aac data\n pipeline.coalesceStream.numberOfTracks++;\n pipeline.audioSegmentStream = new _AudioSegmentStream$1(audioTrack, options);\n pipeline.audioSegmentStream.on('log', self.getLogTrigger_('audioSegmentStream'));\n pipeline.audioSegmentStream.on('timingInfo', self.trigger.bind(self, 'audioTimingInfo'));\n pipeline.audioSegmentStream.on('segmentTimingInfo', self.trigger.bind(self, 'audioSegmentTimingInfo')); // Set up the final part of the audio pipeline\n\n pipeline.adtsStream.pipe(pipeline.audioSegmentStream).pipe(pipeline.coalesceStream);\n } // emit pmt info\n\n\n self.trigger('trackinfo', {\n hasAudio: !!audioTrack,\n hasVideo: !!videoTrack\n });\n }\n }); // Re-emit any data coming from the coalesce stream to the outside world\n\n pipeline.coalesceStream.on('data', this.trigger.bind(this, 'data'));\n pipeline.coalesceStream.on('id3Frame', function (id3Frame) {\n id3Frame.dispatchType = pipeline.metadataStream.dispatchType;\n self.trigger('id3Frame', id3Frame);\n });\n pipeline.coalesceStream.on('caption', this.trigger.bind(this, 'caption')); // Let the consumer know we have finished flushing the entire pipeline\n\n pipeline.coalesceStream.on('done', this.trigger.bind(this, 'done'));\n }; // hook up the segment streams once track metadata is delivered\n\n\n this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {\n var pipeline = this.transmuxPipeline_;\n\n if (!options.keepOriginalTimestamps) {\n this.baseMediaDecodeTime = baseMediaDecodeTime;\n }\n\n if (audioTrack) {\n audioTrack.timelineStartInfo.dts = undefined;\n audioTrack.timelineStartInfo.pts = undefined;\n trackDecodeInfo.clearDtsInfo(audioTrack);\n\n if (pipeline.audioTimestampRolloverStream) {\n pipeline.audioTimestampRolloverStream.discontinuity();\n }\n }\n\n if (videoTrack) {\n if (pipeline.videoSegmentStream) {\n pipeline.videoSegmentStream.gopCache_ = [];\n }\n\n videoTrack.timelineStartInfo.dts = undefined;\n videoTrack.timelineStartInfo.pts = undefined;\n trackDecodeInfo.clearDtsInfo(videoTrack);\n pipeline.captionStream.reset();\n }\n\n if (pipeline.timestampRolloverStream) {\n pipeline.timestampRolloverStream.discontinuity();\n }\n };\n\n this.setAudioAppendStart = function (timestamp) {\n if (audioTrack) {\n this.transmuxPipeline_.audioSegmentStream.setAudioAppendStart(timestamp);\n }\n };\n\n this.setRemux = function (val) {\n var pipeline = this.transmuxPipeline_;\n options.remux = val;\n\n if (pipeline && pipeline.coalesceStream) {\n pipeline.coalesceStream.setRemux(val);\n }\n };\n\n this.alignGopsWith = function (gopsToAlignWith) {\n if (videoTrack && this.transmuxPipeline_.videoSegmentStream) {\n this.transmuxPipeline_.videoSegmentStream.alignGopsWith(gopsToAlignWith);\n }\n };\n\n this.getLogTrigger_ = function (key) {\n var self = this;\n return function (event) {\n event.stream = key;\n self.trigger('log', event);\n };\n }; // feed incoming data to the front of the parsing pipeline\n\n\n this.push = function (data) {\n if (hasFlushed) {\n var isAac = isLikelyAacData$1(data);\n\n if (isAac && this.transmuxPipeline_.type !== 'aac') {\n this.setupAacPipeline();\n } else if (!isAac && this.transmuxPipeline_.type !== 'ts') {\n this.setupTsPipeline();\n }\n\n if (this.transmuxPipeline_) {\n var keys = Object.keys(this.transmuxPipeline_);\n\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i]; // skip non-stream keys and headOfPipeline\n // which is just a duplicate\n\n if (key === 'headOfPipeline' || !this.transmuxPipeline_[key].on) {\n continue;\n }\n\n this.transmuxPipeline_[key].on('log', this.getLogTrigger_(key));\n }\n }\n\n hasFlushed = false;\n }\n\n this.transmuxPipeline_.headOfPipeline.push(data);\n }; // flush any buffered data\n\n\n this.flush = function () {\n hasFlushed = true; // Start at the top of the pipeline and flush all pending work\n\n this.transmuxPipeline_.headOfPipeline.flush();\n };\n\n this.endTimeline = function () {\n this.transmuxPipeline_.headOfPipeline.endTimeline();\n };\n\n this.reset = function () {\n if (this.transmuxPipeline_.headOfPipeline) {\n this.transmuxPipeline_.headOfPipeline.reset();\n }\n }; // Caption data has to be reset when seeking outside buffered range\n\n\n this.resetCaptions = function () {\n if (this.transmuxPipeline_.captionStream) {\n this.transmuxPipeline_.captionStream.reset();\n }\n };\n };\n\n _Transmuxer$1.prototype = new stream();\n var transmuxer$2 = {\n Transmuxer: _Transmuxer$1,\n VideoSegmentStream: _VideoSegmentStream$1,\n AudioSegmentStream: _AudioSegmentStream$1,\n AUDIO_PROPERTIES: audioProperties,\n VIDEO_PROPERTIES: videoProperties,\n // exported for testing\n generateSegmentTimingInfo: generateSegmentTimingInfo\n };\n\n var discardEmulationPreventionBytes = captionPacketParser.discardEmulationPreventionBytes;\n var CaptionStream = captionStream.CaptionStream;\n /**\n * Maps an offset in the mdat to a sample based on the the size of the samples.\n * Assumes that `parseSamples` has been called first.\n *\n * @param {Number} offset - The offset into the mdat\n * @param {Object[]} samples - An array of samples, parsed using `parseSamples`\n * @return {?Object} The matching sample, or null if no match was found.\n *\n * @see ISO-BMFF-12/2015, Section 8.8.8\n **/\n\n var mapToSample = function mapToSample(offset, samples) {\n var approximateOffset = offset;\n\n for (var i = 0; i < samples.length; i++) {\n var sample = samples[i];\n\n if (approximateOffset < sample.size) {\n return sample;\n }\n\n approximateOffset -= sample.size;\n }\n\n return null;\n };\n /**\n * Finds SEI nal units contained in a Media Data Box.\n * Assumes that `parseSamples` has been called first.\n *\n * @param {Uint8Array} avcStream - The bytes of the mdat\n * @param {Object[]} samples - The samples parsed out by `parseSamples`\n * @param {Number} trackId - The trackId of this video track\n * @return {Object[]} seiNals - the parsed SEI NALUs found.\n * The contents of the seiNal should match what is expected by\n * CaptionStream.push (nalUnitType, size, data, escapedRBSP, pts, dts)\n *\n * @see ISO-BMFF-12/2015, Section 8.1.1\n * @see Rec. ITU-T H.264, 7.3.2.3.1\n **/\n\n\n var findSeiNals = function findSeiNals(avcStream, samples, trackId) {\n var avcView = new DataView(avcStream.buffer, avcStream.byteOffset, avcStream.byteLength),\n result = {\n logs: [],\n seiNals: []\n },\n seiNal,\n i,\n length,\n lastMatchedSample;\n\n for (i = 0; i + 4 < avcStream.length; i += length) {\n length = avcView.getUint32(i);\n i += 4; // Bail if this doesn't appear to be an H264 stream\n\n if (length <= 0) {\n continue;\n }\n\n switch (avcStream[i] & 0x1F) {\n case 0x06:\n var data = avcStream.subarray(i + 1, i + 1 + length);\n var matchingSample = mapToSample(i, samples);\n seiNal = {\n nalUnitType: 'sei_rbsp',\n size: length,\n data: data,\n escapedRBSP: discardEmulationPreventionBytes(data),\n trackId: trackId\n };\n\n if (matchingSample) {\n seiNal.pts = matchingSample.pts;\n seiNal.dts = matchingSample.dts;\n lastMatchedSample = matchingSample;\n } else if (lastMatchedSample) {\n // If a matching sample cannot be found, use the last\n // sample's values as they should be as close as possible\n seiNal.pts = lastMatchedSample.pts;\n seiNal.dts = lastMatchedSample.dts;\n } else {\n result.logs.push({\n level: 'warn',\n message: 'We\\'ve encountered a nal unit without data at ' + i + ' for trackId ' + trackId + '. See mux.js#223.'\n });\n break;\n }\n\n result.seiNals.push(seiNal);\n break;\n }\n }\n\n return result;\n };\n /**\n * Parses sample information out of Track Run Boxes and calculates\n * the absolute presentation and decode timestamps of each sample.\n *\n * @param {Array} truns - The Trun Run boxes to be parsed\n * @param {Number} baseMediaDecodeTime - base media decode time from tfdt\n @see ISO-BMFF-12/2015, Section 8.8.12\n * @param {Object} tfhd - The parsed Track Fragment Header\n * @see inspect.parseTfhd\n * @return {Object[]} the parsed samples\n *\n * @see ISO-BMFF-12/2015, Section 8.8.8\n **/\n\n\n var parseSamples = function parseSamples(truns, baseMediaDecodeTime, tfhd) {\n var currentDts = baseMediaDecodeTime;\n var defaultSampleDuration = tfhd.defaultSampleDuration || 0;\n var defaultSampleSize = tfhd.defaultSampleSize || 0;\n var trackId = tfhd.trackId;\n var allSamples = [];\n truns.forEach(function (trun) {\n // Note: We currently do not parse the sample table as well\n // as the trun. It's possible some sources will require this.\n // moov > trak > mdia > minf > stbl\n var trackRun = parseTrun(trun);\n var samples = trackRun.samples;\n samples.forEach(function (sample) {\n if (sample.duration === undefined) {\n sample.duration = defaultSampleDuration;\n }\n\n if (sample.size === undefined) {\n sample.size = defaultSampleSize;\n }\n\n sample.trackId = trackId;\n sample.dts = currentDts;\n\n if (sample.compositionTimeOffset === undefined) {\n sample.compositionTimeOffset = 0;\n }\n\n sample.pts = currentDts + sample.compositionTimeOffset;\n currentDts += sample.duration;\n });\n allSamples = allSamples.concat(samples);\n });\n return allSamples;\n };\n /**\n * Parses out caption nals from an FMP4 segment's video tracks.\n *\n * @param {Uint8Array} segment - The bytes of a single segment\n * @param {Number} videoTrackId - The trackId of a video track in the segment\n * @return {Object.} 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.} timescales - The timescales found in the init segment\n * @see parseEmbeddedCaptions\n * @see m2ts/caption-stream.js\n **/\n\n\n this.parse = function (segment, videoTrackIds, timescales) {\n var parsedData;\n\n if (!this.isInitialized()) {\n return null; // This is not likely to be a video segment\n } else if (!videoTrackIds || !timescales) {\n return null;\n } else if (this.isNewInit(videoTrackIds, timescales)) {\n // Use the first video track only as there is no\n // mechanism to switch to other video tracks\n trackId = videoTrackIds[0];\n timescale = timescales[trackId]; // If an init segment has not been seen yet, hold onto segment\n // data until we have one.\n // the ISO-BMFF spec says that trackId can't be zero, but there's some broken content out there\n } else if (trackId === null || !timescale) {\n segmentCache.push(segment);\n return null;\n } // Now that a timescale and trackId is set, parse cached segments\n\n\n while (segmentCache.length > 0) {\n var cachedSegment = segmentCache.shift();\n this.parse(cachedSegment, videoTrackIds, timescales);\n }\n\n parsedData = parseEmbeddedCaptions(segment, trackId, timescale);\n\n if (parsedData && parsedData.logs) {\n parsedCaptions.logs = parsedCaptions.logs.concat(parsedData.logs);\n }\n\n if (parsedData === null || !parsedData.seiNals) {\n if (parsedCaptions.logs.length) {\n return {\n logs: parsedCaptions.logs,\n captions: [],\n captionStreams: []\n };\n }\n\n return null;\n }\n\n this.pushNals(parsedData.seiNals); // Force the parsed captions to be dispatched\n\n this.flushStream();\n return parsedCaptions;\n };\n /**\n * Pushes SEI NALUs onto CaptionStream\n * @param {Object[]} nals - A list of SEI nals parsed using `parseCaptionNals`\n * Assumes that `parseCaptionNals` has been called first\n * @see m2ts/caption-stream.js\n **/\n\n\n this.pushNals = function (nals) {\n if (!this.isInitialized() || !nals || nals.length === 0) {\n return null;\n }\n\n nals.forEach(function (nal) {\n captionStream.push(nal);\n });\n };\n /**\n * Flushes underlying CaptionStream to dispatch processed, displayable captions\n * @see m2ts/caption-stream.js\n **/\n\n\n this.flushStream = function () {\n if (!this.isInitialized()) {\n return null;\n }\n\n if (!parsingPartial) {\n captionStream.flush();\n } else {\n captionStream.partialFlush();\n }\n };\n /**\n * Reset caption buckets for new data\n **/\n\n\n this.clearParsedCaptions = function () {\n parsedCaptions.captions = [];\n parsedCaptions.captionStreams = {};\n parsedCaptions.logs = [];\n };\n /**\n * Resets underlying CaptionStream\n * @see m2ts/caption-stream.js\n **/\n\n\n this.resetCaptionStream = function () {\n if (!this.isInitialized()) {\n return null;\n }\n\n captionStream.reset();\n };\n /**\n * Convenience method to clear all captions flushed from the\n * CaptionStream and still being parsed\n * @see m2ts/caption-stream.js\n **/\n\n\n this.clearAllCaptions = function () {\n this.clearParsedCaptions();\n this.resetCaptionStream();\n };\n /**\n * Reset caption parser\n **/\n\n\n this.reset = function () {\n segmentCache = [];\n trackId = null;\n timescale = null;\n\n if (!parsedCaptions) {\n parsedCaptions = {\n captions: [],\n // CC1, CC2, CC3, CC4\n captionStreams: {},\n logs: []\n };\n } else {\n this.clearParsedCaptions();\n }\n\n this.resetCaptionStream();\n };\n\n this.reset();\n };\n\n var captionParser = CaptionParser;\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var mp4 = {\n generator: mp4Generator,\n probe: probe$2,\n Transmuxer: transmuxer$2.Transmuxer,\n AudioSegmentStream: transmuxer$2.AudioSegmentStream,\n VideoSegmentStream: transmuxer$2.VideoSegmentStream,\n CaptionParser: captionParser\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n *\n * An object that stores the bytes of an FLV tag and methods for\n * querying and manipulating that data.\n * @see http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf\n */\n\n var _FlvTag; // (type:uint, extraData:Boolean = false) extends ByteArray\n\n\n _FlvTag = function FlvTag(type, extraData) {\n var // Counter if this is a metadata tag, nal start marker if this is a video\n // tag. unused if this is an audio tag\n adHoc = 0,\n // :uint\n // The default size is 16kb but this is not enough to hold iframe\n // data and the resizing algorithm costs a bit so we create a larger\n // starting buffer for video tags\n bufferStartSize = 16384,\n // checks whether the FLV tag has enough capacity to accept the proposed\n // write and re-allocates the internal buffers if necessary\n prepareWrite = function prepareWrite(flv, count) {\n var bytes,\n minLength = flv.position + count;\n\n if (minLength < flv.bytes.byteLength) {\n // there's enough capacity so do nothing\n return;\n } // allocate a new buffer and copy over the data that will not be modified\n\n\n bytes = new Uint8Array(minLength * 2);\n bytes.set(flv.bytes.subarray(0, flv.position), 0);\n flv.bytes = bytes;\n flv.view = new DataView(flv.bytes.buffer);\n },\n // commonly used metadata properties\n widthBytes = _FlvTag.widthBytes || new Uint8Array('width'.length),\n heightBytes = _FlvTag.heightBytes || new Uint8Array('height'.length),\n videocodecidBytes = _FlvTag.videocodecidBytes || new Uint8Array('videocodecid'.length),\n i;\n\n if (!_FlvTag.widthBytes) {\n // calculating the bytes of common metadata names ahead of time makes the\n // corresponding writes faster because we don't have to loop over the\n // characters\n // re-test with test/perf.html if you're planning on changing this\n for (i = 0; i < 'width'.length; i++) {\n widthBytes[i] = 'width'.charCodeAt(i);\n }\n\n for (i = 0; i < 'height'.length; i++) {\n heightBytes[i] = 'height'.charCodeAt(i);\n }\n\n for (i = 0; i < 'videocodecid'.length; i++) {\n videocodecidBytes[i] = 'videocodecid'.charCodeAt(i);\n }\n\n _FlvTag.widthBytes = widthBytes;\n _FlvTag.heightBytes = heightBytes;\n _FlvTag.videocodecidBytes = videocodecidBytes;\n }\n\n this.keyFrame = false; // :Boolean\n\n switch (type) {\n case _FlvTag.VIDEO_TAG:\n this.length = 16; // Start the buffer at 256k\n\n bufferStartSize *= 6;\n break;\n\n case _FlvTag.AUDIO_TAG:\n this.length = 13;\n this.keyFrame = true;\n break;\n\n case _FlvTag.METADATA_TAG:\n this.length = 29;\n this.keyFrame = true;\n break;\n\n default:\n throw new Error('Unknown FLV tag type');\n }\n\n this.bytes = new Uint8Array(bufferStartSize);\n this.view = new DataView(this.bytes.buffer);\n this.bytes[0] = type;\n this.position = this.length;\n this.keyFrame = extraData; // Defaults to false\n // presentation timestamp\n\n this.pts = 0; // decoder timestamp\n\n this.dts = 0; // ByteArray#writeBytes(bytes:ByteArray, offset:uint = 0, length:uint = 0)\n\n this.writeBytes = function (bytes, offset, length) {\n var start = offset || 0,\n end;\n length = length || bytes.byteLength;\n end = start + length;\n prepareWrite(this, length);\n this.bytes.set(bytes.subarray(start, end), this.position);\n this.position += length;\n this.length = Math.max(this.length, this.position);\n }; // ByteArray#writeByte(value:int):void\n\n\n this.writeByte = function (byte) {\n prepareWrite(this, 1);\n this.bytes[this.position] = byte;\n this.position++;\n this.length = Math.max(this.length, this.position);\n }; // ByteArray#writeShort(value:int):void\n\n\n this.writeShort = function (short) {\n prepareWrite(this, 2);\n this.view.setUint16(this.position, short);\n this.position += 2;\n this.length = Math.max(this.length, this.position);\n }; // Negative index into array\n // (pos:uint):int\n\n\n this.negIndex = function (pos) {\n return this.bytes[this.length - pos];\n }; // The functions below ONLY work when this[0] == VIDEO_TAG.\n // We are not going to check for that because we dont want the overhead\n // (nal:ByteArray = null):int\n\n\n this.nalUnitSize = function () {\n if (adHoc === 0) {\n return 0;\n }\n\n return this.length - (adHoc + 4);\n };\n\n this.startNalUnit = function () {\n // remember position and add 4 bytes\n if (adHoc > 0) {\n throw new Error('Attempted to create new NAL wihout closing the old one');\n } // reserve 4 bytes for nal unit size\n\n\n adHoc = this.length;\n this.length += 4;\n this.position = this.length;\n }; // (nal:ByteArray = null):void\n\n\n this.endNalUnit = function (nalContainer) {\n var nalStart, // :uint\n nalLength; // :uint\n // Rewind to the marker and write the size\n\n if (this.length === adHoc + 4) {\n // we started a nal unit, but didnt write one, so roll back the 4 byte size value\n this.length -= 4;\n } else if (adHoc > 0) {\n nalStart = adHoc + 4;\n nalLength = this.length - nalStart;\n this.position = adHoc;\n this.view.setUint32(this.position, nalLength);\n this.position = this.length;\n\n if (nalContainer) {\n // Add the tag to the NAL unit\n nalContainer.push(this.bytes.subarray(nalStart, nalStart + nalLength));\n }\n }\n\n adHoc = 0;\n };\n /**\n * Write out a 64-bit floating point valued metadata property. This method is\n * called frequently during a typical parse and needs to be fast.\n */\n // (key:String, val:Number):void\n\n\n this.writeMetaDataDouble = function (key, val) {\n var i;\n prepareWrite(this, 2 + key.length + 9); // write size of property name\n\n this.view.setUint16(this.position, key.length);\n this.position += 2; // this next part looks terrible but it improves parser throughput by\n // 10kB/s in my testing\n // write property name\n\n if (key === 'width') {\n this.bytes.set(widthBytes, this.position);\n this.position += 5;\n } else if (key === 'height') {\n this.bytes.set(heightBytes, this.position);\n this.position += 6;\n } else if (key === 'videocodecid') {\n this.bytes.set(videocodecidBytes, this.position);\n this.position += 12;\n } else {\n for (i = 0; i < key.length; i++) {\n this.bytes[this.position] = key.charCodeAt(i);\n this.position++;\n }\n } // skip null byte\n\n\n this.position++; // write property value\n\n this.view.setFloat64(this.position, val);\n this.position += 8; // update flv tag length\n\n this.length = Math.max(this.length, this.position);\n ++adHoc;\n }; // (key:String, val:Boolean):void\n\n\n this.writeMetaDataBoolean = function (key, val) {\n var i;\n prepareWrite(this, 2);\n this.view.setUint16(this.position, key.length);\n this.position += 2;\n\n for (i = 0; i < key.length; i++) {\n // if key.charCodeAt(i) >= 255, handle error\n prepareWrite(this, 1);\n this.bytes[this.position] = key.charCodeAt(i);\n this.position++;\n }\n\n prepareWrite(this, 2);\n this.view.setUint8(this.position, 0x01);\n this.position++;\n this.view.setUint8(this.position, val ? 0x01 : 0x00);\n this.position++;\n this.length = Math.max(this.length, this.position);\n ++adHoc;\n }; // ():ByteArray\n\n\n this.finalize = function () {\n var dtsDelta, // :int\n len; // :int\n\n switch (this.bytes[0]) {\n // Video Data\n case _FlvTag.VIDEO_TAG:\n // We only support AVC, 1 = key frame (for AVC, a seekable\n // frame), 2 = inter frame (for AVC, a non-seekable frame)\n this.bytes[11] = (this.keyFrame || extraData ? 0x10 : 0x20) | 0x07;\n this.bytes[12] = extraData ? 0x00 : 0x01;\n dtsDelta = this.pts - this.dts;\n this.bytes[13] = (dtsDelta & 0x00FF0000) >>> 16;\n this.bytes[14] = (dtsDelta & 0x0000FF00) >>> 8;\n this.bytes[15] = (dtsDelta & 0x000000FF) >>> 0;\n break;\n\n case _FlvTag.AUDIO_TAG:\n this.bytes[11] = 0xAF; // 44 kHz, 16-bit stereo\n\n this.bytes[12] = extraData ? 0x00 : 0x01;\n break;\n\n case _FlvTag.METADATA_TAG:\n this.position = 11;\n this.view.setUint8(this.position, 0x02); // String type\n\n this.position++;\n this.view.setUint16(this.position, 0x0A); // 10 Bytes\n\n this.position += 2; // set \"onMetaData\"\n\n this.bytes.set([0x6f, 0x6e, 0x4d, 0x65, 0x74, 0x61, 0x44, 0x61, 0x74, 0x61], this.position);\n this.position += 10;\n this.bytes[this.position] = 0x08; // Array type\n\n this.position++;\n this.view.setUint32(this.position, adHoc);\n this.position = this.length;\n this.bytes.set([0, 0, 9], this.position);\n this.position += 3; // End Data Tag\n\n this.length = this.position;\n break;\n }\n\n len = this.length - 11; // write the DataSize field\n\n this.bytes[1] = (len & 0x00FF0000) >>> 16;\n this.bytes[2] = (len & 0x0000FF00) >>> 8;\n this.bytes[3] = (len & 0x000000FF) >>> 0; // write the Timestamp\n\n this.bytes[4] = (this.dts & 0x00FF0000) >>> 16;\n this.bytes[5] = (this.dts & 0x0000FF00) >>> 8;\n this.bytes[6] = (this.dts & 0x000000FF) >>> 0;\n this.bytes[7] = (this.dts & 0xFF000000) >>> 24; // write the StreamID\n\n this.bytes[8] = 0;\n this.bytes[9] = 0;\n this.bytes[10] = 0; // Sometimes we're at the end of the view and have one slot to write a\n // uint32, so, prepareWrite of count 4, since, view is uint8\n\n prepareWrite(this, 4);\n this.view.setUint32(this.length, this.length);\n this.length += 4;\n this.position += 4; // trim down the byte buffer to what is actually being used\n\n this.bytes = this.bytes.subarray(0, this.length);\n this.frameTime = _FlvTag.frameTime(this.bytes); // if bytes.bytelength isn't equal to this.length, handle error\n\n return this;\n };\n };\n\n _FlvTag.AUDIO_TAG = 0x08; // == 8, :uint\n\n _FlvTag.VIDEO_TAG = 0x09; // == 9, :uint\n\n _FlvTag.METADATA_TAG = 0x12; // == 18, :uint\n // (tag:ByteArray):Boolean {\n\n _FlvTag.isAudioFrame = function (tag) {\n return _FlvTag.AUDIO_TAG === tag[0];\n }; // (tag:ByteArray):Boolean {\n\n\n _FlvTag.isVideoFrame = function (tag) {\n return _FlvTag.VIDEO_TAG === tag[0];\n }; // (tag:ByteArray):Boolean {\n\n\n _FlvTag.isMetaData = function (tag) {\n return _FlvTag.METADATA_TAG === tag[0];\n }; // (tag:ByteArray):Boolean {\n\n\n _FlvTag.isKeyFrame = function (tag) {\n if (_FlvTag.isVideoFrame(tag)) {\n return tag[11] === 0x17;\n }\n\n if (_FlvTag.isAudioFrame(tag)) {\n return true;\n }\n\n if (_FlvTag.isMetaData(tag)) {\n return true;\n }\n\n return false;\n }; // (tag:ByteArray):uint {\n\n\n _FlvTag.frameTime = function (tag) {\n var pts = tag[4] << 16; // :uint\n\n pts |= tag[5] << 8;\n pts |= tag[6] << 0;\n pts |= tag[7] << 24;\n return pts;\n };\n\n var flvTag = _FlvTag;\n\n /**\n * The final stage of the transmuxer that emits the flv tags\n * for audio, video, and metadata. Also tranlates in time and\n * outputs caption data and id3 cues.\n */\n\n\n var CoalesceStream = function CoalesceStream(options) {\n // Number of Tracks per output segment\n // If greater than 1, we combine multiple\n // tracks into a single segment\n this.numberOfTracks = 0;\n this.metadataStream = options.metadataStream;\n this.videoTags = [];\n this.audioTags = [];\n this.videoTrack = null;\n this.audioTrack = null;\n this.pendingCaptions = [];\n this.pendingMetadata = [];\n this.pendingTracks = 0;\n this.processedTracks = 0;\n CoalesceStream.prototype.init.call(this); // Take output from multiple\n\n this.push = function (output) {\n // buffer incoming captions until the associated video segment\n // finishes\n if (output.text) {\n return this.pendingCaptions.push(output);\n } // buffer incoming id3 tags until the final flush\n\n\n if (output.frames) {\n return this.pendingMetadata.push(output);\n }\n\n if (output.track.type === 'video') {\n this.videoTrack = output.track;\n this.videoTags = output.tags;\n this.pendingTracks++;\n }\n\n if (output.track.type === 'audio') {\n this.audioTrack = output.track;\n this.audioTags = output.tags;\n this.pendingTracks++;\n }\n };\n };\n\n CoalesceStream.prototype = new stream();\n\n CoalesceStream.prototype.flush = function (flushSource) {\n var id3,\n caption,\n i,\n timelineStartPts,\n event = {\n tags: {},\n captions: [],\n captionStreams: {},\n metadata: []\n };\n\n if (this.pendingTracks < this.numberOfTracks) {\n if (flushSource !== 'VideoSegmentStream' && flushSource !== 'AudioSegmentStream') {\n // Return because we haven't received a flush from a data-generating\n // portion of the segment (meaning that we have only recieved meta-data\n // or captions.)\n return;\n } else if (this.pendingTracks === 0) {\n // In the case where we receive a flush without any data having been\n // received we consider it an emitted track for the purposes of coalescing\n // `done` events.\n // We do this for the case where there is an audio and video track in the\n // segment but no audio data. (seen in several playlists with alternate\n // audio tracks and no audio present in the main TS segments.)\n this.processedTracks++;\n\n if (this.processedTracks < this.numberOfTracks) {\n return;\n }\n }\n }\n\n this.processedTracks += this.pendingTracks;\n this.pendingTracks = 0;\n\n if (this.processedTracks < this.numberOfTracks) {\n return;\n }\n\n if (this.videoTrack) {\n timelineStartPts = this.videoTrack.timelineStartInfo.pts;\n } else if (this.audioTrack) {\n timelineStartPts = this.audioTrack.timelineStartInfo.pts;\n }\n\n event.tags.videoTags = this.videoTags;\n event.tags.audioTags = this.audioTags; // Translate caption PTS times into second offsets into the\n // video timeline for the segment, and add track info\n\n for (i = 0; i < this.pendingCaptions.length; i++) {\n caption = this.pendingCaptions[i];\n caption.startTime = caption.startPts - timelineStartPts;\n caption.startTime /= 90e3;\n caption.endTime = caption.endPts - timelineStartPts;\n caption.endTime /= 90e3;\n event.captionStreams[caption.stream] = true;\n event.captions.push(caption);\n } // Translate ID3 frame PTS times into second offsets into the\n // video timeline for the segment\n\n\n for (i = 0; i < this.pendingMetadata.length; i++) {\n id3 = this.pendingMetadata[i];\n id3.cueTime = id3.pts - timelineStartPts;\n id3.cueTime /= 90e3;\n event.metadata.push(id3);\n } // We add this to every single emitted segment even though we only need\n // it for the first\n\n\n event.metadata.dispatchType = this.metadataStream.dispatchType; // Reset stream state\n\n this.videoTrack = null;\n this.audioTrack = null;\n this.videoTags = [];\n this.audioTags = [];\n this.pendingCaptions.length = 0;\n this.pendingMetadata.length = 0;\n this.pendingTracks = 0;\n this.processedTracks = 0; // Emit the final segment\n\n this.trigger('data', event);\n this.trigger('done');\n };\n\n var coalesceStream = CoalesceStream;\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var TagList = function TagList() {\n var self = this;\n this.list = [];\n\n this.push = function (tag) {\n this.list.push({\n bytes: tag.bytes,\n dts: tag.dts,\n pts: tag.pts,\n keyFrame: tag.keyFrame,\n metaDataTag: tag.metaDataTag\n });\n };\n\n Object.defineProperty(this, 'length', {\n get: function get() {\n return self.list.length;\n }\n });\n };\n\n var tagList = TagList;\n\n var H264Stream = h264.H264Stream;\n\n var _Transmuxer, _VideoSegmentStream, _AudioSegmentStream, collectTimelineInfo, metaDataTag, extraDataTag;\n /**\n * Store information about the start and end of the tracka and the\n * duration for each frame/sample we process in order to calculate\n * the baseMediaDecodeTime\n */\n\n\n collectTimelineInfo = function collectTimelineInfo(track, data) {\n if (typeof data.pts === 'number') {\n if (track.timelineStartInfo.pts === undefined) {\n track.timelineStartInfo.pts = data.pts;\n } else {\n track.timelineStartInfo.pts = Math.min(track.timelineStartInfo.pts, data.pts);\n }\n }\n\n if (typeof data.dts === 'number') {\n if (track.timelineStartInfo.dts === undefined) {\n track.timelineStartInfo.dts = data.dts;\n } else {\n track.timelineStartInfo.dts = Math.min(track.timelineStartInfo.dts, data.dts);\n }\n }\n };\n\n metaDataTag = function metaDataTag(track, pts) {\n var tag = new flvTag(flvTag.METADATA_TAG); // :FlvTag\n\n tag.dts = pts;\n tag.pts = pts;\n tag.writeMetaDataDouble('videocodecid', 7);\n tag.writeMetaDataDouble('width', track.width);\n tag.writeMetaDataDouble('height', track.height);\n return tag;\n };\n\n extraDataTag = function extraDataTag(track, pts) {\n var i,\n tag = new flvTag(flvTag.VIDEO_TAG, true);\n tag.dts = pts;\n tag.pts = pts;\n tag.writeByte(0x01); // version\n\n tag.writeByte(track.profileIdc); // profile\n\n tag.writeByte(track.profileCompatibility); // compatibility\n\n tag.writeByte(track.levelIdc); // level\n\n tag.writeByte(0xFC | 0x03); // reserved (6 bits), NULA length size - 1 (2 bits)\n\n tag.writeByte(0xE0 | 0x01); // reserved (3 bits), num of SPS (5 bits)\n\n tag.writeShort(track.sps[0].length); // data of SPS\n\n tag.writeBytes(track.sps[0]); // SPS\n\n tag.writeByte(track.pps.length); // num of PPS (will there ever be more that 1 PPS?)\n\n for (i = 0; i < track.pps.length; ++i) {\n tag.writeShort(track.pps[i].length); // 2 bytes for length of PPS\n\n tag.writeBytes(track.pps[i]); // data of PPS\n }\n\n return tag;\n };\n /**\n * Constructs a single-track, media segment from AAC data\n * events. The output of this stream can be fed to flash.\n */\n\n\n _AudioSegmentStream = function AudioSegmentStream(track) {\n var adtsFrames = [],\n videoKeyFrames = [],\n oldExtraData;\n\n _AudioSegmentStream.prototype.init.call(this);\n\n this.push = function (data) {\n collectTimelineInfo(track, data);\n\n if (track) {\n track.audioobjecttype = data.audioobjecttype;\n track.channelcount = data.channelcount;\n track.samplerate = data.samplerate;\n track.samplingfrequencyindex = data.samplingfrequencyindex;\n track.samplesize = data.samplesize;\n track.extraData = track.audioobjecttype << 11 | track.samplingfrequencyindex << 7 | track.channelcount << 3;\n }\n\n data.pts = Math.round(data.pts / 90);\n data.dts = Math.round(data.dts / 90); // buffer audio data until end() is called\n\n adtsFrames.push(data);\n };\n\n this.flush = function () {\n var currentFrame,\n adtsFrame,\n lastMetaPts,\n tags = new tagList(); // return early if no audio data has been observed\n\n if (adtsFrames.length === 0) {\n this.trigger('done', 'AudioSegmentStream');\n return;\n }\n\n lastMetaPts = -Infinity;\n\n while (adtsFrames.length) {\n currentFrame = adtsFrames.shift(); // write out a metadata frame at every video key frame\n\n if (videoKeyFrames.length && currentFrame.pts >= videoKeyFrames[0]) {\n lastMetaPts = videoKeyFrames.shift();\n this.writeMetaDataTags(tags, lastMetaPts);\n } // also write out metadata tags every 1 second so that the decoder\n // is re-initialized quickly after seeking into a different\n // audio configuration.\n\n\n if (track.extraData !== oldExtraData || currentFrame.pts - lastMetaPts >= 1000) {\n this.writeMetaDataTags(tags, currentFrame.pts);\n oldExtraData = track.extraData;\n lastMetaPts = currentFrame.pts;\n }\n\n adtsFrame = new flvTag(flvTag.AUDIO_TAG);\n adtsFrame.pts = currentFrame.pts;\n adtsFrame.dts = currentFrame.dts;\n adtsFrame.writeBytes(currentFrame.data);\n tags.push(adtsFrame.finalize());\n }\n\n videoKeyFrames.length = 0;\n oldExtraData = null;\n this.trigger('data', {\n track: track,\n tags: tags.list\n });\n this.trigger('done', 'AudioSegmentStream');\n };\n\n this.writeMetaDataTags = function (tags, pts) {\n var adtsFrame;\n adtsFrame = new flvTag(flvTag.METADATA_TAG); // For audio, DTS is always the same as PTS. We want to set the DTS\n // however so we can compare with video DTS to determine approximate\n // packet order\n\n adtsFrame.pts = pts;\n adtsFrame.dts = pts; // AAC is always 10\n\n adtsFrame.writeMetaDataDouble('audiocodecid', 10);\n adtsFrame.writeMetaDataBoolean('stereo', track.channelcount === 2);\n adtsFrame.writeMetaDataDouble('audiosamplerate', track.samplerate); // Is AAC always 16 bit?\n\n adtsFrame.writeMetaDataDouble('audiosamplesize', 16);\n tags.push(adtsFrame.finalize());\n adtsFrame = new flvTag(flvTag.AUDIO_TAG, true); // For audio, DTS is always the same as PTS. We want to set the DTS\n // however so we can compare with video DTS to determine approximate\n // packet order\n\n adtsFrame.pts = pts;\n adtsFrame.dts = pts;\n adtsFrame.view.setUint16(adtsFrame.position, track.extraData);\n adtsFrame.position += 2;\n adtsFrame.length = Math.max(adtsFrame.length, adtsFrame.position);\n tags.push(adtsFrame.finalize());\n };\n\n this.onVideoKeyFrame = function (pts) {\n videoKeyFrames.push(pts);\n };\n };\n\n _AudioSegmentStream.prototype = new stream();\n /**\n * Store FlvTags for the h264 stream\n * @param track {object} track metadata configuration\n */\n\n _VideoSegmentStream = function VideoSegmentStream(track) {\n var nalUnits = [],\n config,\n h264Frame;\n\n _VideoSegmentStream.prototype.init.call(this);\n\n this.finishFrame = function (tags, frame) {\n if (!frame) {\n return;\n } // Check if keyframe and the length of tags.\n // This makes sure we write metadata on the first frame of a segment.\n\n\n if (config && track && track.newMetadata && (frame.keyFrame || tags.length === 0)) {\n // Push extra data on every IDR frame in case we did a stream change + seek\n var metaTag = metaDataTag(config, frame.dts).finalize();\n var extraTag = extraDataTag(track, frame.dts).finalize();\n metaTag.metaDataTag = extraTag.metaDataTag = true;\n tags.push(metaTag);\n tags.push(extraTag);\n track.newMetadata = false;\n this.trigger('keyframe', frame.dts);\n }\n\n frame.endNalUnit();\n tags.push(frame.finalize());\n h264Frame = null;\n };\n\n this.push = function (data) {\n collectTimelineInfo(track, data);\n data.pts = Math.round(data.pts / 90);\n data.dts = Math.round(data.dts / 90); // buffer video until flush() is called\n\n nalUnits.push(data);\n };\n\n this.flush = function () {\n var currentNal,\n tags = new tagList(); // Throw away nalUnits at the start of the byte stream until we find\n // the first AUD\n\n while (nalUnits.length) {\n if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {\n break;\n }\n\n nalUnits.shift();\n } // return early if no video data has been observed\n\n\n if (nalUnits.length === 0) {\n this.trigger('done', 'VideoSegmentStream');\n return;\n }\n\n while (nalUnits.length) {\n currentNal = nalUnits.shift(); // record the track config\n\n if (currentNal.nalUnitType === 'seq_parameter_set_rbsp') {\n track.newMetadata = true;\n config = currentNal.config;\n track.width = config.width;\n track.height = config.height;\n track.sps = [currentNal.data];\n track.profileIdc = config.profileIdc;\n track.levelIdc = config.levelIdc;\n track.profileCompatibility = config.profileCompatibility;\n h264Frame.endNalUnit();\n } else if (currentNal.nalUnitType === 'pic_parameter_set_rbsp') {\n track.newMetadata = true;\n track.pps = [currentNal.data];\n h264Frame.endNalUnit();\n } else if (currentNal.nalUnitType === 'access_unit_delimiter_rbsp') {\n if (h264Frame) {\n this.finishFrame(tags, h264Frame);\n }\n\n h264Frame = new flvTag(flvTag.VIDEO_TAG);\n h264Frame.pts = currentNal.pts;\n h264Frame.dts = currentNal.dts;\n } else {\n if (currentNal.nalUnitType === 'slice_layer_without_partitioning_rbsp_idr') {\n // the current sample is a key frame\n h264Frame.keyFrame = true;\n }\n\n h264Frame.endNalUnit();\n }\n\n h264Frame.startNalUnit();\n h264Frame.writeBytes(currentNal.data);\n }\n\n if (h264Frame) {\n this.finishFrame(tags, h264Frame);\n }\n\n this.trigger('data', {\n track: track,\n tags: tags.list\n }); // Continue with the flush process now\n\n this.trigger('done', 'VideoSegmentStream');\n };\n };\n\n _VideoSegmentStream.prototype = new stream();\n /**\n * An object that incrementally transmuxes MPEG2 Trasport Stream\n * chunks into an FLV.\n */\n\n _Transmuxer = function Transmuxer(options) {\n var self = this,\n packetStream,\n parseStream,\n elementaryStream,\n videoTimestampRolloverStream,\n audioTimestampRolloverStream,\n timedMetadataTimestampRolloverStream,\n adtsStream,\n h264Stream,\n videoSegmentStream,\n audioSegmentStream,\n captionStream,\n coalesceStream$1;\n\n _Transmuxer.prototype.init.call(this);\n\n options = options || {}; // expose the metadata stream\n\n this.metadataStream = new m2ts_1.MetadataStream();\n options.metadataStream = this.metadataStream; // set up the parsing pipeline\n\n packetStream = new m2ts_1.TransportPacketStream();\n parseStream = new m2ts_1.TransportParseStream();\n elementaryStream = new m2ts_1.ElementaryStream();\n videoTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('video');\n audioTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('audio');\n timedMetadataTimestampRolloverStream = new m2ts_1.TimestampRolloverStream('timed-metadata');\n adtsStream = new adts();\n h264Stream = new H264Stream();\n coalesceStream$1 = new coalesceStream(options); // disassemble MPEG2-TS packets into elementary streams\n\n packetStream.pipe(parseStream).pipe(elementaryStream); // !!THIS ORDER IS IMPORTANT!!\n // demux the streams\n\n elementaryStream.pipe(videoTimestampRolloverStream).pipe(h264Stream);\n elementaryStream.pipe(audioTimestampRolloverStream).pipe(adtsStream);\n elementaryStream.pipe(timedMetadataTimestampRolloverStream).pipe(this.metadataStream).pipe(coalesceStream$1); // if CEA-708 parsing is available, hook up a caption stream\n\n captionStream = new m2ts_1.CaptionStream(options);\n h264Stream.pipe(captionStream).pipe(coalesceStream$1); // hook up the segment streams once track metadata is delivered\n\n elementaryStream.on('data', function (data) {\n var i, videoTrack, audioTrack;\n\n if (data.type === 'metadata') {\n i = data.tracks.length; // scan the tracks listed in the metadata\n\n while (i--) {\n if (data.tracks[i].type === 'video') {\n videoTrack = data.tracks[i];\n } else if (data.tracks[i].type === 'audio') {\n audioTrack = data.tracks[i];\n }\n } // hook up the video segment stream to the first track with h264 data\n\n\n if (videoTrack && !videoSegmentStream) {\n coalesceStream$1.numberOfTracks++;\n videoSegmentStream = new _VideoSegmentStream(videoTrack); // Set up the final part of the video pipeline\n\n h264Stream.pipe(videoSegmentStream).pipe(coalesceStream$1);\n }\n\n if (audioTrack && !audioSegmentStream) {\n // hook up the audio segment stream to the first track with aac data\n coalesceStream$1.numberOfTracks++;\n audioSegmentStream = new _AudioSegmentStream(audioTrack); // Set up the final part of the audio pipeline\n\n adtsStream.pipe(audioSegmentStream).pipe(coalesceStream$1);\n\n if (videoSegmentStream) {\n videoSegmentStream.on('keyframe', audioSegmentStream.onVideoKeyFrame);\n }\n }\n }\n }); // feed incoming data to the front of the parsing pipeline\n\n this.push = function (data) {\n packetStream.push(data);\n }; // flush any buffered data\n\n\n this.flush = function () {\n // Start at the top of the pipeline and flush all pending work\n packetStream.flush();\n }; // Caption data has to be reset when seeking outside buffered range\n\n\n this.resetCaptions = function () {\n captionStream.reset();\n }; // Re-emit any data coming from the coalesce stream to the outside world\n\n\n coalesceStream$1.on('data', function (event) {\n self.trigger('data', event);\n }); // Let the consumer know we have finished flushing the entire pipeline\n\n coalesceStream$1.on('done', function () {\n self.trigger('done');\n });\n };\n\n _Transmuxer.prototype = new stream(); // forward compatibility\n\n var transmuxer$1 = _Transmuxer;\n\n // http://download.macromedia.com/f4v/video_file_format_spec_v10_1.pdf.\n // Technically, this function returns the header and a metadata FLV tag\n // if duration is greater than zero\n // duration in seconds\n // @return {object} the bytes of the FLV header as a Uint8Array\n\n\n var getFlvHeader = function getFlvHeader(duration, audio, video) {\n // :ByteArray {\n var headBytes = new Uint8Array(3 + 1 + 1 + 4),\n head = new DataView(headBytes.buffer),\n metadata,\n result,\n metadataLength; // default arguments\n\n duration = duration || 0;\n audio = audio === undefined ? true : audio;\n video = video === undefined ? true : video; // signature\n\n head.setUint8(0, 0x46); // 'F'\n\n head.setUint8(1, 0x4c); // 'L'\n\n head.setUint8(2, 0x56); // 'V'\n // version\n\n head.setUint8(3, 0x01); // flags\n\n head.setUint8(4, (audio ? 0x04 : 0x00) | (video ? 0x01 : 0x00)); // data offset, should be 9 for FLV v1\n\n head.setUint32(5, headBytes.byteLength); // init the first FLV tag\n\n if (duration <= 0) {\n // no duration available so just write the first field of the first\n // FLV tag\n result = new Uint8Array(headBytes.byteLength + 4);\n result.set(headBytes);\n result.set([0, 0, 0, 0], headBytes.byteLength);\n return result;\n } // write out the duration metadata tag\n\n\n metadata = new flvTag(flvTag.METADATA_TAG);\n metadata.pts = metadata.dts = 0;\n metadata.writeMetaDataDouble('duration', duration);\n metadataLength = metadata.finalize().length;\n result = new Uint8Array(headBytes.byteLength + metadataLength);\n result.set(headBytes);\n result.set(head.byteLength, metadataLength);\n return result;\n };\n\n var flvHeader = getFlvHeader;\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var flv = {\n tag: flvTag,\n Transmuxer: transmuxer$1,\n getFlvHeader: flvHeader\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var m2ts = m2ts_1;\n\n var ONE_SECOND_IN_TS$1 = clock.ONE_SECOND_IN_TS;\n /**\n * Constructs a single-track, ISO BMFF media segment from AAC data\n * events. The output of this stream can be fed to a SourceBuffer\n * configured with a suitable initialization segment.\n */\n\n var AudioSegmentStream = function AudioSegmentStream(track, options) {\n var adtsFrames = [],\n sequenceNumber = 0,\n earliestAllowedDts = 0,\n audioAppendStartTs = 0,\n videoBaseMediaDecodeTime = Infinity,\n segmentStartPts = null,\n segmentEndPts = null;\n options = options || {};\n AudioSegmentStream.prototype.init.call(this);\n\n this.push = function (data) {\n trackDecodeInfo.collectDtsInfo(track, data);\n\n if (track) {\n audioProperties.forEach(function (prop) {\n track[prop] = data[prop];\n });\n } // buffer audio data until end() is called\n\n\n adtsFrames.push(data);\n };\n\n this.setEarliestDts = function (earliestDts) {\n earliestAllowedDts = earliestDts;\n };\n\n this.setVideoBaseMediaDecodeTime = function (baseMediaDecodeTime) {\n videoBaseMediaDecodeTime = baseMediaDecodeTime;\n };\n\n this.setAudioAppendStart = function (timestamp) {\n audioAppendStartTs = timestamp;\n };\n\n this.processFrames_ = function () {\n var frames, moof, mdat, boxes, timingInfo; // return early if no audio data has been observed\n\n if (adtsFrames.length === 0) {\n return;\n }\n\n frames = audioFrameUtils.trimAdtsFramesByEarliestDts(adtsFrames, track, earliestAllowedDts);\n\n if (frames.length === 0) {\n // return early if the frames are all after the earliest allowed DTS\n // TODO should we clear the adtsFrames?\n return;\n }\n\n track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);\n audioFrameUtils.prefixWithSilence(track, frames, audioAppendStartTs, videoBaseMediaDecodeTime); // we have to build the index from byte locations to\n // samples (that is, adts frames) in the audio data\n\n track.samples = audioFrameUtils.generateSampleTable(frames); // concatenate the audio data to constuct the mdat\n\n mdat = mp4Generator.mdat(audioFrameUtils.concatenateFrameData(frames));\n adtsFrames = [];\n moof = mp4Generator.moof(sequenceNumber, [track]); // bump the sequence number for next time\n\n sequenceNumber++;\n track.initSegment = mp4Generator.initSegment([track]); // it would be great to allocate this array up front instead of\n // throwing away hundreds of media segment fragments\n\n boxes = new Uint8Array(moof.byteLength + mdat.byteLength);\n boxes.set(moof);\n boxes.set(mdat, moof.byteLength);\n trackDecodeInfo.clearDtsInfo(track);\n\n if (segmentStartPts === null) {\n segmentEndPts = segmentStartPts = frames[0].pts;\n }\n\n segmentEndPts += frames.length * (ONE_SECOND_IN_TS$1 * 1024 / track.samplerate);\n timingInfo = {\n start: segmentStartPts\n };\n this.trigger('timingInfo', timingInfo);\n this.trigger('data', {\n track: track,\n boxes: boxes\n });\n };\n\n this.flush = function () {\n this.processFrames_(); // trigger final timing info\n\n this.trigger('timingInfo', {\n start: segmentStartPts,\n end: segmentEndPts\n });\n this.resetTiming_();\n this.trigger('done', 'AudioSegmentStream');\n };\n\n this.partialFlush = function () {\n this.processFrames_();\n this.trigger('partialdone', 'AudioSegmentStream');\n };\n\n this.endTimeline = function () {\n this.flush();\n this.trigger('endedtimeline', 'AudioSegmentStream');\n };\n\n this.resetTiming_ = function () {\n trackDecodeInfo.clearDtsInfo(track);\n segmentStartPts = null;\n segmentEndPts = null;\n };\n\n this.reset = function () {\n this.resetTiming_();\n adtsFrames = [];\n this.trigger('reset');\n };\n };\n\n AudioSegmentStream.prototype = new stream();\n var audioSegmentStream = AudioSegmentStream;\n\n var VideoSegmentStream = function VideoSegmentStream(track, options) {\n var sequenceNumber = 0,\n nalUnits = [],\n frameCache = [],\n // gopsToAlignWith = [],\n config,\n pps,\n segmentStartPts = null,\n segmentEndPts = null,\n gops,\n ensureNextFrameIsKeyFrame = true;\n options = options || {};\n VideoSegmentStream.prototype.init.call(this);\n\n this.push = function (nalUnit) {\n trackDecodeInfo.collectDtsInfo(track, nalUnit);\n\n if (typeof track.timelineStartInfo.dts === 'undefined') {\n track.timelineStartInfo.dts = nalUnit.dts;\n } // record the track config\n\n\n if (nalUnit.nalUnitType === 'seq_parameter_set_rbsp' && !config) {\n config = nalUnit.config;\n track.sps = [nalUnit.data];\n videoProperties.forEach(function (prop) {\n track[prop] = config[prop];\n }, this);\n }\n\n if (nalUnit.nalUnitType === 'pic_parameter_set_rbsp' && !pps) {\n pps = nalUnit.data;\n track.pps = [nalUnit.data];\n } // buffer video until flush() is called\n\n\n nalUnits.push(nalUnit);\n };\n\n this.processNals_ = function (cacheLastFrame) {\n var i;\n nalUnits = frameCache.concat(nalUnits); // Throw away nalUnits at the start of the byte stream until\n // we find the first AUD\n\n while (nalUnits.length) {\n if (nalUnits[0].nalUnitType === 'access_unit_delimiter_rbsp') {\n break;\n }\n\n nalUnits.shift();\n } // Return early if no video data has been observed\n\n\n if (nalUnits.length === 0) {\n return;\n }\n\n var frames = frameUtils.groupNalsIntoFrames(nalUnits);\n\n if (!frames.length) {\n return;\n } // note that the frame cache may also protect us from cases where we haven't\n // pushed data for the entire first or last frame yet\n\n\n frameCache = frames[frames.length - 1];\n\n if (cacheLastFrame) {\n frames.pop();\n frames.duration -= frameCache.duration;\n frames.nalCount -= frameCache.length;\n frames.byteLength -= frameCache.byteLength;\n }\n\n if (!frames.length) {\n nalUnits = [];\n return;\n }\n\n this.trigger('timelineStartInfo', track.timelineStartInfo);\n\n if (ensureNextFrameIsKeyFrame) {\n gops = frameUtils.groupFramesIntoGops(frames);\n\n if (!gops[0][0].keyFrame) {\n gops = frameUtils.extendFirstKeyFrame(gops);\n\n if (!gops[0][0].keyFrame) {\n // we haven't yet gotten a key frame, so reset nal units to wait for more nal\n // units\n nalUnits = [].concat.apply([], frames).concat(frameCache);\n frameCache = [];\n return;\n }\n\n frames = [].concat.apply([], gops);\n frames.duration = gops.duration;\n }\n\n ensureNextFrameIsKeyFrame = false;\n }\n\n if (segmentStartPts === null) {\n segmentStartPts = frames[0].pts;\n segmentEndPts = segmentStartPts;\n }\n\n segmentEndPts += frames.duration;\n this.trigger('timingInfo', {\n start: segmentStartPts,\n end: segmentEndPts\n });\n\n for (i = 0; i < frames.length; i++) {\n var frame = frames[i];\n track.samples = frameUtils.generateSampleTableForFrame(frame);\n var mdat = mp4Generator.mdat(frameUtils.concatenateNalDataForFrame(frame));\n trackDecodeInfo.clearDtsInfo(track);\n trackDecodeInfo.collectDtsInfo(track, frame);\n track.baseMediaDecodeTime = trackDecodeInfo.calculateTrackBaseMediaDecodeTime(track, options.keepOriginalTimestamps);\n var moof = mp4Generator.moof(sequenceNumber, [track]);\n sequenceNumber++;\n track.initSegment = mp4Generator.initSegment([track]);\n var boxes = new Uint8Array(moof.byteLength + mdat.byteLength);\n boxes.set(moof);\n boxes.set(mdat, moof.byteLength);\n this.trigger('data', {\n track: track,\n boxes: boxes,\n sequence: sequenceNumber,\n videoFrameDts: frame.dts,\n videoFramePts: frame.pts\n });\n }\n\n nalUnits = [];\n };\n\n this.resetTimingAndConfig_ = function () {\n config = undefined;\n pps = undefined;\n segmentStartPts = null;\n segmentEndPts = null;\n };\n\n this.partialFlush = function () {\n this.processNals_(true);\n this.trigger('partialdone', 'VideoSegmentStream');\n };\n\n this.flush = function () {\n this.processNals_(false); // reset config and pps because they may differ across segments\n // for instance, when we are rendition switching\n\n this.resetTimingAndConfig_();\n this.trigger('done', 'VideoSegmentStream');\n };\n\n this.endTimeline = function () {\n this.flush();\n this.trigger('endedtimeline', 'VideoSegmentStream');\n };\n\n this.reset = function () {\n this.resetTimingAndConfig_();\n frameCache = [];\n nalUnits = [];\n ensureNextFrameIsKeyFrame = true;\n this.trigger('reset');\n };\n };\n\n VideoSegmentStream.prototype = new stream();\n var videoSegmentStream = VideoSegmentStream;\n\n var isLikelyAacData = utils.isLikelyAacData;\n\n var createPipeline = function createPipeline(object) {\n object.prototype = new stream();\n object.prototype.init.call(object);\n return object;\n };\n\n var tsPipeline = function tsPipeline(options) {\n var pipeline = {\n type: 'ts',\n tracks: {\n audio: null,\n video: null\n },\n packet: new m2ts_1.TransportPacketStream(),\n parse: new m2ts_1.TransportParseStream(),\n elementary: new m2ts_1.ElementaryStream(),\n timestampRollover: new m2ts_1.TimestampRolloverStream(),\n adts: new codecs.Adts(),\n h264: new codecs.h264.H264Stream(),\n captionStream: new m2ts_1.CaptionStream(options),\n metadataStream: new m2ts_1.MetadataStream()\n };\n pipeline.headOfPipeline = pipeline.packet; // Transport Stream\n\n pipeline.packet.pipe(pipeline.parse).pipe(pipeline.elementary).pipe(pipeline.timestampRollover); // H264\n\n pipeline.timestampRollover.pipe(pipeline.h264); // Hook up CEA-608/708 caption stream\n\n pipeline.h264.pipe(pipeline.captionStream);\n pipeline.timestampRollover.pipe(pipeline.metadataStream); // ADTS\n\n pipeline.timestampRollover.pipe(pipeline.adts);\n pipeline.elementary.on('data', function (data) {\n if (data.type !== 'metadata') {\n return;\n }\n\n for (var i = 0; i < data.tracks.length; i++) {\n if (!pipeline.tracks[data.tracks[i].type]) {\n pipeline.tracks[data.tracks[i].type] = data.tracks[i];\n pipeline.tracks[data.tracks[i].type].timelineStartInfo.baseMediaDecodeTime = options.baseMediaDecodeTime;\n }\n }\n\n if (pipeline.tracks.video && !pipeline.videoSegmentStream) {\n pipeline.videoSegmentStream = new videoSegmentStream(pipeline.tracks.video, options);\n pipeline.videoSegmentStream.on('timelineStartInfo', function (timelineStartInfo) {\n if (pipeline.tracks.audio && !options.keepOriginalTimestamps) {\n pipeline.audioSegmentStream.setEarliestDts(timelineStartInfo.dts - options.baseMediaDecodeTime);\n }\n });\n pipeline.videoSegmentStream.on('timingInfo', pipeline.trigger.bind(pipeline, 'videoTimingInfo'));\n pipeline.videoSegmentStream.on('data', function (data) {\n pipeline.trigger('data', {\n type: 'video',\n data: data\n });\n });\n pipeline.videoSegmentStream.on('done', pipeline.trigger.bind(pipeline, 'done'));\n pipeline.videoSegmentStream.on('partialdone', pipeline.trigger.bind(pipeline, 'partialdone'));\n pipeline.videoSegmentStream.on('endedtimeline', pipeline.trigger.bind(pipeline, 'endedtimeline'));\n pipeline.h264.pipe(pipeline.videoSegmentStream);\n }\n\n if (pipeline.tracks.audio && !pipeline.audioSegmentStream) {\n pipeline.audioSegmentStream = new audioSegmentStream(pipeline.tracks.audio, options);\n pipeline.audioSegmentStream.on('data', function (data) {\n pipeline.trigger('data', {\n type: 'audio',\n data: data\n });\n });\n pipeline.audioSegmentStream.on('done', pipeline.trigger.bind(pipeline, 'done'));\n pipeline.audioSegmentStream.on('partialdone', pipeline.trigger.bind(pipeline, 'partialdone'));\n pipeline.audioSegmentStream.on('endedtimeline', pipeline.trigger.bind(pipeline, 'endedtimeline'));\n pipeline.audioSegmentStream.on('timingInfo', pipeline.trigger.bind(pipeline, 'audioTimingInfo'));\n pipeline.adts.pipe(pipeline.audioSegmentStream);\n } // emit pmt info\n\n\n pipeline.trigger('trackinfo', {\n hasAudio: !!pipeline.tracks.audio,\n hasVideo: !!pipeline.tracks.video\n });\n });\n pipeline.captionStream.on('data', function (caption) {\n var timelineStartPts;\n\n if (pipeline.tracks.video) {\n timelineStartPts = pipeline.tracks.video.timelineStartInfo.pts || 0;\n } else {\n // This will only happen if we encounter caption packets before\n // video data in a segment. This is an unusual/unlikely scenario,\n // so we assume the timeline starts at zero for now.\n timelineStartPts = 0;\n } // Translate caption PTS times into second offsets into the\n // video timeline for the segment\n\n\n caption.startTime = clock.metadataTsToSeconds(caption.startPts, timelineStartPts, options.keepOriginalTimestamps);\n caption.endTime = clock.metadataTsToSeconds(caption.endPts, timelineStartPts, options.keepOriginalTimestamps);\n pipeline.trigger('caption', caption);\n });\n pipeline = createPipeline(pipeline);\n pipeline.metadataStream.on('data', pipeline.trigger.bind(pipeline, 'id3Frame'));\n return pipeline;\n };\n\n var aacPipeline = function aacPipeline(options) {\n var pipeline = {\n type: 'aac',\n tracks: {\n audio: null\n },\n metadataStream: new m2ts_1.MetadataStream(),\n aacStream: new aac(),\n audioRollover: new m2ts_1.TimestampRolloverStream('audio'),\n timedMetadataRollover: new m2ts_1.TimestampRolloverStream('timed-metadata'),\n adtsStream: new adts(true)\n }; // set up the parsing pipeline\n\n pipeline.headOfPipeline = pipeline.aacStream;\n pipeline.aacStream.pipe(pipeline.audioRollover).pipe(pipeline.adtsStream);\n pipeline.aacStream.pipe(pipeline.timedMetadataRollover).pipe(pipeline.metadataStream);\n pipeline.metadataStream.on('timestamp', function (frame) {\n pipeline.aacStream.setTimestamp(frame.timeStamp);\n });\n pipeline.aacStream.on('data', function (data) {\n if (data.type !== 'timed-metadata' && data.type !== 'audio' || pipeline.audioSegmentStream) {\n return;\n }\n\n pipeline.tracks.audio = pipeline.tracks.audio || {\n timelineStartInfo: {\n baseMediaDecodeTime: options.baseMediaDecodeTime\n },\n codec: 'adts',\n type: 'audio'\n }; // hook up the audio segment stream to the first track with aac data\n\n pipeline.audioSegmentStream = new audioSegmentStream(pipeline.tracks.audio, options);\n pipeline.audioSegmentStream.on('data', function (data) {\n pipeline.trigger('data', {\n type: 'audio',\n data: data\n });\n });\n pipeline.audioSegmentStream.on('partialdone', pipeline.trigger.bind(pipeline, 'partialdone'));\n pipeline.audioSegmentStream.on('done', pipeline.trigger.bind(pipeline, 'done'));\n pipeline.audioSegmentStream.on('endedtimeline', pipeline.trigger.bind(pipeline, 'endedtimeline'));\n pipeline.audioSegmentStream.on('timingInfo', pipeline.trigger.bind(pipeline, 'audioTimingInfo')); // Set up the final part of the audio pipeline\n\n pipeline.adtsStream.pipe(pipeline.audioSegmentStream);\n pipeline.trigger('trackinfo', {\n hasAudio: !!pipeline.tracks.audio,\n hasVideo: !!pipeline.tracks.video\n });\n }); // set the pipeline up as a stream before binding to get access to the trigger function\n\n pipeline = createPipeline(pipeline);\n pipeline.metadataStream.on('data', pipeline.trigger.bind(pipeline, 'id3Frame'));\n return pipeline;\n };\n\n var setupPipelineListeners = function setupPipelineListeners(pipeline, transmuxer) {\n pipeline.on('data', transmuxer.trigger.bind(transmuxer, 'data'));\n pipeline.on('done', transmuxer.trigger.bind(transmuxer, 'done'));\n pipeline.on('partialdone', transmuxer.trigger.bind(transmuxer, 'partialdone'));\n pipeline.on('endedtimeline', transmuxer.trigger.bind(transmuxer, 'endedtimeline'));\n pipeline.on('audioTimingInfo', transmuxer.trigger.bind(transmuxer, 'audioTimingInfo'));\n pipeline.on('videoTimingInfo', transmuxer.trigger.bind(transmuxer, 'videoTimingInfo'));\n pipeline.on('trackinfo', transmuxer.trigger.bind(transmuxer, 'trackinfo'));\n pipeline.on('id3Frame', function (event) {\n // add this to every single emitted segment even though it's only needed for the first\n event.dispatchType = pipeline.metadataStream.dispatchType; // keep original time, can be adjusted if needed at a higher level\n\n event.cueTime = clock.videoTsToSeconds(event.pts);\n transmuxer.trigger('id3Frame', event);\n });\n pipeline.on('caption', function (event) {\n transmuxer.trigger('caption', event);\n });\n };\n\n var Transmuxer = function Transmuxer(options) {\n var pipeline = null,\n hasFlushed = true;\n options = options || {};\n Transmuxer.prototype.init.call(this);\n options.baseMediaDecodeTime = options.baseMediaDecodeTime || 0;\n\n this.push = function (bytes) {\n if (hasFlushed) {\n var isAac = isLikelyAacData(bytes);\n\n if (isAac && (!pipeline || pipeline.type !== 'aac')) {\n pipeline = aacPipeline(options);\n setupPipelineListeners(pipeline, this);\n } else if (!isAac && (!pipeline || pipeline.type !== 'ts')) {\n pipeline = tsPipeline(options);\n setupPipelineListeners(pipeline, this);\n }\n\n hasFlushed = false;\n }\n\n pipeline.headOfPipeline.push(bytes);\n };\n\n this.flush = function () {\n if (!pipeline) {\n return;\n }\n\n hasFlushed = true;\n pipeline.headOfPipeline.flush();\n };\n\n this.partialFlush = function () {\n if (!pipeline) {\n return;\n }\n\n pipeline.headOfPipeline.partialFlush();\n };\n\n this.endTimeline = function () {\n if (!pipeline) {\n return;\n }\n\n pipeline.headOfPipeline.endTimeline();\n };\n\n this.reset = function () {\n if (!pipeline) {\n return;\n }\n\n pipeline.headOfPipeline.reset();\n };\n\n this.setBaseMediaDecodeTime = function (baseMediaDecodeTime) {\n if (!options.keepOriginalTimestamps) {\n options.baseMediaDecodeTime = baseMediaDecodeTime;\n }\n\n if (!pipeline) {\n return;\n }\n\n if (pipeline.tracks.audio) {\n pipeline.tracks.audio.timelineStartInfo.dts = undefined;\n pipeline.tracks.audio.timelineStartInfo.pts = undefined;\n trackDecodeInfo.clearDtsInfo(pipeline.tracks.audio);\n\n if (pipeline.audioRollover) {\n pipeline.audioRollover.discontinuity();\n }\n }\n\n if (pipeline.tracks.video) {\n if (pipeline.videoSegmentStream) {\n pipeline.videoSegmentStream.gopCache_ = [];\n }\n\n pipeline.tracks.video.timelineStartInfo.dts = undefined;\n pipeline.tracks.video.timelineStartInfo.pts = undefined;\n trackDecodeInfo.clearDtsInfo(pipeline.tracks.video); // pipeline.captionStream.reset();\n }\n\n if (pipeline.timestampRollover) {\n pipeline.timestampRollover.discontinuity();\n }\n };\n\n this.setRemux = function (val) {\n options.remux = val;\n\n if (pipeline && pipeline.coalesceStream) {\n pipeline.coalesceStream.setRemux(val);\n }\n };\n\n this.setAudioAppendStart = function (audioAppendStart) {\n if (!pipeline || !pipeline.tracks.audio || !pipeline.audioSegmentStream) {\n return;\n }\n\n pipeline.audioSegmentStream.setAudioAppendStart(audioAppendStart);\n }; // TODO GOP alignment support\n // Support may be a bit trickier than with full segment appends, as GOPs may be split\n // and processed in a more granular fashion\n\n\n this.alignGopsWith = function (gopsToAlignWith) {\n return;\n };\n };\n\n Transmuxer.prototype = new stream();\n var transmuxer = Transmuxer;\n\n var partial = {\n Transmuxer: transmuxer\n };\n\n var MAX_UINT32$1 = Math.pow(2, 32);\n\n var parseSidx = function parseSidx(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n references: [],\n referenceId: view.getUint32(4),\n timescale: view.getUint32(8)\n },\n i = 12;\n\n if (result.version === 0) {\n result.earliestPresentationTime = view.getUint32(i);\n result.firstOffset = view.getUint32(i + 4);\n i += 8;\n } else {\n // read 64 bits\n result.earliestPresentationTime = view.getUint32(i) * MAX_UINT32$1 + view.getUint32(i + 4);\n result.firstOffset = view.getUint32(i + 8) * MAX_UINT32$1 + view.getUint32(i + 12);\n i += 16;\n }\n\n i += 2; // reserved\n\n var referenceCount = view.getUint16(i);\n i += 2; // start of references\n\n for (; referenceCount > 0; i += 12, referenceCount--) {\n result.references.push({\n referenceType: (data[i] & 0x80) >>> 7,\n referencedSize: view.getUint32(i) & 0x7FFFFFFF,\n subsegmentDuration: view.getUint32(i + 4),\n startsWithSap: !!(data[i + 8] & 0x80),\n sapType: (data[i + 8] & 0x70) >>> 4,\n sapDeltaTime: view.getUint32(i + 8) & 0x0FFFFFFF\n });\n }\n\n return result;\n };\n\n var parseSidx_1 = parseSidx;\n\n var MAX_UINT32 = Math.pow(2, 32);\n\n var inspectMp4,\n _textifyMp,\n parseMp4Date = function parseMp4Date(seconds) {\n return new Date(seconds * 1000 - 2082844800000);\n },\n nalParse = function nalParse(avcStream) {\n var avcView = new DataView(avcStream.buffer, avcStream.byteOffset, avcStream.byteLength),\n result = [],\n i,\n length;\n\n for (i = 0; i + 4 < avcStream.length; i += length) {\n length = avcView.getUint32(i);\n i += 4; // bail if this doesn't appear to be an H264 stream\n\n if (length <= 0) {\n result.push('MALFORMED DATA');\n continue;\n }\n\n switch (avcStream[i] & 0x1F) {\n case 0x01:\n result.push('slice_layer_without_partitioning_rbsp');\n break;\n\n case 0x05:\n result.push('slice_layer_without_partitioning_rbsp_idr');\n break;\n\n case 0x06:\n result.push('sei_rbsp');\n break;\n\n case 0x07:\n result.push('seq_parameter_set_rbsp');\n break;\n\n case 0x08:\n result.push('pic_parameter_set_rbsp');\n break;\n\n case 0x09:\n result.push('access_unit_delimiter_rbsp');\n break;\n\n default:\n result.push('UNKNOWN NAL - ' + avcStream[i] & 0x1F);\n break;\n }\n }\n\n return result;\n },\n // registry of handlers for individual mp4 box types\n parse = {\n // codingname, not a first-class box type. stsd entries share the\n // same format as real boxes so the parsing infrastructure can be\n // shared\n avc1: function avc1(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n return {\n dataReferenceIndex: view.getUint16(6),\n width: view.getUint16(24),\n height: view.getUint16(26),\n horizresolution: view.getUint16(28) + view.getUint16(30) / 16,\n vertresolution: view.getUint16(32) + view.getUint16(34) / 16,\n frameCount: view.getUint16(40),\n depth: view.getUint16(74),\n config: inspectMp4(data.subarray(78, data.byteLength))\n };\n },\n avcC: function avcC(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n configurationVersion: data[0],\n avcProfileIndication: data[1],\n profileCompatibility: data[2],\n avcLevelIndication: data[3],\n lengthSizeMinusOne: data[4] & 0x03,\n sps: [],\n pps: []\n },\n numOfSequenceParameterSets = data[5] & 0x1f,\n numOfPictureParameterSets,\n nalSize,\n offset,\n i; // iterate past any SPSs\n\n offset = 6;\n\n for (i = 0; i < numOfSequenceParameterSets; i++) {\n nalSize = view.getUint16(offset);\n offset += 2;\n result.sps.push(new Uint8Array(data.subarray(offset, offset + nalSize)));\n offset += nalSize;\n } // iterate past any PPSs\n\n\n numOfPictureParameterSets = data[offset];\n offset++;\n\n for (i = 0; i < numOfPictureParameterSets; i++) {\n nalSize = view.getUint16(offset);\n offset += 2;\n result.pps.push(new Uint8Array(data.subarray(offset, offset + nalSize)));\n offset += nalSize;\n }\n\n return result;\n },\n btrt: function btrt(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n return {\n bufferSizeDB: view.getUint32(0),\n maxBitrate: view.getUint32(4),\n avgBitrate: view.getUint32(8)\n };\n },\n edts: function edts(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n elst: function elst(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: view.getUint8(0),\n flags: new Uint8Array(data.subarray(1, 4)),\n edits: []\n },\n entryCount = view.getUint32(4),\n i;\n\n for (i = 8; entryCount; entryCount--) {\n if (result.version === 0) {\n result.edits.push({\n segmentDuration: view.getUint32(i),\n mediaTime: view.getInt32(i + 4),\n mediaRate: view.getUint16(i + 8) + view.getUint16(i + 10) / (256 * 256)\n });\n i += 12;\n } else {\n result.edits.push({\n segmentDuration: view.getUint32(i) * MAX_UINT32 + view.getUint32(i + 4),\n mediaTime: view.getUint32(i + 8) * MAX_UINT32 + view.getUint32(i + 12),\n mediaRate: view.getUint16(i + 16) + view.getUint16(i + 18) / (256 * 256)\n });\n i += 20;\n }\n }\n\n return result;\n },\n esds: function esds(data) {\n return {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n esId: data[6] << 8 | data[7],\n streamPriority: data[8] & 0x1f,\n decoderConfig: {\n objectProfileIndication: data[11],\n streamType: data[12] >>> 2 & 0x3f,\n bufferSize: data[13] << 16 | data[14] << 8 | data[15],\n maxBitrate: data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19],\n avgBitrate: data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23],\n decoderConfigDescriptor: {\n tag: data[24],\n length: data[25],\n audioObjectType: data[26] >>> 3 & 0x1f,\n samplingFrequencyIndex: (data[26] & 0x07) << 1 | data[27] >>> 7 & 0x01,\n channelConfiguration: data[27] >>> 3 & 0x0f\n }\n }\n };\n },\n ftyp: function ftyp(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n majorBrand: parseType_1(data.subarray(0, 4)),\n minorVersion: view.getUint32(4),\n compatibleBrands: []\n },\n i = 8;\n\n while (i < data.byteLength) {\n result.compatibleBrands.push(parseType_1(data.subarray(i, i + 4)));\n i += 4;\n }\n\n return result;\n },\n dinf: function dinf(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n dref: function dref(data) {\n return {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n dataReferences: inspectMp4(data.subarray(8))\n };\n },\n hdlr: function hdlr(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: view.getUint8(0),\n flags: new Uint8Array(data.subarray(1, 4)),\n handlerType: parseType_1(data.subarray(8, 12)),\n name: ''\n },\n i = 8; // parse out the name field\n\n for (i = 24; i < data.byteLength; i++) {\n if (data[i] === 0x00) {\n // the name field is null-terminated\n i++;\n break;\n }\n\n result.name += String.fromCharCode(data[i]);\n } // decode UTF-8 to javascript's internal representation\n // see http://ecmanaut.blogspot.com/2006/07/encoding-decoding-utf8-in-javascript.html\n\n\n result.name = decodeURIComponent(escape(result.name));\n return result;\n },\n mdat: function mdat(data) {\n return {\n byteLength: data.byteLength,\n nals: nalParse(data)\n };\n },\n mdhd: function mdhd(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n i = 4,\n language,\n result = {\n version: view.getUint8(0),\n flags: new Uint8Array(data.subarray(1, 4)),\n language: ''\n };\n\n if (result.version === 1) {\n i += 4;\n result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n i += 8;\n result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n i += 4;\n result.timescale = view.getUint32(i);\n i += 8;\n result.duration = view.getUint32(i); // truncating top 4 bytes\n } else {\n result.creationTime = parseMp4Date(view.getUint32(i));\n i += 4;\n result.modificationTime = parseMp4Date(view.getUint32(i));\n i += 4;\n result.timescale = view.getUint32(i);\n i += 4;\n result.duration = view.getUint32(i);\n }\n\n i += 4; // language is stored as an ISO-639-2/T code in an array of three 5-bit fields\n // each field is the packed difference between its ASCII value and 0x60\n\n language = view.getUint16(i);\n result.language += String.fromCharCode((language >> 10) + 0x60);\n result.language += String.fromCharCode(((language & 0x03e0) >> 5) + 0x60);\n result.language += String.fromCharCode((language & 0x1f) + 0x60);\n return result;\n },\n mdia: function mdia(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n mfhd: function mfhd(data) {\n return {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n sequenceNumber: data[4] << 24 | data[5] << 16 | data[6] << 8 | data[7]\n };\n },\n minf: function minf(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n // codingname, not a first-class box type. stsd entries share the\n // same format as real boxes so the parsing infrastructure can be\n // shared\n mp4a: function mp4a(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n // 6 bytes reserved\n dataReferenceIndex: view.getUint16(6),\n // 4 + 4 bytes reserved\n channelcount: view.getUint16(16),\n samplesize: view.getUint16(18),\n // 2 bytes pre_defined\n // 2 bytes reserved\n samplerate: view.getUint16(24) + view.getUint16(26) / 65536\n }; // if there are more bytes to process, assume this is an ISO/IEC\n // 14496-14 MP4AudioSampleEntry and parse the ESDBox\n\n if (data.byteLength > 28) {\n result.streamDescriptor = inspectMp4(data.subarray(28))[0];\n }\n\n return result;\n },\n moof: function moof(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n moov: function moov(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n mvex: function mvex(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n mvhd: function mvhd(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n i = 4,\n result = {\n version: view.getUint8(0),\n flags: new Uint8Array(data.subarray(1, 4))\n };\n\n if (result.version === 1) {\n i += 4;\n result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n i += 8;\n result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n i += 4;\n result.timescale = view.getUint32(i);\n i += 8;\n result.duration = view.getUint32(i); // truncating top 4 bytes\n } else {\n result.creationTime = parseMp4Date(view.getUint32(i));\n i += 4;\n result.modificationTime = parseMp4Date(view.getUint32(i));\n i += 4;\n result.timescale = view.getUint32(i);\n i += 4;\n result.duration = view.getUint32(i);\n }\n\n i += 4; // convert fixed-point, base 16 back to a number\n\n result.rate = view.getUint16(i) + view.getUint16(i + 2) / 16;\n i += 4;\n result.volume = view.getUint8(i) + view.getUint8(i + 1) / 8;\n i += 2;\n i += 2;\n i += 2 * 4;\n result.matrix = new Uint32Array(data.subarray(i, i + 9 * 4));\n i += 9 * 4;\n i += 6 * 4;\n result.nextTrackId = view.getUint32(i);\n return result;\n },\n pdin: function pdin(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n return {\n version: view.getUint8(0),\n flags: new Uint8Array(data.subarray(1, 4)),\n rate: view.getUint32(4),\n initialDelay: view.getUint32(8)\n };\n },\n sdtp: function sdtp(data) {\n var result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n samples: []\n },\n i;\n\n for (i = 4; i < data.byteLength; i++) {\n result.samples.push({\n dependsOn: (data[i] & 0x30) >> 4,\n isDependedOn: (data[i] & 0x0c) >> 2,\n hasRedundancy: data[i] & 0x03\n });\n }\n\n return result;\n },\n sidx: parseSidx_1,\n smhd: function smhd(data) {\n return {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n balance: data[4] + data[5] / 256\n };\n },\n stbl: function stbl(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n ctts: function ctts(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: view.getUint8(0),\n flags: new Uint8Array(data.subarray(1, 4)),\n compositionOffsets: []\n },\n entryCount = view.getUint32(4),\n i;\n\n for (i = 8; entryCount; i += 8, entryCount--) {\n result.compositionOffsets.push({\n sampleCount: view.getUint32(i),\n sampleOffset: view[result.version === 0 ? 'getUint32' : 'getInt32'](i + 4)\n });\n }\n\n return result;\n },\n stss: function stss(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: view.getUint8(0),\n flags: new Uint8Array(data.subarray(1, 4)),\n syncSamples: []\n },\n entryCount = view.getUint32(4),\n i;\n\n for (i = 8; entryCount; i += 4, entryCount--) {\n result.syncSamples.push(view.getUint32(i));\n }\n\n return result;\n },\n stco: function stco(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n chunkOffsets: []\n },\n entryCount = view.getUint32(4),\n i;\n\n for (i = 8; entryCount; i += 4, entryCount--) {\n result.chunkOffsets.push(view.getUint32(i));\n }\n\n return result;\n },\n stsc: function stsc(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n entryCount = view.getUint32(4),\n result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n sampleToChunks: []\n },\n i;\n\n for (i = 8; entryCount; i += 12, entryCount--) {\n result.sampleToChunks.push({\n firstChunk: view.getUint32(i),\n samplesPerChunk: view.getUint32(i + 4),\n sampleDescriptionIndex: view.getUint32(i + 8)\n });\n }\n\n return result;\n },\n stsd: function stsd(data) {\n return {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n sampleDescriptions: inspectMp4(data.subarray(8))\n };\n },\n stsz: function stsz(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n sampleSize: view.getUint32(4),\n entries: []\n },\n i;\n\n for (i = 12; i < data.byteLength; i += 4) {\n result.entries.push(view.getUint32(i));\n }\n\n return result;\n },\n stts: function stts(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n result = {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n timeToSamples: []\n },\n entryCount = view.getUint32(4),\n i;\n\n for (i = 8; entryCount; i += 8, entryCount--) {\n result.timeToSamples.push({\n sampleCount: view.getUint32(i),\n sampleDelta: view.getUint32(i + 4)\n });\n }\n\n return result;\n },\n styp: function styp(data) {\n return parse.ftyp(data);\n },\n tfdt: parseTfdt,\n tfhd: parseTfhd,\n tkhd: function tkhd(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength),\n i = 4,\n result = {\n version: view.getUint8(0),\n flags: new Uint8Array(data.subarray(1, 4))\n };\n\n if (result.version === 1) {\n i += 4;\n result.creationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n i += 8;\n result.modificationTime = parseMp4Date(view.getUint32(i)); // truncating top 4 bytes\n\n i += 4;\n result.trackId = view.getUint32(i);\n i += 4;\n i += 8;\n result.duration = view.getUint32(i); // truncating top 4 bytes\n } else {\n result.creationTime = parseMp4Date(view.getUint32(i));\n i += 4;\n result.modificationTime = parseMp4Date(view.getUint32(i));\n i += 4;\n result.trackId = view.getUint32(i);\n i += 4;\n i += 4;\n result.duration = view.getUint32(i);\n }\n\n i += 4;\n i += 2 * 4;\n result.layer = view.getUint16(i);\n i += 2;\n result.alternateGroup = view.getUint16(i);\n i += 2; // convert fixed-point, base 16 back to a number\n\n result.volume = view.getUint8(i) + view.getUint8(i + 1) / 8;\n i += 2;\n i += 2;\n result.matrix = new Uint32Array(data.subarray(i, i + 9 * 4));\n i += 9 * 4;\n result.width = view.getUint16(i) + view.getUint16(i + 2) / 65536;\n i += 4;\n result.height = view.getUint16(i) + view.getUint16(i + 2) / 65536;\n return result;\n },\n traf: function traf(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n trak: function trak(data) {\n return {\n boxes: inspectMp4(data)\n };\n },\n trex: function trex(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n return {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n trackId: view.getUint32(4),\n defaultSampleDescriptionIndex: view.getUint32(8),\n defaultSampleDuration: view.getUint32(12),\n defaultSampleSize: view.getUint32(16),\n sampleDependsOn: data[20] & 0x03,\n sampleIsDependedOn: (data[21] & 0xc0) >> 6,\n sampleHasRedundancy: (data[21] & 0x30) >> 4,\n samplePaddingValue: (data[21] & 0x0e) >> 1,\n sampleIsDifferenceSample: !!(data[21] & 0x01),\n sampleDegradationPriority: view.getUint16(22)\n };\n },\n trun: parseTrun,\n 'url ': function url(data) {\n return {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4))\n };\n },\n vmhd: function vmhd(data) {\n var view = new DataView(data.buffer, data.byteOffset, data.byteLength);\n return {\n version: data[0],\n flags: new Uint8Array(data.subarray(1, 4)),\n graphicsmode: view.getUint16(4),\n opcolor: new Uint16Array([view.getUint16(6), view.getUint16(8), view.getUint16(10)])\n };\n }\n };\n /**\n * Return a javascript array of box objects parsed from an ISO base\n * media file.\n * @param data {Uint8Array} the binary data of the media to be inspected\n * @return {array} a javascript array of potentially nested box objects\n */\n\n\n inspectMp4 = function inspectMp4(data) {\n var i = 0,\n result = [],\n view,\n size,\n type,\n end,\n box; // Convert data from Uint8Array to ArrayBuffer, to follow Dataview API\n\n var ab = new ArrayBuffer(data.length);\n var v = new Uint8Array(ab);\n\n for (var z = 0; z < data.length; ++z) {\n v[z] = data[z];\n }\n\n view = new DataView(ab);\n\n while (i < data.byteLength) {\n // parse box data\n size = view.getUint32(i);\n type = parseType_1(data.subarray(i + 4, i + 8));\n end = size > 1 ? i + size : data.byteLength; // parse type-specific data\n\n box = (parse[type] || function (data) {\n return {\n data: data\n };\n })(data.subarray(i + 8, end));\n\n box.size = size;\n box.type = type; // store this box and move to the next\n\n result.push(box);\n i = end;\n }\n\n return result;\n };\n /**\n * Returns a textual representation of the javascript represtentation\n * of an MP4 file. You can use it as an alternative to\n * JSON.stringify() to compare inspected MP4s.\n * @param inspectedMp4 {array} the parsed array of boxes in an MP4\n * file\n * @param depth {number} (optional) the number of ancestor boxes of\n * the elements of inspectedMp4. Assumed to be zero if unspecified.\n * @return {string} a text representation of the parsed MP4\n */\n\n\n _textifyMp = function textifyMp4(inspectedMp4, depth) {\n var indent;\n depth = depth || 0;\n indent = new Array(depth * 2 + 1).join(' '); // iterate over all the boxes\n\n return inspectedMp4.map(function (box, index) {\n // list the box type first at the current indentation level\n return indent + box.type + '\\n' + // the type is already included and handle child boxes separately\n Object.keys(box).filter(function (key) {\n return key !== 'type' && key !== 'boxes'; // output all the box properties\n }).map(function (key) {\n var prefix = indent + ' ' + key + ': ',\n value = box[key]; // print out raw bytes as hexademical\n\n if (value instanceof Uint8Array || value instanceof Uint32Array) {\n var bytes = Array.prototype.slice.call(new Uint8Array(value.buffer, value.byteOffset, value.byteLength)).map(function (byte) {\n return ' ' + ('00' + byte.toString(16)).slice(-2);\n }).join('').match(/.{1,24}/g);\n\n if (!bytes) {\n return prefix + '<>';\n }\n\n if (bytes.length === 1) {\n return prefix + '<' + bytes.join('').slice(1) + '>';\n }\n\n return prefix + '<\\n' + bytes.map(function (line) {\n return indent + ' ' + line;\n }).join('\\n') + '\\n' + indent + ' >';\n } // stringify generic objects\n\n\n return prefix + JSON.stringify(value, null, 2).split('\\n').map(function (line, index) {\n if (index === 0) {\n return line;\n }\n\n return indent + ' ' + line;\n }).join('\\n');\n }).join('\\n') + ( // recursively textify the child boxes\n box.boxes ? '\\n' + _textifyMp(box.boxes, depth + 1) : '');\n }).join('\\n');\n };\n\n var mp4Inspector = {\n inspect: inspectMp4,\n textify: _textifyMp,\n parseType: parseType_1,\n findBox: findBox_1,\n parseTraf: parse.traf,\n parseTfdt: parse.tfdt,\n parseHdlr: parse.hdlr,\n parseTfhd: parse.tfhd,\n parseTrun: parse.trun,\n parseSidx: parse.sidx\n };\n\n /**\n * mux.js\n *\n * Copyright (c) Brightcove\n * Licensed Apache-2.0 https://github.com/videojs/mux.js/blob/master/LICENSE\n */\n\n var tagTypes = {\n 0x08: 'audio',\n 0x09: 'video',\n 0x12: 'metadata'\n },\n hex = function hex(val) {\n return '0x' + ('00' + val.toString(16)).slice(-2).toUpperCase();\n },\n hexStringList = function hexStringList(data) {\n var arr = [],\n i;\n\n while (data.byteLength > 0) {\n i = 0;\n arr.push(hex(data[i++]));\n data = data.subarray(i);\n }\n\n return arr.join(' ');\n },\n parseAVCTag = function parseAVCTag(tag, obj) {\n var avcPacketTypes = ['AVC Sequence Header', 'AVC NALU', 'AVC End-of-Sequence'],\n compositionTime = tag[1] & parseInt('01111111', 2) << 16 | tag[2] << 8 | tag[3];\n obj = obj || {};\n obj.avcPacketType = avcPacketTypes[tag[0]];\n obj.CompositionTime = tag[1] & parseInt('10000000', 2) ? -compositionTime : compositionTime;\n\n if (tag[0] === 1) {\n obj.nalUnitTypeRaw = hexStringList(tag.subarray(4, 100));\n } else {\n obj.data = hexStringList(tag.subarray(4));\n }\n\n return obj;\n },\n parseVideoTag = function parseVideoTag(tag, obj) {\n var frameTypes = ['Unknown', 'Keyframe (for AVC, a seekable frame)', 'Inter frame (for AVC, a nonseekable frame)', 'Disposable inter frame (H.263 only)', 'Generated keyframe (reserved for server use only)', 'Video info/command frame'],\n codecID = tag[0] & parseInt('00001111', 2);\n obj = obj || {};\n obj.frameType = frameTypes[(tag[0] & parseInt('11110000', 2)) >>> 4];\n obj.codecID = codecID;\n\n if (codecID === 7) {\n return parseAVCTag(tag.subarray(1), obj);\n }\n\n return obj;\n },\n parseAACTag = function parseAACTag(tag, obj) {\n var packetTypes = ['AAC Sequence Header', 'AAC Raw'];\n obj = obj || {};\n obj.aacPacketType = packetTypes[tag[0]];\n obj.data = hexStringList(tag.subarray(1));\n return obj;\n },\n parseAudioTag = function parseAudioTag(tag, obj) {\n var formatTable = ['Linear PCM, platform endian', 'ADPCM', 'MP3', 'Linear PCM, little endian', 'Nellymoser 16-kHz mono', 'Nellymoser 8-kHz mono', 'Nellymoser', 'G.711 A-law logarithmic PCM', 'G.711 mu-law logarithmic PCM', 'reserved', 'AAC', 'Speex', 'MP3 8-Khz', 'Device-specific sound'],\n samplingRateTable = ['5.5-kHz', '11-kHz', '22-kHz', '44-kHz'],\n soundFormat = (tag[0] & parseInt('11110000', 2)) >>> 4;\n obj = obj || {};\n obj.soundFormat = formatTable[soundFormat];\n obj.soundRate = samplingRateTable[(tag[0] & parseInt('00001100', 2)) >>> 2];\n obj.soundSize = (tag[0] & parseInt('00000010', 2)) >>> 1 ? '16-bit' : '8-bit';\n obj.soundType = tag[0] & parseInt('00000001', 2) ? 'Stereo' : 'Mono';\n\n if (soundFormat === 10) {\n return parseAACTag(tag.subarray(1), obj);\n }\n\n return obj;\n },\n parseGenericTag = function parseGenericTag(tag) {\n return {\n tagType: tagTypes[tag[0]],\n dataSize: tag[1] << 16 | tag[2] << 8 | tag[3],\n timestamp: tag[7] << 24 | tag[4] << 16 | tag[5] << 8 | tag[6],\n streamID: tag[8] << 16 | tag[9] << 8 | tag[10]\n };\n },\n inspectFlvTag = function inspectFlvTag(tag) {\n var header = parseGenericTag(tag);\n\n switch (tag[0]) {\n case 0x08:\n parseAudioTag(tag.subarray(11), header);\n break;\n\n case 0x09:\n parseVideoTag(tag.subarray(11), header);\n break;\n }\n\n return header;\n },\n inspectFlv = function inspectFlv(bytes) {\n var i = 9,\n // header\n dataSize,\n parsedResults = [],\n tag; // traverse the tags\n\n i += 4; // skip previous tag size\n\n while (i < bytes.byteLength) {\n dataSize = bytes[i + 1] << 16;\n dataSize |= bytes[i + 2] << 8;\n dataSize |= bytes[i + 3];\n dataSize += 11;\n tag = bytes.subarray(i, i + dataSize);\n parsedResults.push(inspectFlvTag(tag));\n i += dataSize + 4;\n }\n\n return parsedResults;\n },\n textifyFlv = function textifyFlv(flvTagArray) {\n return JSON.stringify(flvTagArray, null, 2);\n };\n\n var flvInspector = {\n inspectTag: inspectFlvTag,\n inspect: inspectFlv,\n textify: textifyFlv\n };\n\n var parsePid = function parsePid(packet) {\n var pid = packet[1] & 0x1f;\n pid <<= 8;\n pid |= packet[2];\n return pid;\n };\n\n var parsePayloadUnitStartIndicator = function parsePayloadUnitStartIndicator(packet) {\n return !!(packet[1] & 0x40);\n };\n\n var parseAdaptionField = function parseAdaptionField(packet) {\n var offset = 0; // if an adaption field is present, its length is specified by the\n // fifth byte of the TS packet header. The adaptation field is\n // used to add stuffing to PES packets that don't fill a complete\n // TS packet, and to specify some forms of timing and control data\n // that we do not currently use.\n\n if ((packet[3] & 0x30) >>> 4 > 0x01) {\n offset += packet[4] + 1;\n }\n\n return offset;\n };\n\n var parseType = function parseType(packet, pmtPid) {\n var pid = parsePid(packet);\n\n if (pid === 0) {\n return 'pat';\n } else if (pid === pmtPid) {\n return 'pmt';\n } else if (pmtPid) {\n return 'pes';\n }\n\n return null;\n };\n\n var parsePat = function parsePat(packet) {\n var pusi = parsePayloadUnitStartIndicator(packet);\n var offset = 4 + parseAdaptionField(packet);\n\n if (pusi) {\n offset += packet[offset] + 1;\n }\n\n return (packet[offset + 10] & 0x1f) << 8 | packet[offset + 11];\n };\n\n var parsePmt = function parsePmt(packet) {\n var programMapTable = {};\n var pusi = parsePayloadUnitStartIndicator(packet);\n var payloadOffset = 4 + parseAdaptionField(packet);\n\n if (pusi) {\n payloadOffset += packet[payloadOffset] + 1;\n } // PMTs can be sent ahead of the time when they should actually\n // take effect. We don't believe this should ever be the case\n // for HLS but we'll ignore \"forward\" PMT declarations if we see\n // them. Future PMT declarations have the current_next_indicator\n // set to zero.\n\n\n if (!(packet[payloadOffset + 5] & 0x01)) {\n return;\n }\n\n var sectionLength, tableEnd, programInfoLength; // the mapping table ends at the end of the current section\n\n sectionLength = (packet[payloadOffset + 1] & 0x0f) << 8 | packet[payloadOffset + 2];\n tableEnd = 3 + sectionLength - 4; // to determine where the table is, we have to figure out how\n // long the program info descriptors are\n\n programInfoLength = (packet[payloadOffset + 10] & 0x0f) << 8 | packet[payloadOffset + 11]; // advance the offset to the first entry in the mapping table\n\n var offset = 12 + programInfoLength;\n\n while (offset < tableEnd) {\n var i = payloadOffset + offset; // add an entry that maps the elementary_pid to the stream_type\n\n programMapTable[(packet[i + 1] & 0x1F) << 8 | packet[i + 2]] = packet[i]; // move to the next table entry\n // skip past the elementary stream descriptors, if present\n\n offset += ((packet[i + 3] & 0x0F) << 8 | packet[i + 4]) + 5;\n }\n\n return programMapTable;\n };\n\n var parsePesType = function parsePesType(packet, programMapTable) {\n var pid = parsePid(packet);\n var type = programMapTable[pid];\n\n switch (type) {\n case streamTypes.H264_STREAM_TYPE:\n return 'video';\n\n case streamTypes.ADTS_STREAM_TYPE:\n return 'audio';\n\n case streamTypes.METADATA_STREAM_TYPE:\n return 'timed-metadata';\n\n default:\n return null;\n }\n };\n\n var parsePesTime = function parsePesTime(packet) {\n var pusi = parsePayloadUnitStartIndicator(packet);\n\n if (!pusi) {\n return null;\n }\n\n var offset = 4 + parseAdaptionField(packet);\n\n if (offset >= packet.byteLength) {\n // From the H 222.0 MPEG-TS spec\n // \"For transport stream packets carrying PES packets, stuffing is needed when there\n // is insufficient PES packet data to completely fill the transport stream packet\n // payload bytes. Stuffing is accomplished by defining an adaptation field longer than\n // the sum of the lengths of the data elements in it, so that the payload bytes\n // remaining after the adaptation field exactly accommodates the available PES packet\n // data.\"\n //\n // If the offset is >= the length of the packet, then the packet contains no data\n // and instead is just adaption field stuffing bytes\n return null;\n }\n\n var pes = null;\n var ptsDtsFlags; // PES packets may be annotated with a PTS value, or a PTS value\n // and a DTS value. Determine what combination of values is\n // available to work with.\n\n ptsDtsFlags = packet[offset + 7]; // PTS and DTS are normally stored as a 33-bit number. Javascript\n // performs all bitwise operations on 32-bit integers but javascript\n // supports a much greater range (52-bits) of integer using standard\n // mathematical operations.\n // We construct a 31-bit value using bitwise operators over the 31\n // most significant bits and then multiply by 4 (equal to a left-shift\n // of 2) before we add the final 2 least significant bits of the\n // timestamp (equal to an OR.)\n\n if (ptsDtsFlags & 0xC0) {\n pes = {}; // the PTS and DTS are not written out directly. For information\n // on how they are encoded, see\n // http://dvd.sourceforge.net/dvdinfo/pes-hdr.html\n\n pes.pts = (packet[offset + 9] & 0x0E) << 27 | (packet[offset + 10] & 0xFF) << 20 | (packet[offset + 11] & 0xFE) << 12 | (packet[offset + 12] & 0xFF) << 5 | (packet[offset + 13] & 0xFE) >>> 3;\n pes.pts *= 4; // Left shift by 2\n\n pes.pts += (packet[offset + 13] & 0x06) >>> 1; // OR by the two LSBs\n\n pes.dts = pes.pts;\n\n if (ptsDtsFlags & 0x40) {\n pes.dts = (packet[offset + 14] & 0x0E) << 27 | (packet[offset + 15] & 0xFF) << 20 | (packet[offset + 16] & 0xFE) << 12 | (packet[offset + 17] & 0xFF) << 5 | (packet[offset + 18] & 0xFE) >>> 3;\n pes.dts *= 4; // Left shift by 2\n\n pes.dts += (packet[offset + 18] & 0x06) >>> 1; // OR by the two LSBs\n }\n }\n\n return pes;\n };\n\n var parseNalUnitType = function parseNalUnitType(type) {\n switch (type) {\n case 0x05:\n return 'slice_layer_without_partitioning_rbsp_idr';\n\n case 0x06:\n return 'sei_rbsp';\n\n case 0x07:\n return 'seq_parameter_set_rbsp';\n\n case 0x08:\n return 'pic_parameter_set_rbsp';\n\n case 0x09:\n return 'access_unit_delimiter_rbsp';\n\n default:\n return null;\n }\n };\n\n var videoPacketContainsKeyFrame = function videoPacketContainsKeyFrame(packet) {\n var offset = 4 + parseAdaptionField(packet);\n var frameBuffer = packet.subarray(offset);\n var frameI = 0;\n var frameSyncPoint = 0;\n var foundKeyFrame = false;\n var nalType; // advance the sync point to a NAL start, if necessary\n\n for (; frameSyncPoint < frameBuffer.byteLength - 3; frameSyncPoint++) {\n if (frameBuffer[frameSyncPoint + 2] === 1) {\n // the sync point is properly aligned\n frameI = frameSyncPoint + 5;\n break;\n }\n }\n\n while (frameI < frameBuffer.byteLength) {\n // look at the current byte to determine if we've hit the end of\n // a NAL unit boundary\n switch (frameBuffer[frameI]) {\n case 0:\n // skip past non-sync sequences\n if (frameBuffer[frameI - 1] !== 0) {\n frameI += 2;\n break;\n } else if (frameBuffer[frameI - 2] !== 0) {\n frameI++;\n break;\n }\n\n if (frameSyncPoint + 3 !== frameI - 2) {\n nalType = parseNalUnitType(frameBuffer[frameSyncPoint + 3] & 0x1f);\n\n if (nalType === 'slice_layer_without_partitioning_rbsp_idr') {\n foundKeyFrame = true;\n }\n } // drop trailing zeroes\n\n\n do {\n frameI++;\n } while (frameBuffer[frameI] !== 1 && frameI < frameBuffer.length);\n\n frameSyncPoint = frameI - 2;\n frameI += 3;\n break;\n\n case 1:\n // skip past non-sync sequences\n if (frameBuffer[frameI - 1] !== 0 || frameBuffer[frameI - 2] !== 0) {\n frameI += 3;\n break;\n }\n\n nalType = parseNalUnitType(frameBuffer[frameSyncPoint + 3] & 0x1f);\n\n if (nalType === 'slice_layer_without_partitioning_rbsp_idr') {\n foundKeyFrame = true;\n }\n\n frameSyncPoint = frameI - 2;\n frameI += 3;\n break;\n\n default:\n // the current byte isn't a one or zero, so it cannot be part\n // of a sync sequence\n frameI += 3;\n break;\n }\n }\n\n frameBuffer = frameBuffer.subarray(frameSyncPoint);\n frameI -= frameSyncPoint;\n frameSyncPoint = 0; // parse the final nal\n\n if (frameBuffer && frameBuffer.byteLength > 3) {\n nalType = parseNalUnitType(frameBuffer[frameSyncPoint + 3] & 0x1f);\n\n if (nalType === 'slice_layer_without_partitioning_rbsp_idr') {\n foundKeyFrame = true;\n }\n }\n\n return foundKeyFrame;\n };\n\n var probe$1 = {\n parseType: parseType,\n parsePat: parsePat,\n parsePmt: parsePmt,\n parsePayloadUnitStartIndicator: parsePayloadUnitStartIndicator,\n parsePesType: parsePesType,\n parsePesTime: parsePesTime,\n videoPacketContainsKeyFrame: videoPacketContainsKeyFrame\n };\n\n var handleRollover = timestampRolloverStream.handleRollover;\n var probe = {};\n probe.ts = probe$1;\n probe.aac = utils;\n var ONE_SECOND_IN_TS = clock.ONE_SECOND_IN_TS;\n var MP2T_PACKET_LENGTH = 188,\n // bytes\n SYNC_BYTE = 0x47;\n /**\n * walks through segment data looking for pat and pmt packets to parse out\n * program map table information\n */\n\n var parsePsi_ = function parsePsi_(bytes, pmt) {\n var startIndex = 0,\n endIndex = MP2T_PACKET_LENGTH,\n packet,\n type;\n\n while (endIndex < bytes.byteLength) {\n // Look for a pair of start and end sync bytes in the data..\n if (bytes[startIndex] === SYNC_BYTE && bytes[endIndex] === SYNC_BYTE) {\n // We found a packet\n packet = bytes.subarray(startIndex, endIndex);\n type = probe.ts.parseType(packet, pmt.pid);\n\n switch (type) {\n case 'pat':\n pmt.pid = probe.ts.parsePat(packet);\n break;\n\n case 'pmt':\n var table = probe.ts.parsePmt(packet);\n pmt.table = pmt.table || {};\n Object.keys(table).forEach(function (key) {\n pmt.table[key] = table[key];\n });\n break;\n }\n\n startIndex += MP2T_PACKET_LENGTH;\n endIndex += MP2T_PACKET_LENGTH;\n continue;\n } // If we get here, we have somehow become de-synchronized and we need to step\n // forward one byte at a time until we find a pair of sync bytes that denote\n // a packet\n\n\n startIndex++;\n endIndex++;\n }\n };\n /**\n * walks through the segment data from the start and end to get timing information\n * for the first and last audio pes packets\n */\n\n\n var parseAudioPes_ = function parseAudioPes_(bytes, pmt, result) {\n var startIndex = 0,\n endIndex = MP2T_PACKET_LENGTH,\n packet,\n type,\n pesType,\n pusi,\n parsed;\n var endLoop = false; // Start walking from start of segment to get first audio packet\n\n while (endIndex <= bytes.byteLength) {\n // Look for a pair of start and end sync bytes in the data..\n if (bytes[startIndex] === SYNC_BYTE && (bytes[endIndex] === SYNC_BYTE || endIndex === bytes.byteLength)) {\n // We found a packet\n packet = bytes.subarray(startIndex, endIndex);\n type = probe.ts.parseType(packet, pmt.pid);\n\n switch (type) {\n case 'pes':\n pesType = probe.ts.parsePesType(packet, pmt.table);\n pusi = probe.ts.parsePayloadUnitStartIndicator(packet);\n\n if (pesType === 'audio' && pusi) {\n parsed = probe.ts.parsePesTime(packet);\n\n if (parsed) {\n parsed.type = 'audio';\n result.audio.push(parsed);\n endLoop = true;\n }\n }\n\n break;\n }\n\n if (endLoop) {\n break;\n }\n\n startIndex += MP2T_PACKET_LENGTH;\n endIndex += MP2T_PACKET_LENGTH;\n continue;\n } // If we get here, we have somehow become de-synchronized and we need to step\n // forward one byte at a time until we find a pair of sync bytes that denote\n // a packet\n\n\n startIndex++;\n endIndex++;\n } // Start walking from end of segment to get last audio packet\n\n\n endIndex = bytes.byteLength;\n startIndex = endIndex - MP2T_PACKET_LENGTH;\n endLoop = false;\n\n while (startIndex >= 0) {\n // Look for a pair of start and end sync bytes in the data..\n if (bytes[startIndex] === SYNC_BYTE && (bytes[endIndex] === SYNC_BYTE || endIndex === bytes.byteLength)) {\n // We found a packet\n packet = bytes.subarray(startIndex, endIndex);\n type = probe.ts.parseType(packet, pmt.pid);\n\n switch (type) {\n case 'pes':\n pesType = probe.ts.parsePesType(packet, pmt.table);\n pusi = probe.ts.parsePayloadUnitStartIndicator(packet);\n\n if (pesType === 'audio' && pusi) {\n parsed = probe.ts.parsePesTime(packet);\n\n if (parsed) {\n parsed.type = 'audio';\n result.audio.push(parsed);\n endLoop = true;\n }\n }\n\n break;\n }\n\n if (endLoop) {\n break;\n }\n\n startIndex -= MP2T_PACKET_LENGTH;\n endIndex -= MP2T_PACKET_LENGTH;\n continue;\n } // If we get here, we have somehow become de-synchronized and we need to step\n // forward one byte at a time until we find a pair of sync bytes that denote\n // a packet\n\n\n startIndex--;\n endIndex--;\n }\n };\n /**\n * walks through the segment data from the start and end to get timing information\n * for the first and last video pes packets as well as timing information for the first\n * key frame.\n */\n\n\n var parseVideoPes_ = function parseVideoPes_(bytes, pmt, result) {\n var startIndex = 0,\n endIndex = MP2T_PACKET_LENGTH,\n packet,\n type,\n pesType,\n pusi,\n parsed,\n frame,\n i,\n pes;\n var endLoop = false;\n var currentFrame = {\n data: [],\n size: 0\n }; // Start walking from start of segment to get first video packet\n\n while (endIndex < bytes.byteLength) {\n // Look for a pair of start and end sync bytes in the data..\n if (bytes[startIndex] === SYNC_BYTE && bytes[endIndex] === SYNC_BYTE) {\n // We found a packet\n packet = bytes.subarray(startIndex, endIndex);\n type = probe.ts.parseType(packet, pmt.pid);\n\n switch (type) {\n case 'pes':\n pesType = probe.ts.parsePesType(packet, pmt.table);\n pusi = probe.ts.parsePayloadUnitStartIndicator(packet);\n\n if (pesType === 'video') {\n if (pusi && !endLoop) {\n parsed = probe.ts.parsePesTime(packet);\n\n if (parsed) {\n parsed.type = 'video';\n result.video.push(parsed);\n endLoop = true;\n }\n }\n\n if (!result.firstKeyFrame) {\n if (pusi) {\n if (currentFrame.size !== 0) {\n frame = new Uint8Array(currentFrame.size);\n i = 0;\n\n while (currentFrame.data.length) {\n pes = currentFrame.data.shift();\n frame.set(pes, i);\n i += pes.byteLength;\n }\n\n if (probe.ts.videoPacketContainsKeyFrame(frame)) {\n var firstKeyFrame = probe.ts.parsePesTime(frame); // PTS/DTS may not be available. Simply *not* setting\n // the keyframe seems to work fine with HLS playback\n // and definitely preferable to a crash with TypeError...\n\n if (firstKeyFrame) {\n result.firstKeyFrame = firstKeyFrame;\n result.firstKeyFrame.type = 'video';\n } else {\n // eslint-disable-next-line\n console.warn('Failed to extract PTS/DTS from PES at first keyframe. ' + 'This could be an unusual TS segment, or else mux.js did not ' + 'parse your TS segment correctly. If you know your TS ' + 'segments do contain PTS/DTS on keyframes please file a bug ' + 'report! You can try ffprobe to double check for yourself.');\n }\n }\n\n currentFrame.size = 0;\n }\n }\n\n currentFrame.data.push(packet);\n currentFrame.size += packet.byteLength;\n }\n }\n\n break;\n }\n\n if (endLoop && result.firstKeyFrame) {\n break;\n }\n\n startIndex += MP2T_PACKET_LENGTH;\n endIndex += MP2T_PACKET_LENGTH;\n continue;\n } // If we get here, we have somehow become de-synchronized and we need to step\n // forward one byte at a time until we find a pair of sync bytes that denote\n // a packet\n\n\n startIndex++;\n endIndex++;\n } // Start walking from end of segment to get last video packet\n\n\n endIndex = bytes.byteLength;\n startIndex = endIndex - MP2T_PACKET_LENGTH;\n endLoop = false;\n\n while (startIndex >= 0) {\n // Look for a pair of start and end sync bytes in the data..\n if (bytes[startIndex] === SYNC_BYTE && bytes[endIndex] === SYNC_BYTE) {\n // We found a packet\n packet = bytes.subarray(startIndex, endIndex);\n type = probe.ts.parseType(packet, pmt.pid);\n\n switch (type) {\n case 'pes':\n pesType = probe.ts.parsePesType(packet, pmt.table);\n pusi = probe.ts.parsePayloadUnitStartIndicator(packet);\n\n if (pesType === 'video' && pusi) {\n parsed = probe.ts.parsePesTime(packet);\n\n if (parsed) {\n parsed.type = 'video';\n result.video.push(parsed);\n endLoop = true;\n }\n }\n\n break;\n }\n\n if (endLoop) {\n break;\n }\n\n startIndex -= MP2T_PACKET_LENGTH;\n endIndex -= MP2T_PACKET_LENGTH;\n continue;\n } // If we get here, we have somehow become de-synchronized and we need to step\n // forward one byte at a time until we find a pair of sync bytes that denote\n // a packet\n\n\n startIndex--;\n endIndex--;\n }\n };\n /**\n * Adjusts the timestamp information for the segment to account for\n * rollover and convert to seconds based on pes packet timescale (90khz clock)\n */\n\n\n var adjustTimestamp_ = function adjustTimestamp_(segmentInfo, baseTimestamp) {\n if (segmentInfo.audio && segmentInfo.audio.length) {\n var audioBaseTimestamp = baseTimestamp;\n\n if (typeof audioBaseTimestamp === 'undefined' || isNaN(audioBaseTimestamp)) {\n audioBaseTimestamp = segmentInfo.audio[0].dts;\n }\n\n segmentInfo.audio.forEach(function (info) {\n info.dts = handleRollover(info.dts, audioBaseTimestamp);\n info.pts = handleRollover(info.pts, audioBaseTimestamp); // time in seconds\n\n info.dtsTime = info.dts / ONE_SECOND_IN_TS;\n info.ptsTime = info.pts / ONE_SECOND_IN_TS;\n });\n }\n\n if (segmentInfo.video && segmentInfo.video.length) {\n var videoBaseTimestamp = baseTimestamp;\n\n if (typeof videoBaseTimestamp === 'undefined' || isNaN(videoBaseTimestamp)) {\n videoBaseTimestamp = segmentInfo.video[0].dts;\n }\n\n segmentInfo.video.forEach(function (info) {\n info.dts = handleRollover(info.dts, videoBaseTimestamp);\n info.pts = handleRollover(info.pts, videoBaseTimestamp); // time in seconds\n\n info.dtsTime = info.dts / ONE_SECOND_IN_TS;\n info.ptsTime = info.pts / ONE_SECOND_IN_TS;\n });\n\n if (segmentInfo.firstKeyFrame) {\n var frame = segmentInfo.firstKeyFrame;\n frame.dts = handleRollover(frame.dts, videoBaseTimestamp);\n frame.pts = handleRollover(frame.pts, videoBaseTimestamp); // time in seconds\n\n frame.dtsTime = frame.dts / ONE_SECOND_IN_TS;\n frame.ptsTime = frame.pts / ONE_SECOND_IN_TS;\n }\n }\n };\n /**\n * inspects the aac data stream for start and end time information\n */\n\n\n var inspectAac_ = function inspectAac_(bytes) {\n var endLoop = false,\n audioCount = 0,\n sampleRate = null,\n timestamp = null,\n frameSize = 0,\n byteIndex = 0,\n packet;\n\n while (bytes.length - byteIndex >= 3) {\n var type = probe.aac.parseType(bytes, byteIndex);\n\n switch (type) {\n case 'timed-metadata':\n // Exit early because we don't have enough to parse\n // the ID3 tag header\n if (bytes.length - byteIndex < 10) {\n endLoop = true;\n break;\n }\n\n frameSize = probe.aac.parseId3TagSize(bytes, byteIndex); // Exit early if we don't have enough in the buffer\n // to emit a full packet\n\n if (frameSize > bytes.length) {\n endLoop = true;\n break;\n }\n\n if (timestamp === null) {\n packet = bytes.subarray(byteIndex, byteIndex + frameSize);\n timestamp = probe.aac.parseAacTimestamp(packet);\n }\n\n byteIndex += frameSize;\n break;\n\n case 'audio':\n // Exit early because we don't have enough to parse\n // the ADTS frame header\n if (bytes.length - byteIndex < 7) {\n endLoop = true;\n break;\n }\n\n frameSize = probe.aac.parseAdtsSize(bytes, byteIndex); // Exit early if we don't have enough in the buffer\n // to emit a full packet\n\n if (frameSize > bytes.length) {\n endLoop = true;\n break;\n }\n\n if (sampleRate === null) {\n packet = bytes.subarray(byteIndex, byteIndex + frameSize);\n sampleRate = probe.aac.parseSampleRate(packet);\n }\n\n audioCount++;\n byteIndex += frameSize;\n break;\n\n default:\n byteIndex++;\n break;\n }\n\n if (endLoop) {\n return null;\n }\n }\n\n if (sampleRate === null || timestamp === null) {\n return null;\n }\n\n var audioTimescale = ONE_SECOND_IN_TS / sampleRate;\n var result = {\n audio: [{\n type: 'audio',\n dts: timestamp,\n pts: timestamp\n }, {\n type: 'audio',\n dts: timestamp + audioCount * 1024 * audioTimescale,\n pts: timestamp + audioCount * 1024 * audioTimescale\n }]\n };\n return result;\n };\n /**\n * inspects the transport stream segment data for start and end time information\n * of the audio and video tracks (when present) as well as the first key frame's\n * start time.\n */\n\n\n var inspectTs_ = function inspectTs_(bytes) {\n var pmt = {\n pid: null,\n table: null\n };\n var result = {};\n parsePsi_(bytes, pmt);\n\n for (var pid in pmt.table) {\n if (pmt.table.hasOwnProperty(pid)) {\n var type = pmt.table[pid];\n\n switch (type) {\n case streamTypes.H264_STREAM_TYPE:\n result.video = [];\n parseVideoPes_(bytes, pmt, result);\n\n if (result.video.length === 0) {\n delete result.video;\n }\n\n break;\n\n case streamTypes.ADTS_STREAM_TYPE:\n result.audio = [];\n parseAudioPes_(bytes, pmt, result);\n\n if (result.audio.length === 0) {\n delete result.audio;\n }\n\n break;\n }\n }\n }\n\n return result;\n };\n /**\n * Inspects segment byte data and returns an object with start and end timing information\n *\n * @param {Uint8Array} bytes The segment byte data\n * @param {Number} baseTimestamp Relative reference timestamp used when adjusting frame\n * timestamps for rollover. This value must be in 90khz clock.\n * @return {Object} Object containing start and end frame timing info of segment.\n */\n\n\n var inspect = function inspect(bytes, baseTimestamp) {\n var isAacData = probe.aac.isLikelyAacData(bytes);\n var result;\n\n if (isAacData) {\n result = inspectAac_(bytes);\n } else {\n result = inspectTs_(bytes);\n }\n\n if (!result || !result.audio && !result.video) {\n return null;\n }\n\n adjustTimestamp_(result, baseTimestamp);\n return result;\n };\n\n var tsInspector = {\n inspect: inspect,\n parseAudioPes_: parseAudioPes_\n };\n\n var muxjs = {\n codecs: codecs,\n mp4: mp4,\n flv: flv,\n mp2t: m2ts,\n partial: partial\n }; // include all the tools when the full library is required\n\n muxjs.mp4.tools = mp4Inspector;\n muxjs.flv.tools = flvInspector;\n muxjs.mp2t.tools = tsInspector;\n var lib = muxjs;\n\n return lib;\n\n})));\n","\n\n\n","\n\n\n\n\n","import { render } from \"./Player.vue?vue&type=template&id=406694ae\"\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=406694ae&lang=css\"\nscript.render = render\n\nexport default script","\n\n","import { render } from \"./Comment.vue?vue&type=template&id=e3d1a22a\"\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=639898e8\"\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 eventListener() {\n if (errorListener !== undefined) {\n emitter.removeListener('error', errorListener);\n }\n resolve([].slice.call(arguments));\n };\n var errorListener;\n\n // Adding an error listener is not optional because\n // if an error is thrown on an event emitter we cannot\n // guarantee that the actual event we are waiting will\n // be fired. The result could be a silent way to create\n // memory or file descriptor leaks, which is something\n // we should avoid.\n if (name !== 'error') {\n errorListener = function errorListener(err) {\n emitter.removeListener(name, eventListener);\n reject(err);\n };\n\n emitter.once('error', errorListener);\n }\n\n emitter.once(name, eventListener);\n });\n}\n"],"sourceRoot":""}