https://www.webrtc-experiment.com/EBML.js

1(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.EBML = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
2"use strict";
3Object.defineProperty(exports, "__esModule", { value: true });
4var tools_1 = require("./tools");
5var int64_buffer_1 = require("int64-buffer");
6var tools = require("./tools");
7var schema = require("matroska/lib/schema");
8var byEbmlID = schema.byEbmlID;
9// https://www.matroska.org/technical/specs/index.html
10var State;
11(function (State) {
12    State[State["STATE_TAG"] = 1] = "STATE_TAG";
13    State[State["STATE_SIZE"] = 2] = "STATE_SIZE";
14    State[State["STATE_CONTENT"] = 3] = "STATE_CONTENT";
15})(State || (State = {}));
16var EBMLDecoder = /** @class */ (function () {
17    function EBMLDecoder() {
18        this._buffer = new tools_1.Buffer(0);
19        this._tag_stack = [];
20        this._state = State.STATE_TAG;
21        this._cursor = 0;
22        this._total = 0;
23        this._schema = byEbmlID;
24        this._result = [];
25    }
26    EBMLDecoder.prototype.decode = function (chunk) {
27        this.readChunk(chunk);
28        var diff = this._result;
29        this._result = [];
30        return diff;
31    };
32    EBMLDecoder.prototype.readChunk = function (chunk) {
33        // 読みかけの(読めなかった) this._buffer と 新しい chunk を合わせて読み直す
34        this._buffer = tools.concat([this._buffer, new tools_1.Buffer(chunk)]);
35        while (this._cursor < this._buffer.length) {
36            // console.log(this._cursor, this._total, this._tag_stack);
37            if (this._state === State.STATE_TAG && !this.readTag()) {
38                break;
39            }
40            if (this._state === State.STATE_SIZE && !this.readSize()) {
41                break;
42            }
43            if (this._state === State.STATE_CONTENT && !this.readContent()) {
44                break;
45            }
46        }
47    };
48    EBMLDecoder.prototype.getSchemaInfo = function (tagNum) {
49        return this._schema[tagNum] || {
50            name: "unknown",
51            level: -1,
52            type: "unknown",
53            description: "unknown"
54        };
55    };
56    /**
57     * vint された parsing tag
58     * @return - return false when waiting for more data
59     */
60    EBMLDecoder.prototype.readTag = function () {
61        // tag.length が buffer の外にある
62        if (this._cursor >= this._buffer.length) {
63            return false;
64        }
65        // read ebml id vint without first byte
66        var tag = tools_1.readVint(this._buffer, this._cursor);
67        // tag が読めなかった
68        if (tag == null) {
69            return false;
70        }
71        // >>>>>>>>>
72        // tag 識別子
73        //const tagStr = this._buffer.toString("hex", this._cursor, this._cursor + tag.length);
74        //const tagNum = parseInt(tagStr, 16);
75        // 上と等価
76        var buf = this._buffer.slice(this._cursor, this._cursor + tag.length);
77        var tagNum = buf.reduce(function (o, v, i, arr) { return o + v * Math.pow(16, 2 * (arr.length - 1 - i)); }, 0);
78        var schema = this.getSchemaInfo(tagNum);
79        var tagObj = {
80            EBML_ID: tagNum.toString(16),
81            schema: schema,
82            type: schema.type,
83            name: schema.name,
84            level: schema.level,
85            tagStart: this._total,
86            tagEnd: this._total + tag.length,
87            sizeStart: this._total + tag.length,
88            sizeEnd: null,
89            dataStart: null,
90            dataEnd: null,
91            dataSize: null,
92            data: null
93        };
94        // | tag: vint | size: vint | data: Buffer(size) |
95        this._tag_stack.push(tagObj);
96        // <<<<<<<<
97        // ポインタを進める
98        this._cursor += tag.length;
99        this._total += tag.length;
100        // 読み込み状態変更
101        this._state = State.STATE_SIZE;
102        return true;
103    };
104    /**
105     * vint された現在のタグの内容の大きさを読み込む
106     * @return - return false when waiting for more data
107     */
108    EBMLDecoder.prototype.readSize = function () {
109        // tag.length が buffer の外にある
110        if (this._cursor >= this._buffer.length) {
111            return false;

112        }
113        // read ebml datasize vint without first byte
114        var size = tools_1.readVint(this._buffer, this._cursor);
115        // まだ読めない
116        if (size == null) {
117            return false;
118        }
119        // >>>>>>>>>
120        // current tag の data size 決定
121        var tagObj = this._tag_stack[this._tag_stack.length - 1];
122        tagObj.sizeEnd = tagObj.sizeStart + size.length;
123        tagObj.dataStart = tagObj.sizeEnd;
124        tagObj.dataSize = size.value;
125        if (size.value === -1) {
126            // unknown size
127            tagObj.dataEnd = -1;
128            if (tagObj.type === "m") {
129                tagObj.unknownSize = true;
130            }
131        }
132        else {
133            tagObj.dataEnd = tagObj.sizeEnd + size.value;
134        }
135        // <<<<<<<<
136        // ポインタを進める
137        this._cursor += size.length;
138        this._total += size.length;
139        this._state = State.STATE_CONTENT;
140        return true;
141    };
142    /**
143     * データ読み込み
144     */
145    EBMLDecoder.prototype.readContent = function () {
146        var tagObj = this._tag_stack[this._tag_stack.length - 1];
147        // master element は子要素を持つので生データはない
148        if (tagObj.type === 'm') {
149            // console.log('content should be tags');
150            tagObj.isEnd = false;
151            this._result.push(tagObj);
152            this._state = State.STATE_TAG;
153            // この Mastert Element は空要素か
154            if (tagObj.dataSize === 0) {
155                // 即座に終了タグを追加
156                var elm = Object.assign({}, tagObj, { isEnd: true });
157                this._result.push(elm);
158                this._tag_stack.pop(); // スタックからこのタグを捨てる
159            }
160            return true;
161        }
162        // waiting for more data
163        if (this._buffer.length < this._cursor + tagObj.dataSize) {
164            return false;
165        }
166        // タグの中身の生データ
167        var data = this._buffer.slice(this._cursor, this._cursor + tagObj.dataSize);
168        // 読み終わったバッファを捨てて読み込んでいる部分のバッファのみ残す
169        this._buffer = this._buffer.slice(this._cursor + tagObj.dataSize);
170        tagObj.data = data;
171        // >>>>>>>>>
172        switch (tagObj.type) {
173            //case "m": break;
174            // Master-Element - contains other EBML sub-elements of the next lower level
175            case "u":
176                tagObj.value = data.readUIntBE(0, data.length);
177                break;
178            // Unsigned Integer - Big-endian, any size from 1 to 8 octets
179            case "i":
180                tagObj.value = data.readIntBE(0, data.length);
181                break;
182            // Signed Integer - Big-endian, any size from 1 to 8 octets
183            case "f":
184                tagObj.value = tagObj.dataSize === 4 ? data.readFloatBE(0) :
185                    tagObj.dataSize === 8 ? data.readDoubleBE(0) :
186                        (console.warn("cannot read " + tagObj.dataSize + " octets float. failback to 0"), 0);
187                break;
188            // Float - Big-endian, defined for 4 and 8 octets (32, 64 bits)
189            case "s":
190                tagObj.value = data.toString("ascii");
191                break; // ascii
192            //  Printable ASCII (0x20 to 0x7E), zero-padded when needed
193            case "8":
194                tagObj.value = data.toString("utf8");
195                break;
196            //  Unicode string, zero padded when needed (RFC 2279)
197            case "b":
198                tagObj.value = data;
199                break;
200            // Binary - not interpreted by the parser
201            case "d":
202                tagObj.value = tools_1.convertEBMLDateToJSDate(new int64_buffer_1.Int64BE(data).toNumber());
203                break;
204            // nano second; Date.UTC(2001,1,1,0,0,0,0) === 980985600000
205            // Date - signed 8 octets integer in nanoseconds with 0 indicating 
206            // the precise beginning of the millennium (at 2001-01-01T00:00:00,000000000 UTC)
207        }
208        if (tagObj.value === null) {
209            throw new Error("unknown tag type:" + tagObj.type);
210        }
211        this._result.push(tagObj);
212        // <<<<<<<<
213        // ポインタを進める
214        this._total += tagObj.dataSize;
215        // タグ待ちモードに変更
216        this._state = State.STATE_TAG;
217        this._cursor = 0;
218        this._tag_stack.pop(); // remove the object from the stack
219        while (this._tag_stack.length > 0) {
220            var topEle = this._tag_stack[this._tag_stack.length - 1];
221            // 親が不定長サイズなので閉じタグは期待できない
222            if (topEle.dataEnd < 0) {
223                this._tag_stack.pop(); // 親タグを捨てる
224                return true;
225            }
226            // 閉じタグの来るべき場所まで来たかどうか
227            if (this._total < topEle.dataEnd) {
228                break;
229            }
230            // 閉じタグを挿入すべきタイミングが来た
231            if (topEle.type !== "m") {
232                throw new Error("parent element is not master element");
233            }
234            var elm = Object.assign({}, topEle, { isEnd: true });
235            this._result.push(elm);
236            this._tag_stack.pop();
237        }
238        return true;
239    };
240    return EBMLDecoder;
241}());
242exports.default = EBMLDecoder;
243
244},{"./tools":5,"int64-buffer":15,"matroska/lib/schema":17}],2:[function(require,module,exports){
245"use strict";
246Object.defineProperty(exports, "__esModule", { value: true });
247var tools = require("./tools");
248var tools_1 = require("./tools");
249var schema = require("matroska/lib/schema");
250var byEbmlID = schema.byEbmlID;
251var EBMLEncoder = /** @class */ (function () {
252    function EBMLEncoder() {
253        this._schema = byEbmlID;
254        this._buffers = [];
255        this._stack = [];
256    }
257    EBMLEncoder.prototype.encode = function (elms) {
258        var _this = this;
259        return tools.concat(elms.reduce(function (lst, elm) {
260            return lst.concat(_this.encodeChunk(elm));
261        }, [])).buffer;
262    };
263    EBMLEncoder.prototype.encodeChunk = function (elm) {
264        if (elm.type === "m") {
265            if (!elm.isEnd) {
266                this.startTag(elm);
267            }
268            else {
269                this.endTag(elm);
270            }
271        }
272        else {
273            this.writeTag(elm);
274        }
275        return this.flush();
276    };
277    EBMLEncoder.prototype.flush = function () {
278        var ret = this._buffers;
279        this._buffers = [];
280        return ret;
281    };
282    EBMLEncoder.prototype.getSchemaInfo = function (tagName) {
283        var tagNums = Object.keys(this._schema).map(Number);
284        for (var i = 0; i < tagNums.length; i++) {
285            var tagNum = tagNums[i];
286            if (this._schema[tagNum].name === tagName) {
287                return new tools_1.Buffer(tagNum.toString(16), 'hex');
288            }
289        }
290        return null;
291    };
292    EBMLEncoder.prototype.writeTag = function (elm) {
293        var tagName = elm.name;

294        var tagId = this.getSchemaInfo(tagName);
295        var tagData = elm.data;
296        if (tagId == null) {
297            throw new Error('No schema entry found for ' + tagName);
298        }
299        var data = tools.encodeTag(tagId, tagData);
300        /**
301         * 親要素が閉じタグあり(isEnd)なら閉じタグが来るまで待つ(children queに入る)
302         */
303        if (this._stack.length > 0) {
304            var last = this._stack[this._stack.length - 1];
305            last.children.push({
306                tagId: tagId,
307                elm: elm,
308                children: [],
309                data: data
310            });
311            return;
312        }
313        this._buffers = this._buffers.concat(data);
314        return;
315    };
316    EBMLEncoder.prototype.startTag = function (elm) {
317        var tagName = elm.name;
318        var tagId = this.getSchemaInfo(tagName);
319        if (tagId == null) {
320            throw new Error('No schema entry found for ' + tagName);
321        }
322        /**
323         * 閉じタグ不定長の場合はスタックに積まずに即時バッファに書き込む
324         */
325        if (elm.unknownSize) {
326            var data = tools.encodeTag(tagId, new tools_1.Buffer(0), elm.unknownSize);
327            this._buffers = this._buffers.concat(data);
328            return;
329        }
330        var tag = {
331            tagId: tagId,
332            elm: elm,
333            children: [],
334            data: null
335        };
336        if (this._stack.length > 0) {
337            this._stack[this._stack.length - 1].children.push(tag);
338        }
339        this._stack.push(tag);
340    };
341    EBMLEncoder.prototype.endTag = function (elm) {
342        var tagName = elm.name;
343        var tag = this._stack.pop();
344        if (tag == null) {
345            throw new Error("EBML structure is broken");
346        }
347        if (tag.elm.name !== elm.name) {
348            throw new Error("EBML structure is broken");
349        }
350        var childTagDataBuffers = tag.children.reduce(function (lst, child) {
351            if (child.data === null) {
352                throw new Error("EBML structure is broken");
353            }
354            return lst.concat(child.data);
355        }, []);
356        var childTagDataBuffer = tools.concat(childTagDataBuffers);
357        if (tag.elm.type === "m") {
358            tag.data = tools.encodeTag(tag.tagId, childTagDataBuffer, tag.elm.unknownSize);
359        }
360        else {
361            tag.data = tools.encodeTag(tag.tagId, childTagDataBuffer);
362        }
363        if (this._stack.length < 1) {
364            this._buffers = this._buffers.concat(tag.data);
365        }
366    };
367    return EBMLEncoder;
368}());
369exports.default = EBMLEncoder;
370
371},{"./tools":5,"matroska/lib/schema":17}],3:[function(require,module,exports){
372"use strict";
373var __extends = (this && this.__extends) || (function () {
374    var extendStatics = Object.setPrototypeOf ||
375        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
376        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
377    return function (d, b) {
378        extendStatics(d, b);
379        function __() { this.constructor = d; }
380        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
381    };
382})();
383Object.defineProperty(exports, "__esModule", { value: true });
384var events_1 = require("events");
385var tools = require("./tools");
386/**
387 * This is an informal code for reference.
388 * EBMLReader is a class for getting information to enable seeking Webm recorded by MediaRecorder.
389 * So please do not use for regular WebM files.
390 */
391var EBMLReader = /** @class */ (function (_super) {
392    __extends(EBMLReader, _super);
393    function EBMLReader() {
394        var _this = _super.call(this) || this;
395        _this.logGroup = "";
396        _this.hasLoggingStarted = false;
397        _this.metadataloaded = false;
398        _this.chunks = [];
399        _this.stack = [];
400        _this.segmentOffset = 0;
401        _this.last2SimpleBlockVideoTrackTimecode = [0, 0];
402        _this.last2SimpleBlockAudioTrackTimecode = [0, 0];
403        _this.lastClusterTimecode = 0;
404        _this.lastClusterPosition = 0;
405        _this.timecodeScale = 1000000; // webm default TimecodeScale is 1ms
406        _this.metadataSize = 0;
407        _this.metadatas = [];
408        _this.cues = [];

409        _this.firstVideoBlockRead = false;
410        _this.firstAudioBlockRead = false;
411        _this.currentTrack = { TrackNumber: -1, TrackType: -1, DefaultDuration: null, CodecDelay: null };
412        _this.trackTypes = [];
413        _this.trackDefaultDuration = [];
414        _this.trackCodecDelay = [];
415        _this.trackInfo = { type: "nothing" };
416        _this.ended = false;
417        _this.logging = false;
418        _this.use_duration_every_simpleblock = false;
419        _this.use_webp = false;
420        _this.use_segment_info = true;
421        _this.drop_default_duration = true;
422        return _this;
423    }
424    /**
425     * emit final state.
426     */
427    EBMLReader.prototype.stop = function () {
428        this.ended = true;
429        this.emit_segment_info();
430        // clean up any unclosed Master Elements at the end of the stream.
431        while (this.stack.length) {
432            this.stack.pop();
433            if (this.logging) {
434                console.groupEnd();
435            }
436        }
437        // close main group if set, logging is enabled, and has actually logged anything.
438        if (this.logging && this.hasLoggingStarted && this.logGroup) {
439            console.groupEnd();
440        }
441    };
442    /**
443     * emit chunk info
444     */
445    EBMLReader.prototype.emit_segment_info = function () {
446        var data = this.chunks;
447        this.chunks = [];
448        if (!this.metadataloaded) {
449            this.metadataloaded = true;
450            this.metadatas = data;
451            var videoTrackNum = this.trackTypes.indexOf(1); // find first video track
452            var audioTrackNum = this.trackTypes.indexOf(2); // find first audio track
453            this.trackInfo = videoTrackNum >= 0 && audioTrackNum >= 0 ? { type: "both", trackNumber: videoTrackNum }
454                : videoTrackNum >= 0 ? { type: "video", trackNumber: videoTrackNum }
455                    : audioTrackNum >= 0 ? { type: "audio", trackNumber: audioTrackNum }
456                        : { type: "nothing" };
457            if (!this.use_segment_info) {
458                return;
459            }
460            this.emit("metadata", { data: data, metadataSize: this.metadataSize });
461        }
462        else {
463            if (!this.use_segment_info) {
464                return;
465            }
466            var timecode = this.lastClusterTimecode;
467            var duration = this.duration;
468            var timecodeScale = this.timecodeScale;
469            this.emit("cluster", { timecode: timecode, data: data });
470            this.emit("duration", { timecodeScale: timecodeScale, duration: duration });
471        }
472    };
473    EBMLReader.prototype.read = function (elm) {
474        var _this = this;
475        var drop = false;
476        if (this.ended) {
477            // reader is finished
478            return;
479        }
480        if (elm.type === "m") {
481            // 閉じタグの自動挿入
482            if (elm.isEnd) {
483                this.stack.pop();
484            }
485            else {
486                var parent_1 = this.stack[this.stack.length - 1];
487                if (parent_1 != null && parent_1.level >= elm.level) {
488                    // 閉じタグなしでレベルが下がったら閉じタグを挿入
489                    this.stack.pop();
490                    // From http://w3c.github.io/media-source/webm-byte-stream-format.html#webm-media-segments
491                    // This fixes logging for webm streams with Cluster of unknown length and no Cluster closing elements.
492                    if (this.logging) {
493                        console.groupEnd();
494                    }
495                    parent_1.dataEnd = elm.dataEnd;
496                    parent_1.dataSize = elm.dataEnd - parent_1.dataStart;
497                    parent_1.unknownSize = false;
498                    var o = Object.assign({}, parent_1, { name: parent_1.name, type: parent_1.type, isEnd: true });
499                    this.chunks.push(o);
500                }
501                this.stack.push(elm);
502            }
503        }
504        if (elm.type === "m" && elm.name == "Segment") {
505            if (this.segmentOffset != 0) {
506                console.warn("Multiple segments detected!");
507            }
508            this.segmentOffset = elm.dataStart;

509            this.emit("segment_offset", this.segmentOffset);
510        }
511        else if (elm.type === "b" && elm.name === "SimpleBlock") {
512            var _a = tools.ebmlBlock(elm.data), timecode = _a.timecode, trackNumber = _a.trackNumber, frames_1 = _a.frames;
513            if (this.trackTypes[trackNumber] === 1) { // trackType === 1 => video track
514                if (!this.firstVideoBlockRead) {
515                    this.firstVideoBlockRead = true;
516                    if (this.trackInfo.type === "both" || this.trackInfo.type === "video") {
517                        var CueTime = this.lastClusterTimecode + timecode;
518                        this.cues.push({ CueTrack: trackNumber, CueClusterPosition: this.lastClusterPosition, CueTime: CueTime });
519                        this.emit("cue_info", { CueTrack: trackNumber, CueClusterPosition: this.lastClusterPosition, CueTime: this.lastClusterTimecode });
520                        this.emit("cue", { CueTrack: trackNumber, CueClusterPosition: this.lastClusterPosition, CueTime: CueTime });
521                    }
522                }
523                this.last2SimpleBlockVideoTrackTimecode = [this.last2SimpleBlockVideoTrackTimecode[1], timecode];
524            }
525            else if (this.trackTypes[trackNumber] === 2) { // trackType === 2 => audio track
526                if (!this.firstAudioBlockRead) {
527                    this.firstAudioBlockRead = true;
528                    if (this.trackInfo.type === "audio") {
529                        var CueTime = this.lastClusterTimecode + timecode;
530                        this.cues.push({ CueTrack: trackNumber, CueClusterPosition: this.lastClusterPosition, CueTime: CueTime });
531                        this.emit("cue_info", { CueTrack: trackNumber, CueClusterPosition: this.lastClusterPosition, CueTime: this.lastClusterTimecode });
532                        this.emit("cue", { CueTrack: trackNumber, CueClusterPosition: this.lastClusterPosition, CueTime: CueTime });
533                    }
534                }
535                this.last2SimpleBlockAudioTrackTimecode = [this.last2SimpleBlockAudioTrackTimecode[1], timecode];
536            }
537            if (this.use_duration_every_simpleblock) {
538                this.emit("duration", { timecodeScale: this.timecodeScale, duration: this.duration });
539            }
540            if (this.use_webp) {
541                frames_1.forEach(function (frame) {
542                    var startcode = frame.slice(3, 6).toString("hex");
543                    if (startcode !== "9d012a") {
544                        return;
545                    }
546                    ; // VP8 の場合
547                    var webpBuf = tools.VP8BitStreamToRiffWebPBuffer(frame);
548                    var webp = new Blob([webpBuf], { type: "image/webp" });
549                    var currentTime = _this.duration;
550                    _this.emit("webp", { currentTime: currentTime, webp: webp });
551                });
552            }
553        }
554        else if (elm.type === "m" && elm.name === "Cluster" && elm.isEnd === false) {
555            this.firstVideoBlockRead = false;
556            this.firstAudioBlockRead = false;
557            this.emit_segment_info();
558            this.emit("cluster_ptr", elm.tagStart);
559            this.lastClusterPosition = elm.tagStart;
560        }
561        else if (elm.type === "u" && elm.name === "Timecode") {
562            this.lastClusterTimecode = elm.value;
563        }
564        else if (elm.type === "u" && elm.name === "TimecodeScale") {
565            this.timecodeScale = elm.value;
566        }
567        else if (elm.type === "m" && elm.name === "TrackEntry") {
568            if (elm.isEnd) {
569                this.trackTypes[this.currentTrack.TrackNumber] = this.currentTrack.TrackType;
570                this.trackDefaultDuration[this.currentTrack.TrackNumber] = this.currentTrack.DefaultDuration;
571                this.trackCodecDelay[this.currentTrack.TrackNumber] = this.currentTrack.CodecDelay;
572            }
573            else {
574                this.currentTrack = { TrackNumber: -1, TrackType: -1, DefaultDuration: null, CodecDelay: null };
575            }
576        }
577        else if (elm.type === "u" && elm.name === "TrackType") {
578            this.currentTrack.TrackType = elm.value;
579        }
580        else if (elm.type === "u" && elm.name === "TrackNumber") {
581            this.currentTrack.TrackNumber = elm.value;
582        }
583        else if (elm.type === "u" && elm.name === "CodecDelay") {
584            this.currentTrack.CodecDelay = elm.value;
585        }
586        else if (elm.type === "u" && elm.name === "DefaultDuration") {

587            // media source api は DefaultDuration を計算するとバグる。
588            // https://bugs.chromium.org/p/chromium/issues/detail?id=606000#c22
589            // chrome 58 ではこれを回避するために DefaultDuration 要素を抜き取った。
590            // chrome 58 以前でもこのタグを抜き取ることで回避できる
591            if (this.drop_default_duration) {
592                console.warn("DefaultDuration detected!, remove it");
593                drop = true;
594            }
595            else {
596                this.currentTrack.DefaultDuration = elm.value;
597            }
598        }
599        else if (elm.name === "unknown") {
600            console.warn(elm);
601        }
602        if (!this.metadataloaded && elm.dataEnd > 0) {
603            this.metadataSize = elm.dataEnd;
604        }
605        if (!drop) {
606            this.chunks.push(elm);
607        }
608        if (this.logging) {
609            this.put(elm);
610        }
611    };
612    Object.defineProperty(EBMLReader.prototype, "duration", {
613        /**
614         * DefaultDuration が定義されている場合は最後のフレームのdurationも考慮する
615         * 単位 timecodeScale
616         *
617         * !!! if you need duration with seconds !!!
618         * ```js
619         * const nanosec = reader.duration * reader.timecodeScale;
620         * const sec = nanosec / 1000 / 1000 / 1000;
621         * ```
622         */
623        get: function () {
624            if (this.trackInfo.type === "nothing") {
625                console.warn("no video, no audio track");
626                return 0;
627            }
628            // defaultDuration は 生の nano sec
629            var defaultDuration = 0;
630            // nanoseconds
631            var codecDelay = 0;
632            var lastTimecode = 0;
633            var _defaultDuration = this.trackDefaultDuration[this.trackInfo.trackNumber];
634            if (typeof _defaultDuration === "number") {
635                defaultDuration = _defaultDuration;
636            }
637            else {
638                // https://bugs.chromium.org/p/chromium/issues/detail?id=606000#c22
639                // default duration がないときに使う delta
640                if (this.trackInfo.type === "both") {
641                    if (this.last2SimpleBlockAudioTrackTimecode[1] > this.last2SimpleBlockVideoTrackTimecode[1]) {
642                        // audio diff
643                        defaultDuration = (this.last2SimpleBlockAudioTrackTimecode[1] - this.last2SimpleBlockAudioTrackTimecode[0]) * this.timecodeScale;
644                        // audio delay
645                        var delay = this.trackCodecDelay[this.trackTypes.indexOf(2)]; // 2 => audio
646                        if (typeof delay === "number") {
647                            codecDelay = delay;
648                        }
649                        // audio timecode
650                        lastTimecode = this.last2SimpleBlockAudioTrackTimecode[1];
651                    }
652                    else {
653                        // video diff
654                        defaultDuration = (this.last2SimpleBlockVideoTrackTimecode[1] - this.last2SimpleBlockVideoTrackTimecode[0]) * this.timecodeScale;
655                        // video delay
656                        var delay = this.trackCodecDelay[this.trackTypes.indexOf(1)]; // 1 => video
657                        if (typeof delay === "number") {
658                            codecDelay = delay;
659                        }
660                        // video timecode
661                        lastTimecode = this.last2SimpleBlockVideoTrackTimecode[1];
662                    }
663                }
664                else if (this.trackInfo.type === "video") {
665                    defaultDuration = (this.last2SimpleBlockVideoTrackTimecode[1] - this.last2SimpleBlockVideoTrackTimecode[0]) * this.timecodeScale;
666                    var delay = this.trackCodecDelay[this.trackInfo.trackNumber]; // 2 => audio
667                    if (typeof delay === "number") {
668                        codecDelay = delay;
669                    }
670                    lastTimecode = this.last2SimpleBlockVideoTrackTimecode[1];
671                }
672                else if (this.trackInfo.type === "audio") {
673                    defaultDuration = (this.last2SimpleBlockAudioTrackTimeco

673de[1] - this.last2SimpleBlockAudioTrackTimecode[0]) * this.timecodeScale;
674                    var delay = this.trackCodecDelay[this.trackInfo.trackNumber]; // 1 => video
675                    if (typeof delay === "number") {
676                        codecDelay = delay;
677                    }
678                    lastTimecode = this.last2SimpleBlockAudioTrackTimecode[1];
679                } // else { not reached }
680            }
681            // convert to timecodescale
682            var duration_nanosec = ((this.lastClusterTimecode + lastTimecode) * this.timecodeScale) + defaultDuration - codecDelay;
683            var duration = duration_nanosec / this.timecodeScale;
684            return Math.floor(duration);
685        },
686        enumerable: true,
687        configurable: true
688    });
689    EBMLReader.prototype.addListener = function (event, listener) {
690        return _super.prototype.addListener.call(this, event, listener);
691    };
692    EBMLReader.prototype.put = function (elm) {
693        if (!this.hasLoggingStarted) {
694            this.hasLoggingStarted = true;
695            if (this.logging && this.logGroup) {
696                console.groupCollapsed(this.logGroup);
697            }
698        }
699        if (elm.type === "m") {
700            if (elm.isEnd) {
701                console.groupEnd();
702            }
703            else {
704                console.group(elm.name + ":" + elm.tagStart);
705            }
706        }
707        else if (elm.type === "b") {
708            // for debug
709            //if(elm.name === "SimpleBlock"){
710            //const o = EBML.tools.ebmlBlock(elm.value);
711            //console.log(elm.name, elm.type, o.trackNumber, o.timecode);
712            //}else{
713            console.log(elm.name, elm.type);
714            //}
715        }
716        else {
717            console.log(elm.name, elm.tagStart, elm.type, elm.value);
718        }
719    };
720    return EBMLReader;
721}(events_1.EventEmitter));
722exports.default = EBMLReader;
723;
724;
725;
726;
727
728},{"./tools":5,"events":13}],4:[function(require,module,exports){
729"use strict";
730Object.defineProperty(exports, "__esModule", { value: true });
731var EBMLDecoder_1 = require("./EBMLDecoder");
732exports.Decoder = EBMLDecoder_1.default;
733var EBMLEncoder_1 = require("./EBMLEncoder");
734exports.Encoder = EBMLEncoder_1.default;
735var EBMLReader_1 = require("./EBMLReader");
736exports.Reader = EBMLReader_1.default;
737var tools = require("./tools");
738exports.tools = tools;
739var version = require("../package.json").version;
740exports.version = version;
741
742},{"../package.json":18,"./EBMLDecoder":1,"./EBMLEncoder":2,"./EBMLReader":3,"./tools":5}],5:[function(require,module,exports){
743"use strict";
744Object.defineProperty(exports, "__esModule", { value: true });
745/// <reference types="node"/>
746var int64_buffer_1 = require("int64-buffer");
747var EBMLEncoder_1 = require("./EBMLEncoder");
748var _Buffer = require("buffer/");
749var _tools = require("ebml/lib/ebml/tools");
750var _block = require("ebml-block");
751exports.Buffer = _Buffer.Buffer;
752exports.readVint = _tools.readVint;
753exports.writeVint = _tools.writeVint;
754exports.ebmlBlock = _block;
755function readBlock(buf) {
756    return exports.ebmlBlock(new exports.Buffer(buf));
757}
758exports.readBlock = readBlock;
759/**
760  * @param end - if end === false then length is unknown
761  */
762function encodeTag(tagId, tagData, unknownSize) {
763    if (unknownSize === void 0) { unknownSize = false; }
764    return concat([
765        tagId,
766        unknownSize ?
767            new exports.Buffer('01ffffffffffffff', 'hex') :
768            exports.writeVint(tagData.length),
769        tagData
770    ]);
771}
772exports.encodeTag = encodeTag;
773/**
774 * @return - SimpleBlock to WebP Filter
775 */
776function WebPFrameFilter(elms) {
777    return WebPBlockFilter(elms).reduce(function (lst, elm) {
778        var o = exports.ebmlBlock(elm.data);
779        return o.frames.reduce(function (lst, frame) {
780            // https://developers.Blob.com/speed/webp/docs/riff_container
781            var webpBuf = VP8BitStreamToRiffWebPBuffer(frame);
782            var webp = new Blob([webpBuf], { type: "image/webp" });
783            return lst.concat(webp);
784        }, lst);
785    }, []);
786}
787exports.WebPFrameFilter = WebPFrameFilter;
788/**

789 * WebP ファイルにできる SimpleBlock の パスフィルタ
790 */
791function WebPBlockFilter(elms) {
792    return elms.reduce(function (lst, elm) {
793        if (elm.type !== "b") {
794            return lst;
795        }
796        if (elm.name !== "SimpleBlock") {
797            return lst;
798        }
799        var o = exports.ebmlBlock(elm.data);
800        var hasWebP = o.frames.some(function (frame) {
801            // https://tools.ietf.org/html/rfc6386#section-19.1
802            var startcode = frame.slice(3, 6).toString("hex");
803            return startcode === "9d012a";
804        });
805        if (!hasWebP) {
806            return lst;
807        }
808        return lst.concat(elm);
809    }, []);
810}
811exports.WebPBlockFilter = WebPBlockFilter;
812/**
813 * @param frame - VP8 BitStream のうち startcode をもつ frame
814 * @return - WebP ファイルの ArrayBuffer
815 */
816function VP8BitStreamToRiffWebPBuffer(frame) {
817    var VP8Chunk = createRIFFChunk("VP8 ", frame);
818    var WebPChunk = concat([
819        new exports.Buffer("WEBP", "ascii"),
820        VP8Chunk
821    ]);
822    return createRIFFChunk("RIFF", WebPChunk);
823}
824exports.VP8BitStreamToRiffWebPBuffer = VP8BitStreamToRiffWebPBuffer;
825/**
826 * RIFF データチャンクを作る
827 */
828function createRIFFChunk(FourCC, chunk) {
829    var chunkSize = new exports.Buffer(4);
830    chunkSize.writeUInt32LE(chunk.byteLength, 0);
831    return concat([
832        new exports.Buffer(FourCC.substr(0, 4), "ascii"),
833        chunkSize,
834        chunk,
835        new exports.Buffer(chunk.byteLength % 2 === 0 ? 0 : 1) // padding
836    ]);
837}
838exports.createRIFFChunk = createRIFFChunk;
839/* Original Metadata
840
841 m  0	EBML
842 u  1	  EBMLVersion 1
843 u  1	  EBMLReadVersion 1
844 u  1	  EBMLMaxIDLength 4
845 u  1	  EBMLMaxSizeLength 8
846 s  1	  DocType webm
847 u  1	  DocTypeVersion 4
848 u  1	  DocTypeReadVersion 2
849 m  0	Segment
850 m  1	  Info                                segmentContentStartPos, all CueClusterPositions provided in info.cues will be relative to here and will need adjusted
851 u  2	    TimecodeScale 1000000
852 8  2	    MuxingApp Chrome
853 8  2	    WritingApp Chrome
854 m  1	  Tracks                              tracksStartPos
855 m  2	    TrackEntry
856 u  3	      TrackNumber 1
857 u  3	      TrackUID 31790271978391090
858 u  3	      TrackType 2
859 s  3	      CodecID A_OPUS
860 b  3	      CodecPrivate <Buffer 19>
861 m  3	      Audio
862 f  4	        SamplingFrequency 48000
863 u  4	        Channels 1
864 m  2	    TrackEntry
865 u  3	      TrackNumber 2
866 u  3	      TrackUID 24051277436254136
867 u  3	      TrackType 1
868 s  3	      CodecID V_VP8
869 m  3	      Video
870 u  4	        PixelWidth 1024
871 u  4	        PixelHeight 576
872 m  1	  Cluster                             clusterStartPos
873 u  2	    Timecode 0
874 b  2	    SimpleBlock track:2 timecode:0	keyframe:true	invisible:false	discardable:false	lacing:1
875*/
876/* Desired Metadata
877
878 m	0 EBML
879 u	1   EBMLVersion 1
880 u	1   EBMLReadVersion 1
881 u	1   EBMLMaxIDLength 4
882 u	1   EBMLMaxSizeLength 8
883 s	1   DocType webm
884 u	1   DocTypeVersion 4
885 u	1   DocTypeReadVersion 2
886 m	0 Segment
887 m	1   SeekHead                            -> This is SeekPosition 0, so all SeekPositions can be calculated as (bytePos - segmentContentStartPos), which is 44 in this case
888 m	2     Seek
889 b	3       SeekID                          -> Buffer([0x15, 0x49, 0xA9, 0x66])  Info
890 u	3       SeekPosition                    -> infoStartPos =
891 m	2     Seek
892 b	3       SeekID                          -> Buffer([0x16, 0x54, 0xAE, 0x6B])  Tracks
893 u	3       SeekPosition { tracksStartPos }
894 m	2     Seek
895 b	3       SeekID                          -> Buffer([0x1C, 0x53, 0xBB, 0x6B])  Cues
896 u	3       SeekPosition { cuesStartPos }
897 m	1   Info
898 f	2     Duration 32480                    -> overwrite, or insert if it doesn't exist
899 u	2     TimecodeScale 1000000
900 8	2     MuxingApp Chrome
901 8	2     WritingApp Chrome
902 m	1   Tracks
903 m	2     TrackEntry
904 u	3       TrackNumber 1
905 u	3       TrackUID 31790271978391090
906 u	3       TrackType 2
907 s	3       CodecID A_OPUS
908 b	3       CodecPrivate <Buffer 19>
909 m	3       Audio
910 f	4         SamplingFrequency 48000
911 u	4         Channels 1
912 m	2     TrackEntry
913 u	3       TrackNumber 2
914 u	3       TrackUID 24051277436254136
915 u	3       TrackType 1
916 s	3       CodecID V_VP8
917 m	3       Video
918 u	4         PixelWidth 1024
919 u	4         PixelHeight 576
920 m  1   Cues                                -> cuesStartPos
921 m  2     CuePoint
922 u  3       CueTime 0
923 m  3       CueTrackPositions
924 u  4         CueTrack 1
925 u  4         CueClusterPosition 3911
926 m  2     CuePoint
927 u  3       CueTime 600
928 m  3       CueTrackPositions
929 u  4         CueTrack 1
930 u  4         CueClusterPosition 3911
931 m  1   Cluster

932 u  2     Timecode 0
933 b  2     SimpleBlock track:2 timecode:0	keyframe:true	invisible:false	discardable:false	lacing:1
934*/
935/**
936 * convert the metadata from a streaming webm bytestream to a seekable file by inserting Duration, Seekhead and Cues
937 * @param originalMetadata - orginal metadata (everything before the clusters start) from media recorder
938 * @param duration - Duration (TimecodeScale)
939 * @param cues - cue points for clusters
940 */
941function makeMetadataSeekable(originalMetadata, duration, cuesInfo) {
942    // extract the header, we can reuse this as-is
943    var header = extractElement("EBML", originalMetadata);
944    var headerSize = encodedSizeOfEbml(header);
945    //console.error("Header size: " + headerSize);
946    //printElementIds(header);
947    // After the header comes the Segment open tag, which in this implementation is always 12 bytes (4 byte id, 8 byte 'unknown length')
948    // After that the segment content starts. All SeekPositions and CueClusterPosition must be relative to segmentContentStartPos
949    var segmentContentStartPos = headerSize + 12;
950    //console.error("segmentContentStartPos: " + segmentContentStartPos);    
951    // find the original metadata size, and adjust it for header size and Segment start element so we can keep all positions relative to segmentContentStartPos
952    var originalMetadataSize = originalMetadata[originalMetadata.length - 1].dataEnd - segmentContentStartPos;
953    //console.error("Original Metadata size: " + originalMetadataSize);
954    //printElementIds(originalMetadata);
955    // extract the segment info, remove the potentially existing Duration element, and add our own one.
956    var info = extractElement("Info", originalMetadata);
957    removeElement("Duration", info);
958    info.splice(1, 0, { name: "Duration", type: "f", data: createFloatBuffer(duration, 8) });
959    var infoSize = encodedSizeOfEbml(info);
960    //console.error("Info size: " + infoSize);
961    //printElementIds(info);  
962    // extract the track info, we can re-use this as is
963    var tracks = extractElement("Tracks", originalMetadata);
964    var tracksSize = encodedSizeOfEbml(tracks);
965    //console.error("Tracks size: " + tracksSize);
966    //printElementIds(tracks);  
967    var seekHeadSize = 47; // Initial best guess, but could be slightly larger if the Cues element is huge.
968    var seekHead = [];
969    var cuesSize = 5 + cuesInfo.length * 15; // very rough initial approximation, depends a lot on file size and number of CuePoints                   
970    var cues = [];
971    var lastSizeDifference = -1; // 
972    // The size of SeekHead and Cues elements depends on how many bytes the offsets values can be encoded in.
973    // The actual offsets in CueClusterPosition depend on the final size of the SeekHead and Cues elements
974    // We need to iteratively converge to a stable solution.
975    var maxIterations = 10;
976    var _loop_1 = function (i) {
977        // SeekHead starts at 0
978        var infoStart = seekHeadSize; // Info comes directly after SeekHead
979        var tracksStart = infoStart + infoSize; // Tracks comes directly after Info
980        var cuesStart = tracksStart + tracksSize; // Cues starts directly after 
981        var newMetadataSize = cuesStart + cuesSize; // total size of metadata  
982        // This is the offset all CueClusterPositions should be adjusted by due to the metadata size changing.
983        var sizeDifference = newMetadataSize - originalMetadataSize;
984        // console.error(`infoStart: ${infoStart}, infoSize: ${infoSize}`);
985        // console.error(`tracksStart: ${tracksStart}, tracksSize: ${tracksSize}`);
986        // console.error(`cuesStart: ${cuesStart}, cuesSize: ${cuesSize}`);
987        // console.error(`originalMetadataSize: ${originalMetadataSize}, newMetadataSize: ${newMetadataSize}, sizeDifference: ${sizeDifference}`); 
988        // create the SeekHead element
989        seekHead = [];
990        seekHead.push({ name: "SeekHead", type: "m", isEnd: false });
991        seekHead.push({ name: "Seek", type: "m", isEnd: false });
992        seekHead.push({ name: "SeekID", type: "b", data: new exports.Buffer([0x15, 0x49, 0xA9, 0x66]) }); // Info
993        seekHead.push({ name: "SeekPosition", type: "u", data: createUIntBuffer(infoStart) });
994        seekHead.push({ name: "Seek", type: "m", isEnd: true });
995        seekHead.push({ name: "Seek", type: "m", isEnd: false });
996        seekHead.push({ name: "SeekID", type: "b", data: new exp

996orts.Buffer([0x16, 0x54, 0xAE, 0x6B]) }); // Tracks
997        seekHead.push({ name: "SeekPosition", type: "u", data: createUIntBuffer(tracksStart) });
998        seekHead.push({ name: "Seek", type: "m", isEnd: true });
999        seekHead.push({ name: "Seek", type: "m", isEnd: false });
1000        seekHead.push({ name: "SeekID", type: "b", data: new exports.Buffer([0x1C, 0x53, 0xBB, 0x6B]) }); // Cues
1001        seekHead.push({ name: "SeekPosition", type: "u", data: createUIntBuffer(cuesStart) });
1002        seekHead.push({ name: "Seek", type: "m", isEnd: true });
1003        seekHead.push({ name: "SeekHead", type: "m", isEnd: true });
1004        seekHeadSize = encodedSizeOfEbml(seekHead);
1005        //console.error("SeekHead size: " + seekHeadSize);
1006        //printElementIds(seekHead);  
1007        // create the Cues element
1008        cues = [];
1009        cues.push({ name: "Cues", type: "m", isEnd: false });
1010        cuesInfo.forEach(function (_a) {
1011            var CueTrack = _a.CueTrack, CueClusterPosition = _a.CueClusterPosition, CueTime = _a.CueTime;
1012            cues.push({ name: "CuePoint", type: "m", isEnd: false });
1013            cues.push({ name: "CueTime", type: "u", data: createUIntBuffer(CueTime) });
1014            cues.push({ name: "CueTrackPositions", type: "m", isEnd: false });
1015            cues.push({ name: "CueTrack", type: "u", data: createUIntBuffer(CueTrack) });
1016            //console.error(`CueClusterPosition: ${CueClusterPosition}, Corrected to: ${CueClusterPosition - segmentContentStartPos}  , offset by ${sizeDifference} to become ${(CueClusterPosition - segmentContentStartPos) + sizeDifference - segmentContentStartPos}`);
1017            // EBMLReader returns CueClusterPosition with absolute byte offsets. The Cues section expects them as offsets from the first level 1 element of the Segment, so we need to adjust it.
1018            CueClusterPosition -= segmentContentStartPos;
1019            // We also need to adjust to take into account the change in metadata size from when EBMLReader read the original metadata.
1020            CueClusterPosition += sizeDifference;
1021            cues.push({ name: "CueClusterPosition", type: "u", data: createUIntBuffer(CueClusterPosition) });
1022            cues.push({ name: "CueTrackPositions", type: "m", isEnd: true });
1023            cues.push({ name: "CuePoint", type: "m", isEnd: true });
1024        });
1025        cues.push({ name: "Cues", type: "m", isEnd: true });
1026        cuesSize = encodedSizeOfEbml(cues);
1027        //console.error("Cues size: " + cuesSize);   
1028        //console.error("Cue count: " + cuesInfo.length);
1029        //printElementIds(cues);      
1030        // If the new MetadataSize is not the same as the previous iteration, we need to run once more.
1031        if (lastSizeDifference !== sizeDifference) {
1032            lastSizeDifference = sizeDifference;
1033            if (i === maxIterations - 1) {
1034                throw new Error("Failed to converge to a stable metadata size");
1035            }
1036        }
1037        else {
1038            return "break";
1039        }
1040    };
1041    for (var i = 0; i < maxIterations; i++) {
1042        var state_1 = _loop_1(i);
1043        if (state_1 === "break")
1044            break;
1045    }
1046    var finalMetadata = [].concat.apply([], [
1047        header,
1048        { name: "Segment", type: "m", isEnd: false, unknownSize: true },
1049        seekHead,
1050        info,
1051        tracks,
1052        cues
1053    ]);
1054    var result = new EBMLEncoder_1.default().encode(finalMetadata);
1055    //printElementIds(finalMetadata);
1056    //console.error(`Final metadata buffer size: ${result.byteLength}`);
1057    //console.error(`Final metadata buffer size without header and segment: ${result.byteLength-segmentContentStartPos}`);
1058    return result;
1059}
1060exports.makeMetadataSeekable = makeMetadataSeekable;
1061/**
1062 * print all element id names in a list
1063
1064 * @param metadata - array of EBML elements to print
1065 *
1066export function printElementIds(metadata: EBML.EBMLElementBuffer[]) {
1067
1068  let result: EBML.EBMLElementBuffer[] = [];
1069  let start: number = -1;
1070
1071  for (let i = 0; i < metadata.length; i++) {
1072    console.error("\t id: " + metadata[i].name);
1073  }
1074}
1075*/
1076/**
1077 * remove all occurances of an EBML element from an array of elements
1078 * If it's a MasterElement you will also remove the content. (everything between start and end)
1079 * @param idName - name of the EBML Element to remove.
1080 * @param metadata - array of EBML elements to search
1081 */
1082function removeElement(idName, metadata) {
1083    var result = [];
1084    var start = -1;
1085    for (var i = 0; i < metadata.length; i++) {
1086        var element = metadata[i];
1087        if (element.name === idName) {
1088            // if it's a Master element, extract the start and end element, and everything in between
1089            if (element.type === "m") {
1090                if (!element.isEnd) {
1091                    start = i;
1092                }
1093                else {
1094                    // we've reached the end, extract the whole thing
1095                    if (start == -1)
1096                        throw new Error("Detected " + idName + " closing element before finding the start");
1097                    metadata.splice(start, i - start + 1);
1098                    return;
1099                }
1100            }
1101            else {
1102                // not a Master element, so we've found what we're looking for.
1103                metadata.splice(i, 1);
1104                return;
1105            }
1106        }
1107    }
1108}
1109exports.removeElement = removeElement;
1110/**
1111 * extract the first occurance of an EBML tag from a flattened array of EBML data.
1112 * If it's a MasterElement you will also get the content. (everything between start and end)
1113 * @param idName - name of the EBML Element to extract.
1114 * @param metadata - array of EBML elements to search
1115 */
1116function extractElement(idName, metadata) {
1117    var result = [];
1118    var start = -1;
1119    for (var i = 0; i < metadata.length; i++) {
1120        var element = metadata[i];
1121        if (element.name === idName) {
1122            // if it's a Master element, extract the start and end element, and everything in between
1123            if (element.type === "m") {
1124                if (!element.isEnd) {
1125                    start = i;
1126                }
1127                else {
1128                    // we've reached the end, extract the whole thing
1129                    if (start == -1)
1130                        throw new Error("Detected " + idName + " closing element before finding the start");
1131                    result = metadata.slice(start, i + 1);
1132                    break;
1133                }
1134            }
1135            else {
1136                // not a Master element, so we've found what we're looking for.
1137                result.push(metadata[i]);
1138                break;
1139            }
1140        }
1141    }
1142    return result;
1143}
1144exports.extractElement = extractElement;
1145/**
1146 * @deprecated
1147 * metadata に対して duration と seekhead を追加した metadata を返す
1148 * @param metadata - 変更前の webm における ファイル先頭から 最初の Cluster 要素までの 要素
1149 * @param duration - Duration (TimecodeScale)

1150 * @param cues - cue points for clusters
1151 * @deprecated @param clusterPtrs - 変更前の webm における SeekHead に追加する Cluster 要素 への start pointer
1152 * @deprecated @param cueInfos - please use cues.
1153 */
1154function putRefinedMetaData(metadata, info) {
1155    if (Array.isArray(info.cueInfos) && !Array.isArray(info.cues)) {
1156        console.warn("putRefinedMetaData: info.cueInfos property is deprecated. please use info.cues");
1157        info.cues = info.cueInfos;
1158    }
1159    var ebml = [];
1160    var payload = [];
1161    for (var i_1 = 0; i_1 < metadata.length; i_1++) {
1162        var elm = metadata[i_1];
1163        if (elm.type === "m" && elm.name === "Segment") {
1164            ebml = metadata.slice(0, i_1);
1165            payload = metadata.slice(i_1);
1166            if (elm.unknownSize) {
1167                payload.shift(); // remove segment tag
1168                break;
1169            }
1170            throw new Error("this metadata is not streaming webm file");
1171        }
1172    }
1173    // *0    *4    *5  *36      *40   *48=segmentOffset              *185=originalPayloadOffsetEnd
1174    // |     |     |   |        |     |                              |
1175    // [EBML][size]....[Segment][size][Info][size][Duration][size]...[Cluster]
1176    // |               |        |^inf |                              |
1177    // |               +segmentSiz(12)+                              |
1178    // +-ebmlSize(36)--+        |     +-payloadSize(137)-------------+offsetEndDiff+
1179    //                 |        |     +-newPayloadSize(??)-------------------------+
1180    //                 |        |     |                                            |
1181    //                 [Segment][size][Info][size][Duration][size]....[size][value][Cluster]
1182    //                           ^                                                 |
1183    //                           |                                                 *??=newPayloadOffsetEnd
1184    //                           inf
1185    if (!(payload[payload.length - 1].dataEnd > 0)) {
1186        throw new Error("metadata dataEnd has wrong number");
1187    }
1188    var originalPayloadOffsetEnd = payload[payload.length - 1].dataEnd; // = first cluster ptr
1189    var ebmlSize = ebml[ebml.length - 1].dataEnd; // = first segment ptr
1190    var refinedEBMLSize = new EBMLEncoder_1.default().encode(ebml).byteLength;
1191    var offsetDiff = refinedEBMLSize - ebmlSize;
1192    var payloadSize = originalPayloadOffsetEnd - payload[0].tagStart;
1193    var segmentSize = payload[0].tagStart - ebmlSize;
1194    var segmentOffset = payload[0].tagStart;

1195    var segmentTagBuf = new exports.Buffer([0x18, 0x53, 0x80, 0x67]); // Segment
1196    var segmentSizeBuf = new exports.Buffer('01ffffffffffffff', 'hex'); // Segmentの最後の位置は無数の Cluster 依存なので。 writeVint(newPayloadSize).byteLength ではなく、 infinity.
1197    var _segmentSize = segmentTagBuf.byteLength + segmentSizeBuf.byteLength; // == segmentSize
1198    var newPayloadSize = payloadSize;
1199    // We need the size to be stable between two refinements in order for our offsets to be correct
1200    // Bound the number of possible refinements so we can't go infinate if something goes wrong
1201    var i;
1202    for (i = 1; i < 20; i++) {
1203        var newPayloadOffsetEnd = ebmlSize + _segmentSize + newPayloadSize;
1204        var offsetEndDiff = newPayloadOffsetEnd - originalPayloadOffsetEnd;
1205        var sizeDiff = offsetDiff + offsetEndDiff;
1206        var refined = refineMetadata(payload, sizeDiff, info);
1207        var newNewRefinedSize = new EBMLEncoder_1.default().encode(refined).byteLength; // 一旦 seekhead を作って自身のサイズを調べる
1208        if (newNewRefinedSize === newPayloadSize) {
1209            // Size is stable
1210            return new EBMLEncoder_1.default().encode([].concat(ebml, [{ type: "m", name: "Segment", isEnd: false, unknownSize: true }], refined));
1211        }
1212        newPayloadSize = newNewRefinedSize;
1213    }
1214    throw new Error("unable to refine metadata, stable size could not be found in " + i + " iterations!");
1215}
1216exports.putRefinedMetaData = putRefinedMetaData;
1217// Given a list of EBMLElementBuffers, returns their encoded size in bytes
1218function encodedSizeOfEbml(refinedMetaData) {
1219    var encorder = new EBMLEncoder_1.default();
1220    return refinedMetaData.reduce(function (lst, elm) { return lst.concat(encorder.encode([elm])); }, []).reduce(function (o, buf) { return o + buf.byteLength; }, 0);
1221}
1222function refineMetadata(mesetadata, sizeDiff, info) {
1223    var duration = info.duration, clusterPtrs = info.clusterPtrs, cues = info.cues;
1224    var _metadata = mesetadata.slice(0);
1225    if (typeof duration === "number") {
1226        // duration を追加する
1227        var overwrited_1 = false;
1228        _metadata.forEach(function (elm) {
1229            if (elm.type === "f" && elm.name === "Duration") {
1230                overwrited_1 = true;
1231                elm.data = createFloatBuffer(duration, 8);
1232            }
1233        });
1234        if (!overwrited_1) {
1235            insertTag(_metadata, "Info", [{ name: "Duration", type: "f", data: createFloatBuffer(duration, 8) }]);
1236        }
1237    }
1238    if (Array.isArray(cues)) {
1239        insertTag(_metadata, "Cues", create_cue(cues, sizeDiff));
1240    }
1241    var seekhead_children = [];
1242    if (Array.isArray(clusterPtrs)) {
1243        console.warn("append cluster pointers to seekhead is deprecated. please use cues");
1244        seekhead_children = create_seek_from_clusters(clusterPtrs, sizeDiff);
1245    }
1246    // remove seek info
1247    /*
1248    _metadata = _metadata.filter((elm)=> !(
1249      elm.name === "Seek" ||
1250      elm.name === "SeekID" ||
1251      elm.name === "SeekPosition") );
1252    */
1253    // working on progress
1254    //seekhead_children = seekhead_children.concat(create_seekhead(_metadata));
1255    insertTag(_metadata, "SeekHead", seekhead_children, true);
1256    return _metadata;
1257}
1258function create_seekhead(metadata, sizeDiff) {
1259    var seeks = [];
1260    ["Info", "Tracks", "Cues"].forEach(function (tagName) {
1261        var tagStarts = metadata.filter(function (elm) { return elm.type === "m" && elm.name === tagName && elm.isEnd === false; }).map(function (elm) { return elm["tagStart"]; });
1262        var tagStart = tagStarts[0];
1263        if (typeof tagStart !== "number") {
1264            return;
1265        }
1266        seeks.push({ name: "Seek", type: "m", isEnd: false });
1267        switch (tagName) {
1268            case "Info":
1269                seeks.push({ name: "SeekID", type: "b", data: new exports.Buffer([0x15, 0x49, 0xA9, 0x66]) });
1270                break;
1271            case "Tracks":
1272                seeks.push({ name: "SeekID", type: "b", data: new exports.Buffer([0x16, 0x54, 0xAE, 0x6B]) });
1273                break;
1274            case "Cues":
1275                seeks.push({ name: "SeekID", type: "b", data: new exp

1275orts.Buffer([0x1C, 0x53, 0xBB, 0x6B]) });
1276                break;
1277        }
1278        seeks.push({ name: "SeekPosition", type: "u", data: createUIntBuffer(tagStart + sizeDiff) });
1279        seeks.push({ name: "Seek", type: "m", isEnd: true });
1280    });
1281    return seeks;
1282}
1283function create_seek_from_clusters(clusterPtrs, sizeDiff) {
1284    var seeks = [];
1285    clusterPtrs.forEach(function (start) {
1286        seeks.push({ name: "Seek", type: "m", isEnd: false });
1287        // [0x1F, 0x43, 0xB6, 0x75] で Cluster 意
1288        seeks.push({ name: "SeekID", type: "b", data: new exports.Buffer([0x1F, 0x43, 0xB6, 0x75]) });
1289        seeks.push({ name: "SeekPosition", type: "u", data: createUIntBuffer(start + sizeDiff) });
1290        seeks.push({ name: "Seek", type: "m", isEnd: true });
1291    });
1292    return seeks;
1293}
1294function create_cue(cueInfos, sizeDiff) {
1295    var cues = [];
1296    cueInfos.forEach(function (_a) {
1297        var CueTrack = _a.CueTrack, CueClusterPosition = _a.CueClusterPosition, CueTime = _a.CueTime;
1298        cues.push({ name: "CuePoint", type: "m", isEnd: false });
1299        cues.push({ name: "CueTime", type: "u", data: createUIntBuffer(CueTime) });
1300        cues.push({ name: "CueTrackPositions", type: "m", isEnd: false });
1301        cues.push({ name: "CueTrack", type: "u", data: createUIntBuffer(CueTrack) }); // video track
1302        cues.push({ name: "CueClusterPosition", type: "u", data: createUIntBuffer(CueClusterPosition + sizeDiff) });
1303        cues.push({ name: "CueTrackPositions", type: "m", isEnd: true });
1304        cues.push({ name: "CuePoint", type: "m", isEnd: true });
1305    });
1306    return cues;
1307}
1308function insertTag(_metadata, tagName, children, insertHead) {
1309    if (insertHead === void 0) { insertHead = false; }
1310    // find the tagname from _metadata
1311    var idx = -1;
1312    for (var i = 0; i < _metadata.length; i++) {
1313        var elm = _metadata[i];
1314        if (elm.type === "m" && elm.name === tagName && elm.isEnd === false) {
1315            idx = i;
1316            break;
1317        }
1318    }
1319    if (idx >= 0) {
1320        // insert [<CuePoint />] to <Cues />
1321        Array.prototype.splice.apply(_metadata, [idx + 1, 0].concat(children));
1322    }
1323    else if (insertHead) {
1324        [].concat([{ name: tagName, type: "m", isEnd: false }], children, [{ name: tagName, type: "m", isEnd: true }]).reverse().forEach(function (elm) { _metadata.unshift(elm); });
1325    }
1326    else {
1327        // metadata 末尾に <Cues /> を追加
1328        // insert <Cues />
1329        _metadata.push({ name: tagName, type: "m", isEnd: false });
1330        children.forEach(function (elm) { _metadata.push(elm); });
1331        _metadata.push({ name: tagName, type: "m", isEnd: true });
1332    }
1333}
1334// alter Buffer.concat - https://github.com/feross/buffer/issues/154
1335function concat(list) {
1336    //return Buffer.concat.apply(Buffer, list);
1337    var i = 0;
1338    var length = 0;
1339    for (; i < list.length; ++i) {
1340        length += list[i].length;
1341    }
1342    var buffer = exports.Buffer.allocUnsafe(length);
1343    var pos = 0;
1344    for (i = 0; i < list.length; ++i) {
1345        var buf = list[i];
1346        buf.copy(buffer, pos);
1347        pos += buf.length;
1348    }
1349    return buffer;
1350}
1351exports.concat = concat;
1352function encodeValueToBuffer(elm) {
1353    var data = new exports.Buffer(0);
1354    if (elm.type === "m") {
1355        return elm;
1356    }
1357    switch (elm.type) {
1358        case "u":
1359            data = createUIntBuffer(elm.value);
1360            break;
1361        case "i":
1362            data = createIntBuffer(elm.value);
1363            break;
1364        case "f":
1365            data = createFloatBuffer(elm.value);
1366            break;
1367        case "s":
1368            data = new exports.Buffer(elm.value, 'ascii');
1369            break;
1370        case "8":
1371            data = new exports.Buffer(elm.value, 'utf8');
1372            break;
1373        case "b":
1374            data = elm.value;
1375            break;
1376        case "d":
1377            data = new int64_buffer_1.Int64BE(elm.value.getTime().toString()).toBuffer();
1378            break;
1379    }
1380    return Object.assign({}, elm, { data: data });
1381}
1382exports.encodeValueToBuffer = encodeValueToBuffer;
1383function createUIntBuffer(value) {
1384    // Big-endian, any size from 1 to 8
1385    // but js number is float64, so max 6 bit octets
1386    var bytes = 1;
1387    for (; value >= Math.pow(2, 8 * bytes); bytes++) { }
1388    if (bytes >= 7) {
1389        console.warn("7bit or more bigger uint not supported.");
1390        return new int64_buffer_1.Uint64BE(value).toBuffer();
1391    }

1392    var data = new exports.Buffer(bytes);
1393    data.writeUIntBE(value, 0, bytes);
1394    return data;
1395}
1396exports.createUIntBuffer = createUIntBuffer;
1397function createIntBuffer(value) {
1398    // Big-endian, any size from 1 to 8 octets
1399    // but js number is float64, so max 6 bit
1400    var bytes = 1;
1401    for (; value >= Math.pow(2, 8 * bytes); bytes++) { }
1402    if (bytes >= 7) {
1403        console.warn("7bit or more bigger uint not supported.");
1404        return new int64_buffer_1.Int64BE(value).toBuffer();
1405    }
1406    var data = new exports.Buffer(bytes);
1407    data.writeIntBE(value, 0, bytes);
1408    return data;
1409}
1410exports.createIntBuffer = createIntBuffer;
1411function createFloatBuffer(value, bytes) {
1412    if (bytes === void 0) { bytes = 8; }
1413    // Big-endian, defined for 4 and 8 octets (32, 64 bits)
1414    // js number is float64 so 8 bytes.
1415    if (bytes === 8) {
1416        // 64bit
1417        var data = new exports.Buffer(8);
1418        data.writeDoubleBE(value, 0);
1419        return data;
1420    }
1421    else if (bytes === 4) {
1422        // 32bit
1423        var data = new exports.Buffer(4);
1424        data.writeFloatBE(value, 0);
1425        return data;
1426    }
1427    else {
1428        throw new Error("float type bits must 4bytes or 8bytes");
1429    }
1430}
1431exports.createFloatBuffer = createFloatBuffer;
1432function convertEBMLDateToJSDate(int64str) {
1433    if (int64str instanceof Date) {
1434        return int64str;
1435    }
1436    return new Date(new Date("2001-01-01T00:00:00.000Z").getTime() + (Number(int64str) / 1000 / 1000));
1437}
1438exports.convertEBMLDateToJSDate = convertEBMLDateToJSDate;
1439
1440},{"./EBMLEncoder":2,"buffer/":8,"ebml-block":9,"ebml/lib/ebml/tools":12,"int64-buffer":15}],6:[function(require,module,exports){
1441'use strict'
1442
1443exports.byteLength = byteLength
1444exports.toByteArray = toByteArray
1445exports.fromByteArray = fromByteArray
1446
1447var lookup = []
1448var revLookup = []
1449var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
1450
1451var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
1452for (var i = 0, len = code.length; i < len; ++i) {
1453  lookup[i] = code[i]
1454  revLookup[code.charCodeAt(i)] = i
1455}
1456
1457// Support decoding URL-safe base64 strings, as Node.js does.
1458// See: https://en.wikipedia.org/wiki/Base64#URL_applications
1459revLookup['-'.charCodeAt(0)] = 62
1460revLookup['_'.charCodeAt(0)] = 63
1461
1462function getLens (b64) {
1463  var len = b64.length
1464
1465  if (len % 4 > 0) {
1466    throw new Error('Invalid string. Length must be a multiple of 4')
1467  }
1468
1469  // Trim off extra bytes after placeholder bytes are found
1470  // See: https://github.com/beatgammit/base64-js/issues/42
1471  var validLen = b64.indexOf('=')
1472  if (validLen === -1) validLen = len
1473
1474  var placeHoldersLen = validLen === len
1475    ? 0
1476    : 4 - (validLen % 4)
1477
1478  return [validLen, placeHoldersLen]
1479}
1480
1481// base64 is 4/3 + up to two characters of the original data
1482function byteLength (b64) {
1483  var lens = getLens(b64)
1484  var validLen = lens[0]
1485  var placeHoldersLen = lens[1]
1486  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
1487}
1488
1489function _byteLength (b64, validLen, placeHoldersLen) {
1490  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
1491}
1492
1493function toByteArray (b64) {
1494  var tmp
1495  var lens = getLens(b64)
1496  var validLen = lens[0]
1497  var placeHoldersLen = lens[1]
1498
1499  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
1500
1501  var curByte = 0
1502
1503  // if there are placeholders, only get up to the last complete 4 chars
1504  var len = placeHoldersLen > 0
1505    ? validLen - 4
1506    : validLen
1507
1508  for (var i = 0; i < len; i += 4) {
1509    tmp =
1510      (revLookup[b64.charCodeAt(i)] << 18) |
1511      (revLookup[b64.charCodeAt(i + 1)] << 12) |
1512      (revLookup[b64.charCodeAt(i + 2)] << 6) |
1513      revLookup[b64.charCodeAt(i + 3)]
1514    arr[curByte++] = (tmp >> 16) & 0xFF
1515    arr[curByte++] = (tmp >> 8) & 0xFF
1516    arr[curByte++] = tmp & 0xFF
1517  }
1518
1519  if (placeHoldersLen === 2) {
1520    tmp =
1521      (revLookup[b64.charCodeAt(i)] << 2) |
1522      (revLookup[b64.charCodeAt(i + 1)] >> 4)
1523    arr[curByte++] = tmp & 0xFF
1524  }
1525
1526  if (placeHoldersLen === 1) {
1527    tmp =
1528      (revLookup[b64.charCodeAt(i)] << 10) |
1529      (revLookup[b64.charCodeAt(i + 1)] << 4) |
1530      (revLookup[b64.charCodeAt(i + 2)] >> 2)
1531    arr[curByte++] = (tmp >> 8) & 0xFF
1532    arr[curByte++] = tmp & 0xFF
1533  }
1534
1535  return arr
1536}
1537
1538function tripletToBase64 (num) {
1539  return lookup[num >> 18 & 0x3F] +
1540    lookup[num >> 12 & 0x3F] +
1541    lookup[num >> 6 & 0x3F] +
1542    lookup[num & 0x3F]
1543}
1544
1545function encodeChunk (uint8, start, end) {
1546  var tmp
1547  var output = []
1548  for (var i = start; i < end; i += 3) {
1549    tmp =
1550      ((uint8[i] << 16) & 0xFF0000) +
1551      ((uint8[i + 1] << 8) & 0xFF00) +
1552      (uint8[i + 2] & 0xFF)
1553    output.push(tripletToBase64(tmp))
1554  }
1555  return output.join('')
1556}
1557
1558function fromByteArray (uint8) {
1559  var tmp
1560  var len = uint8.length
1561  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
1562  var parts = []
1563  var maxChunkLength = 16383 // must be multiple of 3
1564
1565  // go through the array every three bytes, we'll deal with trailing stuff later
1566  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
1567    parts.push(encodeChunk(
1568      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
1569    ))
1570  }
1571
1572  // pad the end with zeros, but make sure to not forget the extra bytes
1573  if (extraBytes === 1) {
1574    tmp = uint8[len - 1]
1575    parts.push(
1576      lookup[tmp >> 2] +
1577      lookup[(tmp << 4) & 0x3F] +
1578      '=='
1579    )
1580  } else if (extraBytes === 2) {
1581    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
1582    parts.push(
1583      lookup[tmp >> 10] +
1584      lookup[(tmp >> 4) & 0x3F] +
1585      lookup[(tmp << 2) & 0x3F] +
1586      '='
1587    )
1588  }
1589
1590  return parts.join('')
1591}
1592
1593},{}],7

1593:[function(require,module,exports){
1594(function (global){
1595/*!
1596 * The buffer module from node.js, for the browser.
1597 *
1598 * @author   Feross Aboukhadijeh <[email protected]> <http://feross.org>
1599 * @license  MIT
1600 */
1601/* eslint-disable no-proto */
1602
1603'use strict'
1604
1605var base64 = require('base64-js')
1606var ieee754 = require('ieee754')
1607var isArray = require('isarray')
1608
1609exports.Buffer = Buffer
1610exports.SlowBuffer = SlowBuffer
1611exports.INSPECT_MAX_BYTES = 50
1612
1613/**
1614 * If `Buffer.TYPED_ARRAY_SUPPORT`:
1615 *   === true    Use Uint8Array implementation (fastest)
1616 *   === false   Use Object implementation (most compatible, even IE6)
1617 *
1618 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
1619 * Opera 11.6+, iOS 4.2+.
1620 *
1621 * Due to various browser bugs, sometimes the Object implementation will be used even
1622 * when the browser supports typed arrays.
1623 *
1624 * Note:
1625 *
1626 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
1627 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
1628 *
1629 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
1630 *
1631 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
1632 *     incorrect length in some situations.
1633
1634 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
1635 * get the Object implementation, which is slower but behaves correctly.
1636 */
1637Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
1638  ? global.TYPED_ARRAY_SUPPORT
1639  : typedArraySupport()
1640
1641/*
1642 * Export kMaxLength after typed array support is determined.
1643 */
1644exports.kMaxLength = kMaxLength()
1645
1646function typedArraySupport () {
1647  try {
1648    var arr = new Uint8Array(1)
1649    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
1650    return arr.foo() === 42 && // typed array instances can be augmented
1651        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
1652        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
1653  } catch (e) {
1654    return false
1655  }
1656}
1657
1658function kMaxLength () {
1659  return Buffer.TYPED_ARRAY_SUPPORT
1660    ? 0x7fffffff
1661    : 0x3fffffff
1662}
1663
1664function createBuffer (that, length) {
1665  if (kMaxLength() < length) {
1666    throw new RangeError('Invalid typed array length')
1667  }
1668  if (Buffer.TYPED_ARRAY_SUPPORT) {
1669    // Return an augmented `Uint8Array` instance, for best performance
1670    that = new Uint8Array(length)
1671    that.__proto__ = Buffer.prototype
1672  } else {
1673    // Fallback: Return an object instance of the Buffer class
1674    if (that === null) {
1675      that = new Buffer(length)
1676    }
1677    that.length = length
1678  }
1679
1680  return that
1681}
1682
1683/**
1684 * The Buffer constructor returns instances of `Uint8Array` that have their
1685 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
1686 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
1687 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
1688 * returns a single octet.
1689 *
1690 * The `Uint8Array` prototype remains unmodified.
1691 */
1692
1693function Buffer (arg, encodingOrOffset, length) {
1694  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
1695    return new Buffer(arg, encodingOrOffset, length)
1696  }
1697
1698  // Common case.
1699  if (typeof arg === 'number') {
1700    if (typeof encodingOrOffset === 'string') {
1701      throw new Error(
1702        'If encoding is specified then the first argument must be a string'
1703      )
1704    }
1705    return allocUnsafe(this, arg)
1706  }
1707  return from(this, arg, encodingOrOffset, length)
1708}
1709
1710Buffer.poolSize = 8192 // not used by this implementation
1711
1712// TODO: Legacy, not needed anymore. Remove in next major version.
1713Buffer._augment = function (arr) {
1714  arr.__proto__ = Buffer.prototype
1715  return arr
1716}
1717
1718function from (that, value, encodingOrOffset, length) {
1719  if (typeof value === 'number') {
1720    throw new TypeError('"value" argument must not be a number')
1721  }
1722
1723  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
1724    return fromArrayBuffer(that, value, encodingOrOffset, length)
1725  }
1726
1727  if (typeof value === 'string') {
1728    return fromString(that, value, encodingOrOffset)
1729  }
1730
1731  return fromObject(that, value)
1732}
1733
1734/**
1735 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
1736 * if value is a number.
1737 * Buffer.from(str[, encoding])
1738 * Buffer.from(array)
1739 * Buffer.from(buffer)
1740 * Buffer.from(arrayBuffer[, byteOffset[, length]])
1741 **/
1742Buffer.from = function (value, encodingOrOffset, length) {
1743  return from(null, value, encodingOrOffset, length)
1744}
1745
1746if (Buffer.TYPED_ARRAY_SUPPORT) {
1747  Buffer.prototype.__proto__ = Uint8Array.prototype
1748  Buffer.__proto__ = Uint8Array
1749  if (typeof Symbol !== 'undefined' && Symbol.species &&
1750      Buffer[Symbol.species] === Buffer) {
1751    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
1752    Object.defineProperty(Buffer, Symbol.species, {
1753      value: null,
1754      configurable: true
1755    })
1756  }
1757}
1758
1759function assertSize (size) {
1760  if (typeof size !== 'number') {
1761    throw new TypeError('"size" argument must be a number')
1762  } else if (size < 0) {
1763    throw new RangeError('"size" argument must not be negative')
1764  }
1765}
1766
1767function alloc (that, size, fill, encoding) {
1768  assertSize(size)
1769  if (size <= 0) {
1770    return createBuffer(that, size)
1771  }
1772  if (fill !== undefined) {
1773    // Only pay attention to encoding if it's a string. This
1774    // prevents accidentally sending in a number that would
1775    // be interpretted as a start offset.
1776    return typeof encoding === 'string'
1777      ? createBuffer(that, size).fill(fill, encoding)
1778      : createBuffer(that, size).fill(fill)
1779  }
1780  return createBuffer(that, size)
1781}
1782
1783/**
1784 * Creates a new filled Buffer instance.
1785 * alloc(size[, fill[, encoding]])
1786 **/
1787Buffer.alloc = function (size, fill, encoding) {
1788  return alloc(null, size, fill, encoding)
1789}
1790
1791function allocUnsafe (that, size) {
1792  assertSize(size)
1793  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
1794  if (!Buffer.TYPED_ARRAY_SUPPORT) {
1795    for (var i = 0; i < size; ++i) {
1796      that[i] = 0
1797    }
1798  }
1799  return that
1800}
1801
1802/**
1803 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
1804 * */
1805Buffer.allocUnsafe = function (size) {
1806  return allocUnsafe(null, size)
1807}
1808/**
1809 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
1810 */
1811Buffer.allocUnsafeSlow = function (size) {
1812  return allocUnsafe(null, size)
1813}
1814
1815function fromString (that, string, encoding) {
1816  if (typeof encoding !== 'string' || encoding === '') {
1817    encoding = 'utf8'
1818  }
1819
1820  if (!Buffer.isEncoding(encoding)) {
1821    throw new TypeError('"encoding" must be a valid string encoding')
1822  }
1823
1824  var length = byteLength(string, encoding) | 0
1825  that = createBuffer(that, length)
1826
1827  var actual = that.write(string, encoding)
1828
1829  if (actual !== length) {
1830    // Writing a hex string, for example, that contains invalid characters will
1831    // cause everything after the first invalid character to be ignored. (e.g.
1832    // 'abxxcd' will be treated as 'ab')
1833    that = that.slice(0, actual)
1834  }
1835
1836  return that
1837}
1838
1839function fromArrayLike (that, array) {
1840  var length = array.length < 0 ? 0 : checked(array.length) | 0
1841  that = createBuffer(that, length)
1842  for (var i = 0; i < length; i += 1) {
1843    that[i] = array[i] & 255
1844  }
1845  return that
1846}
1847
1848function fromArrayBuffer (that, array, byteOffset, length) {
1849  array.byteLength // this throws if `array` is not a valid ArrayBuffer
1850
1851  if (byteOffset < 0 || array.byteLength < byteOffset) {
1852    throw new RangeError('\'offset\' is out of bounds')
1853  }
1854
1855  if (array.byteLength < byteOffset + (length || 0)) {
1856    throw new RangeError('\'length\' is out of bounds')
1857  }
1858
1859  if (byteOffset === undefined && length === undefined) {
1860    array = new Uint8Array(array)
1861  } else if (length === undefined) {
1862    array = new Uint8Array(array, byteOffset)
1863  } else {
1864    array = new Uint8Array(array, byteOffset, length)
1865  }
1866
1867  if (Buffer.TYPED_ARRAY_SUPPORT) {
1868    // Return an augmented `Uint8Array` instance, for best performance
1869    that = array
1870    that.__proto__ = Buffer.prototype
1871  } else {
1872    // Fallback: Return an object instance of the Buffer class
1873    that = fromArrayLike(that, array)
1874  }
1875  return that
1876}
1877
1878function fromObject (that, obj) {
1879  if (Buffer.isBuffer(obj)) {
1880    var len = checked(obj.length) | 0
1881    that = createBuffer(that, len)
1882
1883    if (that.length === 0) {
1884      return that
1885    }
1886
1887    obj.copy(that, 0, 0, len)
1888    return that
1889  }
1890
1891  if (obj) {
1892    if ((typeof ArrayBuffer !== 'undefined' &&
1893        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
1894      if (typeof obj.length !== 'number' || isnan(obj.length)) {
1895        return createBuffer(that, 0)
1896      }
1897      return fromArrayLike(that, obj)
1898    }
1899
1900    if (obj.type === 'Buffer' && isArray(obj.data)) {
1901      return fromArrayLike(that, obj.data)
1902    }
1903  }
1904
1905  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
1906}
1907
1908function checked (length) {
1909  // Note: cannot use `length < kMaxLength()` here because that fails when
1910  // length is NaN (which is otherwise coerced to zero.)
1911  if (length >= kMaxLength()) {
1912    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
1913                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
1914  }
1915  return length | 0
1916}
1917
1918function SlowBuffer (length) {
1919  if (+length != length) { // eslint-disable-line eqeqeq
1920    length = 0
1921  }
1922  return Buffer.alloc(+length)
1923}
1924
1925Buffer.isBuffer = function isBuffer (b) {
1926  return !!(b != null && b._isBuffer)
1927}
1928
1929Buffer.compare = function compare (a, b) {
1930  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
1931    throw new TypeError('Arguments must be Buffers')
1932  }
1933
1934  if (a === b) return 0
1935
1936  var x = a.length
1937  var y = b.length
1938
1939  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
1940    if (a[i] !== b[i]) {
1941      x = a[i]
1942      y = b[i]
1943      break
1944    }
1945  }
1946
1947  if (x < y) return -1
1948  if (y < x) return 1
1949  return 0
1950}
1951
1952Buffer.isEncoding = function isEncoding (encoding) {
1953  switch (String(encoding).toLowerCase()) {
1954    case 'hex':
1955    case 'utf8':
1956    case 'utf-8':
1957    case 'ascii':
1958    case 'latin1':
1959    case 'binary':
1960    case 'base64':
1961    case 'ucs2':
1962    case 'ucs-2':
1963    case 'utf16le':
1964    case 'utf-16le':
1965      return true
1966    default:
1967      return false
1968  }
1969}
1970
1971Buffer.concat = function concat (list, length) {
1972  if (!isArray(list)) {
1973    throw new TypeError('"list" argument must be an Array of Buffers')
1974  }
1975
1976  if (list.length === 0) {
1977    return Buffer.alloc(0)
1978  }
1979
1980  var i
1981  if (length === undefined) {
1982    length = 0
1983    for (i = 0; i < list.length; ++i) {
1984      length += list[i].length
1985    }
1986  }
1987
1988  var buffer = Buffer.allocUnsafe(length)
1989  var pos = 0
1990  for (i = 0; i < list.length; ++i) {
1991    var buf = list[i]
1992    if (!Buffer.isBuffer(buf)) {
1993      throw new TypeError('"list" argument must be an Array of Buffers')
1994    }
1995    buf.copy(buffer, pos)
1996    pos += buf.length
1997  }
1998  return buffer
1999}
2000
2001function byteLength (string, encoding) {
2002  if (Buffer.isBuffer(string)) {
2003    return string.length
2004  }
2005  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
2006      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
2007    return string.byteLength
2008  }
2009  if (typeof string !== 'string') {
2010    string = '' + string
2011  }
2012
2013  var len = string.length
2014  if (len === 0) return 0
2015
2016  // Use a for loop to avoid recursion
2017  var loweredCase = false
2018  for (;;) {
2019    switch (encoding) {
2020      case 'ascii':
2021      case 'latin1':
2022      case 'binary':
2023        return len
2024      case 'utf8':
2025      case 'utf-8':
2026      case undefined:
2027        return utf8ToBytes(string).length
2028      case 'ucs2':
2029      case 'ucs-2':
2030      case 'utf16le':
2031      case 'utf-16le':
2032        return len * 2
2033      case 'hex':
2034        return len >>> 1
2035      case 'base64':
2036        return base64ToBytes(string).length
2037      default:
2038        if (loweredCase) return utf8ToBytes(string).length // assume utf8
2039        encoding = ('' + encoding).toLowerCase()
2040        loweredCase = true
2041    }
2042  }
2043}
2044Buffer.byteLength = byteLength
2045
2046function slowToString (encoding, start, end) {
2047  var loweredCase = false
2048
2049  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
2050  // property of a typed array.
2051
2052  // This behaves neither like String nor Uint8Array in that we set start/end
2053  // to their upper/lower bounds if the value passed is out of range.
2054  // undefined is handled specially as per ECMA-262 6th Edition,
2055  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
2056  if (start === undefined || start < 0) {
2057    start = 0
2058  }
2059  // Return early if start > this.length. Done here to prevent potential uint32
2060  // coercion fail below.
2061  if (start > this.length) {
2062    return ''
2063  }
2064
2065  if (end === undefined || end > this.length) {
2066    end = this.length
2067  }
2068
2069  if (end <= 0) {
2070    return ''
2071  }
2072
2073  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
2074  end >>>= 0
2075  start >>>= 0
2076
2077  if (end <= start) {
2078    return ''
2079  }
2080
2081  if (!encoding) encoding = 'utf8'
2082
2083  while (true) {
2084    switch (encoding) {
2085      case 'hex':
2086        return hexSlice(this, start, end)
2087
2088      case 'utf8':
2089      case 'utf-8':
2090        return utf8Slice(this, start, end)
2091
2092      case 'ascii':
2093        return asciiSlice(this, start, end)
2094
2095      case 'latin1':
2096      case 'binary':
2097        return latin1Slice(this, start, end)
2098
2099      case 'base64':
2100        return base64Slice(this, start, end)
2101
2102      case 'ucs2':
2103      case 'ucs-2':
2104      case 'utf16le':
2105      case 'utf-16le':
2106        return utf16leSlice(this, start, end)
2107
2108      default:
2109        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
2110        encoding = (encoding + '').toLowerCase()
2111        loweredCase = true
2112    }
2113  }
2114}
2115
2116// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
2117// Buffer instances.
2118Buffer.prototype._isBuffer = true
2119
2120function swap (b, n, m) {
2121  var i = b[n]
2122  b[n] = b[m]
2123  b[m] = i
2124}
2125
2126Buffer.prototype.swap16 = function swap16 () {
2127  var len = this.length
2128  if (len % 2 !== 0) {
2129    throw new RangeError('Buffer size must be a multiple of 16-bits')
2130  }
2131  for (var i = 0; i < len; i += 2) {
2132    swap(this, i, i + 1)
2133  }
2134  return this
2135}
2136
2137Buffer.prototype.swap32 = function swap32 () {
2138  var len = this.length
2139  if (len % 4 !== 0) {
2140    throw new RangeError('Buffer size must be a multiple of 32-bits')
2141  }
2142  for (var i = 0; i < len; i += 4) {
2143    swap(this, i, i + 3)
2144    swap(this, i + 1, i + 2)
2145  }
2146  return this
2147}
2148
2149Buffer.prototype.swap64 = function swap64 () {
2150  var len = this.length
2151  if (len % 8 !== 0) {
2152    throw new RangeError('Buffer size must be a multiple of 64-bits')
2153  }
2154  for (var i = 0; i < len; i += 8) {
2155    swap(this, i, i + 7)
2156    swap(this, i + 1, i + 6)
2157    swap(this, i + 2, i + 5)
2158    swap(this, i + 3, i + 4)
2159  }
2160  return this
2161}
2162
2163Buffer.prototype.toString = function toString () {
2164  var length = this.length | 0
2165  if (length === 0) return ''
2166  if (arguments.length === 0) return utf8Slice(this, 0, length)
2167  return slowToString.apply(this, arguments)
2168}
2169
2170Buffer.prototype.equals = function equals (b) {
2171  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
2172  if (this === b) return true
2173  return Buffer.compare(this, b) === 0
2174}
2175
2176Buffer.prototype.inspect = function inspect () {
2177  var str = ''
2178  var max = exports.INSPECT_MAX_BYTES
2179  if (this.length > 0) {
2180    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
2181    if (this.length > max) str += ' ... '
2182  }
2183  return '<Buffer ' + str + '>'
2184}
2185
2186Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
2187  if (!Buffer.isBuffer(target)) {
2188    throw new TypeError('Argument must be a Buffer')
2189  }
2190
2191  if (start === undefined) {
2192    start = 0
2193  }
2194  if (end === undefined) {
2195    end = target ? target.length : 0
2196  }
2197  if (thisStart === undefined) {
2198    thisStart = 0
2199  }
2200  if (thisEnd === undefined) {
2201    thisEnd = this.length
2202  }
2203
2204  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
2205    throw new RangeError('out of range index')
2206  }
2207
2208  if (thisStart >= thisEnd && start >= end) {
2209    return 0
2210  }
2211  if (thisStart >= thisEnd) {
2212    return -1
2213  }
2214  if (start >= end) {
2215    return 1
2216  }
2217
2218  start >>>= 0
2219  end >>>= 0
2220  thisStart >>>= 0
2221  thisEnd >>>= 0
2222
2223  if (this === target) return 0
2224
2225  var x = thisEnd - thisStart
2226  var y = end - start
2227  var len = Math.min(x, y)
2228
2229  var thisCopy = this.slice(thisStart, thisEnd)
2230  var targetCopy = target.slice(start, end)
2231
2232  for (var i = 0; i < len; ++i) {
2233    if (thisCopy[i] !== targetCopy[i]) {
2234      x = thisCopy[i]
2235      y = targetCopy[i]
2236      break
2237    }
2238  }
2239
2240  if (x < y) return -1
2241  if (y < x) return 1
2242  return 0
2243}
2244
2245// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
2246// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
2247//
2248// Arguments:
2249// - buffer - a Buffer to search
2250// - val - a string, Buffer, or number
2251// - byteOffset - an index into `buffer`; will be clamped to an int32
2252// - encoding - an optional encoding, relevant is val is a string
2253// - dir - true for indexOf, false for lastIndexOf
2254function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
2255  // Empty buffer means no match
2256  if (buffer.length === 0) return -1
2257
2258  // Normalize byteOffset
2259  if (typeof byteOffset === 'string') {
2260    encoding = byteOffset
2261    byteOffset = 0
2262  } else if (byteOffset > 0x7fffffff) {
2263    byteOffset = 0x7fffffff
2264  } else if (byteOffset < -0x80000000) {
2265    byteOffset = -0x80000000
2266  }
2267  byteOffset = +byteOffset  // Coerce to Number.
2268  if (isNaN(byteOffset)) {
2269    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
2270    byteOffset = dir ? 0 : (buffer.length - 1)
2271  }
2272
2273  // Normalize byteOffset: negative offsets start from the end of the buffer
2274  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
2275  if (byteOffset >= buffer.length) {
2276    if (dir) return -1
2277    else byteOffset = buffer.length - 1
2278  } else if (byteOffset < 0) {
2279    if (dir) byteOffset = 0
2280    else return -1
2281  }
2282
2283  // Normalize val
2284  if (typeof val === 'string') {
2285    val = Buffer.from(val, encoding)
2286  }
2287
2288  // Finally, search either indexOf (if dir is true) or lastIndexOf
2289  if (Buffer.isBuffer(val)) {
2290    // Special case: looking for empty string/buffer always fails
2291    if (val.length === 0) {
2292      return -1
2293    }
2294    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
2295  } else if (typeof val === 'number') {
2296    val = val & 0xFF // Search for a byte value [0-255]
2297    if (Buffer.TYPED_ARRAY_SUPPORT &&
2298        typeof Uint8Array.prototype.indexOf === 'function') {
2299      if (dir) {
2300        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
2301      } else {
2302        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
2303      }
2304    }
2305    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
2306  }
2307
2308  throw new TypeError('val must be string, number or Buffer')
2309}
2310
2311function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
2312  var indexSize = 1
2313  var arrLength = arr.length
2314  var valLength = val.length
2315
2316  if (encoding !== undefined) {
2317    encoding = String(encoding).toLowerCase()
2318    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
2319        encoding === 'utf16le' || encoding === 'utf-16le') {
2320      if (arr.length < 2 || val.length < 2) {
2321        return -1
2322      }
2323      indexSize = 2
2324      arrLength /= 2
2325      valLength /= 2
2326      byteOffset /= 2
2327    }
2328  }
2329
2330  function read (buf, i) {
2331    if (indexSize === 1) {
2332      return buf[i]
2333    } else {
2334      return buf.readUInt16BE(i * indexSize)
2335    }
2336  }
2337
2338  var i
2339  if (dir) {
2340    var foundIndex = -1
2341    for (i = byteOffset; i < arrLength; i++) {
2342      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
2343        if (foundIndex === -1) foundIndex = i
2344        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
2345      } else {
2346        if (foundIndex !== -1) i -= i - foundIndex
2347        foundIndex = -1
2348      }
2349    }
2350  } else {
2351    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
2352    for (i = byteOffset; i >= 0; i--) {
2353      var found = true
2354      for (var j = 0; j < valLength; j++) {
2355        if (read(arr, i + j) !== read(val, j)) {
2356          found = false
2357          break
2358        }
2359      }
2360      if (found) return i
2361    }
2362  }
2363
2364  return -1
2365}
2366
2367Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
2368  return this.indexOf(val, byteOffset, encoding) !== -1
2369}
2370
2371Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
2372  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
2373}
2374
2375Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
2376  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
2377}
2378
2379function hexWrite (buf, string, offset, length) {
2380  offset = Number(offset) || 0
2381  var remaining = buf.length - offset
2382  if (!length) {
2383    length = remaining
2384  } else {
2385    length = Number(length)
2386    if (length > remaining) {
2387      length = remaining
2388    }
2389  }
2390
2391  // must be an even number of digits
2392  var strLen = string.length
2393  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
2394
2395  if (length > strLen / 2) {
2396    length = strLen / 2
2397  }
2398  for (var i = 0; i < length; ++i) {
2399    var parsed = parseInt(string.substr(i * 2, 2), 16)
2400    if (isNaN(parsed)) return i
2401    buf[offset + i] = parsed
2402  }
2403  return i
2404}
2405
2406function utf8Write (buf, string, offset, length) {
2407  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
2408}
2409
2410function asciiWrite (buf, string, offset, length) {
2411  return blitBuffer(asciiToBytes(string), buf, offset, length)
2412}
2413
2414function latin1Write (buf, string, offset, length) {
2415  return asciiWrite(buf, string, offset, length)
2416}
2417
2418function base64Write (buf, string, offset, length) {
2419  return blitBuffer(base64ToBytes(string), buf, offset, length)
2420}
2421
2422function ucs2Write (buf, string, offset, length) {
2423  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
2424}
2425
2426Buffer.prototype.write = function write (string, offset, length, encoding) {
2427  // Buffer#write(string)
2428  if (offset === undefined) {
2429    encoding = 'utf8'
2430    length = this.length
2431    offset = 0
2432  // Buffer#write(string, encoding)
2433  } else if (length === undefined && typeof offset === 'string') {
2434    encoding = offset
2435    length = this.length
2436    offset = 0
2437  // Buffer#write(string, offset[, length][, encoding])
2438  } else if (isFinite(offset)) {
2439    offset = offset | 0
2440    if (isFinite(length)) {
2441      length = length | 0
2442      if (encoding === undefined) encoding = 'utf8'
2443    } else {
2444      encoding = length
2445      length = undefined
2446    }
2447  // legacy write(string, encoding, offset, length) - remove in v0.13
2448  } else {
2449    throw new Error(
2450      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
2451    )
2452  }
2453
2454  var remaining = this.length - offset
2455  if (length === undefined || length > remaining) length = remaining
2456
2457  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
2458    throw new RangeError('Attempt to write outside buffer bounds')
2459  }
2460
2461  if (!encoding) encoding = 'utf8'
2462
2463  var loweredCase = false
2464  for (;;) {
2465    switch (encoding) {
2466      case 'hex':
2467        return hexWrite(this, string, offset, length)
2468
2469      case 'utf8':
2470      case 'utf-8':
2471        return utf8Write(this, string, offset, length)
2472
2473      case 'ascii':
2474        return asciiWrite(this, string, offset, length)
2475
2476      case 'latin1':
2477      case 'binary':
2478        return latin1Write(this, string, offset, length)
2479
2480      case 'base64':
2481        // Warning: maxLength not taken into account in base64Write
2482        return base64Write(this, string, offset, length)
2483
2484      case 'ucs2':
2485      case 'ucs-2':
2486      case 'utf16le':
2487      case 'utf-16le':
2488        return ucs2Write(this, string, offset, length)
2489
2490      default:
2491        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
2492        encoding = ('' + encoding).toLowerCase()
2493        loweredCase = true
2494    }
2495  }
2496}
2497
2498Buffer.prototype.toJSON = function toJSON () {
2499  return {
2500    type: 'Buffer',
2501    data: Array.prototype.slice.call(this._arr || this, 0)
2502  }
2503}
2504
2505function base64Slice (buf, start, end) {
2506  if (start === 0 && end === buf.length) {
2507    return base64.fromByteArray(buf)
2508  } else {
2509    return base64.fromByteArray(buf.slice(start, end))
2510  }
2511}
2512
2513function utf8Slice (buf, start, end) {
2514  end = Math.min(buf.length, end)
2515  var res = []
2516
2517  var i = start
2518  while (i < end) {
2519    var firstByte = buf[i]
2520    var codePoint = null
2521    var bytesPerSequence = (firstByte > 0xEF) ? 4
2522      : (firstByte > 0xDF) ? 3
2523      : (firstByte > 0xBF) ? 2
2524      : 1
2525
2526    if (i + bytesPerSequence <= end) {
2527      var secondByte, thirdByte, fourthByte, tempCodePoint
2528
2529      switch (bytesPerSequence) {
2530        case 1:
2531          if (firstByte < 0x80) {
2532            codePoint = firstByte
2533          }
2534          break
2535        case 2:
2536          secondByte = buf[i + 1]
2537          if ((secondByte & 0xC0) === 0x80) {
2538            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
2539            if (tempCodePoint > 0x7F) {
2540              codePoint = tempCodePoint
2541            }
2542          }
2543          break
2544        case 3:
2545          secondByte = buf[i + 1]
2546          thirdByte = buf[i + 2]
2547          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
2548            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
2549            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
2550              codePoint = tempCodePoint
2551            }
2552          }
2553          break
2554        case 4:
2555          secondByte = buf[i + 1]
2556          thirdByte = buf[i + 2]
2557          fourthByte = buf[i + 3]
2558          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
2559            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
2560            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
2561              codePoint = tempCodePoint
2562            }
2563          }
2564      }
2565    }
2566
2567    if (codePoint === null) {
2568      // we did not generate a valid codePoint so insert a
2569      // replacement char (U+FFFD) and advance only 1 byte
2570      codePoint = 0xFFFD
2571      bytesPerSequence = 1
2572    } else if (codePoint > 0xFFFF) {
2573      // encode to utf16 (surrogate pair dance)
2574      codePoint -= 0x10000
2575      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
2576      codePoint = 0xDC00 | codePoint & 0x3FF
2577    }
2578
2579    res.push(codePoint)
2580    i += bytesPerSequence
2581  }
2582
2583  return decodeCodePointsArray(res)
2584}
2585
2586// Based on http://stackoverflow.com/a/22747272/680742, the browser with
2587// the lowest limit is Chrome, with 0x10000 args.
2588// We go 1 magnitude less, for safety
2589var MAX_ARGUMENTS_LENGTH = 0x1000
2590
2591function decodeCodePointsArray (codePoints) {
2592  var len = codePoints.length
2593  if (len <= MAX_ARGUMENTS_LENGTH) {
2594    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
2595  }
2596
2597  // Decode in chunks to avoid "call stack size exceeded".
2598  var res = ''
2599  var i = 0
2600  while (i < len) {
2601    res += String.fromCharCode.apply(
2602      String,
2603      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
2604    )
2605  }
2606  return res
2607}
2608
2609function asciiSlice (buf, start, end) {
2610  var ret = ''
2611  end = Math.min(buf.length, end)
2612
2613  for (var i = start; i < end; ++i) {
2614    ret += String.fromCharCode(buf[i] & 0x7F)
2615  }
2616  return ret
2617}
2618
2619function latin1Slice (buf, start, end) {
2620  var ret = ''
2621  end = Math.min(buf.length, end)
2622
2623  for (var i = start; i < end; ++i) {
2624    ret += String.fromCharCode(buf[i])
2625  }
2626  return ret
2627}
2628
2629function hexSlice (buf, start, end) {
2630  var len = buf.length
2631
2632  if (!start || start < 0) start = 0
2633  if (!end || end < 0 || end > len) end = len
2634
2635  var out = ''
2636  for (var i = start; i < end; ++i) {
2637    out += toHex(buf[i])
2638  }
2639  return out
2640}
2641
2642function utf16leSlice (buf, start, end) {
2643  var bytes = buf.slice(start, end)
2644  var res = ''
2645  for (var i = 0; i < bytes.length; i += 2) {
2646    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
2647  }
2648  return res
2649}
2650
2651Buffer.prototype.slice = function slice (start, end) {
2652  var len = this.length
2653  start = ~~start
2654  end = end === undefined ? len : ~~end
2655
2656  if (start < 0) {
2657    start += len
2658    if (start < 0) start = 0
2659  } else if (start > len) {
2660    start = len
2661  }
2662
2663  if (end < 0) {
2664    end += len
2665    if (end < 0) end = 0
2666  } else if (end > len) {
2667    end = len
2668  }
2669
2670  if (end < start) end = start
2671
2672  var newBuf
2673  if (Buffer.TYPED_ARRAY_SUPPORT) {
2674    newBuf = this.subarray(start, end)
2675    newBuf.__proto__ = Buffer.prototype
2676  } else {
2677    var sliceLen = end - start
2678    newBuf = new Buffer(sliceLen, undefined)
2679    for (var i = 0; i < sliceLen; ++i) {
2680      newBuf[i] = this[i + start]
2681    }
2682  }
2683
2684  return newBuf
2685}
2686
2687/*
2688 * Need to make sure that buffer isn't trying to write out of bounds.
2689 */
2690function checkOffset (offset, ext, length) {
2691  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
2692  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
2693}
2694
2695Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
2696  offset = offset | 0
2697  byteLength = byteLength | 0
2698  if (!noAssert) checkOffset(offset, byteLength, this.length)
2699
2700  var val = this[offset]
2701  var mul = 1
2702  var i = 0
2703  while (++i < byteLength && (mul *= 0x100)) {
2704    val += this[offset + i] * mul
2705  }
2706
2707  return val
2708}
2709
2710Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
2711  offset = offset | 0
2712  byteLength = byteLength | 0
2713  if (!noAssert) {
2714    checkOffset(offset, byteLength, this.length)
2715  }
2716
2717  var val = this[offset + --byteLength]
2718  var mul = 1
2719  while (byteLength > 0 && (mul *= 0x100)) {
2720    val += this[offset + --byteLength] * mul
2721  }
2722
2723  return val
2724}
2725
2726Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
2727  if (!noAssert) checkOffset(offset, 1, this.length)
2728  return this[offset]
2729}
2730
2731Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
2732  if (!noAssert) checkOffset(offset, 2, this.length)
2733  return this[offset] | (this[offset + 1] << 8)
2734}
2735
2736Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
2737  if (!noAssert) checkOffset(offset, 2, this.length)
2738  return (this[offset] << 8) | this[offset + 1]
2739}
2740
2741Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
2742  if (!noAssert) checkOffset(offset, 4, this.length)
2743
2744  return ((this[offset]) |
2745      (this[offset + 1] << 8) |
2746      (this[offset + 2] << 16)) +
2747      (this[offset + 3] * 0x1000000)
2748}
2749
2750Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
2751  if (!noAssert) checkOffset(offset, 4, this.length)
2752
2753  return (this[offset] * 0x1000000) +
2754    ((this[offset + 1] << 16) |
2755    (this[offset + 2] << 8) |
2756    this[offset + 3])
2757}
2758
2759Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
2760  offset = offset | 0
2761  byteLength = byteLength | 0
2762  if (!noAssert) checkOffset(offset, byteLength, this.length)
2763
2764  var val = this[offset]
2765  var mul = 1
2766  var i = 0
2767  while (++i < byteLength && (mul *= 0x100)) {
2768    val += this[offset + i] * mul
2769  }
2770  mul *= 0x80
2771
2772  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
2773
2774  return val
2775}
2776
2777Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
2778  offset = offset | 0
2779  byteLength = byteLength | 0
2780  if (!noAssert) checkOffset(offset, byteLength, this.length)
2781
2782  var i = byteLength
2783  var mul = 1
2784  var val = this[offset + --i]
2785  while (i > 0 && (mul *= 0x100)) {
2786    val += this[offset + --i] * mul
2787  }
2788  mul *= 0x80
2789
2790  if (val >= mul) val -= Math.pow(2, 8 * byteLength)
2791
2792  return val
2793}
2794
2795Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
2796  if (!noAssert) checkOffset(offset, 1, this.length)
2797  if (!(this[offset] & 0x80)) return (this[offset])
2798  return ((0xff - this[offset] + 1) * -1)
2799}
2800
2801Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
2802  if (!noAssert) checkOffset(offset, 2, this.length)
2803  var val = this[offset] | (this[offset + 1] << 8)
2804  return (val & 0x8000) ? val | 0xFFFF0000 : val
2805}
2806
2807Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
2808  if (!noAssert) checkOffset(offset, 2, this.length)
2809  var val = this[offset + 1] | (this[offset] << 8)
2810  return (val & 0x8000) ? val | 0xFFFF0000 : val
2811}
2812
2813Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
2814  if (!noAssert) checkOffset(offset, 4, this.length)
2815
2816  return (this[offset]) |
2817    (this[offset + 1] << 8) |
2818    (this[offset + 2] << 16) |
2819    (this[offset + 3] << 24)
2820}
2821
2822Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
2823  if (!noAssert) checkOffset(offset, 4, this.length)
2824
2825  return (this[offset] << 24) |
2826    (this[offset + 1] << 16) |
2827    (this[offset + 2] << 8) |
2828    (this[offset + 3])
2829}
2830
2831Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
2832  if (!noAssert) checkOffset(offset, 4, this.length)
2833  return ieee754.read(this, offset, true, 23, 4)
2834}
2835
2836Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
2837  if (!noAssert) checkOffset(offset, 4, this.length)
2838  return ieee754.read(this, offset, false, 23, 4)
2839}
2840
2841Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
2842  if (!noAssert) checkOffset(offset, 8, this.length)
2843  return ieee754.read(this, offset, true, 52, 8)
2844}
2845
2846Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
2847  if (!noAssert) checkOffset(offset, 8, this.length)
2848  return ieee754.read(this, offset, false, 52, 8)
2849}
2850
2851function checkInt (buf, value, offset, ext, max, min) {
2852  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
2853  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
2854  if (offset + ext > buf.length) throw new RangeError('Index out of range')
2855}
2856
2857Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
2858  value = +value
2859  offset = offset | 0
2860  byteLength = byteLength | 0
2861  if (!noAssert) {
2862    var maxBytes = Math.pow(2, 8 * byteLength) - 1
2863    checkInt(this, value, offset, byteLength, maxBytes, 0)
2864  }
2865
2866  var mul = 1
2867  var i = 0
2868  this[offset] = value & 0xFF
2869  while (++i < byteLength && (mul *= 0x100)) {
2870    this[offset + i] = (value / mul) & 0xFF
2871  }
2872
2873  return offset + byteLength
2874}
2875
2876Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
2877  value = +value
2878  offset = offset | 0
2879  byteLength = byteLength | 0
2880  if (!noAssert) {
2881    var maxBytes = Math.pow(2, 8 * byteLength) - 1
2882    checkInt(this, value, offset, byteLength, maxBytes, 0)
2883  }
2884
2885  var i = byteLength - 1
2886  var mul = 1
2887  this[offset + i] = value & 0xFF
2888  while (--i >= 0 && (mul *= 0x100)) {
2889    this[offset + i] = (value / mul) & 0xFF
2890  }
2891
2892  return offset + byteLength
2893}
2894
2895Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
2896  value = +value
2897  offset = offset | 0
2898  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
2899  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
2900  this[offset] = (value & 0xff)
2901  return offset + 1
2902}
2903
2904function objectWriteUInt16 (buf, value, offset, littleEndian) {
2905  if (value < 0) value = 0xffff + value + 1
2906  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
2907    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
2908      (littleEndian ? i : 1 - i) * 8
2909  }
2910}
2911
2912Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
2913  value = +value
2914  offset = offset | 0
2915  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
2916  if (Buffer.TYPED_ARRAY_SUPPORT) {
2917    this[offset] = (value & 0xff)
2918    this[offset + 1] = (value >>> 8)
2919  } else {
2920    objectWriteUInt16(this, value, offset, true)
2921  }
2922  return offset + 2
2923}
2924
2925Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
2926  value = +value
2927  offset = offset | 0
2928  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
2929  if (Buffer.TYPED_ARRAY_SUPPORT) {
2930    this[offset] = (value >>> 8)
2931    this[offset + 1] = (value & 0xff)
2932  } else {
2933    objectWriteUInt16(this, value, offset, false)
2934  }
2935  return offset + 2
2936}
2937
2938function objectWriteUInt32 (buf, value, offset, littleEndian) {
2939  if (value < 0) value = 0xffffffff + value + 1
2940  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
2941    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
2942  }
2943}
2944
2945Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
2946  value = +value
2947  offset = offset | 0
2948  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
2949  if (Buffer.TYPED_ARRAY_SUPPORT) {
2950    this[offset + 3] = (value >>> 24)
2951    this[offset + 2] = (value >>> 16)
2952    this[offset + 1] = (value >>> 8)
2953    this[offset] = (value & 0xff)
2954  } else {
2955    objectWriteUInt32(this, value, offset, true)
2956  }
2957  return offset + 4
2958}
2959
2960Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
2961  value = +value
2962  offset = offset | 0
2963  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
2964  if (Buffer.TYPED_ARRAY_SUPPORT) {
2965    this[offset] = (value >>> 24)
2966    this[offset + 1] = (value >>> 16)
2967    this[offset + 2] = (value >>> 8)
2968    this[offset + 3] = (value & 0xff)
2969  } else {
2970    objectWriteUInt32(this, value, offset, false)
2971  }
2972  return offset + 4
2973}
2974
2975Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
2976  value = +value
2977  offset = offset | 0
2978  if (!noAssert) {
2979    var limit = Math.pow(2, 8 * byteLength - 1)
2980
2981    checkInt(this, value, offset, byteLength, limit - 1, -limit)
2982  }
2983
2984  var i = 0
2985  var mul = 1
2986  var sub = 0
2987  this[offset] = value & 0xFF
2988  while (++i < byteLength && (mul *= 0x100)) {
2989    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
2990      sub = 1
2991    }
2992    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
2993  }
2994
2995  return offset + byteLength
2996}
2997
2998Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
2999  value = +value
3000  offset = offset | 0
3001  if (!noAssert) {
3002    var limit = Math.pow(2, 8 * byteLength - 1)
3003
3004    checkInt(this, value, offset, byteLength, limit - 1, -limit)
3005  }
3006
3007  var i = byteLength - 1
3008  var mul = 1
3009  var sub = 0
3010  this[offset + i] = value & 0xFF
3011  while (--i >= 0 && (mul *= 0x100)) {
3012    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
3013      sub = 1
3014    }
3015    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
3016  }
3017
3018  return offset + byteLength
3019}
3020
3021Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
3022  value = +value
3023  offset = offset | 0
3024  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
3025  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
3026  if (value < 0) value = 0xff + value + 1
3027  this[offset] = (value & 0xff)
3028  return offset + 1
3029}
3030
3031Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
3032  value = +value
3033  offset = offset | 0
3034  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
3035  if (Buffer.TYPED_ARRAY_SUPPORT) {
3036    this[offset] = (value & 0xff)
3037    this[offset + 1] = (value >>> 8)
3038  } else {
3039    objectWriteUInt16(this, value, offset, true)
3040  }
3041  return offset + 2
3042}
3043
3044Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
3045  value = +value
3046  offset = offset | 0
3047  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
3048  if (Buffer.TYPED_ARRAY_SUPPORT) {
3049    this[offset] = (value >>> 8)
3050    this[offset + 1] = (value & 0xff)
3051  } else {
3052    objectWriteUInt16(this, value, offset, false)
3053  }
3054  return offset + 2
3055}
3056
3057Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
3058  value = +value
3059  offset = offset | 0
3060  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
3061  if (Buffer.TYPED_ARRAY_SUPPORT) {
3062    this[offset] = (value & 0xff)
3063    this[offset + 1] = (value >>> 8)
3064    this[offset + 2] = (value >>> 16)
3065    this[offset + 3] = (value >>> 24)
3066  } else {
3067    objectWriteUInt32(this, value, offset, true)
3068  }
3069  return offset + 4
3070}
3071
3072Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
3073  value = +value
3074  offset = offset | 0
3075  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
3076  if (value < 0) value = 0xffffffff + value + 1
3077  if (Buffer.TYPED_ARRAY_SUPPORT) {
3078    this[offset] = (value >>> 24)
3079    this[offset + 1] = (value >>> 16)
3080    this[offset + 2] = (value >>> 8)
3081    this[offset + 3] = (value & 0xff)
3082  } else {
3083    objectWriteUInt32(this, value, offset, false)
3084  }
3085  return offset + 4
3086}
3087
3088function checkIEEE754 (buf, value, offset, ext, max, min) {
3089  if (offset + ext > buf.length) throw new RangeError('Index out of range')
3090  if (offset < 0) throw new RangeError('Index out of range')
3091}
3092
3093function writeFloat (buf, value, offset, littleEndian, noAssert) {
3094  if (!noAssert) {
3095    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
3096  }
3097  ieee754.write(buf, value, offset, littleEndian, 23, 4)
3098  return offset + 4
3099}
3100
3101Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
3102  return writeFloat(this, value, offset, true, noAssert)
3103}
3104
3105Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
3106  return writeFloat(this, value, offset, false, noAssert)
3107}
3108
3109function writeDouble (buf, value, offset, littleEndian, noAssert) {
3110  if (!noAssert) {
3111    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
3112  }
3113  ieee754.write(buf, value, offset, littleEndian, 52, 8)
3114  return offset + 8
3115}
3116
3117Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
3118  return writeDouble(this, value, offset, true, noAssert)
3119}
3120
3121Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
3122  return writeDouble(this, value, offset, false, noAssert)
3123}
3124
3125// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
3126Buffer.prototype.copy = function copy (target, targetStart, start, end) {
3127  if (!start) start = 0
3128  if (!end && end !== 0) end = this.length
3129  if (targetStart >= target.length) targetStart = target.length
3130  if (!targetStart) targetStart = 0
3131  if (end > 0 && end < start) end = start
3132
3133  // Copy 0 bytes; we're done
3134  if (end === start) return 0
3135  if (target.length === 0 || this.length === 0) return 0
3136
3137  // Fatal error conditions
3138  if (targetStart < 0) {
3139    throw new RangeError('targetStart out of bounds')
3140  }
3141  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
3142  if (end < 0) throw new RangeError('sourceEnd out of bounds')
3143
3144  // Are we oob?
3145  if (end > this.length) end = this.length
3146  if (target.length - targetStart < end - start) {
3147    end = target.length - targetStart + start
3148  }
3149
3150  var len = end - start
3151  var i
3152
3153  if (this === target && start < targetStart && targetStart < end) {
3154    // descending copy from end
3155    for (i = len - 1; i >= 0; --i) {
3156      target[i + targetStart] = this[i + start]
3157    }
3158  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
3159    // ascending copy from start
3160    for (i = 0; i < len; ++i) {
3161      target[i + targetStart] = this[i + start]
3162    }
3163  } else {
3164    Uint8Array.prototype.set.call(
3165      target,
3166      this.subarray(start, start + len),
3167      targetStart
3168    )
3169  }
3170
3171  return len
3172}
3173
3174// Usage:
3175//    buffer.fill(number[, offset[, end]])
3176//    buffer.fill(buffer[, offset[, end]])
3177//    buffer.fill(string[, offset[, end]][, encoding])
3178Buffer.prototype.fill = function fill (val, start, end, encoding) {
3179  // Handle string cases:
3180  if (typeof val === 'string') {
3181    if (typeof start === 'string') {
3182      encoding = start
3183      start = 0
3184      end = this.length
3185    } else if (typeof end === 'string') {
3186      encoding = end
3187      end = this.length
3188    }
3189    if (val.length === 1) {
3190      var code = val.charCodeAt(0)
3191      if (code < 256) {
3192        val = code
3193      }
3194    }
3195    if (encoding !== undefined && typeof encoding !== 'string') {
3196      throw new TypeError('encoding must be a string')
3197    }
3198    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
3199      throw new TypeError('Unknown encoding: ' + encoding)
3200    }
3201  } else if (typeof val === 'number') {
3202    val = val & 255
3203  }
3204
3205  // Invalid ranges are not set to a default, so can range check early.
3206  if (start < 0 || this.length < start || this.length < end) {
3207    throw new RangeError('Out of range index')
3208  }
3209
3210  if (end <= start) {
3211    return this
3212  }
3213
3214  start = start >>> 0
3215  end = end === undefined ? this.length : end >>> 0
3216
3217  if (!val) val = 0
3218
3219  var i
3220  if (typeof val === 'number') {
3221    for (i = start; i < end; ++i) {
3222      this[i] = val
3223    }
3224  } else {
3225    var bytes = Buffer.isBuffer(val)
3226      ? val
3227      : utf8ToBytes(new Buffer(val, encoding).toString())
3228    var len = bytes.length
3229    for (i = 0; i < end - start; ++i) {
3230      this[i + start] = bytes[i % len]
3231    }
3232  }
3233
3234  return this
3235}
3236
3237// HELPER FUNCTIONS
3238// ================
3239
3240var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
3241
3242function base64clean (str) {
3243  // Node strips out invalid characters like \n and \t from the string, base64-js does not
3244  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
3245  // Node converts strings with length < 2 to ''
3246  if (str.length < 2) return ''
3247  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
3248  while (str.length % 4 !== 0) {
3249    str = str + '='
3250  }
3251  return str
3252}
3253
3254function stringtrim (str) {
3255  if (str.trim) return str.trim()
3256  return str.replace(/^\s+|\s+$/g, '')
3257}
3258
3259function toHex (n) {
3260  if (n < 16) return '0' + n.toString(16)
3261  return n.toString(16)
3262}
3263
3264function utf8ToBytes (string, units) {
3265  units = units || Infinity
3266  var codePoint
3267  var length = string.length
3268  var leadSurrogate = null
3269  var bytes = []
3270
3271  for (var i = 0; i < length; ++i) {
3272    codePoint = string.charCodeAt(i)
3273
3274    // is surrogate component
3275    if (codePoint > 0xD7FF && codePoint < 0xE000) {
3276      // last char was a lead
3277      if (!leadSurrogate) {
3278        // no lead yet
3279        if (codePoint > 0xDBFF) {
3280          // unexpected trail
3281          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
3282          continue
3283        } else if (i + 1 === length) {
3284          // unpaired lead
3285          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
3286          continue
3287        }
3288
3289        // valid lead
3290        leadSurrogate = codePoint
3291
3292        continue
3293      }
3294
3295      // 2 leads in a row
3296      if (codePoint < 0xDC00) {
3297        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
3298        leadSurrogate = codePoint
3299        continue
3300      }
3301
3302      // valid surrogate pair
3303      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
3304    } else if (leadSurrogate) {
3305      // valid bmp char, but last char was a lead
3306      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
3307    }
3308
3309    leadSurrogate = null
3310
3311    // encode utf8
3312    if (codePoint < 0x80) {
3313      if ((units -= 1) < 0) break
3314      bytes.push(codePoint)
3315    } else if (codePoint < 0x800) {
3316      if ((units -= 2) < 0) break
3317      bytes.push(
3318        codePoint >> 0x6 | 0xC0,
3319        codePoint & 0x3F | 0x80
3320      )
3321    } else if (codePoint < 0x10000) {
3322      if ((units -= 3) < 0) break
3323      bytes.push(
3324        codePoint >> 0xC | 0xE0,
3325        codePoint >> 0x6 & 0x3F | 0x80,
3326        codePoint & 0x3F | 0x80
3327      )
3328    } else if (codePoint < 0x110000) {
3329      if ((units -= 4) < 0) break
3330      bytes.push(
3331        codePoint >> 0x12 | 0xF0,
3332        codePoint >> 0xC & 0x3F | 0x80,
3333        codePoint >> 0x6 & 0x3F | 0x80,
3334        codePoint & 0x3F | 0x80
3335      )
3336    } else {
3337      throw new Error('Invalid code point')
3338    }
3339  }
3340
3341  return bytes
3342}
3343
3344function asciiToBytes (str) {
3345  var byteArray = []
3346  for (var i = 0; i < str.length; ++i) {
3347    // Node's code seems to be doing this and not & 0x7F..
3348    byteArray.push(str.charCodeAt(i) & 0xFF)
3349  }
3350  return byteArray
3351}
3352
3353function utf16leToBytes (str, units) {
3354  var c, hi, lo
3355  var byteArray = []
3356  for (var i = 0; i < str.length; ++i) {
3357    if ((units -= 2) < 0) break
3358
3359    c = str.charCodeAt(i)
3360    hi = c >> 8
3361    lo = c % 256
3362    byteArray.push(lo)
3363    byteArray.push(hi)
3364  }
3365
3366  return byteArray
3367}
3368
3369function base64ToBytes (str) {
3370  return base64.toByteArray(base64clean(str))
3371}
3372
3373function blitBuffer (src, dst, offset, length) {
3374  for (var i = 0; i < length; ++i) {
3375    if ((i + offset >= dst.length) || (i >= src.length)) break
3376    dst[i + offset] = src[i]
3377  }
3378  return i
3379}
3380
3381function isnan (val) {
3382  return val !== val // eslint-disable-line no-self-compare
3383}
3384
3385}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
3386},{"base64-js":