diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 423cb70b94a8bb418d8c700860ff0c9fe95c3d99..c65ed6228263d4730add6d6d983ae26a0a129ab6 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -42,10 +42,10 @@ webserver-deploy:
variables:
NODE_SERVER: '10.0.0.9'
script:
- - npm install web-service/server
+ - npm install web-service
- browserify web-service/public/js/index.js -o web-service/public/js/bundle.js
- rsync -vr --delete web-service/ nodejs@${NODE_SERVER}:/srv/nodejs/web-service
- - ssh nodejs@${NODE_SERVER} -- "npm install web-service/server && pm2 restart web-service"
+ - ssh nodejs@${NODE_SERVER} -- "npm install web-service && pm2 restart web-service"
- doxygen
- rsync -vr --delete doc/ nodejs@${NODE_SERVER}:/srv/nodejs/doc
diff --git a/web-service/server/package.json b/web-service/package.json
similarity index 78%
rename from web-service/server/package.json
rename to web-service/package.json
index af0c459ede99227ca71debcef2883c69047ae1aa..dc609e1d1160158b3336664eed9ee669be73caf5 100644
--- a/web-service/server/package.json
+++ b/web-service/package.json
@@ -7,9 +7,10 @@
"test": "test"
},
"scripts": {
- "start": "node src/index.js",
+ "start": "node server/src/index.js",
"watch": "nodemon src/index.js",
- "test": "mocha test"
+ "test": "mocha test",
+ "build": "browserify ./public/js/index.js -o ./public/js/bundle.js"
},
"author": "Nicolas Pope",
"license": "ISC",
@@ -20,6 +21,7 @@
"h264-converter": "^0.1.0",
"mongoose": "^5.7.3",
"msgpack5": "^4.2.1",
+ "rematrix": "^0.7.0",
"url-parse": "^1.4.7",
"uuid": "^3.3.3"
},
diff --git a/web-service/public/js/bundle.js b/web-service/public/js/bundle.js
index fd03f5f407eccfc8aabdbf90baa69492ddbd2fd9..7c5a935496b0d3ccc95ec61b47607cfb7ca4b80c 100644
--- a/web-service/public/js/bundle.js
+++ b/web-service/public/js/bundle.js
@@ -1,390 +1,547 @@
(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){
-'use strict'
-var DuplexStream = require('readable-stream').Duplex
- , util = require('util')
- , Buffer = require('safe-buffer').Buffer
-
-function BufferList (callback) {
- if (!(this instanceof BufferList))
- return new BufferList(callback)
-
- this._bufs = []
- this.length = 0
+(function (global){
+'use strict';
- if (typeof callback == 'function') {
- this._callback = callback
+var objectAssign = require('object-assign');
- var piper = function piper (err) {
- if (this._callback) {
- this._callback(err)
- this._callback = null
- }
- }.bind(this)
+// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
+// original notice:
- this.on('pipe', function onPipe (src) {
- src.on('error', piper)
- })
- this.on('unpipe', function onUnpipe (src) {
- src.removeListener('error', piper)
- })
- } else {
- this.append(callback)
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license MIT
+ */
+function compare(a, b) {
+ if (a === b) {
+ return 0;
}
- DuplexStream.call(this)
-}
-
-
-util.inherits(BufferList, DuplexStream)
-
+ var x = a.length;
+ var y = b.length;
-BufferList.prototype._offset = function _offset (offset) {
- var tot = 0, i = 0, _t
- if (offset === 0) return [ 0, 0 ]
- for (; i < this._bufs.length; i++) {
- _t = tot + this._bufs[i].length
- if (offset < _t || i == this._bufs.length - 1) {
- return [ i, offset - tot ]
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i];
+ y = b[i];
+ break;
}
- tot = _t
}
-}
-BufferList.prototype._reverseOffset = function (blOffset) {
- var bufferId = blOffset[0]
- var offset = blOffset[1]
- for (var i = 0; i < bufferId; i++) {
- offset += this._bufs[i].length
+ if (x < y) {
+ return -1;
}
- return offset
-}
-
-BufferList.prototype.append = function append (buf) {
- var i = 0
-
- if (Buffer.isBuffer(buf)) {
- this._appendBuffer(buf)
- } else if (Array.isArray(buf)) {
- for (; i < buf.length; i++)
- this.append(buf[i])
- } else if (buf instanceof BufferList) {
- // unwrap argument into individual BufferLists
- for (; i < buf._bufs.length; i++)
- this.append(buf._bufs[i])
- } else if (buf != null) {
- // coerce number arguments to strings, since Buffer(number) does
- // uninitialized memory allocation
- if (typeof buf == 'number')
- buf = buf.toString()
-
- this._appendBuffer(Buffer.from(buf))
+ if (y < x) {
+ return 1;
}
-
- return this
+ return 0;
}
-
-
-BufferList.prototype._appendBuffer = function appendBuffer (buf) {
- this._bufs.push(buf)
- this.length += buf.length
+function isBuffer(b) {
+ if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {
+ return global.Buffer.isBuffer(b);
+ }
+ return !!(b != null && b._isBuffer);
}
+// based on node assert, original notice:
+// NB: The URL to the CommonJS spec is kept just for tradition.
+// node-assert has evolved a lot since then, both in API and behavior.
-BufferList.prototype._write = function _write (buf, encoding, callback) {
- this._appendBuffer(buf)
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the 'Software'), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- if (typeof callback == 'function')
- callback()
+var util = require('util/');
+var hasOwn = Object.prototype.hasOwnProperty;
+var pSlice = Array.prototype.slice;
+var functionsHaveNames = (function () {
+ return function foo() {}.name === 'foo';
+}());
+function pToString (obj) {
+ return Object.prototype.toString.call(obj);
}
-
-
-BufferList.prototype._read = function _read (size) {
- if (!this.length)
- return this.push(null)
-
- size = Math.min(size, this.length)
- this.push(this.slice(0, size))
- this.consume(size)
+function isView(arrbuf) {
+ if (isBuffer(arrbuf)) {
+ return false;
+ }
+ if (typeof global.ArrayBuffer !== 'function') {
+ return false;
+ }
+ if (typeof ArrayBuffer.isView === 'function') {
+ return ArrayBuffer.isView(arrbuf);
+ }
+ if (!arrbuf) {
+ return false;
+ }
+ if (arrbuf instanceof DataView) {
+ return true;
+ }
+ if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
+ return true;
+ }
+ return false;
}
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+var assert = module.exports = ok;
-BufferList.prototype.end = function end (chunk) {
- DuplexStream.prototype.end.call(this, chunk)
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({ message: message,
+// actual: actual,
+// expected: expected })
- if (this._callback) {
- this._callback(null, this.slice())
- this._callback = null
+var regex = /\s*function\s+([^\(\s]*)\s*/;
+// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
+function getName(func) {
+ if (!util.isFunction(func)) {
+ return;
}
+ if (functionsHaveNames) {
+ return func.name;
+ }
+ var str = func.toString();
+ var match = str.match(regex);
+ return match && match[1];
}
+assert.AssertionError = function AssertionError(options) {
+ this.name = 'AssertionError';
+ this.actual = options.actual;
+ this.expected = options.expected;
+ this.operator = options.operator;
+ if (options.message) {
+ this.message = options.message;
+ this.generatedMessage = false;
+ } else {
+ this.message = getMessage(this);
+ this.generatedMessage = true;
+ }
+ var stackStartFunction = options.stackStartFunction || fail;
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, stackStartFunction);
+ } else {
+ // non v8 browsers so we can have a stacktrace
+ var err = new Error();
+ if (err.stack) {
+ var out = err.stack;
+ // try to strip useless frames
+ var fn_name = getName(stackStartFunction);
+ var idx = out.indexOf('\n' + fn_name);
+ if (idx >= 0) {
+ // once we have located the function frame
+ // we need to strip out everything before it (and its line)
+ var next_line = out.indexOf('\n', idx + 1);
+ out = out.substring(next_line + 1);
+ }
-BufferList.prototype.get = function get (index) {
- if (index > this.length || index < 0) {
- return undefined
+ this.stack = out;
+ }
}
- var offset = this._offset(index)
- return this._bufs[offset[0]][offset[1]]
-}
+};
+// assert.AssertionError instanceof Error
+util.inherits(assert.AssertionError, Error);
-BufferList.prototype.slice = function slice (start, end) {
- if (typeof start == 'number' && start < 0)
- start += this.length
- if (typeof end == 'number' && end < 0)
- end += this.length
- return this.copy(null, 0, start, end)
+function truncate(s, n) {
+ if (typeof s === 'string') {
+ return s.length < n ? s : s.slice(0, n);
+ } else {
+ return s;
+ }
+}
+function inspect(something) {
+ if (functionsHaveNames || !util.isFunction(something)) {
+ return util.inspect(something);
+ }
+ var rawname = getName(something);
+ var name = rawname ? ': ' + rawname : '';
+ return '[Function' + name + ']';
+}
+function getMessage(self) {
+ return truncate(inspect(self.actual), 128) + ' ' +
+ self.operator + ' ' +
+ truncate(inspect(self.expected), 128);
}
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
-BufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
- if (typeof srcStart != 'number' || srcStart < 0)
- srcStart = 0
- if (typeof srcEnd != 'number' || srcEnd > this.length)
- srcEnd = this.length
- if (srcStart >= this.length)
- return dst || Buffer.alloc(0)
- if (srcEnd <= 0)
- return dst || Buffer.alloc(0)
-
- var copy = !!dst
- , off = this._offset(srcStart)
- , len = srcEnd - srcStart
- , bytes = len
- , bufoff = (copy && dstStart) || 0
- , start = off[1]
- , l
- , i
-
- // copy/slice everything
- if (srcStart === 0 && srcEnd == this.length) {
- if (!copy) { // slice, but full concat if multiple buffers
- return this._bufs.length === 1
- ? this._bufs[0]
- : Buffer.concat(this._bufs, this.length)
- }
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided. All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
- // copy, need to copy individual buffers
- for (i = 0; i < this._bufs.length; i++) {
- this._bufs[i].copy(dst, bufoff)
- bufoff += this._bufs[i].length
- }
+function fail(actual, expected, message, operator, stackStartFunction) {
+ throw new assert.AssertionError({
+ message: message,
+ actual: actual,
+ expected: expected,
+ operator: operator,
+ stackStartFunction: stackStartFunction
+ });
+}
- return dst
- }
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
- // easy, cheap case where it's a subset of one of the buffers
- if (bytes <= this._bufs[off[0]].length - start) {
- return copy
- ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
- : this._bufs[off[0]].slice(start, start + bytes)
- }
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, !!guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
- if (!copy) // a slice, we need something to copy in to
- dst = Buffer.allocUnsafe(len)
+function ok(value, message) {
+ if (!value) fail(value, true, message, '==', assert.ok);
+}
+assert.ok = ok;
- for (i = off[0]; i < this._bufs.length; i++) {
- l = this._bufs[i].length - start
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
- if (bytes > l) {
- this._bufs[i].copy(dst, bufoff, start)
- } else {
- this._bufs[i].copy(dst, bufoff, start, start + bytes)
- break
- }
+assert.equal = function equal(actual, expected, message) {
+ if (actual != expected) fail(actual, expected, message, '==', assert.equal);
+};
- bufoff += l
- bytes -= l
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
- if (start)
- start = 0
+assert.notEqual = function notEqual(actual, expected, message) {
+ if (actual == expected) {
+ fail(actual, expected, message, '!=', assert.notEqual);
}
+};
- return dst
-}
-
-BufferList.prototype.shallowSlice = function shallowSlice (start, end) {
- start = start || 0
- end = typeof end !== 'number' ? this.length : end
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
- if (start < 0)
- start += this.length
- if (end < 0)
- end += this.length
+assert.deepEqual = function deepEqual(actual, expected, message) {
+ if (!_deepEqual(actual, expected, false)) {
+ fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+ }
+};
- if (start === end) {
- return new BufferList()
+assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+ if (!_deepEqual(actual, expected, true)) {
+ fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
}
- var startOffset = this._offset(start)
- , endOffset = this._offset(end)
- , buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
+};
- if (endOffset[1] == 0)
- buffers.pop()
- else
- buffers[buffers.length-1] = buffers[buffers.length-1].slice(0, endOffset[1])
+function _deepEqual(actual, expected, strict, memos) {
+ // 7.1. All identical values are equivalent, as determined by ===.
+ if (actual === expected) {
+ return true;
+ } else if (isBuffer(actual) && isBuffer(expected)) {
+ return compare(actual, expected) === 0;
- if (startOffset[1] != 0)
- buffers[0] = buffers[0].slice(startOffset[1])
+ // 7.2. If the expected value is a Date object, the actual value is
+ // equivalent if it is also a Date object that refers to the same time.
+ } else if (util.isDate(actual) && util.isDate(expected)) {
+ return actual.getTime() === expected.getTime();
- return new BufferList(buffers)
-}
+ // 7.3 If the expected value is a RegExp object, the actual value is
+ // equivalent if it is also a RegExp object with the same source and
+ // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
+ } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
+ return actual.source === expected.source &&
+ actual.global === expected.global &&
+ actual.multiline === expected.multiline &&
+ actual.lastIndex === expected.lastIndex &&
+ actual.ignoreCase === expected.ignoreCase;
-BufferList.prototype.toString = function toString (encoding, start, end) {
- return this.slice(start, end).toString(encoding)
-}
+ // 7.4. Other pairs that do not both pass typeof value == 'object',
+ // equivalence is determined by ==.
+ } else if ((actual === null || typeof actual !== 'object') &&
+ (expected === null || typeof expected !== 'object')) {
+ return strict ? actual === expected : actual == expected;
-BufferList.prototype.consume = function consume (bytes) {
- while (this._bufs.length) {
- if (bytes >= this._bufs[0].length) {
- bytes -= this._bufs[0].length
- this.length -= this._bufs[0].length
- this._bufs.shift()
- } else {
- this._bufs[0] = this._bufs[0].slice(bytes)
- this.length -= bytes
- break
- }
- }
- return this
-}
+ // If both values are instances of typed arrays, wrap their underlying
+ // ArrayBuffers in a Buffer each to increase performance
+ // This optimization requires the arrays to have the same type as checked by
+ // Object.prototype.toString (aka pToString). Never perform binary
+ // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
+ // bit patterns are not identical.
+ } else if (isView(actual) && isView(expected) &&
+ pToString(actual) === pToString(expected) &&
+ !(actual instanceof Float32Array ||
+ actual instanceof Float64Array)) {
+ return compare(new Uint8Array(actual.buffer),
+ new Uint8Array(expected.buffer)) === 0;
+ // 7.5 For all other Object pairs, including Array objects, equivalence is
+ // determined by having the same number of owned properties (as verified
+ // with Object.prototype.hasOwnProperty.call), the same set of keys
+ // (although not necessarily the same order), equivalent values for every
+ // corresponding key, and an identical 'prototype' property. Note: this
+ // accounts for both named and indexed properties on Arrays.
+ } else if (isBuffer(actual) !== isBuffer(expected)) {
+ return false;
+ } else {
+ memos = memos || {actual: [], expected: []};
-BufferList.prototype.duplicate = function duplicate () {
- var i = 0
- , copy = new BufferList()
+ var actualIndex = memos.actual.indexOf(actual);
+ if (actualIndex !== -1) {
+ if (actualIndex === memos.expected.indexOf(expected)) {
+ return true;
+ }
+ }
- for (; i < this._bufs.length; i++)
- copy.append(this._bufs[i])
+ memos.actual.push(actual);
+ memos.expected.push(expected);
- return copy
+ return objEquiv(actual, expected, strict, memos);
+ }
}
-
-BufferList.prototype.destroy = function destroy () {
- this._bufs.length = 0
- this.length = 0
- this.push(null)
+function isArguments(object) {
+ return Object.prototype.toString.call(object) == '[object Arguments]';
}
-
-BufferList.prototype.indexOf = function (search, offset, encoding) {
- if (encoding === undefined && typeof offset === 'string') {
- encoding = offset
- offset = undefined
- }
- if (typeof search === 'function' || Array.isArray(search)) {
- throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.')
- } else if (typeof search === 'number') {
- search = Buffer.from([search])
- } else if (typeof search === 'string') {
- search = Buffer.from(search, encoding)
- } else if (search instanceof BufferList) {
- search = search.slice()
- } else if (!Buffer.isBuffer(search)) {
- search = Buffer.from(search)
+function objEquiv(a, b, strict, actualVisitedObjects) {
+ if (a === null || a === undefined || b === null || b === undefined)
+ return false;
+ // if one is a primitive, the other must be same
+ if (util.isPrimitive(a) || util.isPrimitive(b))
+ return a === b;
+ if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
+ return false;
+ var aIsArgs = isArguments(a);
+ var bIsArgs = isArguments(b);
+ if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
+ return false;
+ if (aIsArgs) {
+ a = pSlice.call(a);
+ b = pSlice.call(b);
+ return _deepEqual(a, b, strict);
}
-
- offset = Number(offset || 0)
- if (isNaN(offset)) {
- offset = 0
+ var ka = objectKeys(a);
+ var kb = objectKeys(b);
+ var key, i;
+ // having the same number of owned properties (keys incorporates
+ // hasOwnProperty)
+ if (ka.length !== kb.length)
+ return false;
+ //the same set of keys (although not necessarily the same order),
+ ka.sort();
+ kb.sort();
+ //~~~cheap key test
+ for (i = ka.length - 1; i >= 0; i--) {
+ if (ka[i] !== kb[i])
+ return false;
}
+ //equivalent values for every corresponding key, and
+ //~~~possibly expensive deep test
+ for (i = ka.length - 1; i >= 0; i--) {
+ key = ka[i];
+ if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
+ return false;
+ }
+ return true;
+}
- if (offset < 0) {
- offset = this.length + offset
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+ if (_deepEqual(actual, expected, false)) {
+ fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
}
+};
- if (offset < 0) {
- offset = 0
+assert.notDeepStrictEqual = notDeepStrictEqual;
+function notDeepStrictEqual(actual, expected, message) {
+ if (_deepEqual(actual, expected, true)) {
+ fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
}
+}
- if (search.length === 0) {
- return offset > this.length ? this.length : offset
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+ if (actual !== expected) {
+ fail(actual, expected, message, '===', assert.strictEqual);
}
+};
- var blOffset = this._offset(offset)
- var blIndex = blOffset[0] // index of which internal buffer we're working on
- var buffOffset = blOffset[1] // offset of the internal buffer we're working on
+// 10. The strict non-equality assertion tests for strict inequality, as
+// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
- // scan over each buffer
- for (blIndex; blIndex < this._bufs.length; blIndex++) {
- var buff = this._bufs[blIndex]
- while(buffOffset < buff.length) {
- var availableWindow = buff.length - buffOffset
- if (availableWindow >= search.length) {
- var nativeSearchResult = buff.indexOf(search, buffOffset)
- if (nativeSearchResult !== -1) {
- return this._reverseOffset([blIndex, nativeSearchResult])
- }
- buffOffset = buff.length - search.length + 1 // end of native search window
- } else {
- var revOffset = this._reverseOffset([blIndex, buffOffset])
- if (this._match(revOffset, search)) {
- return revOffset
- }
- buffOffset++
- }
- }
- buffOffset = 0
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+ if (actual === expected) {
+ fail(actual, expected, message, '!==', assert.notStrictEqual);
}
- return -1
-}
+};
-BufferList.prototype._match = function(offset, search) {
- if (this.length - offset < search.length) {
- return false
+function expectedException(actual, expected) {
+ if (!actual || !expected) {
+ return false;
}
- for (var searchOffset = 0; searchOffset < search.length ; searchOffset++) {
- if(this.get(offset + searchOffset) !== search[searchOffset]){
- return false
+
+ if (Object.prototype.toString.call(expected) == '[object RegExp]') {
+ return expected.test(actual);
+ }
+
+ try {
+ if (actual instanceof expected) {
+ return true;
}
+ } catch (e) {
+ // Ignore. The instanceof check doesn't work for arrow functions.
}
- return true
+
+ if (Error.isPrototypeOf(expected)) {
+ return false;
+ }
+
+ return expected.call({}, actual) === true;
}
+function _tryBlock(block) {
+ var error;
+ try {
+ block();
+ } catch (e) {
+ error = e;
+ }
+ return error;
+}
-;(function () {
- var methods = {
- 'readDoubleBE' : 8
- , 'readDoubleLE' : 8
- , 'readFloatBE' : 4
- , 'readFloatLE' : 4
- , 'readInt32BE' : 4
- , 'readInt32LE' : 4
- , 'readUInt32BE' : 4
- , 'readUInt32LE' : 4
- , 'readInt16BE' : 2
- , 'readInt16LE' : 2
- , 'readUInt16BE' : 2
- , 'readUInt16LE' : 2
- , 'readInt8' : 1
- , 'readUInt8' : 1
- , 'readIntBE' : null
- , 'readIntLE' : null
- , 'readUIntBE' : null
- , 'readUIntLE' : null
+function _throws(shouldThrow, block, expected, message) {
+ var actual;
+
+ if (typeof block !== 'function') {
+ throw new TypeError('"block" argument must be a function');
}
- for (var m in methods) {
- (function (m) {
- if (methods[m] === null) {
- BufferList.prototype[m] = function (offset, byteLength) {
- return this.slice(offset, offset + byteLength)[m](0, byteLength)
- }
- }
- else {
- BufferList.prototype[m] = function (offset) {
- return this.slice(offset, offset + methods[m])[m](0)
- }
- }
- }(m))
+ if (typeof expected === 'string') {
+ message = expected;
+ expected = null;
}
-}())
+ actual = _tryBlock(block);
+
+ message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
+ (message ? ' ' + message : '.');
-module.exports = BufferList
+ if (shouldThrow && !actual) {
+ fail(actual, expected, 'Missing expected exception' + message);
+ }
-},{"readable-stream":18,"safe-buffer":19,"util":74}],2:[function(require,module,exports){
-(function (Buffer){
+ var userProvidedMessage = typeof message === 'string';
+ var isUnwantedException = !shouldThrow && util.isError(actual);
+ var isUnexpectedException = !shouldThrow && actual && !expected;
+
+ if ((isUnwantedException &&
+ userProvidedMessage &&
+ expectedException(actual, expected)) ||
+ isUnexpectedException) {
+ fail(actual, expected, 'Got unwanted exception' + message);
+ }
+
+ if ((shouldThrow && actual && expected &&
+ !expectedException(actual, expected)) || (!shouldThrow && actual)) {
+ throw actual;
+ }
+}
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+ _throws(true, block, error, message);
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
+ _throws(false, block, error, message);
+};
+
+assert.ifError = function(err) { if (err) throw err; };
+
+// Expose a strict only variant of assert
+function strict(value, message) {
+ if (!value) fail(value, true, message, '==', strict);
+}
+assert.strict = objectAssign(strict, assert, {
+ equal: assert.strictEqual,
+ deepEqual: assert.deepStrictEqual,
+ notEqual: assert.notStrictEqual,
+ notDeepEqual: assert.notDeepStrictEqual
+});
+assert.strict.strict = assert.strict;
+
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) {
+ if (hasOwn.call(obj, key)) keys.push(key);
+ }
+ return keys;
+};
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"object-assign":19,"util/":4}],2:[function(require,module,exports){
+if (typeof Object.create === 'function') {
+ // implementation from standard node.js 'util' module
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ ctor.prototype = Object.create(superCtor.prototype, {
+ constructor: {
+ value: ctor,
+ enumerable: false,
+ writable: true,
+ configurable: true
+ }
+ });
+ };
+} else {
+ // old school shim for old browsers
+ module.exports = function inherits(ctor, superCtor) {
+ ctor.super_ = superCtor
+ var TempCtor = function () {}
+ TempCtor.prototype = superCtor.prototype
+ ctor.prototype = new TempCtor()
+ ctor.prototype.constructor = ctor
+ }
+}
+
+},{}],3:[function(require,module,exports){
+module.exports = function isBuffer(arg) {
+ return arg && typeof arg === 'object'
+ && typeof arg.copy === 'function'
+ && typeof arg.fill === 'function'
+ && typeof arg.readUInt8 === 'function';
+}
+},{}],4:[function(require,module,exports){
+(function (process,global){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
@@ -406,12401 +563,10257 @@ module.exports = BufferList
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
-// NOTE: These type checking functions intentionally don't use `instanceof`
-// because it is fragile and can be easily faked with `Object.create()`.
-
-function isArray(arg) {
- if (Array.isArray) {
- return Array.isArray(arg);
+var formatRegExp = /%[sdj%]/g;
+exports.format = function(f) {
+ if (!isString(f)) {
+ var objects = [];
+ for (var i = 0; i < arguments.length; i++) {
+ objects.push(inspect(arguments[i]));
+ }
+ return objects.join(' ');
}
- return objectToString(arg) === '[object Array]';
-}
-exports.isArray = isArray;
-function isBoolean(arg) {
- return typeof arg === 'boolean';
-}
-exports.isBoolean = isBoolean;
+ var i = 1;
+ var args = arguments;
+ var len = args.length;
+ var str = String(f).replace(formatRegExp, function(x) {
+ if (x === '%%') return '%';
+ if (i >= len) return x;
+ switch (x) {
+ case '%s': return String(args[i++]);
+ case '%d': return Number(args[i++]);
+ case '%j':
+ try {
+ return JSON.stringify(args[i++]);
+ } catch (_) {
+ return '[Circular]';
+ }
+ default:
+ return x;
+ }
+ });
+ for (var x = args[i]; i < len; x = args[++i]) {
+ if (isNull(x) || !isObject(x)) {
+ str += ' ' + x;
+ } else {
+ str += ' ' + inspect(x);
+ }
+ }
+ return str;
+};
-function isNull(arg) {
- return arg === null;
-}
-exports.isNull = isNull;
-function isNullOrUndefined(arg) {
- return arg == null;
-}
-exports.isNullOrUndefined = isNullOrUndefined;
+// Mark that a method should not be used.
+// Returns a modified function which warns once by default.
+// If --no-deprecation is set, then it is a no-op.
+exports.deprecate = function(fn, msg) {
+ // Allow for deprecating things in the process of starting up.
+ if (isUndefined(global.process)) {
+ return function() {
+ return exports.deprecate(fn, msg).apply(this, arguments);
+ };
+ }
-function isNumber(arg) {
- return typeof arg === 'number';
-}
-exports.isNumber = isNumber;
+ if (process.noDeprecation === true) {
+ return fn;
+ }
-function isString(arg) {
- return typeof arg === 'string';
-}
-exports.isString = isString;
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (process.throwDeprecation) {
+ throw new Error(msg);
+ } else if (process.traceDeprecation) {
+ console.trace(msg);
+ } else {
+ console.error(msg);
+ }
+ warned = true;
+ }
+ return fn.apply(this, arguments);
+ }
-function isSymbol(arg) {
- return typeof arg === 'symbol';
-}
-exports.isSymbol = isSymbol;
+ return deprecated;
+};
-function isUndefined(arg) {
- return arg === void 0;
-}
-exports.isUndefined = isUndefined;
-function isRegExp(re) {
- return objectToString(re) === '[object RegExp]';
-}
-exports.isRegExp = isRegExp;
+var debugs = {};
+var debugEnviron;
+exports.debuglog = function(set) {
+ if (isUndefined(debugEnviron))
+ debugEnviron = process.env.NODE_DEBUG || '';
+ set = set.toUpperCase();
+ if (!debugs[set]) {
+ if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
+ var pid = process.pid;
+ debugs[set] = function() {
+ var msg = exports.format.apply(exports, arguments);
+ console.error('%s %d: %s', set, pid, msg);
+ };
+ } else {
+ debugs[set] = function() {};
+ }
+ }
+ return debugs[set];
+};
-function isObject(arg) {
- return typeof arg === 'object' && arg !== null;
-}
-exports.isObject = isObject;
-function isDate(d) {
- return objectToString(d) === '[object Date]';
+/**
+ * Echos the value of a value. Trys to print the value out
+ * in the best way possible given the different types.
+ *
+ * @param {Object} obj The object to print out.
+ * @param {Object} opts Optional options object that alters the output.
+ */
+/* legacy: obj, showHidden, depth, colors*/
+function inspect(obj, opts) {
+ // default options
+ var ctx = {
+ seen: [],
+ stylize: stylizeNoColor
+ };
+ // legacy...
+ if (arguments.length >= 3) ctx.depth = arguments[2];
+ if (arguments.length >= 4) ctx.colors = arguments[3];
+ if (isBoolean(opts)) {
+ // legacy...
+ ctx.showHidden = opts;
+ } else if (opts) {
+ // got an "options" object
+ exports._extend(ctx, opts);
+ }
+ // set default options
+ if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
+ if (isUndefined(ctx.depth)) ctx.depth = 2;
+ if (isUndefined(ctx.colors)) ctx.colors = false;
+ if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
+ if (ctx.colors) ctx.stylize = stylizeWithColor;
+ return formatValue(ctx, obj, ctx.depth);
}
-exports.isDate = isDate;
+exports.inspect = inspect;
-function isError(e) {
- return (objectToString(e) === '[object Error]' || e instanceof Error);
-}
-exports.isError = isError;
-function isFunction(arg) {
- return typeof arg === 'function';
-}
-exports.isFunction = isFunction;
+// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+inspect.colors = {
+ 'bold' : [1, 22],
+ 'italic' : [3, 23],
+ 'underline' : [4, 24],
+ 'inverse' : [7, 27],
+ 'white' : [37, 39],
+ 'grey' : [90, 39],
+ 'black' : [30, 39],
+ 'blue' : [34, 39],
+ 'cyan' : [36, 39],
+ 'green' : [32, 39],
+ 'magenta' : [35, 39],
+ 'red' : [31, 39],
+ 'yellow' : [33, 39]
+};
-function isPrimitive(arg) {
- return arg === null ||
- typeof arg === 'boolean' ||
- typeof arg === 'number' ||
- typeof arg === 'string' ||
- typeof arg === 'symbol' || // ES6 symbol
- typeof arg === 'undefined';
-}
-exports.isPrimitive = isPrimitive;
+// Don't use 'blue' not visible on cmd.exe
+inspect.styles = {
+ 'special': 'cyan',
+ 'number': 'yellow',
+ 'boolean': 'yellow',
+ 'undefined': 'grey',
+ 'null': 'bold',
+ 'string': 'green',
+ 'date': 'magenta',
+ // "name": intentionally not styling
+ 'regexp': 'red'
+};
-exports.isBuffer = Buffer.isBuffer;
-function objectToString(o) {
- return Object.prototype.toString.call(o);
-}
+function stylizeWithColor(str, styleType) {
+ var style = inspect.styles[styleType];
-}).call(this,{"isBuffer":require("../../../../../../../../usr/local/lib/node_modules/browserify/node_modules/is-buffer/index.js")})
-},{"../../../../../../../../usr/local/lib/node_modules/browserify/node_modules/is-buffer/index.js":68}],3:[function(require,module,exports){
-if (typeof Object.create === 'function') {
- // implementation from standard node.js 'util' module
- module.exports = function inherits(ctor, superCtor) {
- ctor.super_ = superCtor
- ctor.prototype = Object.create(superCtor.prototype, {
- constructor: {
- value: ctor,
- enumerable: false,
- writable: true,
- configurable: true
- }
- });
- };
-} else {
- // old school shim for old browsers
- module.exports = function inherits(ctor, superCtor) {
- ctor.super_ = superCtor
- var TempCtor = function () {}
- TempCtor.prototype = superCtor.prototype
- ctor.prototype = new TempCtor()
- ctor.prototype.constructor = ctor
+ if (style) {
+ return '\u001b[' + inspect.colors[style][0] + 'm' + str +
+ '\u001b[' + inspect.colors[style][1] + 'm';
+ } else {
+ return str;
}
}
-},{}],4:[function(require,module,exports){
-var toString = {}.toString;
-module.exports = Array.isArray || function (arr) {
- return toString.call(arr) == '[object Array]';
-};
+function stylizeNoColor(str, styleType) {
+ return str;
+}
-},{}],5:[function(require,module,exports){
-'use strict'
-var Buffer = require('safe-buffer').Buffer
-var assert = require('assert')
-var bl = require('bl')
-var streams = require('./lib/streams')
-var buildDecode = require('./lib/decoder')
-var buildEncode = require('./lib/encoder')
+function arrayToHash(array) {
+ var hash = {};
-function msgpack (options) {
- var encodingTypes = []
- var decodingTypes = []
-
- options = options || {
- forceFloat64: false,
- compatibilityMode: false,
- disableTimestampEncoding: false // if true, skips encoding Dates using the msgpack timestamp ext format (-1)
- }
+ array.forEach(function(val, idx) {
+ hash[val] = true;
+ });
- function registerEncoder (check, encode) {
- assert(check, 'must have an encode function')
- assert(encode, 'must have an encode function')
+ return hash;
+}
- encodingTypes.push({
- check: check, encode: encode
- })
- return this
+function formatValue(ctx, value, recurseTimes) {
+ // Provide a hook for user-specified inspect functions.
+ // Check that value is an object with an inspect function on it
+ if (ctx.customInspect &&
+ value &&
+ isFunction(value.inspect) &&
+ // Filter out the util module, it's inspect function is special
+ value.inspect !== exports.inspect &&
+ // Also filter out any prototype objects using the circular check.
+ !(value.constructor && value.constructor.prototype === value)) {
+ var ret = value.inspect(recurseTimes, ctx);
+ if (!isString(ret)) {
+ ret = formatValue(ctx, ret, recurseTimes);
+ }
+ return ret;
}
- function registerDecoder (type, decode) {
- assert(type >= 0, 'must have a non-negative type')
- assert(decode, 'must have a decode function')
+ // Primitive types cannot have properties
+ var primitive = formatPrimitive(ctx, value);
+ if (primitive) {
+ return primitive;
+ }
- decodingTypes.push({
- type: type, decode: decode
- })
+ // Look up the keys of the object.
+ var keys = Object.keys(value);
+ var visibleKeys = arrayToHash(keys);
- return this
+ if (ctx.showHidden) {
+ keys = Object.getOwnPropertyNames(value);
}
- function register (type, constructor, encode, decode) {
- assert(constructor, 'must have a constructor')
- assert(encode, 'must have an encode function')
- assert(type >= 0, 'must have a non-negative type')
- assert(decode, 'must have a decode function')
+ // IE doesn't make error fields non-enumerable
+ // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
+ if (isError(value)
+ && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
+ return formatError(value);
+ }
- function check (obj) {
- return (obj instanceof constructor)
+ // Some type of object without properties can be shortcutted.
+ if (keys.length === 0) {
+ if (isFunction(value)) {
+ var name = value.name ? ': ' + value.name : '';
+ return ctx.stylize('[Function' + name + ']', 'special');
}
-
- function reEncode (obj) {
- var buf = bl()
- var header = Buffer.allocUnsafe(1)
-
- header.writeInt8(type, 0)
-
- buf.append(header)
- buf.append(encode(obj))
-
- return buf
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ }
+ if (isDate(value)) {
+ return ctx.stylize(Date.prototype.toString.call(value), 'date');
+ }
+ if (isError(value)) {
+ return formatError(value);
}
+ }
- this.registerEncoder(check, reEncode)
- this.registerDecoder(type, decode)
+ var base = '', array = false, braces = ['{', '}'];
- return this
+ // Make Array say that they are Array
+ if (isArray(value)) {
+ array = true;
+ braces = ['[', ']'];
}
- return {
- encode: buildEncode(encodingTypes, options.forceFloat64, options.compatibilityMode, options.disableTimestampEncoding),
- decode: buildDecode(decodingTypes),
- register: register,
- registerEncoder: registerEncoder,
- registerDecoder: registerDecoder,
- encoder: streams.encoder,
- decoder: streams.decoder,
- // needed for levelup support
- buffer: true,
- type: 'msgpack5',
- IncompleteBufferError: buildDecode.IncompleteBufferError
+ // Make functions say that they are functions
+ if (isFunction(value)) {
+ var n = value.name ? ': ' + value.name : '';
+ base = ' [Function' + n + ']';
}
-}
-
-module.exports = msgpack
-
-},{"./lib/decoder":6,"./lib/encoder":7,"./lib/streams":8,"assert":59,"bl":1,"safe-buffer":19}],6:[function(require,module,exports){
-'use strict'
-
-var bl = require('bl')
-var util = require('util')
-function IncompleteBufferError (message) {
- Error.call(this) // super constructor
- if (Error.captureStackTrace) {
- Error.captureStackTrace(this, this.constructor) // super helper method to include stack trace in error object
+ // Make RegExps say that they are RegExps
+ if (isRegExp(value)) {
+ base = ' ' + RegExp.prototype.toString.call(value);
}
- this.name = this.constructor.name
- this.message = message || 'unable to decode'
-}
-
-util.inherits(IncompleteBufferError, Error)
-
-module.exports = function buildDecode (decodingTypes) {
- return decode
- function getSize (first) {
- switch (first) {
- case 0xc4:
- return 2
- case 0xc5:
- return 3
- case 0xc6:
- return 5
- case 0xc7:
- return 3
- case 0xc8:
- return 4
- case 0xc9:
- return 6
- case 0xca:
- return 5
- case 0xcb:
- return 9
- case 0xcc:
- return 2
- case 0xcd:
- return 3
- case 0xce:
- return 5
- case 0xcf:
- return 9
- case 0xd0:
- return 2
- case 0xd1:
- return 3
- case 0xd2:
- return 5
- case 0xd3:
- return 9
- case 0xd4:
- return 3
- case 0xd5:
- return 4
- case 0xd6:
- return 6
- case 0xd7:
- return 10
- case 0xd8:
- return 18
- case 0xd9:
- return 2
- case 0xda:
- return 3
- case 0xdb:
- return 5
- case 0xde:
- return 3
- default:
- return -1
- }
+ // Make dates with properties first say the date
+ if (isDate(value)) {
+ base = ' ' + Date.prototype.toUTCString.call(value);
}
- function hasMinBufferSize (first, length) {
- var size = getSize(first)
-
- if (size !== -1 && length < size) {
- return false
- } else {
- return true
- }
+ // Make error with message first say the error
+ if (isError(value)) {
+ base = ' ' + formatError(value);
}
- function isValidDataSize (dataLength, bufLength, headerLength) {
- return bufLength >= headerLength + dataLength
+ if (keys.length === 0 && (!array || value.length == 0)) {
+ return braces[0] + base + braces[1];
}
- function buildDecodeResult (value, bytesConsumed) {
- return {
- value: value,
- bytesConsumed: bytesConsumed
+ if (recurseTimes < 0) {
+ if (isRegExp(value)) {
+ return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
+ } else {
+ return ctx.stylize('[Object]', 'special');
}
}
- function decode (buf) {
- if (!(buf instanceof bl)) {
- buf = bl().append(buf)
- }
+ ctx.seen.push(value);
- var result = tryDecode(buf)
- if (result) {
- buf.consume(result.bytesConsumed)
- return result.value
- } else {
- throw new IncompleteBufferError()
- }
+ var output;
+ if (array) {
+ output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+ } else {
+ output = keys.map(function(key) {
+ return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+ });
}
- function tryDecode (buf, offset) {
- offset = offset === undefined ? 0 : offset
- var bufLength = buf.length - offset
- if (bufLength <= 0) {
- return null
- }
+ ctx.seen.pop();
- var first = buf.readUInt8(offset)
- var length
- var result = 0
- var type
- var bytePos
+ return reduceToSingleString(output, base, braces);
+}
- if (!hasMinBufferSize(first, bufLength)) {
- return null
- }
- switch (first) {
- case 0xc0:
- return buildDecodeResult(null, 1)
- case 0xc2:
- return buildDecodeResult(false, 1)
- case 0xc3:
- return buildDecodeResult(true, 1)
- case 0xcc:
- // 1-byte unsigned int
- result = buf.readUInt8(offset + 1)
- return buildDecodeResult(result, 2)
- case 0xcd:
- // 2-bytes BE unsigned int
- result = buf.readUInt16BE(offset + 1)
- return buildDecodeResult(result, 3)
- case 0xce:
- // 4-bytes BE unsigned int
- result = buf.readUInt32BE(offset + 1)
- return buildDecodeResult(result, 5)
- case 0xcf:
- // 8-bytes BE unsigned int
- // Read long byte by byte, big-endian
- for (bytePos = 7; bytePos >= 0; bytePos--) {
- result += (buf.readUInt8(offset + bytePos + 1) * Math.pow(2, (8 * (7 - bytePos))))
- }
- return buildDecodeResult(result, 9)
- case 0xd0:
- // 1-byte signed int
- result = buf.readInt8(offset + 1)
- return buildDecodeResult(result, 2)
- case 0xd1:
- // 2-bytes signed int
- result = buf.readInt16BE(offset + 1)
- return buildDecodeResult(result, 3)
- case 0xd2:
- // 4-bytes signed int
- result = buf.readInt32BE(offset + 1)
- return buildDecodeResult(result, 5)
- case 0xd3:
- result = readInt64BE(buf.slice(offset + 1, offset + 9), 0)
- return buildDecodeResult(result, 9)
- case 0xca:
- // 4-bytes float
- result = buf.readFloatBE(offset + 1)
- return buildDecodeResult(result, 5)
- case 0xcb:
- // 8-bytes double
- result = buf.readDoubleBE(offset + 1)
- return buildDecodeResult(result, 9)
- case 0xd9:
- // strings up to 2^8 - 1 bytes
- length = buf.readUInt8(offset + 1)
- if (!isValidDataSize(length, bufLength, 2)) {
- return null
- }
- result = buf.toString('utf8', offset + 2, offset + 2 + length)
- return buildDecodeResult(result, 2 + length)
- case 0xda:
- // strings up to 2^16 - 2 bytes
- length = buf.readUInt16BE(offset + 1)
- if (!isValidDataSize(length, bufLength, 3)) {
- return null
- }
- result = buf.toString('utf8', offset + 3, offset + 3 + length)
- return buildDecodeResult(result, 3 + length)
- case 0xdb:
- // strings up to 2^32 - 4 bytes
- length = buf.readUInt32BE(offset + 1)
- if (!isValidDataSize(length, bufLength, 5)) {
- return null
- }
- result = buf.toString('utf8', offset + 5, offset + 5 + length)
- return buildDecodeResult(result, 5 + length)
- case 0xc4:
- // buffers up to 2^8 - 1 bytes
- length = buf.readUInt8(offset + 1)
- if (!isValidDataSize(length, bufLength, 2)) {
- return null
- }
- result = buf.slice(offset + 2, offset + 2 + length)
- return buildDecodeResult(result, 2 + length)
- case 0xc5:
- // buffers up to 2^16 - 1 bytes
- length = buf.readUInt16BE(offset + 1)
- if (!isValidDataSize(length, bufLength, 3)) {
- return null
- }
- result = buf.slice(offset + 3, offset + 3 + length)
- return buildDecodeResult(result, 3 + length)
- case 0xc6:
- // buffers up to 2^32 - 1 bytes
- length = buf.readUInt32BE(offset + 1)
- if (!isValidDataSize(length, bufLength, 5)) {
- return null
- }
- result = buf.slice(offset + 5, offset + 5 + length)
- return buildDecodeResult(result, 5 + length)
- case 0xdc:
- // array up to 2^16 elements - 2 bytes
- if (bufLength < 3) {
- return null
- }
+function formatPrimitive(ctx, value) {
+ if (isUndefined(value))
+ return ctx.stylize('undefined', 'undefined');
+ if (isString(value)) {
+ var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
+ .replace(/'/g, "\\'")
+ .replace(/\\"/g, '"') + '\'';
+ return ctx.stylize(simple, 'string');
+ }
+ if (isNumber(value))
+ return ctx.stylize('' + value, 'number');
+ if (isBoolean(value))
+ return ctx.stylize('' + value, 'boolean');
+ // For some reason typeof null is "object", so special case here.
+ if (isNull(value))
+ return ctx.stylize('null', 'null');
+}
- length = buf.readUInt16BE(offset + 1)
- return decodeArray(buf, offset, length, 3)
- case 0xdd:
- // array up to 2^32 elements - 4 bytes
- if (bufLength < 5) {
- return null
- }
- length = buf.readUInt32BE(offset + 1)
- return decodeArray(buf, offset, length, 5)
- case 0xde:
- // maps up to 2^16 elements - 2 bytes
- length = buf.readUInt16BE(offset + 1)
- return decodeMap(buf, offset, length, 3)
- case 0xdf:
- length = buf.readUInt32BE(offset + 1)
- return decodeMap(buf, offset, length, 5)
- case 0xd4:
- return decodeFixExt(buf, offset, 1)
- case 0xd5:
- return decodeFixExt(buf, offset, 2)
- case 0xd6:
- return decodeFixExt(buf, offset, 4)
- case 0xd7:
- return decodeFixExt(buf, offset, 8)
- case 0xd8:
- return decodeFixExt(buf, offset, 16)
- case 0xc7:
- // ext up to 2^8 - 1 bytes
- length = buf.readUInt8(offset + 1)
- type = buf.readUInt8(offset + 2)
- if (!isValidDataSize(length, bufLength, 3)) {
- return null
- }
- return decodeExt(buf, offset, type, length, 3)
- case 0xc8:
- // ext up to 2^16 - 1 bytes
- length = buf.readUInt16BE(offset + 1)
- type = buf.readUInt8(offset + 3)
- if (!isValidDataSize(length, bufLength, 4)) {
- return null
- }
- return decodeExt(buf, offset, type, length, 4)
- case 0xc9:
- // ext up to 2^32 - 1 bytes
- length = buf.readUInt32BE(offset + 1)
- type = buf.readUInt8(offset + 5)
- if (!isValidDataSize(length, bufLength, 6)) {
- return null
- }
- return decodeExt(buf, offset, type, length, 6)
- }
+function formatError(value) {
+ return '[' + Error.prototype.toString.call(value) + ']';
+}
- if ((first & 0xf0) === 0x90) {
- // we have an array with less than 15 elements
- length = first & 0x0f
- return decodeArray(buf, offset, length, 1)
- } else if ((first & 0xf0) === 0x80) {
- // we have a map with less than 15 elements
- length = first & 0x0f
- return decodeMap(buf, offset, length, 1)
- } else if ((first & 0xe0) === 0xa0) {
- // fixstr up to 31 bytes
- length = first & 0x1f
- if (isValidDataSize(length, bufLength, 1)) {
- result = buf.toString('utf8', offset + 1, offset + length + 1)
- return buildDecodeResult(result, length + 1)
- } else {
- return null
- }
- } else if (first >= 0xe0) {
- // 5 bits negative ints
- result = first - 0x100
- return buildDecodeResult(result, 1)
- } else if (first < 0x80) {
- // 7-bits positive ints
- return buildDecodeResult(first, 1)
+
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+ var output = [];
+ for (var i = 0, l = value.length; i < l; ++i) {
+ if (hasOwnProperty(value, String(i))) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ String(i), true));
} else {
- throw new Error('not implemented yet')
+ output.push('');
}
}
-
- function readInt64BE (buf, offset) {
- var negate = (buf[offset] & 0x80) == 0x80 // eslint-disable-line
-
- if (negate) {
- var carry = 1
- for (var i = offset + 7; i >= offset; i--) {
- var v = (buf[i] ^ 0xff) + carry
- buf[i] = v & 0xff
- carry = v >> 8
- }
+ keys.forEach(function(key) {
+ if (!key.match(/^\d+$/)) {
+ output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
+ key, true));
}
+ });
+ return output;
+}
- var hi = buf.readUInt32BE(offset + 0)
- var lo = buf.readUInt32BE(offset + 4)
- return (hi * 4294967296 + lo) * (negate ? -1 : +1)
- }
-
- function decodeArray (buf, offset, length, headerLength) {
- var result = []
- var i
- var totalBytesConsumed = 0
- offset += headerLength
- for (i = 0; i < length; i++) {
- var decodeResult = tryDecode(buf, offset)
- if (decodeResult) {
- result.push(decodeResult.value)
- offset += decodeResult.bytesConsumed
- totalBytesConsumed += decodeResult.bytesConsumed
- } else {
- return null
- }
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+ var name, str, desc;
+ desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
+ if (desc.get) {
+ if (desc.set) {
+ str = ctx.stylize('[Getter/Setter]', 'special');
+ } else {
+ str = ctx.stylize('[Getter]', 'special');
+ }
+ } else {
+ if (desc.set) {
+ str = ctx.stylize('[Setter]', 'special');
}
- return buildDecodeResult(result, headerLength + totalBytesConsumed)
}
-
- function decodeMap (buf, offset, length, headerLength) {
- var result = {}
- var key
- var i
- var totalBytesConsumed = 0
-
- offset += headerLength
- for (i = 0; i < length; i++) {
- var keyResult = tryDecode(buf, offset)
- if (keyResult) {
- offset += keyResult.bytesConsumed
- var valueResult = tryDecode(buf, offset)
- if (valueResult) {
- key = keyResult.value
- result[key] = valueResult.value
- offset += valueResult.bytesConsumed
- totalBytesConsumed += (keyResult.bytesConsumed + valueResult.bytesConsumed)
+ if (!hasOwnProperty(visibleKeys, key)) {
+ name = '[' + key + ']';
+ }
+ if (!str) {
+ if (ctx.seen.indexOf(desc.value) < 0) {
+ if (isNull(recurseTimes)) {
+ str = formatValue(ctx, desc.value, null);
+ } else {
+ str = formatValue(ctx, desc.value, recurseTimes - 1);
+ }
+ if (str.indexOf('\n') > -1) {
+ if (array) {
+ str = str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n').substr(2);
} else {
- return null
+ str = '\n' + str.split('\n').map(function(line) {
+ return ' ' + line;
+ }).join('\n');
}
- } else {
- return null
}
+ } else {
+ str = ctx.stylize('[Circular]', 'special');
}
- return buildDecodeResult(result, headerLength + totalBytesConsumed)
}
-
- function decodeFixExt (buf, offset, size) {
- var type = buf.readInt8(offset + 1) // Signed
- return decodeExt(buf, offset, type, size, 2)
+ if (isUndefined(name)) {
+ if (array && key.match(/^\d+$/)) {
+ return str;
+ }
+ name = JSON.stringify('' + key);
+ if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
+ name = name.substr(1, name.length - 2);
+ name = ctx.stylize(name, 'name');
+ } else {
+ name = name.replace(/'/g, "\\'")
+ .replace(/\\"/g, '"')
+ .replace(/(^"|"$)/g, "'");
+ name = ctx.stylize(name, 'string');
+ }
}
- function decodeTimestamp (buf, size, headerSize) {
- var seconds
- var nanoseconds = 0
-
- switch (size) {
- case 4:
- // timestamp 32 stores the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC in an 32-bit unsigned integer
- seconds = buf.readUInt32BE(0)
- break
+ return name + ': ' + str;
+}
- case 8:
- // Timestamp 64 stores the number of seconds and nanoseconds that have elapsed
- // since 1970-01-01 00:00:00 UTC in 32-bit unsigned integers, split 30/34 bits
- var upper = buf.readUInt32BE(0)
- var lower = buf.readUInt32BE(4)
- nanoseconds = upper / 4
- seconds = ((upper & 0x03) * Math.pow(2, 32)) + lower // If we use bitwise operators, we get truncated to 32bits
- break
- case 12:
- throw new Error('timestamp 96 is not yet implemented')
- }
+function reduceToSingleString(output, base, braces) {
+ var numLinesEst = 0;
+ var length = output.reduce(function(prev, cur) {
+ numLinesEst++;
+ if (cur.indexOf('\n') >= 0) numLinesEst++;
+ return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
+ }, 0);
- var millis = (seconds * 1000) + Math.round(nanoseconds / 1E6)
- return buildDecodeResult(new Date(millis), size + headerSize)
+ if (length > 60) {
+ return braces[0] +
+ (base === '' ? '' : base + '\n ') +
+ ' ' +
+ output.join(',\n ') +
+ ' ' +
+ braces[1];
}
- function decodeExt (buf, offset, type, size, headerSize) {
- var i,
- toDecode
+ return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
+}
- offset += headerSize
- // Pre-defined
- if (type < 0) { // Reserved for future extensions
- switch (type) {
- case -1: // Tiemstamp https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
- toDecode = buf.slice(offset, offset + size)
- return decodeTimestamp(toDecode, size, headerSize)
- }
- }
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+function isArray(ar) {
+ return Array.isArray(ar);
+}
+exports.isArray = isArray;
- for (i = 0; i < decodingTypes.length; i++) {
- if (type === decodingTypes[i].type) {
- toDecode = buf.slice(offset, offset + size)
- var value = decodingTypes[i].decode(toDecode)
- return buildDecodeResult(value, headerSize + size)
- }
- }
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
- throw new Error('unable to find ext type ' + type)
- }
+function isNull(arg) {
+ return arg === null;
}
+exports.isNull = isNull;
-module.exports.IncompleteBufferError = IncompleteBufferError
+function isNullOrUndefined(arg) {
+ return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
-},{"bl":1,"util":74}],7:[function(require,module,exports){
-'use strict'
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
-var Buffer = require('safe-buffer').Buffer
-var bl = require('bl')
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
-module.exports = function buildEncode (encodingTypes, forceFloat64, compatibilityMode, disableTimestampEncoding) {
- function encode (obj, avoidSlice) {
- var buf
- var len
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
- if (obj === undefined) {
- throw new Error('undefined is not encodable in msgpack!')
- } else if (isNaN(obj)) {
- throw new Error('NaN is not encodable in msgpack!')
- } else if (obj === null) {
- buf = Buffer.allocUnsafe(1)
- buf[0] = 0xc0
- } else if (obj === true) {
- buf = Buffer.allocUnsafe(1)
- buf[0] = 0xc3
- } else if (obj === false) {
- buf = Buffer.allocUnsafe(1)
- buf[0] = 0xc2
- } else if (typeof obj === 'string') {
- len = Buffer.byteLength(obj)
- if (len < 32) {
- buf = Buffer.allocUnsafe(1 + len)
- buf[0] = 0xa0 | len
- if (len > 0) {
- buf.write(obj, 1)
- }
- } else if (len <= 0xff && !compatibilityMode) {
- // str8, but only when not in compatibility mode
- buf = Buffer.allocUnsafe(2 + len)
- buf[0] = 0xd9
- buf[1] = len
- buf.write(obj, 2)
- } else if (len <= 0xffff) {
- buf = Buffer.allocUnsafe(3 + len)
- buf[0] = 0xda
- buf.writeUInt16BE(len, 1)
- buf.write(obj, 3)
- } else {
- buf = Buffer.allocUnsafe(5 + len)
- buf[0] = 0xdb
- buf.writeUInt32BE(len, 1)
- buf.write(obj, 5)
- }
- } else if (obj && (obj.readUInt32LE || obj instanceof Uint8Array)) {
- if (obj instanceof Uint8Array) {
- obj = Buffer.from(obj)
- }
- // weird hack to support Buffer
- // and Buffer-like objects
- if (obj.length <= 0xff) {
- buf = Buffer.allocUnsafe(2)
- buf[0] = 0xc4
- buf[1] = obj.length
- } else if (obj.length <= 0xffff) {
- buf = Buffer.allocUnsafe(3)
- buf[0] = 0xc5
- buf.writeUInt16BE(obj.length, 1)
- } else {
- buf = Buffer.allocUnsafe(5)
- buf[0] = 0xc6
- buf.writeUInt32BE(obj.length, 1)
- }
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
- buf = bl([buf, obj])
- } else if (Array.isArray(obj)) {
- if (obj.length < 16) {
- buf = Buffer.allocUnsafe(1)
- buf[0] = 0x90 | obj.length
- } else if (obj.length < 65536) {
- buf = Buffer.allocUnsafe(3)
- buf[0] = 0xdc
- buf.writeUInt16BE(obj.length, 1)
- } else {
- buf = Buffer.allocUnsafe(5)
- buf[0] = 0xdd
- buf.writeUInt32BE(obj.length, 1)
- }
+function isRegExp(re) {
+ return isObject(re) && objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
- buf = obj.reduce(function (acc, obj) {
- acc.append(encode(obj, true))
- return acc
- }, bl().append(buf))
- } else if (!disableTimestampEncoding && typeof obj.getDate === 'function') {
- return encodeDate(obj)
- } else if (typeof obj === 'object') {
- buf = encodeExt(obj) || encodeObject(obj)
- } else if (typeof obj === 'number') {
- if (isFloat(obj)) {
- return encodeFloat(obj, forceFloat64)
- } else if (obj >= 0) {
- if (obj < 128) {
- buf = Buffer.allocUnsafe(1)
- buf[0] = obj
- } else if (obj < 256) {
- buf = Buffer.allocUnsafe(2)
- buf[0] = 0xcc
- buf[1] = obj
- } else if (obj < 65536) {
- buf = Buffer.allocUnsafe(3)
- buf[0] = 0xcd
- buf.writeUInt16BE(obj, 1)
- } else if (obj <= 0xffffffff) {
- buf = Buffer.allocUnsafe(5)
- buf[0] = 0xce
- buf.writeUInt32BE(obj, 1)
- } else if (obj <= 9007199254740991) {
- buf = Buffer.allocUnsafe(9)
- buf[0] = 0xcf
- write64BitUint(buf, obj)
- } else {
- return encodeFloat(obj, true)
- }
- } else {
- if (obj >= -32) {
- buf = Buffer.allocUnsafe(1)
- buf[0] = 0x100 + obj
- } else if (obj >= -128) {
- buf = Buffer.allocUnsafe(2)
- buf[0] = 0xd0
- buf.writeInt8(obj, 1)
- } else if (obj >= -32768) {
- buf = Buffer.allocUnsafe(3)
- buf[0] = 0xd1
- buf.writeInt16BE(obj, 1)
- } else if (obj > -214748365) {
- buf = Buffer.allocUnsafe(5)
- buf[0] = 0xd2
- buf.writeInt32BE(obj, 1)
- } else if (obj >= -9007199254740991) {
- buf = Buffer.allocUnsafe(9)
- buf[0] = 0xd3
- write64BitInt(buf, 1, obj)
- } else {
- return encodeFloat(obj, true)
- }
- }
- }
-
- if (!buf) {
- throw new Error('not implemented yet')
- }
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
- if (avoidSlice) {
- return buf
- } else {
- return buf.slice()
- }
- }
+function isDate(d) {
+ return isObject(d) && objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
- function encodeDate (dt) {
- var encoded
- var millis = dt * 1
- var seconds = Math.floor(millis / 1000)
- var nanos = (millis - (seconds * 1000)) * 1E6
+function isError(e) {
+ return isObject(e) &&
+ (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
- if (nanos || seconds > 0xFFFFFFFF) {
- // Timestamp64
- encoded = Buffer.allocUnsafe(10)
- encoded[0] = 0xd7
- encoded[1] = -1
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
- var upperNanos = ((nanos * 4))
- var upperSeconds = seconds / Math.pow(2, 32)
- var upper = (upperNanos + upperSeconds) & 0xFFFFFFFF
- var lower = seconds & 0xFFFFFFFF
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
- encoded.writeInt32BE(upper, 2)
- encoded.writeInt32BE(lower, 6)
- } else {
- // Timestamp32
- encoded = Buffer.allocUnsafe(6)
- encoded[0] = 0xd6
- encoded[1] = -1
- encoded.writeUInt32BE(Math.floor(millis / 1000), 2)
- }
- return bl().append(encoded)
- }
+exports.isBuffer = require('./support/isBuffer');
- function encodeExt (obj) {
- var i
- var encoded
- var length = -1
- var headers = []
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
- for (i = 0; i < encodingTypes.length; i++) {
- if (encodingTypes[i].check(obj)) {
- encoded = encodingTypes[i].encode(obj)
- break
- }
- }
- if (!encoded) {
- return null
- }
+function pad(n) {
+ return n < 10 ? '0' + n.toString(10) : n.toString(10);
+}
- // we subtract 1 because the length does not
- // include the type
- length = encoded.length - 1
- if (length === 1) {
- headers.push(0xd4)
- } else if (length === 2) {
- headers.push(0xd5)
- } else if (length === 4) {
- headers.push(0xd6)
- } else if (length === 8) {
- headers.push(0xd7)
- } else if (length === 16) {
- headers.push(0xd8)
- } else if (length < 256) {
- headers.push(0xc7)
- headers.push(length)
- } else if (length < 0x10000) {
- headers.push(0xc8)
- headers.push(length >> 8)
- headers.push(length & 0x00ff)
- } else {
- headers.push(0xc9)
- headers.push(length >> 24)
- headers.push((length >> 16) & 0x000000ff)
- headers.push((length >> 8) & 0x000000ff)
- headers.push(length & 0x000000ff)
- }
+var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
+ 'Oct', 'Nov', 'Dec'];
- return bl().append(Buffer.from(headers)).append(encoded)
- }
+// 26 Feb 16:19:34
+function timestamp() {
+ var d = new Date();
+ var time = [pad(d.getHours()),
+ pad(d.getMinutes()),
+ pad(d.getSeconds())].join(':');
+ return [d.getDate(), months[d.getMonth()], time].join(' ');
+}
- function encodeObject (obj) {
- var acc = []
- var length = 0
- var key
- var header
- for (key in obj) {
- if (obj.hasOwnProperty(key) &&
- obj[key] !== undefined &&
- typeof obj[key] !== 'function') {
- ++length
- acc.push(encode(key, true))
- acc.push(encode(obj[key], true))
- }
- }
+// log is just a thin wrapper to console.log that prepends a timestamp
+exports.log = function() {
+ console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+};
- if (length < 16) {
- header = Buffer.allocUnsafe(1)
- header[0] = 0x80 | length
- } else if (length < 0xFFFF) {
- header = Buffer.allocUnsafe(3)
- header[0] = 0xde
- header.writeUInt16BE(length, 1)
- } else {
- header = Buffer.allocUnsafe(5)
- header[0] = 0xdf
- header.writeUInt32BE(length, 1)
- }
- acc.unshift(header)
+/**
+ * Inherit the prototype methods from one constructor into another.
+ *
+ * The Function.prototype.inherits from lang.js rewritten as a standalone
+ * function (not on Function.prototype). NOTE: If this file is to be loaded
+ * during bootstrapping this function needs to be rewritten using some native
+ * functions as prototype setup using normal JavaScript does not work as
+ * expected during bootstrapping (see mirror.js in r114903).
+ *
+ * @param {function} ctor Constructor function which needs to inherit the
+ * prototype.
+ * @param {function} superCtor Constructor function to inherit prototype from.
+ */
+exports.inherits = require('inherits');
- var result = acc.reduce(function (list, buf) {
- return list.append(buf)
- }, bl())
+exports._extend = function(origin, add) {
+ // Don't do anything if add isn't an object
+ if (!add || !isObject(add)) return origin;
- return result
+ var keys = Object.keys(add);
+ var i = keys.length;
+ while (i--) {
+ origin[keys[i]] = add[keys[i]];
}
+ return origin;
+};
- return encode
+function hasOwnProperty(obj, prop) {
+ return Object.prototype.hasOwnProperty.call(obj, prop);
}
-function write64BitUint (buf, obj) {
- // Write long byte by byte, in big-endian order
- for (var currByte = 7; currByte >= 0; currByte--) {
- buf[currByte + 1] = (obj & 0xff)
- obj = obj / 256
- }
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./support/isBuffer":3,"_process":21,"inherits":2}],5:[function(require,module,exports){
+'use strict'
+
+exports.byteLength = byteLength
+exports.toByteArray = toByteArray
+exports.fromByteArray = fromByteArray
+
+var lookup = []
+var revLookup = []
+var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+for (var i = 0, len = code.length; i < len; ++i) {
+ lookup[i] = code[i]
+ revLookup[code.charCodeAt(i)] = i
}
-function write64BitInt (buf, offset, num) {
- var negate = num < 0
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup['-'.charCodeAt(0)] = 62
+revLookup['_'.charCodeAt(0)] = 63
- if (negate) {
- num = Math.abs(num)
+function getLens (b64) {
+ var len = b64.length
+
+ if (len % 4 > 0) {
+ throw new Error('Invalid string. Length must be a multiple of 4')
}
- var lo = num % 4294967296
- var hi = num / 4294967296
- buf.writeUInt32BE(Math.floor(hi), offset + 0)
- buf.writeUInt32BE(lo, offset + 4)
+ // Trim off extra bytes after placeholder bytes are found
+ // See: https://github.com/beatgammit/base64-js/issues/42
+ var validLen = b64.indexOf('=')
+ if (validLen === -1) validLen = len
- if (negate) {
- var carry = 1
- for (var i = offset + 7; i >= offset; i--) {
- var v = (buf[i] ^ 0xff) + carry
- buf[i] = v & 0xff
- carry = v >> 8
- }
- }
+ var placeHoldersLen = validLen === len
+ ? 0
+ : 4 - (validLen % 4)
+
+ return [validLen, placeHoldersLen]
}
-function isFloat (n) {
- return n % 1 !== 0
+// base64 is 4/3 + up to two characters of the original data
+function byteLength (b64) {
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
-function isNaN (n) {
- /* eslint-disable no-self-compare */
- return n !== n && typeof n === 'number'
- /* eslint-enable no-self-compare */
+function _byteLength (b64, validLen, placeHoldersLen) {
+ return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}
-function encodeFloat (obj, forceFloat64) {
- var useDoublePrecision = true
+function toByteArray (b64) {
+ var tmp
+ var lens = getLens(b64)
+ var validLen = lens[0]
+ var placeHoldersLen = lens[1]
- // If `fround` is supported, we can check if a float
- // is double or single precision by rounding the object
- // to single precision and comparing the difference.
- // If it's not supported, it's safer to use a 64 bit
- // float so we don't lose precision without meaning to.
- if (Math.fround) {
- useDoublePrecision = Math.fround(obj) !== obj
- }
+ var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
- if (forceFloat64) {
- useDoublePrecision = true
+ var curByte = 0
+
+ // if there are placeholders, only get up to the last complete 4 chars
+ var len = placeHoldersLen > 0
+ ? validLen - 4
+ : validLen
+
+ var i
+ for (i = 0; i < len; i += 4) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 18) |
+ (revLookup[b64.charCodeAt(i + 1)] << 12) |
+ (revLookup[b64.charCodeAt(i + 2)] << 6) |
+ revLookup[b64.charCodeAt(i + 3)]
+ arr[curByte++] = (tmp >> 16) & 0xFF
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
}
- var buf
+ if (placeHoldersLen === 2) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 2) |
+ (revLookup[b64.charCodeAt(i + 1)] >> 4)
+ arr[curByte++] = tmp & 0xFF
+ }
- if (useDoublePrecision) {
- buf = Buffer.allocUnsafe(9)
- buf[0] = 0xcb
- buf.writeDoubleBE(obj, 1)
- } else {
- buf = Buffer.allocUnsafe(5)
- buf[0] = 0xca
- buf.writeFloatBE(obj, 1)
+ if (placeHoldersLen === 1) {
+ tmp =
+ (revLookup[b64.charCodeAt(i)] << 10) |
+ (revLookup[b64.charCodeAt(i + 1)] << 4) |
+ (revLookup[b64.charCodeAt(i + 2)] >> 2)
+ arr[curByte++] = (tmp >> 8) & 0xFF
+ arr[curByte++] = tmp & 0xFF
}
- return buf
+ return arr
}
-},{"bl":1,"safe-buffer":19}],8:[function(require,module,exports){
-'use strict'
+function tripletToBase64 (num) {
+ return lookup[num >> 18 & 0x3F] +
+ lookup[num >> 12 & 0x3F] +
+ lookup[num >> 6 & 0x3F] +
+ lookup[num & 0x3F]
+}
-var Transform = require('readable-stream').Transform
-var inherits = require('inherits')
-var bl = require('bl')
+function encodeChunk (uint8, start, end) {
+ var tmp
+ var output = []
+ for (var i = start; i < end; i += 3) {
+ tmp =
+ ((uint8[i] << 16) & 0xFF0000) +
+ ((uint8[i + 1] << 8) & 0xFF00) +
+ (uint8[i + 2] & 0xFF)
+ output.push(tripletToBase64(tmp))
+ }
+ return output.join('')
+}
-function Base (opts) {
- opts = opts || {}
+function fromByteArray (uint8) {
+ var tmp
+ var len = uint8.length
+ var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+ var parts = []
+ var maxChunkLength = 16383 // must be multiple of 3
- opts.objectMode = true
- opts.highWaterMark = 16
+ // go through the array every three bytes, we'll deal with trailing stuff later
+ for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+ parts.push(encodeChunk(
+ uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
+ ))
+ }
- Transform.call(this, opts)
+ // pad the end with zeros, but make sure to not forget the extra bytes
+ if (extraBytes === 1) {
+ tmp = uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 2] +
+ lookup[(tmp << 4) & 0x3F] +
+ '=='
+ )
+ } else if (extraBytes === 2) {
+ tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+ parts.push(
+ lookup[tmp >> 10] +
+ lookup[(tmp >> 4) & 0x3F] +
+ lookup[(tmp << 2) & 0x3F] +
+ '='
+ )
+ }
- this._msgpack = opts.msgpack
+ return parts.join('')
}
-inherits(Base, Transform)
+},{}],6:[function(require,module,exports){
+'use strict'
+var DuplexStream = require('readable-stream').Duplex
+ , util = require('util')
+ , Buffer = require('safe-buffer').Buffer
-function Encoder (opts) {
- if (!(this instanceof Encoder)) {
- opts = opts || {}
- opts.msgpack = this
- return new Encoder(opts)
- }
+function BufferList (callback) {
+ if (!(this instanceof BufferList))
+ return new BufferList(callback)
- Base.call(this, opts)
- this._wrap = ('wrap' in opts) && opts.wrap
-}
+ this._bufs = []
+ this.length = 0
-inherits(Encoder, Base)
+ if (typeof callback == 'function') {
+ this._callback = callback
-Encoder.prototype._transform = function (obj, enc, done) {
- var buf = null
+ var piper = function piper (err) {
+ if (this._callback) {
+ this._callback(err)
+ this._callback = null
+ }
+ }.bind(this)
- try {
- buf = this._msgpack.encode(this._wrap ? obj.value : obj).slice(0)
- } catch (err) {
- this.emit('error', err)
- return done()
+ this.on('pipe', function onPipe (src) {
+ src.on('error', piper)
+ })
+ this.on('unpipe', function onUnpipe (src) {
+ src.removeListener('error', piper)
+ })
+ } else {
+ this.append(callback)
}
- this.push(buf)
- done()
+ DuplexStream.call(this)
}
-function Decoder (opts) {
- if (!(this instanceof Decoder)) {
- opts = opts || {}
- opts.msgpack = this
- return new Decoder(opts)
- }
-
- Base.call(this, opts)
-
- this._chunks = bl()
- this._wrap = ('wrap' in opts) && opts.wrap
-}
-inherits(Decoder, Base)
+util.inherits(BufferList, DuplexStream)
-Decoder.prototype._transform = function (buf, enc, done) {
- if (buf) {
- this._chunks.append(buf)
- }
- try {
- var result = this._msgpack.decode(this._chunks)
- if (this._wrap) {
- result = {value: result}
- }
- this.push(result)
- } catch (err) {
- if (err instanceof this._msgpack.IncompleteBufferError) {
- done()
- } else {
- this.emit('error', err)
+BufferList.prototype._offset = function _offset (offset) {
+ var tot = 0, i = 0, _t
+ if (offset === 0) return [ 0, 0 ]
+ for (; i < this._bufs.length; i++) {
+ _t = tot + this._bufs[i].length
+ if (offset < _t || i == this._bufs.length - 1) {
+ return [ i, offset - tot ]
}
- return
+ tot = _t
}
+}
- if (this._chunks.length > 0) {
- this._transform(null, enc, done)
- } else {
- done()
+BufferList.prototype._reverseOffset = function (blOffset) {
+ var bufferId = blOffset[0]
+ var offset = blOffset[1]
+ for (var i = 0; i < bufferId; i++) {
+ offset += this._bufs[i].length
}
+ return offset
}
-module.exports.decoder = Decoder
-module.exports.encoder = Encoder
-
-},{"bl":1,"inherits":3,"readable-stream":18}],9:[function(require,module,exports){
-(function (process){
-'use strict';
+BufferList.prototype.append = function append (buf) {
+ var i = 0
-if (!process.version ||
- process.version.indexOf('v0.') === 0 ||
- process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
- module.exports = { nextTick: nextTick };
-} else {
- module.exports = process
-}
+ if (Buffer.isBuffer(buf)) {
+ this._appendBuffer(buf)
+ } else if (Array.isArray(buf)) {
+ for (; i < buf.length; i++)
+ this.append(buf[i])
+ } else if (buf instanceof BufferList) {
+ // unwrap argument into individual BufferLists
+ for (; i < buf._bufs.length; i++)
+ this.append(buf._bufs[i])
+ } else if (buf != null) {
+ // coerce number arguments to strings, since Buffer(number) does
+ // uninitialized memory allocation
+ if (typeof buf == 'number')
+ buf = buf.toString()
-function nextTick(fn, arg1, arg2, arg3) {
- if (typeof fn !== 'function') {
- throw new TypeError('"callback" argument must be a function');
- }
- var len = arguments.length;
- var args, i;
- switch (len) {
- case 0:
- case 1:
- return process.nextTick(fn);
- case 2:
- return process.nextTick(function afterTickOne() {
- fn.call(null, arg1);
- });
- case 3:
- return process.nextTick(function afterTickTwo() {
- fn.call(null, arg1, arg2);
- });
- case 4:
- return process.nextTick(function afterTickThree() {
- fn.call(null, arg1, arg2, arg3);
- });
- default:
- args = new Array(len - 1);
- i = 0;
- while (i < args.length) {
- args[i++] = arguments[i];
- }
- return process.nextTick(function afterTick() {
- fn.apply(null, args);
- });
+ this._appendBuffer(Buffer.from(buf))
}
+
+ return this
}
-}).call(this,require('_process'))
-},{"_process":70}],10:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+BufferList.prototype._appendBuffer = function appendBuffer (buf) {
+ this._bufs.push(buf)
+ this.length += buf.length
+}
-// a duplex stream is just a stream that is both readable and writable.
-// Since JS doesn't have multiple prototypal inheritance, this class
-// prototypally inherits from Readable, and then parasitically from
-// Writable.
-'use strict';
+BufferList.prototype._write = function _write (buf, encoding, callback) {
+ this._appendBuffer(buf)
-/*<replacement>*/
+ if (typeof callback == 'function')
+ callback()
+}
-var pna = require('process-nextick-args');
-/*</replacement>*/
-/*<replacement>*/
-var objectKeys = Object.keys || function (obj) {
- var keys = [];
- for (var key in obj) {
- keys.push(key);
- }return keys;
-};
-/*</replacement>*/
+BufferList.prototype._read = function _read (size) {
+ if (!this.length)
+ return this.push(null)
-module.exports = Duplex;
+ size = Math.min(size, this.length)
+ this.push(this.slice(0, size))
+ this.consume(size)
+}
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
-var Readable = require('./_stream_readable');
-var Writable = require('./_stream_writable');
+BufferList.prototype.end = function end (chunk) {
+ DuplexStream.prototype.end.call(this, chunk)
-util.inherits(Duplex, Readable);
+ if (this._callback) {
+ this._callback(null, this.slice())
+ this._callback = null
+ }
+}
-{
- // avoid scope creep, the keys array can then be collected
- var keys = objectKeys(Writable.prototype);
- for (var v = 0; v < keys.length; v++) {
- var method = keys[v];
- if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
+
+BufferList.prototype.get = function get (index) {
+ if (index > this.length || index < 0) {
+ return undefined
}
+ var offset = this._offset(index)
+ return this._bufs[offset[0]][offset[1]]
}
-function Duplex(options) {
- if (!(this instanceof Duplex)) return new Duplex(options);
- Readable.call(this, options);
- Writable.call(this, options);
+BufferList.prototype.slice = function slice (start, end) {
+ if (typeof start == 'number' && start < 0)
+ start += this.length
+ if (typeof end == 'number' && end < 0)
+ end += this.length
+ return this.copy(null, 0, start, end)
+}
- if (options && options.readable === false) this.readable = false;
- if (options && options.writable === false) this.writable = false;
+BufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
+ if (typeof srcStart != 'number' || srcStart < 0)
+ srcStart = 0
+ if (typeof srcEnd != 'number' || srcEnd > this.length)
+ srcEnd = this.length
+ if (srcStart >= this.length)
+ return dst || Buffer.alloc(0)
+ if (srcEnd <= 0)
+ return dst || Buffer.alloc(0)
- this.allowHalfOpen = true;
- if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
+ var copy = !!dst
+ , off = this._offset(srcStart)
+ , len = srcEnd - srcStart
+ , bytes = len
+ , bufoff = (copy && dstStart) || 0
+ , start = off[1]
+ , l
+ , i
- this.once('end', onend);
-}
+ // copy/slice everything
+ if (srcStart === 0 && srcEnd == this.length) {
+ if (!copy) { // slice, but full concat if multiple buffers
+ return this._bufs.length === 1
+ ? this._bufs[0]
+ : Buffer.concat(this._bufs, this.length)
+ }
-Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
- // making it explicit this property is not enumerable
- // because otherwise some prototype manipulation in
- // userland will fail
- enumerable: false,
- get: function () {
- return this._writableState.highWaterMark;
+ // copy, need to copy individual buffers
+ for (i = 0; i < this._bufs.length; i++) {
+ this._bufs[i].copy(dst, bufoff)
+ bufoff += this._bufs[i].length
+ }
+
+ return dst
}
-});
-// the no-half-open enforcer
-function onend() {
- // if we allow half-open state, or if the writable side ended,
- // then we're ok.
- if (this.allowHalfOpen || this._writableState.ended) return;
+ // easy, cheap case where it's a subset of one of the buffers
+ if (bytes <= this._bufs[off[0]].length - start) {
+ return copy
+ ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
+ : this._bufs[off[0]].slice(start, start + bytes)
+ }
- // no more data can be written.
- // But allow more writes to happen in this tick.
- pna.nextTick(onEndNT, this);
-}
+ if (!copy) // a slice, we need something to copy in to
+ dst = Buffer.allocUnsafe(len)
-function onEndNT(self) {
- self.end();
-}
+ for (i = off[0]; i < this._bufs.length; i++) {
+ l = this._bufs[i].length - start
-Object.defineProperty(Duplex.prototype, 'destroyed', {
- get: function () {
- if (this._readableState === undefined || this._writableState === undefined) {
- return false;
- }
- return this._readableState.destroyed && this._writableState.destroyed;
- },
- set: function (value) {
- // we ignore the value if the stream
- // has not been initialized yet
- if (this._readableState === undefined || this._writableState === undefined) {
- return;
+ if (bytes > l) {
+ this._bufs[i].copy(dst, bufoff, start)
+ } else {
+ this._bufs[i].copy(dst, bufoff, start, start + bytes)
+ break
}
- // backward compatibility, the user is explicitly
- // managing destroyed
- this._readableState.destroyed = value;
- this._writableState.destroyed = value;
+ bufoff += l
+ bytes -= l
+
+ if (start)
+ start = 0
}
-});
-Duplex.prototype._destroy = function (err, cb) {
- this.push(null);
- this.end();
+ return dst
+}
- pna.nextTick(cb, err);
-};
-},{"./_stream_readable":12,"./_stream_writable":14,"core-util-is":2,"inherits":3,"process-nextick-args":9}],11:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a passthrough stream.
-// basically just the most minimal sort of Transform stream.
-// Every written chunk gets output as-is.
-
-'use strict';
-
-module.exports = PassThrough;
+BufferList.prototype.shallowSlice = function shallowSlice (start, end) {
+ start = start || 0
+ end = typeof end !== 'number' ? this.length : end
-var Transform = require('./_stream_transform');
+ if (start < 0)
+ start += this.length
+ if (end < 0)
+ end += this.length
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
+ if (start === end) {
+ return new BufferList()
+ }
+ var startOffset = this._offset(start)
+ , endOffset = this._offset(end)
+ , buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)
-util.inherits(PassThrough, Transform);
+ if (endOffset[1] == 0)
+ buffers.pop()
+ else
+ buffers[buffers.length-1] = buffers[buffers.length-1].slice(0, endOffset[1])
-function PassThrough(options) {
- if (!(this instanceof PassThrough)) return new PassThrough(options);
+ if (startOffset[1] != 0)
+ buffers[0] = buffers[0].slice(startOffset[1])
- Transform.call(this, options);
+ return new BufferList(buffers)
}
-PassThrough.prototype._transform = function (chunk, encoding, cb) {
- cb(null, chunk);
-};
-},{"./_stream_transform":13,"core-util-is":2,"inherits":3}],12:[function(require,module,exports){
-(function (process,global){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+BufferList.prototype.toString = function toString (encoding, start, end) {
+ return this.slice(start, end).toString(encoding)
+}
-'use strict';
+BufferList.prototype.consume = function consume (bytes) {
+ while (this._bufs.length) {
+ if (bytes >= this._bufs[0].length) {
+ bytes -= this._bufs[0].length
+ this.length -= this._bufs[0].length
+ this._bufs.shift()
+ } else {
+ this._bufs[0] = this._bufs[0].slice(bytes)
+ this.length -= bytes
+ break
+ }
+ }
+ return this
+}
-/*<replacement>*/
-var pna = require('process-nextick-args');
-/*</replacement>*/
+BufferList.prototype.duplicate = function duplicate () {
+ var i = 0
+ , copy = new BufferList()
-module.exports = Readable;
+ for (; i < this._bufs.length; i++)
+ copy.append(this._bufs[i])
-/*<replacement>*/
-var isArray = require('isarray');
-/*</replacement>*/
+ return copy
+}
-/*<replacement>*/
-var Duplex;
-/*</replacement>*/
-Readable.ReadableState = ReadableState;
+BufferList.prototype.destroy = function destroy () {
+ this._bufs.length = 0
+ this.length = 0
+ this.push(null)
+}
-/*<replacement>*/
-var EE = require('events').EventEmitter;
-var EElistenerCount = function (emitter, type) {
- return emitter.listeners(type).length;
-};
-/*</replacement>*/
+BufferList.prototype.indexOf = function (search, offset, encoding) {
+ if (encoding === undefined && typeof offset === 'string') {
+ encoding = offset
+ offset = undefined
+ }
+ if (typeof search === 'function' || Array.isArray(search)) {
+ throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.')
+ } else if (typeof search === 'number') {
+ search = Buffer.from([search])
+ } else if (typeof search === 'string') {
+ search = Buffer.from(search, encoding)
+ } else if (search instanceof BufferList) {
+ search = search.slice()
+ } else if (!Buffer.isBuffer(search)) {
+ search = Buffer.from(search)
+ }
-/*<replacement>*/
-var Stream = require('./internal/streams/stream');
-/*</replacement>*/
+ offset = Number(offset || 0)
+ if (isNaN(offset)) {
+ offset = 0
+ }
-/*<replacement>*/
+ if (offset < 0) {
+ offset = this.length + offset
+ }
-var Buffer = require('safe-buffer').Buffer;
-var OurUint8Array = global.Uint8Array || function () {};
-function _uint8ArrayToBuffer(chunk) {
- return Buffer.from(chunk);
-}
-function _isUint8Array(obj) {
- return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
-}
+ if (offset < 0) {
+ offset = 0
+ }
-/*</replacement>*/
+ if (search.length === 0) {
+ return offset > this.length ? this.length : offset
+ }
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
+ var blOffset = this._offset(offset)
+ var blIndex = blOffset[0] // index of which internal buffer we're working on
+ var buffOffset = blOffset[1] // offset of the internal buffer we're working on
-/*<replacement>*/
-var debugUtil = require('util');
-var debug = void 0;
-if (debugUtil && debugUtil.debuglog) {
- debug = debugUtil.debuglog('stream');
-} else {
- debug = function () {};
+ // scan over each buffer
+ for (blIndex; blIndex < this._bufs.length; blIndex++) {
+ var buff = this._bufs[blIndex]
+ while(buffOffset < buff.length) {
+ var availableWindow = buff.length - buffOffset
+ if (availableWindow >= search.length) {
+ var nativeSearchResult = buff.indexOf(search, buffOffset)
+ if (nativeSearchResult !== -1) {
+ return this._reverseOffset([blIndex, nativeSearchResult])
+ }
+ buffOffset = buff.length - search.length + 1 // end of native search window
+ } else {
+ var revOffset = this._reverseOffset([blIndex, buffOffset])
+ if (this._match(revOffset, search)) {
+ return revOffset
+ }
+ buffOffset++
+ }
+ }
+ buffOffset = 0
+ }
+ return -1
}
-/*</replacement>*/
-var BufferList = require('./internal/streams/BufferList');
-var destroyImpl = require('./internal/streams/destroy');
-var StringDecoder;
+BufferList.prototype._match = function(offset, search) {
+ if (this.length - offset < search.length) {
+ return false
+ }
+ for (var searchOffset = 0; searchOffset < search.length ; searchOffset++) {
+ if(this.get(offset + searchOffset) !== search[searchOffset]){
+ return false
+ }
+ }
+ return true
+}
-util.inherits(Readable, Stream);
-var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
+;(function () {
+ var methods = {
+ 'readDoubleBE' : 8
+ , 'readDoubleLE' : 8
+ , 'readFloatBE' : 4
+ , 'readFloatLE' : 4
+ , 'readInt32BE' : 4
+ , 'readInt32LE' : 4
+ , 'readUInt32BE' : 4
+ , 'readUInt32LE' : 4
+ , 'readInt16BE' : 2
+ , 'readInt16LE' : 2
+ , 'readUInt16BE' : 2
+ , 'readUInt16LE' : 2
+ , 'readInt8' : 1
+ , 'readUInt8' : 1
+ , 'readIntBE' : null
+ , 'readIntLE' : null
+ , 'readUIntBE' : null
+ , 'readUIntLE' : null
+ }
-function prependListener(emitter, event, fn) {
- // Sadly this is not cacheable as some libraries bundle their own
- // event emitter implementation with them.
- if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
+ for (var m in methods) {
+ (function (m) {
+ if (methods[m] === null) {
+ BufferList.prototype[m] = function (offset, byteLength) {
+ return this.slice(offset, offset + byteLength)[m](0, byteLength)
+ }
+ }
+ else {
+ BufferList.prototype[m] = function (offset) {
+ return this.slice(offset, offset + methods[m])[m](0)
+ }
+ }
+ }(m))
+ }
+}())
- // This is a hack to make sure that our error handler is attached before any
- // userland ones. NEVER DO THIS. This is here only because this code needs
- // to continue to work with older versions of Node.js that do not include
- // the prependListener() method. The goal is to eventually remove this hack.
- if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
-}
-function ReadableState(options, stream) {
- Duplex = Duplex || require('./_stream_duplex');
+module.exports = BufferList
- options = options || {};
+},{"readable-stream":30,"safe-buffer":32,"util":37}],7:[function(require,module,exports){
- // Duplex streams are both readable and writable, but share
- // the same options object.
- // However, some cases require setting options to different
- // values for the readable and the writable sides of the duplex stream.
- // These options can be provided separately as readableXXX and writableXXX.
- var isDuplex = stream instanceof Duplex;
-
- // object stream flag. Used to make read(n) ignore n and to
- // make all the buffer merging and length checks go away
- this.objectMode = !!options.objectMode;
-
- if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
-
- // the point at which it stops calling _read() to fill the buffer
- // Note: 0 is a valid value, means "don't call _read preemptively ever"
- var hwm = options.highWaterMark;
- var readableHwm = options.readableHighWaterMark;
- var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+},{}],8:[function(require,module,exports){
+(function (Buffer){
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh <https://feross.org>
+ * @license MIT
+ */
+/* eslint-disable no-proto */
- if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
+'use strict'
- // cast to ints.
- this.highWaterMark = Math.floor(this.highWaterMark);
+var base64 = require('base64-js')
+var ieee754 = require('ieee754')
- // A linked list is used to store data chunks instead of an array because the
- // linked list can remove elements from the beginning faster than
- // array.shift()
- this.buffer = new BufferList();
- this.length = 0;
- this.pipes = null;
- this.pipesCount = 0;
- this.flowing = null;
- this.ended = false;
- this.endEmitted = false;
- this.reading = false;
+exports.Buffer = Buffer
+exports.SlowBuffer = SlowBuffer
+exports.INSPECT_MAX_BYTES = 50
- // a flag to be able to tell if the event 'readable'/'data' is emitted
- // immediately, or on a later tick. We set this to true at first, because
- // any actions that shouldn't happen until "later" should generally also
- // not happen before the first read call.
- this.sync = true;
+var K_MAX_LENGTH = 0x7fffffff
+exports.kMaxLength = K_MAX_LENGTH
- // whenever we return null, then we set a flag to say
- // that we're awaiting a 'readable' event emission.
- this.needReadable = false;
- this.emittedReadable = false;
- this.readableListening = false;
- this.resumeScheduled = false;
+/**
+ * If `Buffer.TYPED_ARRAY_SUPPORT`:
+ * === true Use Uint8Array implementation (fastest)
+ * === false Print warning and recommend using `buffer` v4.x which has an Object
+ * implementation (most compatible, even IE6)
+ *
+ * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+ * Opera 11.6+, iOS 4.2+.
+ *
+ * We report that the browser does not support typed arrays if the are not subclassable
+ * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
+ * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
+ * for __proto__ and has a buggy typed array implementation.
+ */
+Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
- // has it been destroyed
- this.destroyed = false;
+if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
+ typeof console.error === 'function') {
+ console.error(
+ 'This browser lacks typed array (Uint8Array) support which is required by ' +
+ '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
+ )
+}
- // Crypto is kind of old and crusty. Historically, its default string
- // encoding is 'binary' so we have to make this configurable.
- // Everything else in the universe uses 'utf8', though.
- this.defaultEncoding = options.defaultEncoding || 'utf8';
+function typedArraySupport () {
+ // Can typed array instances can be augmented?
+ try {
+ var arr = new Uint8Array(1)
+ arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
+ return arr.foo() === 42
+ } catch (e) {
+ return false
+ }
+}
- // the number of writers that are awaiting a drain event in .pipe()s
- this.awaitDrain = 0;
+Object.defineProperty(Buffer.prototype, 'parent', {
+ enumerable: true,
+ get: function () {
+ if (!Buffer.isBuffer(this)) return undefined
+ return this.buffer
+ }
+})
- // if true, a maybeReadMore has been scheduled
- this.readingMore = false;
+Object.defineProperty(Buffer.prototype, 'offset', {
+ enumerable: true,
+ get: function () {
+ if (!Buffer.isBuffer(this)) return undefined
+ return this.byteOffset
+ }
+})
- this.decoder = null;
- this.encoding = null;
- if (options.encoding) {
- if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
- this.decoder = new StringDecoder(options.encoding);
- this.encoding = options.encoding;
+function createBuffer (length) {
+ if (length > K_MAX_LENGTH) {
+ throw new RangeError('The value "' + length + '" is invalid for option "size"')
}
+ // Return an augmented `Uint8Array` instance
+ var buf = new Uint8Array(length)
+ buf.__proto__ = Buffer.prototype
+ return buf
}
-function Readable(options) {
- Duplex = Duplex || require('./_stream_duplex');
+/**
+ * The Buffer constructor returns instances of `Uint8Array` that have their
+ * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+ * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+ * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+ * returns a single octet.
+ *
+ * The `Uint8Array` prototype remains unmodified.
+ */
- if (!(this instanceof Readable)) return new Readable(options);
+function Buffer (arg, encodingOrOffset, length) {
+ // Common case.
+ if (typeof arg === 'number') {
+ if (typeof encodingOrOffset === 'string') {
+ throw new TypeError(
+ 'The "string" argument must be of type string. Received type number'
+ )
+ }
+ return allocUnsafe(arg)
+ }
+ return from(arg, encodingOrOffset, length)
+}
- this._readableState = new ReadableState(options, this);
+// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+if (typeof Symbol !== 'undefined' && Symbol.species != null &&
+ Buffer[Symbol.species] === Buffer) {
+ Object.defineProperty(Buffer, Symbol.species, {
+ value: null,
+ configurable: true,
+ enumerable: false,
+ writable: false
+ })
+}
- // legacy
- this.readable = true;
+Buffer.poolSize = 8192 // not used by this implementation
- if (options) {
- if (typeof options.read === 'function') this._read = options.read;
+function from (value, encodingOrOffset, length) {
+ if (typeof value === 'string') {
+ return fromString(value, encodingOrOffset)
+ }
- if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ if (ArrayBuffer.isView(value)) {
+ return fromArrayLike(value)
}
- Stream.call(this);
-}
+ if (value == null) {
+ throw TypeError(
+ 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+ 'or Array-like Object. Received type ' + (typeof value)
+ )
+ }
-Object.defineProperty(Readable.prototype, 'destroyed', {
- get: function () {
- if (this._readableState === undefined) {
- return false;
- }
- return this._readableState.destroyed;
- },
- set: function (value) {
- // we ignore the value if the stream
- // has not been initialized yet
- if (!this._readableState) {
- return;
- }
+ if (isInstance(value, ArrayBuffer) ||
+ (value && isInstance(value.buffer, ArrayBuffer))) {
+ return fromArrayBuffer(value, encodingOrOffset, length)
+ }
- // backward compatibility, the user is explicitly
- // managing destroyed
- this._readableState.destroyed = value;
+ if (typeof value === 'number') {
+ throw new TypeError(
+ 'The "value" argument must not be of type number. Received type number'
+ )
}
-});
-Readable.prototype.destroy = destroyImpl.destroy;
-Readable.prototype._undestroy = destroyImpl.undestroy;
-Readable.prototype._destroy = function (err, cb) {
- this.push(null);
- cb(err);
-};
+ var valueOf = value.valueOf && value.valueOf()
+ if (valueOf != null && valueOf !== value) {
+ return Buffer.from(valueOf, encodingOrOffset, length)
+ }
-// Manually shove something into the read() buffer.
-// This returns true if the highWaterMark has not been hit yet,
-// similar to how Writable.write() returns true if you should
-// write() some more.
-Readable.prototype.push = function (chunk, encoding) {
- var state = this._readableState;
- var skipChunkCheck;
+ var b = fromObject(value)
+ if (b) return b
- if (!state.objectMode) {
- if (typeof chunk === 'string') {
- encoding = encoding || state.defaultEncoding;
- if (encoding !== state.encoding) {
- chunk = Buffer.from(chunk, encoding);
- encoding = '';
- }
- skipChunkCheck = true;
- }
- } else {
- skipChunkCheck = true;
+ if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
+ typeof value[Symbol.toPrimitive] === 'function') {
+ return Buffer.from(
+ value[Symbol.toPrimitive]('string'), encodingOrOffset, length
+ )
}
- return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
-};
-
-// Unshift should *always* be something directly out of read()
-Readable.prototype.unshift = function (chunk) {
- return readableAddChunk(this, chunk, null, true, false);
-};
+ throw new TypeError(
+ 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+ 'or Array-like Object. Received type ' + (typeof value)
+ )
+}
-function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
- var state = stream._readableState;
- if (chunk === null) {
- state.reading = false;
- onEofChunk(stream, state);
- } else {
- var er;
- if (!skipChunkCheck) er = chunkInvalid(state, chunk);
- if (er) {
- stream.emit('error', er);
- } else if (state.objectMode || chunk && chunk.length > 0) {
- if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
- chunk = _uint8ArrayToBuffer(chunk);
- }
-
- if (addToFront) {
- if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
- } else if (state.ended) {
- stream.emit('error', new Error('stream.push() after EOF'));
- } else {
- state.reading = false;
- if (state.decoder && !encoding) {
- chunk = state.decoder.write(chunk);
- if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
- } else {
- addChunk(stream, state, chunk, false);
- }
- }
- } else if (!addToFront) {
- state.reading = false;
- }
- }
-
- return needMoreData(state);
+/**
+ * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+ * if value is a number.
+ * Buffer.from(str[, encoding])
+ * Buffer.from(array)
+ * Buffer.from(buffer)
+ * Buffer.from(arrayBuffer[, byteOffset[, length]])
+ **/
+Buffer.from = function (value, encodingOrOffset, length) {
+ return from(value, encodingOrOffset, length)
}
-function addChunk(stream, state, chunk, addToFront) {
- if (state.flowing && state.length === 0 && !state.sync) {
- stream.emit('data', chunk);
- stream.read(0);
- } else {
- // update the buffer info.
- state.length += state.objectMode ? 1 : chunk.length;
- if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
+// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
+// https://github.com/feross/buffer/pull/148
+Buffer.prototype.__proto__ = Uint8Array.prototype
+Buffer.__proto__ = Uint8Array
- if (state.needReadable) emitReadable(stream);
+function assertSize (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('"size" argument must be of type number')
+ } else if (size < 0) {
+ throw new RangeError('The value "' + size + '" is invalid for option "size"')
}
- maybeReadMore(stream, state);
}
-function chunkInvalid(state, chunk) {
- var er;
- if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
- er = new TypeError('Invalid non-string/buffer chunk');
+function alloc (size, fill, encoding) {
+ assertSize(size)
+ if (size <= 0) {
+ return createBuffer(size)
}
- return er;
+ if (fill !== undefined) {
+ // Only pay attention to encoding if it's a string. This
+ // prevents accidentally sending in a number that would
+ // be interpretted as a start offset.
+ return typeof encoding === 'string'
+ ? createBuffer(size).fill(fill, encoding)
+ : createBuffer(size).fill(fill)
+ }
+ return createBuffer(size)
}
-// if it's past the high water mark, we can push in some more.
-// Also, if we have no data yet, we can stand some
-// more bytes. This is to work around cases where hwm=0,
-// such as the repl. Also, if the push() triggered a
-// readable event, and the user called read(largeNumber) such that
-// needReadable was set, then we ought to push more, so that another
-// 'readable' event will be triggered.
-function needMoreData(state) {
- return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+/**
+ * Creates a new filled Buffer instance.
+ * alloc(size[, fill[, encoding]])
+ **/
+Buffer.alloc = function (size, fill, encoding) {
+ return alloc(size, fill, encoding)
}
-Readable.prototype.isPaused = function () {
- return this._readableState.flowing === false;
-};
-
-// backwards compatibility.
-Readable.prototype.setEncoding = function (enc) {
- if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
- this._readableState.decoder = new StringDecoder(enc);
- this._readableState.encoding = enc;
- return this;
-};
+function allocUnsafe (size) {
+ assertSize(size)
+ return createBuffer(size < 0 ? 0 : checked(size) | 0)
+}
-// Don't raise the hwm > 8MB
-var MAX_HWM = 0x800000;
-function computeNewHighWaterMark(n) {
- if (n >= MAX_HWM) {
- n = MAX_HWM;
- } else {
- // Get the next highest power of 2 to prevent increasing hwm excessively in
- // tiny amounts
- n--;
- n |= n >>> 1;
- n |= n >>> 2;
- n |= n >>> 4;
- n |= n >>> 8;
- n |= n >>> 16;
- n++;
- }
- return n;
+/**
+ * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+ * */
+Buffer.allocUnsafe = function (size) {
+ return allocUnsafe(size)
+}
+/**
+ * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+ */
+Buffer.allocUnsafeSlow = function (size) {
+ return allocUnsafe(size)
}
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function howMuchToRead(n, state) {
- if (n <= 0 || state.length === 0 && state.ended) return 0;
- if (state.objectMode) return 1;
- if (n !== n) {
- // Only flow one buffer at a time
- if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
+function fromString (string, encoding) {
+ if (typeof encoding !== 'string' || encoding === '') {
+ encoding = 'utf8'
}
- // If we're asking for more than the current hwm, then raise the hwm.
- if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
- if (n <= state.length) return n;
- // Don't have enough
- if (!state.ended) {
- state.needReadable = true;
- return 0;
+
+ if (!Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
}
- return state.length;
-}
-// you can override either this method, or the async _read(n) below.
-Readable.prototype.read = function (n) {
- debug('read', n);
- n = parseInt(n, 10);
- var state = this._readableState;
- var nOrig = n;
+ var length = byteLength(string, encoding) | 0
+ var buf = createBuffer(length)
- if (n !== 0) state.emittedReadable = false;
+ var actual = buf.write(string, encoding)
- // if we're doing read(0) to trigger a readable event, but we
- // already have a bunch of data in the buffer, then just trigger
- // the 'readable' event and move on.
- if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
- debug('read: emitReadable', state.length, state.ended);
- if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
- return null;
+ if (actual !== length) {
+ // Writing a hex string, for example, that contains invalid characters will
+ // cause everything after the first invalid character to be ignored. (e.g.
+ // 'abxxcd' will be treated as 'ab')
+ buf = buf.slice(0, actual)
}
- n = howMuchToRead(n, state);
+ return buf
+}
- // if we've ended, and we're now clear, then finish it up.
- if (n === 0 && state.ended) {
- if (state.length === 0) endReadable(this);
- return null;
+function fromArrayLike (array) {
+ var length = array.length < 0 ? 0 : checked(array.length) | 0
+ var buf = createBuffer(length)
+ for (var i = 0; i < length; i += 1) {
+ buf[i] = array[i] & 255
}
+ return buf
+}
- // All the actual chunk generation logic needs to be
- // *below* the call to _read. The reason is that in certain
- // synthetic stream cases, such as passthrough streams, _read
- // may be a completely synchronous operation which may change
- // the state of the read buffer, providing enough data when
- // before there was *not* enough.
- //
- // So, the steps are:
- // 1. Figure out what the state of things will be after we do
- // a read from the buffer.
- //
- // 2. If that resulting state will trigger a _read, then call _read.
- // Note that this may be asynchronous, or synchronous. Yes, it is
- // deeply ugly to write APIs this way, but that still doesn't mean
- // that the Readable class should behave improperly, as streams are
- // designed to be sync/async agnostic.
- // Take note if the _read call is sync or async (ie, if the read call
- // has returned yet), so that we know whether or not it's safe to emit
- // 'readable' etc.
- //
- // 3. Actually pull the requested chunks out of the buffer and return.
-
- // if we need a readable event, then we need to do some reading.
- var doRead = state.needReadable;
- debug('need readable', doRead);
+function fromArrayBuffer (array, byteOffset, length) {
+ if (byteOffset < 0 || array.byteLength < byteOffset) {
+ throw new RangeError('"offset" is outside of buffer bounds')
+ }
- // if we currently have less than the highWaterMark, then also read some
- if (state.length === 0 || state.length - n < state.highWaterMark) {
- doRead = true;
- debug('length less than watermark', doRead);
+ if (array.byteLength < byteOffset + (length || 0)) {
+ throw new RangeError('"length" is outside of buffer bounds')
}
- // however, if we've ended, then there's no point, and if we're already
- // reading, then it's unnecessary.
- if (state.ended || state.reading) {
- doRead = false;
- debug('reading or ended', doRead);
- } else if (doRead) {
- debug('do read');
- state.reading = true;
- state.sync = true;
- // if the length is currently zero, then we *need* a readable event.
- if (state.length === 0) state.needReadable = true;
- // call internal read method
- this._read(state.highWaterMark);
- state.sync = false;
- // If _read pushed data synchronously, then `reading` will be false,
- // and we need to re-evaluate how much data we can return to the user.
- if (!state.reading) n = howMuchToRead(nOrig, state);
+ var buf
+ if (byteOffset === undefined && length === undefined) {
+ buf = new Uint8Array(array)
+ } else if (length === undefined) {
+ buf = new Uint8Array(array, byteOffset)
+ } else {
+ buf = new Uint8Array(array, byteOffset, length)
}
- var ret;
- if (n > 0) ret = fromList(n, state);else ret = null;
+ // Return an augmented `Uint8Array` instance
+ buf.__proto__ = Buffer.prototype
+ return buf
+}
- if (ret === null) {
- state.needReadable = true;
- n = 0;
- } else {
- state.length -= n;
- }
+function fromObject (obj) {
+ if (Buffer.isBuffer(obj)) {
+ var len = checked(obj.length) | 0
+ var buf = createBuffer(len)
- if (state.length === 0) {
- // If we have nothing in the buffer, then we want to know
- // as soon as we *do* get something into the buffer.
- if (!state.ended) state.needReadable = true;
+ if (buf.length === 0) {
+ return buf
+ }
- // If we tried to read() past the EOF, then emit end on the next tick.
- if (nOrig !== n && state.ended) endReadable(this);
+ obj.copy(buf, 0, 0, len)
+ return buf
}
- if (ret !== null) this.emit('data', ret);
-
- return ret;
-};
-
-function onEofChunk(stream, state) {
- if (state.ended) return;
- if (state.decoder) {
- var chunk = state.decoder.end();
- if (chunk && chunk.length) {
- state.buffer.push(chunk);
- state.length += state.objectMode ? 1 : chunk.length;
+ if (obj.length !== undefined) {
+ if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
+ return createBuffer(0)
}
+ return fromArrayLike(obj)
}
- state.ended = true;
-
- // emit 'readable' now to make sure it gets picked up.
- emitReadable(stream);
-}
-// Don't emit readable right away in sync mode, because this can trigger
-// another read() call => stack overflow. This way, it might trigger
-// a nextTick recursion warning, but that's not so bad.
-function emitReadable(stream) {
- var state = stream._readableState;
- state.needReadable = false;
- if (!state.emittedReadable) {
- debug('emitReadable', state.flowing);
- state.emittedReadable = true;
- if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
+ if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+ return fromArrayLike(obj.data)
}
}
-function emitReadable_(stream) {
- debug('emit readable');
- stream.emit('readable');
- flow(stream);
-}
-
-// at this point, the user has presumably seen the 'readable' event,
-// and called read() to consume some data. that may have triggered
-// in turn another _read(n) call, in which case reading = true if
-// it's in progress.
-// However, if we're not ended, or reading, and the length < hwm,
-// then go ahead and try to read some more preemptively.
-function maybeReadMore(stream, state) {
- if (!state.readingMore) {
- state.readingMore = true;
- pna.nextTick(maybeReadMore_, stream, state);
+function checked (length) {
+ // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
+ // length is NaN (which is otherwise coerced to zero.)
+ if (length >= K_MAX_LENGTH) {
+ throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+ 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
}
+ return length | 0
}
-function maybeReadMore_(stream, state) {
- var len = state.length;
- while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
- debug('maybeReadMore read 0');
- stream.read(0);
- if (len === state.length)
- // didn't get any data, stop spinning.
- break;else len = state.length;
+function SlowBuffer (length) {
+ if (+length != length) { // eslint-disable-line eqeqeq
+ length = 0
}
- state.readingMore = false;
+ return Buffer.alloc(+length)
}
-// abstract method. to be overridden in specific implementation classes.
-// call cb(er, data) where data is <= n in length.
-// for virtual (non-string, non-buffer) streams, "length" is somewhat
-// arbitrary, and perhaps not very meaningful.
-Readable.prototype._read = function (n) {
- this.emit('error', new Error('_read() is not implemented'));
-};
-
-Readable.prototype.pipe = function (dest, pipeOpts) {
- var src = this;
- var state = this._readableState;
+Buffer.isBuffer = function isBuffer (b) {
+ return b != null && b._isBuffer === true &&
+ b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
+}
- switch (state.pipesCount) {
- case 0:
- state.pipes = dest;
- break;
- case 1:
- state.pipes = [state.pipes, dest];
- break;
- default:
- state.pipes.push(dest);
- break;
+Buffer.compare = function compare (a, b) {
+ if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
+ if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
+ if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+ throw new TypeError(
+ 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+ )
}
- state.pipesCount += 1;
- debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
- var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+ if (a === b) return 0
- var endFn = doEnd ? onend : unpipe;
- if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
+ var x = a.length
+ var y = b.length
- dest.on('unpipe', onunpipe);
- function onunpipe(readable, unpipeInfo) {
- debug('onunpipe');
- if (readable === src) {
- if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
- unpipeInfo.hasUnpiped = true;
- cleanup();
- }
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i]
+ y = b[i]
+ break
}
}
- function onend() {
- debug('onend');
- dest.end();
- }
-
- // when the dest drains, it reduces the awaitDrain counter
- // on the source. This would be more elegant with a .once()
- // handler in flow(), but adding and removing repeatedly is
- // too slow.
- var ondrain = pipeOnDrain(src);
- dest.on('drain', ondrain);
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
- var cleanedUp = false;
- function cleanup() {
- debug('cleanup');
- // cleanup event handlers once the pipe is broken
- dest.removeListener('close', onclose);
- dest.removeListener('finish', onfinish);
- dest.removeListener('drain', ondrain);
- dest.removeListener('error', onerror);
- dest.removeListener('unpipe', onunpipe);
- src.removeListener('end', onend);
- src.removeListener('end', unpipe);
- src.removeListener('data', ondata);
+Buffer.isEncoding = function isEncoding (encoding) {
+ switch (String(encoding).toLowerCase()) {
+ case 'hex':
+ case 'utf8':
+ case 'utf-8':
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ case 'base64':
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return true
+ default:
+ return false
+ }
+}
- cleanedUp = true;
+Buffer.concat = function concat (list, length) {
+ if (!Array.isArray(list)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
- // if the reader is waiting for a drain event from this
- // specific writer, then it would cause it to never start
- // flowing again.
- // So, if this is awaiting a drain, then we just call it now.
- // If we don't know, then assume that we are waiting for one.
- if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+ if (list.length === 0) {
+ return Buffer.alloc(0)
}
- // If the user pushes more data while we're writing to dest then we'll end up
- // in ondata again. However, we only want to increase awaitDrain once because
- // dest will only emit one 'drain' event for the multiple writes.
- // => Introduce a guard on increasing awaitDrain.
- var increasedAwaitDrain = false;
- src.on('data', ondata);
- function ondata(chunk) {
- debug('ondata');
- increasedAwaitDrain = false;
- var ret = dest.write(chunk);
- if (false === ret && !increasedAwaitDrain) {
- // If the user unpiped during `dest.write()`, it is possible
- // to get stuck in a permanently paused state if that write
- // also returned false.
- // => Check whether `dest` is still a piping destination.
- if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
- debug('false write response, pause', src._readableState.awaitDrain);
- src._readableState.awaitDrain++;
- increasedAwaitDrain = true;
- }
- src.pause();
+ var i
+ if (length === undefined) {
+ length = 0
+ for (i = 0; i < list.length; ++i) {
+ length += list[i].length
}
}
- // if the dest has an error, then stop piping into it.
- // however, don't suppress the throwing behavior for this.
- function onerror(er) {
- debug('onerror', er);
- unpipe();
- dest.removeListener('error', onerror);
- if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+ var buffer = Buffer.allocUnsafe(length)
+ var pos = 0
+ for (i = 0; i < list.length; ++i) {
+ var buf = list[i]
+ if (isInstance(buf, Uint8Array)) {
+ buf = Buffer.from(buf)
+ }
+ if (!Buffer.isBuffer(buf)) {
+ throw new TypeError('"list" argument must be an Array of Buffers')
+ }
+ buf.copy(buffer, pos)
+ pos += buf.length
}
+ return buffer
+}
- // Make sure our error handler is attached before userland ones.
- prependListener(dest, 'error', onerror);
-
- // Both close and finish should trigger unpipe, but only once.
- function onclose() {
- dest.removeListener('finish', onfinish);
- unpipe();
- }
- dest.once('close', onclose);
- function onfinish() {
- debug('onfinish');
- dest.removeListener('close', onclose);
- unpipe();
+function byteLength (string, encoding) {
+ if (Buffer.isBuffer(string)) {
+ return string.length
}
- dest.once('finish', onfinish);
-
- function unpipe() {
- debug('unpipe');
- src.unpipe(dest);
+ if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+ return string.byteLength
}
-
- // tell the dest that it's being piped to
- dest.emit('pipe', src);
-
- // start the flow if it hasn't been started already.
- if (!state.flowing) {
- debug('pipe resume');
- src.resume();
+ if (typeof string !== 'string') {
+ throw new TypeError(
+ 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
+ 'Received type ' + typeof string
+ )
}
- return dest;
-};
+ var len = string.length
+ var mustMatch = (arguments.length > 2 && arguments[2] === true)
+ if (!mustMatch && len === 0) return 0
-function pipeOnDrain(src) {
- return function () {
- var state = src._readableState;
- debug('pipeOnDrain', state.awaitDrain);
- if (state.awaitDrain) state.awaitDrain--;
- if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
- state.flowing = true;
- flow(src);
+ // Use a for loop to avoid recursion
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'ascii':
+ case 'latin1':
+ case 'binary':
+ return len
+ case 'utf8':
+ case 'utf-8':
+ return utf8ToBytes(string).length
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return len * 2
+ case 'hex':
+ return len >>> 1
+ case 'base64':
+ return base64ToBytes(string).length
+ default:
+ if (loweredCase) {
+ return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
+ }
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
}
- };
+ }
}
+Buffer.byteLength = byteLength
-Readable.prototype.unpipe = function (dest) {
- var state = this._readableState;
- var unpipeInfo = { hasUnpiped: false };
-
- // if we're not piping anywhere, then do nothing.
- if (state.pipesCount === 0) return this;
+function slowToString (encoding, start, end) {
+ var loweredCase = false
- // just one destination. most common case.
- if (state.pipesCount === 1) {
- // passed in one, but it's not the right one.
- if (dest && dest !== state.pipes) return this;
+ // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+ // property of a typed array.
- if (!dest) dest = state.pipes;
+ // This behaves neither like String nor Uint8Array in that we set start/end
+ // to their upper/lower bounds if the value passed is out of range.
+ // undefined is handled specially as per ECMA-262 6th Edition,
+ // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+ if (start === undefined || start < 0) {
+ start = 0
+ }
+ // Return early if start > this.length. Done here to prevent potential uint32
+ // coercion fail below.
+ if (start > this.length) {
+ return ''
+ }
- // got a match.
- state.pipes = null;
- state.pipesCount = 0;
- state.flowing = false;
- if (dest) dest.emit('unpipe', this, unpipeInfo);
- return this;
+ if (end === undefined || end > this.length) {
+ end = this.length
}
- // slow case. multiple pipe destinations.
+ if (end <= 0) {
+ return ''
+ }
- if (!dest) {
- // remove all.
- var dests = state.pipes;
- var len = state.pipesCount;
- state.pipes = null;
- state.pipesCount = 0;
- state.flowing = false;
+ // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+ end >>>= 0
+ start >>>= 0
- for (var i = 0; i < len; i++) {
- dests[i].emit('unpipe', this, unpipeInfo);
- }return this;
+ if (end <= start) {
+ return ''
}
- // try to find the right one.
- var index = indexOf(state.pipes, dest);
- if (index === -1) return this;
+ if (!encoding) encoding = 'utf8'
- state.pipes.splice(index, 1);
- state.pipesCount -= 1;
- if (state.pipesCount === 1) state.pipes = state.pipes[0];
+ while (true) {
+ switch (encoding) {
+ case 'hex':
+ return hexSlice(this, start, end)
- dest.emit('unpipe', this, unpipeInfo);
+ case 'utf8':
+ case 'utf-8':
+ return utf8Slice(this, start, end)
- return this;
-};
+ case 'ascii':
+ return asciiSlice(this, start, end)
-// set up data events if they are asked for
-// Ensure readable listeners eventually get something
-Readable.prototype.on = function (ev, fn) {
- var res = Stream.prototype.on.call(this, ev, fn);
+ case 'latin1':
+ case 'binary':
+ return latin1Slice(this, start, end)
- if (ev === 'data') {
- // Start flowing on next tick if stream isn't explicitly paused
- if (this._readableState.flowing !== false) this.resume();
- } else if (ev === 'readable') {
- var state = this._readableState;
- if (!state.endEmitted && !state.readableListening) {
- state.readableListening = state.needReadable = true;
- state.emittedReadable = false;
- if (!state.reading) {
- pna.nextTick(nReadingNextTick, this);
- } else if (state.length) {
- emitReadable(this);
- }
+ case 'base64':
+ return base64Slice(this, start, end)
+
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return utf16leSlice(this, start, end)
+
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = (encoding + '').toLowerCase()
+ loweredCase = true
}
}
+}
- return res;
-};
-Readable.prototype.addListener = Readable.prototype.on;
+// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+// reliably in a browserify context because there could be multiple different
+// copies of the 'buffer' package in use. This method works even for Buffer
+// instances that were created from another copy of the `buffer` package.
+// See: https://github.com/feross/buffer/issues/154
+Buffer.prototype._isBuffer = true
-function nReadingNextTick(self) {
- debug('readable nexttick read 0');
- self.read(0);
+function swap (b, n, m) {
+ var i = b[n]
+ b[n] = b[m]
+ b[m] = i
}
-// pause() and resume() are remnants of the legacy readable stream API
-// If the user uses them, then switch into old mode.
-Readable.prototype.resume = function () {
- var state = this._readableState;
- if (!state.flowing) {
- debug('resume');
- state.flowing = true;
- resume(this, state);
+Buffer.prototype.swap16 = function swap16 () {
+ var len = this.length
+ if (len % 2 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 16-bits')
}
- return this;
-};
-
-function resume(stream, state) {
- if (!state.resumeScheduled) {
- state.resumeScheduled = true;
- pna.nextTick(resume_, stream, state);
+ for (var i = 0; i < len; i += 2) {
+ swap(this, i, i + 1)
}
+ return this
}
-function resume_(stream, state) {
- if (!state.reading) {
- debug('resume read 0');
- stream.read(0);
+Buffer.prototype.swap32 = function swap32 () {
+ var len = this.length
+ if (len % 4 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 32-bits')
}
-
- state.resumeScheduled = false;
- state.awaitDrain = 0;
- stream.emit('resume');
- flow(stream);
- if (state.flowing && !state.reading) stream.read(0);
-}
-
-Readable.prototype.pause = function () {
- debug('call pause flowing=%j', this._readableState.flowing);
- if (false !== this._readableState.flowing) {
- debug('pause');
- this._readableState.flowing = false;
- this.emit('pause');
+ for (var i = 0; i < len; i += 4) {
+ swap(this, i, i + 3)
+ swap(this, i + 1, i + 2)
}
- return this;
-};
-
-function flow(stream) {
- var state = stream._readableState;
- debug('flow', state.flowing);
- while (state.flowing && stream.read() !== null) {}
+ return this
}
-// wrap an old-style stream as the async data source.
-// This is *not* part of the readable stream interface.
-// It is an ugly unfortunate mess of history.
-Readable.prototype.wrap = function (stream) {
- var _this = this;
+Buffer.prototype.swap64 = function swap64 () {
+ var len = this.length
+ if (len % 8 !== 0) {
+ throw new RangeError('Buffer size must be a multiple of 64-bits')
+ }
+ for (var i = 0; i < len; i += 8) {
+ swap(this, i, i + 7)
+ swap(this, i + 1, i + 6)
+ swap(this, i + 2, i + 5)
+ swap(this, i + 3, i + 4)
+ }
+ return this
+}
- var state = this._readableState;
- var paused = false;
+Buffer.prototype.toString = function toString () {
+ var length = this.length
+ if (length === 0) return ''
+ if (arguments.length === 0) return utf8Slice(this, 0, length)
+ return slowToString.apply(this, arguments)
+}
- stream.on('end', function () {
- debug('wrapped end');
- if (state.decoder && !state.ended) {
- var chunk = state.decoder.end();
- if (chunk && chunk.length) _this.push(chunk);
- }
+Buffer.prototype.toLocaleString = Buffer.prototype.toString
- _this.push(null);
- });
+Buffer.prototype.equals = function equals (b) {
+ if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+ if (this === b) return true
+ return Buffer.compare(this, b) === 0
+}
- stream.on('data', function (chunk) {
- debug('wrapped data');
- if (state.decoder) chunk = state.decoder.write(chunk);
+Buffer.prototype.inspect = function inspect () {
+ var str = ''
+ var max = exports.INSPECT_MAX_BYTES
+ str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
+ if (this.length > max) str += ' ... '
+ return '<Buffer ' + str + '>'
+}
- // don't skip over falsy values in objectMode
- if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
+Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
+ if (isInstance(target, Uint8Array)) {
+ target = Buffer.from(target, target.offset, target.byteLength)
+ }
+ if (!Buffer.isBuffer(target)) {
+ throw new TypeError(
+ 'The "target" argument must be one of type Buffer or Uint8Array. ' +
+ 'Received type ' + (typeof target)
+ )
+ }
- var ret = _this.push(chunk);
- if (!ret) {
- paused = true;
- stream.pause();
- }
- });
+ if (start === undefined) {
+ start = 0
+ }
+ if (end === undefined) {
+ end = target ? target.length : 0
+ }
+ if (thisStart === undefined) {
+ thisStart = 0
+ }
+ if (thisEnd === undefined) {
+ thisEnd = this.length
+ }
- // proxy all the other methods.
- // important when wrapping filters and duplexes.
- for (var i in stream) {
- if (this[i] === undefined && typeof stream[i] === 'function') {
- this[i] = function (method) {
- return function () {
- return stream[method].apply(stream, arguments);
- };
- }(i);
- }
+ if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+ throw new RangeError('out of range index')
}
- // proxy certain important events.
- for (var n = 0; n < kProxyEvents.length; n++) {
- stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+ if (thisStart >= thisEnd && start >= end) {
+ return 0
+ }
+ if (thisStart >= thisEnd) {
+ return -1
+ }
+ if (start >= end) {
+ return 1
}
- // when we try to consume some more bytes, simply unpause the
- // underlying stream.
- this._read = function (n) {
- debug('wrapped _read', n);
- if (paused) {
- paused = false;
- stream.resume();
- }
- };
+ start >>>= 0
+ end >>>= 0
+ thisStart >>>= 0
+ thisEnd >>>= 0
- return this;
-};
+ if (this === target) return 0
-Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
- // making it explicit this property is not enumerable
- // because otherwise some prototype manipulation in
- // userland will fail
- enumerable: false,
- get: function () {
- return this._readableState.highWaterMark;
+ var x = thisEnd - thisStart
+ var y = end - start
+ var len = Math.min(x, y)
+
+ var thisCopy = this.slice(thisStart, thisEnd)
+ var targetCopy = target.slice(start, end)
+
+ for (var i = 0; i < len; ++i) {
+ if (thisCopy[i] !== targetCopy[i]) {
+ x = thisCopy[i]
+ y = targetCopy[i]
+ break
+ }
}
-});
-// exposed for testing purposes only.
-Readable._fromList = fromList;
+ if (x < y) return -1
+ if (y < x) return 1
+ return 0
+}
-// Pluck off n bytes from an array of buffers.
-// Length is the combined lengths of all the buffers in the list.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function fromList(n, state) {
- // nothing buffered
- if (state.length === 0) return null;
+// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+//
+// Arguments:
+// - buffer - a Buffer to search
+// - val - a string, Buffer, or number
+// - byteOffset - an index into `buffer`; will be clamped to an int32
+// - encoding - an optional encoding, relevant is val is a string
+// - dir - true for indexOf, false for lastIndexOf
+function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
+ // Empty buffer means no match
+ if (buffer.length === 0) return -1
- var ret;
- if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
- // read it all, truncate the list
- if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
- state.buffer.clear();
- } else {
- // read part of list
- ret = fromListPartial(n, state.buffer, state.decoder);
+ // Normalize byteOffset
+ if (typeof byteOffset === 'string') {
+ encoding = byteOffset
+ byteOffset = 0
+ } else if (byteOffset > 0x7fffffff) {
+ byteOffset = 0x7fffffff
+ } else if (byteOffset < -0x80000000) {
+ byteOffset = -0x80000000
+ }
+ byteOffset = +byteOffset // Coerce to Number.
+ if (numberIsNaN(byteOffset)) {
+ // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+ byteOffset = dir ? 0 : (buffer.length - 1)
}
- return ret;
-}
+ // Normalize byteOffset: negative offsets start from the end of the buffer
+ if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+ if (byteOffset >= buffer.length) {
+ if (dir) return -1
+ else byteOffset = buffer.length - 1
+ } else if (byteOffset < 0) {
+ if (dir) byteOffset = 0
+ else return -1
+ }
-// Extracts only enough buffered data to satisfy the amount requested.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function fromListPartial(n, list, hasStrings) {
- var ret;
- if (n < list.head.data.length) {
- // slice is the same for buffers and strings
- ret = list.head.data.slice(0, n);
- list.head.data = list.head.data.slice(n);
- } else if (n === list.head.data.length) {
- // first chunk is a perfect match
- ret = list.shift();
- } else {
- // result spans more than one buffer
- ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
+ // Normalize val
+ if (typeof val === 'string') {
+ val = Buffer.from(val, encoding)
}
- return ret;
-}
-// Copies a specified amount of characters from the list of buffered data
-// chunks.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function copyFromBufferString(n, list) {
- var p = list.head;
- var c = 1;
- var ret = p.data;
- n -= ret.length;
- while (p = p.next) {
- var str = p.data;
- var nb = n > str.length ? str.length : n;
- if (nb === str.length) ret += str;else ret += str.slice(0, n);
- n -= nb;
- if (n === 0) {
- if (nb === str.length) {
- ++c;
- if (p.next) list.head = p.next;else list.head = list.tail = null;
+ // Finally, search either indexOf (if dir is true) or lastIndexOf
+ if (Buffer.isBuffer(val)) {
+ // Special case: looking for empty string/buffer always fails
+ if (val.length === 0) {
+ return -1
+ }
+ return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+ } else if (typeof val === 'number') {
+ val = val & 0xFF // Search for a byte value [0-255]
+ if (typeof Uint8Array.prototype.indexOf === 'function') {
+ if (dir) {
+ return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
} else {
- list.head = p;
- p.data = str.slice(nb);
+ return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
}
- break;
}
- ++c;
+ return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
}
- list.length -= c;
- return ret;
+
+ throw new TypeError('val must be string, number or Buffer')
}
-// Copies a specified amount of bytes from the list of buffered data chunks.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function copyFromBuffer(n, list) {
- var ret = Buffer.allocUnsafe(n);
- var p = list.head;
- var c = 1;
- p.data.copy(ret);
- n -= p.data.length;
- while (p = p.next) {
- var buf = p.data;
- var nb = n > buf.length ? buf.length : n;
- buf.copy(ret, ret.length - n, 0, nb);
- n -= nb;
- if (n === 0) {
- if (nb === buf.length) {
- ++c;
- if (p.next) list.head = p.next;else list.head = list.tail = null;
+function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
+ var indexSize = 1
+ var arrLength = arr.length
+ var valLength = val.length
+
+ if (encoding !== undefined) {
+ encoding = String(encoding).toLowerCase()
+ if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+ encoding === 'utf16le' || encoding === 'utf-16le') {
+ if (arr.length < 2 || val.length < 2) {
+ return -1
+ }
+ indexSize = 2
+ arrLength /= 2
+ valLength /= 2
+ byteOffset /= 2
+ }
+ }
+
+ function read (buf, i) {
+ if (indexSize === 1) {
+ return buf[i]
+ } else {
+ return buf.readUInt16BE(i * indexSize)
+ }
+ }
+
+ var i
+ if (dir) {
+ var foundIndex = -1
+ for (i = byteOffset; i < arrLength; i++) {
+ if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+ if (foundIndex === -1) foundIndex = i
+ if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
} else {
- list.head = p;
- p.data = buf.slice(nb);
+ if (foundIndex !== -1) i -= i - foundIndex
+ foundIndex = -1
}
- break;
}
- ++c;
+ } else {
+ if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+ for (i = byteOffset; i >= 0; i--) {
+ var found = true
+ for (var j = 0; j < valLength; j++) {
+ if (read(arr, i + j) !== read(val, j)) {
+ found = false
+ break
+ }
+ }
+ if (found) return i
+ }
}
- list.length -= c;
- return ret;
+
+ return -1
}
-function endReadable(stream) {
- var state = stream._readableState;
+Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
+ return this.indexOf(val, byteOffset, encoding) !== -1
+}
- // If we get here before consuming all the bytes, then that is a
- // bug in node. Should never happen.
- if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
+Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+}
- if (!state.endEmitted) {
- state.ended = true;
- pna.nextTick(endReadableNT, state, stream);
- }
+Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
+ return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}
-function endReadableNT(state, stream) {
- // Check that we didn't get one last unshift.
- if (!state.endEmitted && state.length === 0) {
- state.endEmitted = true;
- stream.readable = false;
- stream.emit('end');
+function hexWrite (buf, string, offset, length) {
+ offset = Number(offset) || 0
+ var remaining = buf.length - offset
+ if (!length) {
+ length = remaining
+ } else {
+ length = Number(length)
+ if (length > remaining) {
+ length = remaining
+ }
}
-}
-function indexOf(xs, x) {
- for (var i = 0, l = xs.length; i < l; i++) {
- if (xs[i] === x) return i;
+ var strLen = string.length
+
+ if (length > strLen / 2) {
+ length = strLen / 2
}
- return -1;
+ for (var i = 0; i < length; ++i) {
+ var parsed = parseInt(string.substr(i * 2, 2), 16)
+ if (numberIsNaN(parsed)) return i
+ buf[offset + i] = parsed
+ }
+ return i
}
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./_stream_duplex":10,"./internal/streams/BufferList":15,"./internal/streams/destroy":16,"./internal/streams/stream":17,"_process":70,"core-util-is":2,"events":66,"inherits":3,"isarray":4,"process-nextick-args":9,"safe-buffer":19,"string_decoder/":20,"util":64}],13:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a transform stream is a readable/writable stream where you do
-// something with the data. Sometimes it's called a "filter",
-// but that's not a great name for it, since that implies a thing where
-// some bits pass through, and others are simply ignored. (That would
-// be a valid example of a transform, of course.)
-//
-// While the output is causally related to the input, it's not a
-// necessarily symmetric or synchronous transformation. For example,
-// a zlib stream might take multiple plain-text writes(), and then
-// emit a single compressed chunk some time in the future.
-//
-// Here's how this works:
-//
-// The Transform stream has all the aspects of the readable and writable
-// stream classes. When you write(chunk), that calls _write(chunk,cb)
-// internally, and returns false if there's a lot of pending writes
-// buffered up. When you call read(), that calls _read(n) until
-// there's enough pending readable data buffered up.
-//
-// In a transform stream, the written data is placed in a buffer. When
-// _read(n) is called, it transforms the queued up data, calling the
-// buffered _write cb's as it consumes chunks. If consuming a single
-// written chunk would result in multiple output chunks, then the first
-// outputted bit calls the readcb, and subsequent chunks just go into
-// the read buffer, and will cause it to emit 'readable' if necessary.
-//
-// This way, back-pressure is actually determined by the reading side,
-// since _read has to be called to start processing a new chunk. However,
-// a pathological inflate type of transform can cause excessive buffering
-// here. For example, imagine a stream where every byte of input is
-// interpreted as an integer from 0-255, and then results in that many
-// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
-// 1kb of data being output. In this case, you could write a very small
-// amount of input, and end up with a very large amount of output. In
-// such a pathological inflating mechanism, there'd be no way to tell
-// the system to stop doing the transform. A single 4MB write could
-// cause the system to run out of memory.
-//
-// However, even in such a pathological case, only a single written chunk
-// would be consumed, and then the rest would wait (un-transformed) until
-// the results of the previous transformed chunk were consumed.
-'use strict';
+function utf8Write (buf, string, offset, length) {
+ return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+}
-module.exports = Transform;
+function asciiWrite (buf, string, offset, length) {
+ return blitBuffer(asciiToBytes(string), buf, offset, length)
+}
-var Duplex = require('./_stream_duplex');
+function latin1Write (buf, string, offset, length) {
+ return asciiWrite(buf, string, offset, length)
+}
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
+function base64Write (buf, string, offset, length) {
+ return blitBuffer(base64ToBytes(string), buf, offset, length)
+}
-util.inherits(Transform, Duplex);
+function ucs2Write (buf, string, offset, length) {
+ return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+}
-function afterTransform(er, data) {
- var ts = this._transformState;
- ts.transforming = false;
+Buffer.prototype.write = function write (string, offset, length, encoding) {
+ // Buffer#write(string)
+ if (offset === undefined) {
+ encoding = 'utf8'
+ length = this.length
+ offset = 0
+ // Buffer#write(string, encoding)
+ } else if (length === undefined && typeof offset === 'string') {
+ encoding = offset
+ length = this.length
+ offset = 0
+ // Buffer#write(string, offset[, length][, encoding])
+ } else if (isFinite(offset)) {
+ offset = offset >>> 0
+ if (isFinite(length)) {
+ length = length >>> 0
+ if (encoding === undefined) encoding = 'utf8'
+ } else {
+ encoding = length
+ length = undefined
+ }
+ } else {
+ throw new Error(
+ 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+ )
+ }
- var cb = ts.writecb;
+ var remaining = this.length - offset
+ if (length === undefined || length > remaining) length = remaining
- if (!cb) {
- return this.emit('error', new Error('write callback called multiple times'));
+ if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+ throw new RangeError('Attempt to write outside buffer bounds')
}
- ts.writechunk = null;
- ts.writecb = null;
-
- if (data != null) // single equals check for both `null` and `undefined`
- this.push(data);
+ if (!encoding) encoding = 'utf8'
- cb(er);
+ var loweredCase = false
+ for (;;) {
+ switch (encoding) {
+ case 'hex':
+ return hexWrite(this, string, offset, length)
- var rs = this._readableState;
- rs.reading = false;
- if (rs.needReadable || rs.length < rs.highWaterMark) {
- this._read(rs.highWaterMark);
- }
-}
-
-function Transform(options) {
- if (!(this instanceof Transform)) return new Transform(options);
-
- Duplex.call(this, options);
+ case 'utf8':
+ case 'utf-8':
+ return utf8Write(this, string, offset, length)
- this._transformState = {
- afterTransform: afterTransform.bind(this),
- needTransform: false,
- transforming: false,
- writecb: null,
- writechunk: null,
- writeencoding: null
- };
+ case 'ascii':
+ return asciiWrite(this, string, offset, length)
- // start out asking for a readable event once data is transformed.
- this._readableState.needReadable = true;
+ case 'latin1':
+ case 'binary':
+ return latin1Write(this, string, offset, length)
- // we have implemented the _read method, and done the other things
- // that Readable wants before the first _read call, so unset the
- // sync guard flag.
- this._readableState.sync = false;
+ case 'base64':
+ // Warning: maxLength not taken into account in base64Write
+ return base64Write(this, string, offset, length)
- if (options) {
- if (typeof options.transform === 'function') this._transform = options.transform;
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return ucs2Write(this, string, offset, length)
- if (typeof options.flush === 'function') this._flush = options.flush;
+ default:
+ if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+ encoding = ('' + encoding).toLowerCase()
+ loweredCase = true
+ }
}
-
- // When the writable side finishes, then flush out anything remaining.
- this.on('prefinish', prefinish);
}
-function prefinish() {
- var _this = this;
+Buffer.prototype.toJSON = function toJSON () {
+ return {
+ type: 'Buffer',
+ data: Array.prototype.slice.call(this._arr || this, 0)
+ }
+}
- if (typeof this._flush === 'function') {
- this._flush(function (er, data) {
- done(_this, er, data);
- });
+function base64Slice (buf, start, end) {
+ if (start === 0 && end === buf.length) {
+ return base64.fromByteArray(buf)
} else {
- done(this, null, null);
+ return base64.fromByteArray(buf.slice(start, end))
}
}
-Transform.prototype.push = function (chunk, encoding) {
- this._transformState.needTransform = false;
- return Duplex.prototype.push.call(this, chunk, encoding);
-};
+function utf8Slice (buf, start, end) {
+ end = Math.min(buf.length, end)
+ var res = []
-// This is the part where you do stuff!
-// override this function in implementation classes.
-// 'chunk' is an input chunk.
-//
-// Call `push(newChunk)` to pass along transformed output
-// to the readable side. You may call 'push' zero or more times.
-//
-// Call `cb(err)` when you are done with this chunk. If you pass
-// an error, then that'll put the hurt on the whole operation. If you
-// never call cb(), then you'll never get another chunk.
-Transform.prototype._transform = function (chunk, encoding, cb) {
- throw new Error('_transform() is not implemented');
-};
+ var i = start
+ while (i < end) {
+ var firstByte = buf[i]
+ var codePoint = null
+ var bytesPerSequence = (firstByte > 0xEF) ? 4
+ : (firstByte > 0xDF) ? 3
+ : (firstByte > 0xBF) ? 2
+ : 1
-Transform.prototype._write = function (chunk, encoding, cb) {
- var ts = this._transformState;
- ts.writecb = cb;
- ts.writechunk = chunk;
- ts.writeencoding = encoding;
- if (!ts.transforming) {
- var rs = this._readableState;
- if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
- }
-};
+ if (i + bytesPerSequence <= end) {
+ var secondByte, thirdByte, fourthByte, tempCodePoint
-// Doesn't matter what the args are here.
-// _transform does all the work.
-// That we got here means that the readable side wants more data.
-Transform.prototype._read = function (n) {
- var ts = this._transformState;
+ switch (bytesPerSequence) {
+ case 1:
+ if (firstByte < 0x80) {
+ codePoint = firstByte
+ }
+ break
+ case 2:
+ secondByte = buf[i + 1]
+ if ((secondByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+ if (tempCodePoint > 0x7F) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 3:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+ if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+ codePoint = tempCodePoint
+ }
+ }
+ break
+ case 4:
+ secondByte = buf[i + 1]
+ thirdByte = buf[i + 2]
+ fourthByte = buf[i + 3]
+ if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+ tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+ if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+ codePoint = tempCodePoint
+ }
+ }
+ }
+ }
- if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
- ts.transforming = true;
- this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
- } else {
- // mark that we need a transform, so that any data that comes in
- // will get processed, now that we've asked for it.
- ts.needTransform = true;
- }
-};
+ if (codePoint === null) {
+ // we did not generate a valid codePoint so insert a
+ // replacement char (U+FFFD) and advance only 1 byte
+ codePoint = 0xFFFD
+ bytesPerSequence = 1
+ } else if (codePoint > 0xFFFF) {
+ // encode to utf16 (surrogate pair dance)
+ codePoint -= 0x10000
+ res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+ codePoint = 0xDC00 | codePoint & 0x3FF
+ }
-Transform.prototype._destroy = function (err, cb) {
- var _this2 = this;
+ res.push(codePoint)
+ i += bytesPerSequence
+ }
- Duplex.prototype._destroy.call(this, err, function (err2) {
- cb(err2);
- _this2.emit('close');
- });
-};
+ return decodeCodePointsArray(res)
+}
-function done(stream, er, data) {
- if (er) return stream.emit('error', er);
+// Based on http://stackoverflow.com/a/22747272/680742, the browser with
+// the lowest limit is Chrome, with 0x10000 args.
+// We go 1 magnitude less, for safety
+var MAX_ARGUMENTS_LENGTH = 0x1000
- if (data != null) // single equals check for both `null` and `undefined`
- stream.push(data);
+function decodeCodePointsArray (codePoints) {
+ var len = codePoints.length
+ if (len <= MAX_ARGUMENTS_LENGTH) {
+ return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+ }
- // if there's nothing in the write buffer, then that means
- // that nothing more will ever be provided
- if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
+ // Decode in chunks to avoid "call stack size exceeded".
+ var res = ''
+ var i = 0
+ while (i < len) {
+ res += String.fromCharCode.apply(
+ String,
+ codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+ )
+ }
+ return res
+}
- if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
+function asciiSlice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
- return stream.push(null);
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i] & 0x7F)
+ }
+ return ret
}
-},{"./_stream_duplex":10,"core-util-is":2,"inherits":3}],14:[function(require,module,exports){
-(function (process,global,setImmediate){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-// A bit simpler than readable streams.
-// Implement an async ._write(chunk, encoding, cb), and it'll handle all
-// the drain event emission and buffering.
+function latin1Slice (buf, start, end) {
+ var ret = ''
+ end = Math.min(buf.length, end)
-'use strict';
+ for (var i = start; i < end; ++i) {
+ ret += String.fromCharCode(buf[i])
+ }
+ return ret
+}
-/*<replacement>*/
+function hexSlice (buf, start, end) {
+ var len = buf.length
-var pna = require('process-nextick-args');
-/*</replacement>*/
+ if (!start || start < 0) start = 0
+ if (!end || end < 0 || end > len) end = len
-module.exports = Writable;
+ var out = ''
+ for (var i = start; i < end; ++i) {
+ out += toHex(buf[i])
+ }
+ return out
+}
-/* <replacement> */
-function WriteReq(chunk, encoding, cb) {
- this.chunk = chunk;
- this.encoding = encoding;
- this.callback = cb;
- this.next = null;
+function utf16leSlice (buf, start, end) {
+ var bytes = buf.slice(start, end)
+ var res = ''
+ for (var i = 0; i < bytes.length; i += 2) {
+ res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
+ }
+ return res
}
-// It seems a linked list but it is not
-// there will be only 2 of these for each stream
-function CorkedRequest(state) {
- var _this = this;
+Buffer.prototype.slice = function slice (start, end) {
+ var len = this.length
+ start = ~~start
+ end = end === undefined ? len : ~~end
- this.next = null;
- this.entry = null;
- this.finish = function () {
- onCorkedFinish(_this, state);
- };
-}
-/* </replacement> */
+ if (start < 0) {
+ start += len
+ if (start < 0) start = 0
+ } else if (start > len) {
+ start = len
+ }
-/*<replacement>*/
-var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
-/*</replacement>*/
+ if (end < 0) {
+ end += len
+ if (end < 0) end = 0
+ } else if (end > len) {
+ end = len
+ }
-/*<replacement>*/
-var Duplex;
-/*</replacement>*/
+ if (end < start) end = start
-Writable.WritableState = WritableState;
+ var newBuf = this.subarray(start, end)
+ // Return an augmented `Uint8Array` instance
+ newBuf.__proto__ = Buffer.prototype
+ return newBuf
+}
-/*<replacement>*/
-var util = require('core-util-is');
-util.inherits = require('inherits');
-/*</replacement>*/
+/*
+ * Need to make sure that buffer isn't trying to write out of bounds.
+ */
+function checkOffset (offset, ext, length) {
+ if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+ if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+}
-/*<replacement>*/
-var internalUtil = {
- deprecate: require('util-deprecate')
-};
-/*</replacement>*/
+Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
-/*<replacement>*/
-var Stream = require('./internal/streams/stream');
-/*</replacement>*/
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
-/*<replacement>*/
+ return val
+}
-var Buffer = require('safe-buffer').Buffer;
-var OurUint8Array = global.Uint8Array || function () {};
-function _uint8ArrayToBuffer(chunk) {
- return Buffer.from(chunk);
+Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ checkOffset(offset, byteLength, this.length)
+ }
+
+ var val = this[offset + --byteLength]
+ var mul = 1
+ while (byteLength > 0 && (mul *= 0x100)) {
+ val += this[offset + --byteLength] * mul
+ }
+
+ return val
}
-function _isUint8Array(obj) {
- return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+
+Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ return this[offset]
}
-/*</replacement>*/
+Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return this[offset] | (this[offset + 1] << 8)
+}
-var destroyImpl = require('./internal/streams/destroy');
+Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ return (this[offset] << 8) | this[offset + 1]
+}
-util.inherits(Writable, Stream);
+Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
-function nop() {}
+ return ((this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16)) +
+ (this[offset + 3] * 0x1000000)
+}
-function WritableState(options, stream) {
- Duplex = Duplex || require('./_stream_duplex');
+Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
- options = options || {};
+ return (this[offset] * 0x1000000) +
+ ((this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ this[offset + 3])
+}
- // Duplex streams are both readable and writable, but share
- // the same options object.
- // However, some cases require setting options to different
- // values for the readable and the writable sides of the duplex stream.
- // These options can be provided separately as readableXXX and writableXXX.
- var isDuplex = stream instanceof Duplex;
+Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
- // object stream flag to indicate whether or not this stream
- // contains buffers or objects.
- this.objectMode = !!options.objectMode;
+ var val = this[offset]
+ var mul = 1
+ var i = 0
+ while (++i < byteLength && (mul *= 0x100)) {
+ val += this[offset + i] * mul
+ }
+ mul *= 0x80
- if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
- // the point at which write() starts returning false
- // Note: 0 is a valid value, means that we always return false if
- // the entire buffer is not flushed immediately on write()
- var hwm = options.highWaterMark;
- var writableHwm = options.writableHighWaterMark;
- var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+ return val
+}
- if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
+Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) checkOffset(offset, byteLength, this.length)
- // cast to ints.
- this.highWaterMark = Math.floor(this.highWaterMark);
+ var i = byteLength
+ var mul = 1
+ var val = this[offset + --i]
+ while (i > 0 && (mul *= 0x100)) {
+ val += this[offset + --i] * mul
+ }
+ mul *= 0x80
- // if _final has been called
- this.finalCalled = false;
+ if (val >= mul) val -= Math.pow(2, 8 * byteLength)
- // drain event flag.
- this.needDrain = false;
- // at the start of calling end()
- this.ending = false;
- // when end() has been called, and returned
- this.ended = false;
- // when 'finish' is emitted
- this.finished = false;
+ return val
+}
- // has it been destroyed
- this.destroyed = false;
+Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 1, this.length)
+ if (!(this[offset] & 0x80)) return (this[offset])
+ return ((0xff - this[offset] + 1) * -1)
+}
- // should we decode strings into buffers before passing to _write?
- // this is here so that some node-core streams can optimize string
- // handling at a lower level.
- var noDecode = options.decodeStrings === false;
- this.decodeStrings = !noDecode;
+Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset] | (this[offset + 1] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
- // Crypto is kind of old and crusty. Historically, its default string
- // encoding is 'binary' so we have to make this configurable.
- // Everything else in the universe uses 'utf8', though.
- this.defaultEncoding = options.defaultEncoding || 'utf8';
+Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 2, this.length)
+ var val = this[offset + 1] | (this[offset] << 8)
+ return (val & 0x8000) ? val | 0xFFFF0000 : val
+}
- // not an actual buffer we keep track of, but a measurement
- // of how much we're waiting to get pushed to some underlying
- // socket or file.
- this.length = 0;
+Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
- // a flag to see when we're in the middle of a write.
- this.writing = false;
+ return (this[offset]) |
+ (this[offset + 1] << 8) |
+ (this[offset + 2] << 16) |
+ (this[offset + 3] << 24)
+}
- // when true all writes will be buffered until .uncork() call
- this.corked = 0;
+Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
- // a flag to be able to tell if the onwrite cb is called immediately,
- // or on a later tick. We set this to true at first, because any
- // actions that shouldn't happen until "later" should generally also
- // not happen before the first write call.
- this.sync = true;
+ return (this[offset] << 24) |
+ (this[offset + 1] << 16) |
+ (this[offset + 2] << 8) |
+ (this[offset + 3])
+}
- // a flag to know if we're processing previously buffered items, which
- // may call the _write() callback in the same tick, so that we don't
- // end up in an overlapped onwrite situation.
- this.bufferProcessing = false;
+Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, true, 23, 4)
+}
- // the callback that's passed to _write(chunk,cb)
- this.onwrite = function (er) {
- onwrite(stream, er);
- };
+Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 4, this.length)
+ return ieee754.read(this, offset, false, 23, 4)
+}
- // the callback that the user supplies to write(chunk,encoding,cb)
- this.writecb = null;
+Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, true, 52, 8)
+}
- // the amount that is being written when _write is called.
- this.writelen = 0;
+Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
+ offset = offset >>> 0
+ if (!noAssert) checkOffset(offset, 8, this.length)
+ return ieee754.read(this, offset, false, 52, 8)
+}
- this.bufferedRequest = null;
- this.lastBufferedRequest = null;
+function checkInt (buf, value, offset, ext, max, min) {
+ if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+ if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+}
- // number of pending user-supplied write callbacks
- // this must be 0 before 'finish' can be emitted
- this.pendingcb = 0;
+Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
- // emit prefinish if the only thing we're waiting for is _write cbs
- // This is relevant for synchronous Transform streams
- this.prefinished = false;
+ var mul = 1
+ var i = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
- // True if the error was already emitted and should not be thrown again
- this.errorEmitted = false;
+ return offset + byteLength
+}
- // count buffered requests
- this.bufferedRequestCount = 0;
+Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ byteLength = byteLength >>> 0
+ if (!noAssert) {
+ var maxBytes = Math.pow(2, 8 * byteLength) - 1
+ checkInt(this, value, offset, byteLength, maxBytes, 0)
+ }
- // allocate the first CorkedRequest, there is always
- // one allocated and free to use, and we maintain at most two
- this.corkedRequestsFree = new CorkedRequest(this);
+ var i = byteLength - 1
+ var mul = 1
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ this[offset + i] = (value / mul) & 0xFF
+ }
+
+ return offset + byteLength
}
-WritableState.prototype.getBuffer = function getBuffer() {
- var current = this.bufferedRequest;
- var out = [];
- while (current) {
- out.push(current);
- current = current.next;
- }
- return out;
-};
+Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+ this[offset] = (value & 0xff)
+ return offset + 1
+}
-(function () {
- try {
- Object.defineProperty(WritableState.prototype, 'buffer', {
- get: internalUtil.deprecate(function () {
- return this.getBuffer();
- }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
- });
- } catch (_) {}
-})();
+Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ return offset + 2
+}
-// Test _writableState for inheritance to account for Duplex streams,
-// whose prototype chain only points to Readable.
-var realHasInstance;
-if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
- realHasInstance = Function.prototype[Symbol.hasInstance];
- Object.defineProperty(Writable, Symbol.hasInstance, {
- value: function (object) {
- if (realHasInstance.call(this, object)) return true;
- if (this !== Writable) return false;
+Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ return offset + 2
+}
- return object && object._writableState instanceof WritableState;
- }
- });
-} else {
- realHasInstance = function (object) {
- return object instanceof this;
- };
+Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ this[offset + 3] = (value >>> 24)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 1] = (value >>> 8)
+ this[offset] = (value & 0xff)
+ return offset + 4
}
-function Writable(options) {
- Duplex = Duplex || require('./_stream_duplex');
+Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ return offset + 4
+}
- // Writable ctor is applied to Duplexes, too.
- // `realHasInstance` is necessary because using plain `instanceof`
- // would return false, as no `_writableState` property is attached.
+Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ var limit = Math.pow(2, (8 * byteLength) - 1)
- // Trying to use the custom `instanceof` for Writable here will also break the
- // Node.js LazyTransform implementation, which has a non-trivial getter for
- // `_writableState` that would lead to infinite recursion.
- if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
- return new Writable(options);
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
}
- this._writableState = new WritableState(options, this);
-
- // legacy.
- this.writable = true;
+ var i = 0
+ var mul = 1
+ var sub = 0
+ this[offset] = value & 0xFF
+ while (++i < byteLength && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ }
- if (options) {
- if (typeof options.write === 'function') this._write = options.write;
+ return offset + byteLength
+}
- if (typeof options.writev === 'function') this._writev = options.writev;
+Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ var limit = Math.pow(2, (8 * byteLength) - 1)
- if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ }
- if (typeof options.final === 'function') this._final = options.final;
+ var i = byteLength - 1
+ var mul = 1
+ var sub = 0
+ this[offset + i] = value & 0xFF
+ while (--i >= 0 && (mul *= 0x100)) {
+ if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+ sub = 1
+ }
+ this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
}
- Stream.call(this);
+ return offset + byteLength
}
-// Otherwise people can pipe Writable streams, which is just wrong.
-Writable.prototype.pipe = function () {
- this.emit('error', new Error('Cannot pipe, not readable'));
-};
-
-function writeAfterEnd(stream, cb) {
- var er = new Error('write after end');
- // TODO: defer error events consistently everywhere, not just the cb
- stream.emit('error', er);
- pna.nextTick(cb, er);
+Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+ if (value < 0) value = 0xff + value + 1
+ this[offset] = (value & 0xff)
+ return offset + 1
}
-// Checks that a user-supplied chunk is valid, especially for the particular
-// mode the stream is in. Currently this means that `null` is never accepted
-// and undefined/non-string values are only allowed in object mode.
-function validChunk(stream, state, chunk, cb) {
- var valid = true;
- var er = false;
+Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ return offset + 2
+}
- if (chunk === null) {
- er = new TypeError('May not write null values to stream');
- } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
- er = new TypeError('Invalid non-string/buffer chunk');
- }
- if (er) {
- stream.emit('error', er);
- pna.nextTick(cb, er);
- valid = false;
- }
- return valid;
+Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+ this[offset] = (value >>> 8)
+ this[offset + 1] = (value & 0xff)
+ return offset + 2
}
-Writable.prototype.write = function (chunk, encoding, cb) {
- var state = this._writableState;
- var ret = false;
- var isBuf = !state.objectMode && _isUint8Array(chunk);
+Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ this[offset] = (value & 0xff)
+ this[offset + 1] = (value >>> 8)
+ this[offset + 2] = (value >>> 16)
+ this[offset + 3] = (value >>> 24)
+ return offset + 4
+}
- if (isBuf && !Buffer.isBuffer(chunk)) {
- chunk = _uint8ArrayToBuffer(chunk);
- }
+Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+ if (value < 0) value = 0xffffffff + value + 1
+ this[offset] = (value >>> 24)
+ this[offset + 1] = (value >>> 16)
+ this[offset + 2] = (value >>> 8)
+ this[offset + 3] = (value & 0xff)
+ return offset + 4
+}
- if (typeof encoding === 'function') {
- cb = encoding;
- encoding = null;
+function checkIEEE754 (buf, value, offset, ext, max, min) {
+ if (offset + ext > buf.length) throw new RangeError('Index out of range')
+ if (offset < 0) throw new RangeError('Index out of range')
+}
+
+function writeFloat (buf, value, offset, littleEndian, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
}
+ ieee754.write(buf, value, offset, littleEndian, 23, 4)
+ return offset + 4
+}
- if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, true, noAssert)
+}
- if (typeof cb !== 'function') cb = nop;
+Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
+ return writeFloat(this, value, offset, false, noAssert)
+}
- if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
- state.pendingcb++;
- ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+function writeDouble (buf, value, offset, littleEndian, noAssert) {
+ value = +value
+ offset = offset >>> 0
+ if (!noAssert) {
+ checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
}
+ ieee754.write(buf, value, offset, littleEndian, 52, 8)
+ return offset + 8
+}
- return ret;
-};
+Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, true, noAssert)
+}
-Writable.prototype.cork = function () {
- var state = this._writableState;
+Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
+ return writeDouble(this, value, offset, false, noAssert)
+}
- state.corked++;
-};
+// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+Buffer.prototype.copy = function copy (target, targetStart, start, end) {
+ if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
+ if (!start) start = 0
+ if (!end && end !== 0) end = this.length
+ if (targetStart >= target.length) targetStart = target.length
+ if (!targetStart) targetStart = 0
+ if (end > 0 && end < start) end = start
-Writable.prototype.uncork = function () {
- var state = this._writableState;
+ // Copy 0 bytes; we're done
+ if (end === start) return 0
+ if (target.length === 0 || this.length === 0) return 0
- if (state.corked) {
- state.corked--;
+ // Fatal error conditions
+ if (targetStart < 0) {
+ throw new RangeError('targetStart out of bounds')
+ }
+ if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
+ if (end < 0) throw new RangeError('sourceEnd out of bounds')
- if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+ // Are we oob?
+ if (end > this.length) end = this.length
+ if (target.length - targetStart < end - start) {
+ end = target.length - targetStart + start
}
-};
-Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
- // node::ParseEncoding() requires lower case.
- if (typeof encoding === 'string') encoding = encoding.toLowerCase();
- if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
- this._writableState.defaultEncoding = encoding;
- return this;
-};
+ var len = end - start
-function decodeChunk(state, chunk, encoding) {
- if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
- chunk = Buffer.from(chunk, encoding);
+ if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
+ // Use built-in when available, missing from IE11
+ this.copyWithin(targetStart, start, end)
+ } else if (this === target && start < targetStart && targetStart < end) {
+ // descending copy from end
+ for (var i = len - 1; i >= 0; --i) {
+ target[i + targetStart] = this[i + start]
+ }
+ } else {
+ Uint8Array.prototype.set.call(
+ target,
+ this.subarray(start, end),
+ targetStart
+ )
}
- return chunk;
+
+ return len
}
-Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
- // making it explicit this property is not enumerable
- // because otherwise some prototype manipulation in
- // userland will fail
- enumerable: false,
- get: function () {
- return this._writableState.highWaterMark;
+// Usage:
+// buffer.fill(number[, offset[, end]])
+// buffer.fill(buffer[, offset[, end]])
+// buffer.fill(string[, offset[, end]][, encoding])
+Buffer.prototype.fill = function fill (val, start, end, encoding) {
+ // Handle string cases:
+ if (typeof val === 'string') {
+ if (typeof start === 'string') {
+ encoding = start
+ start = 0
+ end = this.length
+ } else if (typeof end === 'string') {
+ encoding = end
+ end = this.length
+ }
+ if (encoding !== undefined && typeof encoding !== 'string') {
+ throw new TypeError('encoding must be a string')
+ }
+ if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+ throw new TypeError('Unknown encoding: ' + encoding)
+ }
+ if (val.length === 1) {
+ var code = val.charCodeAt(0)
+ if ((encoding === 'utf8' && code < 128) ||
+ encoding === 'latin1') {
+ // Fast path: If `val` fits into a single byte, use that numeric value.
+ val = code
+ }
+ }
+ } else if (typeof val === 'number') {
+ val = val & 255
}
-});
-// if we're already writing something, then just put this
-// in the queue, and wait our turn. Otherwise, call _write
-// If we return false, then we need a drain event, so set that flag.
-function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
- if (!isBuf) {
- var newChunk = decodeChunk(state, chunk, encoding);
- if (chunk !== newChunk) {
- isBuf = true;
- encoding = 'buffer';
- chunk = newChunk;
- }
+ // Invalid ranges are not set to a default, so can range check early.
+ if (start < 0 || this.length < start || this.length < end) {
+ throw new RangeError('Out of range index')
}
- var len = state.objectMode ? 1 : chunk.length;
- state.length += len;
+ if (end <= start) {
+ return this
+ }
- var ret = state.length < state.highWaterMark;
- // we must ensure that previous needDrain will not be reset to false.
- if (!ret) state.needDrain = true;
+ start = start >>> 0
+ end = end === undefined ? this.length : end >>> 0
- if (state.writing || state.corked) {
- var last = state.lastBufferedRequest;
- state.lastBufferedRequest = {
- chunk: chunk,
- encoding: encoding,
- isBuf: isBuf,
- callback: cb,
- next: null
- };
- if (last) {
- last.next = state.lastBufferedRequest;
- } else {
- state.bufferedRequest = state.lastBufferedRequest;
+ if (!val) val = 0
+
+ var i
+ if (typeof val === 'number') {
+ for (i = start; i < end; ++i) {
+ this[i] = val
}
- state.bufferedRequestCount += 1;
} else {
- doWrite(stream, state, false, len, chunk, encoding, cb);
+ var bytes = Buffer.isBuffer(val)
+ ? val
+ : Buffer.from(val, encoding)
+ var len = bytes.length
+ if (len === 0) {
+ throw new TypeError('The value "' + val +
+ '" is invalid for argument "value"')
+ }
+ for (i = 0; i < end - start; ++i) {
+ this[i + start] = bytes[i % len]
+ }
}
- return ret;
+ return this
}
-function doWrite(stream, state, writev, len, chunk, encoding, cb) {
- state.writelen = len;
- state.writecb = cb;
- state.writing = true;
- state.sync = true;
- if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
- state.sync = false;
-}
+// HELPER FUNCTIONS
+// ================
-function onwriteError(stream, state, sync, er, cb) {
- --state.pendingcb;
+var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
- if (sync) {
- // defer the callback if we are being called synchronously
- // to avoid piling up things on the stack
- pna.nextTick(cb, er);
- // this can emit finish, and it will always happen
- // after error
- pna.nextTick(finishMaybe, stream, state);
- stream._writableState.errorEmitted = true;
- stream.emit('error', er);
- } else {
- // the caller expect this to happen before if
- // it is async
- cb(er);
- stream._writableState.errorEmitted = true;
- stream.emit('error', er);
- // this can emit finish, but finish must
- // always follow error
- finishMaybe(stream, state);
+function base64clean (str) {
+ // Node takes equal signs as end of the Base64 encoding
+ str = str.split('=')[0]
+ // Node strips out invalid characters like \n and \t from the string, base64-js does not
+ str = str.trim().replace(INVALID_BASE64_RE, '')
+ // Node converts strings with length < 2 to ''
+ if (str.length < 2) return ''
+ // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+ while (str.length % 4 !== 0) {
+ str = str + '='
}
+ return str
}
-function onwriteStateUpdate(state) {
- state.writing = false;
- state.writecb = null;
- state.length -= state.writelen;
- state.writelen = 0;
+function toHex (n) {
+ if (n < 16) return '0' + n.toString(16)
+ return n.toString(16)
}
-function onwrite(stream, er) {
- var state = stream._writableState;
- var sync = state.sync;
- var cb = state.writecb;
-
- onwriteStateUpdate(state);
-
- if (er) onwriteError(stream, state, sync, er, cb);else {
- // Check if we're actually ready to finish, but don't emit yet
- var finished = needFinish(state);
-
- if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
- clearBuffer(stream, state);
- }
+function utf8ToBytes (string, units) {
+ units = units || Infinity
+ var codePoint
+ var length = string.length
+ var leadSurrogate = null
+ var bytes = []
- if (sync) {
- /*<replacement>*/
- asyncWrite(afterWrite, stream, state, finished, cb);
- /*</replacement>*/
- } else {
- afterWrite(stream, state, finished, cb);
- }
- }
-}
+ for (var i = 0; i < length; ++i) {
+ codePoint = string.charCodeAt(i)
-function afterWrite(stream, state, finished, cb) {
- if (!finished) onwriteDrain(stream, state);
- state.pendingcb--;
- cb();
- finishMaybe(stream, state);
-}
+ // is surrogate component
+ if (codePoint > 0xD7FF && codePoint < 0xE000) {
+ // last char was a lead
+ if (!leadSurrogate) {
+ // no lead yet
+ if (codePoint > 0xDBFF) {
+ // unexpected trail
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ } else if (i + 1 === length) {
+ // unpaired lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ continue
+ }
-// Must force callback to be called on nextTick, so that we don't
-// emit 'drain' before the write() consumer gets the 'false' return
-// value, and has a chance to attach a 'drain' listener.
-function onwriteDrain(stream, state) {
- if (state.length === 0 && state.needDrain) {
- state.needDrain = false;
- stream.emit('drain');
- }
-}
+ // valid lead
+ leadSurrogate = codePoint
-// if there's something in the buffer waiting, then process it
-function clearBuffer(stream, state) {
- state.bufferProcessing = true;
- var entry = state.bufferedRequest;
+ continue
+ }
- if (stream._writev && entry && entry.next) {
- // Fast case, write everything using _writev()
- var l = state.bufferedRequestCount;
- var buffer = new Array(l);
- var holder = state.corkedRequestsFree;
- holder.entry = entry;
+ // 2 leads in a row
+ if (codePoint < 0xDC00) {
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ leadSurrogate = codePoint
+ continue
+ }
- var count = 0;
- var allBuffers = true;
- while (entry) {
- buffer[count] = entry;
- if (!entry.isBuf) allBuffers = false;
- entry = entry.next;
- count += 1;
+ // valid surrogate pair
+ codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+ } else if (leadSurrogate) {
+ // valid bmp char, but last char was a lead
+ if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
}
- buffer.allBuffers = allBuffers;
- doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+ leadSurrogate = null
- // doWrite is almost always async, defer these to save a bit of time
- // as the hot path ends with doWrite
- state.pendingcb++;
- state.lastBufferedRequest = null;
- if (holder.next) {
- state.corkedRequestsFree = holder.next;
- holder.next = null;
+ // encode utf8
+ if (codePoint < 0x80) {
+ if ((units -= 1) < 0) break
+ bytes.push(codePoint)
+ } else if (codePoint < 0x800) {
+ if ((units -= 2) < 0) break
+ bytes.push(
+ codePoint >> 0x6 | 0xC0,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x10000) {
+ if ((units -= 3) < 0) break
+ bytes.push(
+ codePoint >> 0xC | 0xE0,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
+ } else if (codePoint < 0x110000) {
+ if ((units -= 4) < 0) break
+ bytes.push(
+ codePoint >> 0x12 | 0xF0,
+ codePoint >> 0xC & 0x3F | 0x80,
+ codePoint >> 0x6 & 0x3F | 0x80,
+ codePoint & 0x3F | 0x80
+ )
} else {
- state.corkedRequestsFree = new CorkedRequest(state);
- }
- state.bufferedRequestCount = 0;
- } else {
- // Slow case, write chunks one-by-one
- while (entry) {
- var chunk = entry.chunk;
- var encoding = entry.encoding;
- var cb = entry.callback;
- var len = state.objectMode ? 1 : chunk.length;
-
- doWrite(stream, state, false, len, chunk, encoding, cb);
- entry = entry.next;
- state.bufferedRequestCount--;
- // if we didn't call the onwrite immediately, then
- // it means that we need to wait until it does.
- // also, that means that the chunk and cb are currently
- // being processed, so move the buffer counter past them.
- if (state.writing) {
- break;
- }
+ throw new Error('Invalid code point')
}
-
- if (entry === null) state.lastBufferedRequest = null;
}
- state.bufferedRequest = entry;
- state.bufferProcessing = false;
+ return bytes
}
-Writable.prototype._write = function (chunk, encoding, cb) {
- cb(new Error('_write() is not implemented'));
-};
-
-Writable.prototype._writev = null;
+function asciiToBytes (str) {
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ // Node's code seems to be doing this and not & 0x7F..
+ byteArray.push(str.charCodeAt(i) & 0xFF)
+ }
+ return byteArray
+}
-Writable.prototype.end = function (chunk, encoding, cb) {
- var state = this._writableState;
+function utf16leToBytes (str, units) {
+ var c, hi, lo
+ var byteArray = []
+ for (var i = 0; i < str.length; ++i) {
+ if ((units -= 2) < 0) break
- if (typeof chunk === 'function') {
- cb = chunk;
- chunk = null;
- encoding = null;
- } else if (typeof encoding === 'function') {
- cb = encoding;
- encoding = null;
+ c = str.charCodeAt(i)
+ hi = c >> 8
+ lo = c % 256
+ byteArray.push(lo)
+ byteArray.push(hi)
}
- if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+ return byteArray
+}
- // .end() fully uncorks
- if (state.corked) {
- state.corked = 1;
- this.uncork();
- }
+function base64ToBytes (str) {
+ return base64.toByteArray(base64clean(str))
+}
- // ignore unnecessary end() calls.
- if (!state.ending && !state.finished) endWritable(this, state, cb);
-};
+function blitBuffer (src, dst, offset, length) {
+ for (var i = 0; i < length; ++i) {
+ if ((i + offset >= dst.length) || (i >= src.length)) break
+ dst[i + offset] = src[i]
+ }
+ return i
+}
-function needFinish(state) {
- return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
+// the `instanceof` check but they should be treated as of that type.
+// See: https://github.com/feross/buffer/issues/166
+function isInstance (obj, type) {
+ return obj instanceof type ||
+ (obj != null && obj.constructor != null && obj.constructor.name != null &&
+ obj.constructor.name === type.name)
}
-function callFinal(stream, state) {
- stream._final(function (err) {
- state.pendingcb--;
- if (err) {
- stream.emit('error', err);
- }
- state.prefinished = true;
- stream.emit('prefinish');
- finishMaybe(stream, state);
- });
+function numberIsNaN (obj) {
+ // For IE11 support
+ return obj !== obj // eslint-disable-line no-self-compare
}
-function prefinish(stream, state) {
- if (!state.prefinished && !state.finalCalled) {
- if (typeof stream._final === 'function') {
- state.pendingcb++;
- state.finalCalled = true;
- pna.nextTick(callFinal, stream, state);
- } else {
- state.prefinished = true;
- stream.emit('prefinish');
- }
+
+}).call(this,require("buffer").Buffer)
+},{"base64-js":5,"buffer":8,"ieee754":11}],9:[function(require,module,exports){
+(function (Buffer){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+
+function isArray(arg) {
+ if (Array.isArray) {
+ return Array.isArray(arg);
}
+ return objectToString(arg) === '[object Array]';
}
+exports.isArray = isArray;
-function finishMaybe(stream, state) {
- var need = needFinish(state);
- if (need) {
- prefinish(stream, state);
- if (state.pendingcb === 0) {
- state.finished = true;
- stream.emit('finish');
- }
- }
- return need;
+function isBoolean(arg) {
+ return typeof arg === 'boolean';
}
+exports.isBoolean = isBoolean;
-function endWritable(stream, state, cb) {
- state.ending = true;
- finishMaybe(stream, state);
- if (cb) {
- if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
- }
- state.ended = true;
- stream.writable = false;
+function isNull(arg) {
+ return arg === null;
}
+exports.isNull = isNull;
-function onCorkedFinish(corkReq, state, err) {
- var entry = corkReq.entry;
- corkReq.entry = null;
- while (entry) {
- var cb = entry.callback;
- state.pendingcb--;
- cb(err);
- entry = entry.next;
- }
- if (state.corkedRequestsFree) {
- state.corkedRequestsFree.next = corkReq;
- } else {
- state.corkedRequestsFree = corkReq;
- }
+function isNullOrUndefined(arg) {
+ return arg == null;
}
+exports.isNullOrUndefined = isNullOrUndefined;
-Object.defineProperty(Writable.prototype, 'destroyed', {
- get: function () {
- if (this._writableState === undefined) {
- return false;
- }
- return this._writableState.destroyed;
- },
- set: function (value) {
- // we ignore the value if the stream
- // has not been initialized yet
- if (!this._writableState) {
- return;
- }
+function isNumber(arg) {
+ return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
- // backward compatibility, the user is explicitly
- // managing destroyed
- this._writableState.destroyed = value;
- }
-});
+function isString(arg) {
+ return typeof arg === 'string';
+}
+exports.isString = isString;
-Writable.prototype.destroy = destroyImpl.destroy;
-Writable.prototype._undestroy = destroyImpl.undestroy;
-Writable.prototype._destroy = function (err, cb) {
- this.end();
- cb(err);
-};
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
-},{"./_stream_duplex":10,"./internal/streams/destroy":16,"./internal/streams/stream":17,"_process":70,"core-util-is":2,"inherits":3,"process-nextick-args":9,"safe-buffer":19,"timers":71,"util-deprecate":21}],15:[function(require,module,exports){
-'use strict';
+function isSymbol(arg) {
+ return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function isUndefined(arg) {
+ return arg === void 0;
+}
+exports.isUndefined = isUndefined;
-var Buffer = require('safe-buffer').Buffer;
-var util = require('util');
+function isRegExp(re) {
+ return objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
-function copyBuffer(src, target, offset) {
- src.copy(target, offset);
+function isObject(arg) {
+ return typeof arg === 'object' && arg !== null;
}
+exports.isObject = isObject;
-module.exports = function () {
- function BufferList() {
- _classCallCheck(this, BufferList);
+function isDate(d) {
+ return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
- this.head = null;
- this.tail = null;
- this.length = 0;
- }
+function isError(e) {
+ return (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
- BufferList.prototype.push = function push(v) {
- var entry = { data: v, next: null };
- if (this.length > 0) this.tail.next = entry;else this.head = entry;
- this.tail = entry;
- ++this.length;
- };
+function isFunction(arg) {
+ return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
- BufferList.prototype.unshift = function unshift(v) {
- var entry = { data: v, next: this.head };
- if (this.length === 0) this.tail = entry;
- this.head = entry;
- ++this.length;
- };
+function isPrimitive(arg) {
+ return arg === null ||
+ typeof arg === 'boolean' ||
+ typeof arg === 'number' ||
+ typeof arg === 'string' ||
+ typeof arg === 'symbol' || // ES6 symbol
+ typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
- BufferList.prototype.shift = function shift() {
- if (this.length === 0) return;
- var ret = this.head.data;
- if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
- --this.length;
- return ret;
- };
+exports.isBuffer = Buffer.isBuffer;
- BufferList.prototype.clear = function clear() {
- this.head = this.tail = null;
- this.length = 0;
- };
+function objectToString(o) {
+ return Object.prototype.toString.call(o);
+}
- BufferList.prototype.join = function join(s) {
- if (this.length === 0) return '';
- var p = this.head;
- var ret = '' + p.data;
- while (p = p.next) {
- ret += s + p.data;
- }return ret;
- };
+}).call(this,{"isBuffer":require("../../is-buffer/index.js")})
+},{"../../is-buffer/index.js":13}],10:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
- BufferList.prototype.concat = function concat(n) {
- if (this.length === 0) return Buffer.alloc(0);
- if (this.length === 1) return this.head.data;
- var ret = Buffer.allocUnsafe(n >>> 0);
- var p = this.head;
- var i = 0;
- while (p) {
- copyBuffer(p.data, ret, i);
- i += p.data.length;
- p = p.next;
- }
- return ret;
- };
+var objectCreate = Object.create || objectCreatePolyfill
+var objectKeys = Object.keys || objectKeysPolyfill
+var bind = Function.prototype.bind || functionBindPolyfill
- return BufferList;
-}();
+function EventEmitter() {
+ if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
+ this._events = objectCreate(null);
+ this._eventsCount = 0;
+ }
-if (util && util.inspect && util.inspect.custom) {
- module.exports.prototype[util.inspect.custom] = function () {
- var obj = util.inspect({ length: this.length });
- return this.constructor.name + ' ' + obj;
- };
+ this._maxListeners = this._maxListeners || undefined;
}
-},{"safe-buffer":19,"util":64}],16:[function(require,module,exports){
-'use strict';
-
-/*<replacement>*/
-
-var pna = require('process-nextick-args');
-/*</replacement>*/
-
-// undocumented cb() API, needed for core, not for public API
-function destroy(err, cb) {
- var _this = this;
-
- var readableDestroyed = this._readableState && this._readableState.destroyed;
- var writableDestroyed = this._writableState && this._writableState.destroyed;
-
- if (readableDestroyed || writableDestroyed) {
- if (cb) {
- cb(err);
- } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
- pna.nextTick(emitErrorNT, this, err);
- }
- return this;
- }
+module.exports = EventEmitter;
- // we set destroyed to true before firing error callbacks in order
- // to make it re-entrance safe in case destroy() is called within callbacks
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
- if (this._readableState) {
- this._readableState.destroyed = true;
- }
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
- // if this is a duplex stream mark the writable part as destroyed as well
- if (this._writableState) {
- this._writableState.destroyed = true;
- }
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
- this._destroy(err || null, function (err) {
- if (!cb && err) {
- pna.nextTick(emitErrorNT, _this, err);
- if (_this._writableState) {
- _this._writableState.errorEmitted = true;
- }
- } else if (cb) {
- cb(err);
+var hasDefineProperty;
+try {
+ var o = {};
+ if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
+ hasDefineProperty = o.x === 0;
+} catch (err) { hasDefineProperty = false }
+if (hasDefineProperty) {
+ Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+ enumerable: true,
+ get: function() {
+ return defaultMaxListeners;
+ },
+ set: function(arg) {
+ // check whether the input is a positive number (whose value is zero or
+ // greater and not a NaN).
+ if (typeof arg !== 'number' || arg < 0 || arg !== arg)
+ throw new TypeError('"defaultMaxListeners" must be a positive number');
+ defaultMaxListeners = arg;
}
});
+} else {
+ EventEmitter.defaultMaxListeners = defaultMaxListeners;
+}
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+ if (typeof n !== 'number' || n < 0 || isNaN(n))
+ throw new TypeError('"n" argument must be a positive number');
+ this._maxListeners = n;
return this;
+};
+
+function $getMaxListeners(that) {
+ if (that._maxListeners === undefined)
+ return EventEmitter.defaultMaxListeners;
+ return that._maxListeners;
}
-function undestroy() {
- if (this._readableState) {
- this._readableState.destroyed = false;
- this._readableState.reading = false;
- this._readableState.ended = false;
- this._readableState.endEmitted = false;
- }
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+ return $getMaxListeners(this);
+};
- if (this._writableState) {
- this._writableState.destroyed = false;
- this._writableState.ended = false;
- this._writableState.ending = false;
- this._writableState.finished = false;
- this._writableState.errorEmitted = false;
+// These standalone emit* functions are used to optimize calling of event
+// handlers for fast cases because emit() itself often has a variable number of
+// arguments and can be deoptimized because of that. These functions always have
+// the same number of arguments and thus do not get deoptimized, so the code
+// inside them can execute faster.
+function emitNone(handler, isFn, self) {
+ if (isFn)
+ handler.call(self);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].call(self);
}
}
-
-function emitErrorNT(self, err) {
- self.emit('error', err);
+function emitOne(handler, isFn, self, arg1) {
+ if (isFn)
+ handler.call(self, arg1);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].call(self, arg1);
+ }
}
-
-module.exports = {
- destroy: destroy,
- undestroy: undestroy
-};
-},{"process-nextick-args":9}],17:[function(require,module,exports){
-module.exports = require('events').EventEmitter;
-
-},{"events":66}],18:[function(require,module,exports){
-exports = module.exports = require('./lib/_stream_readable.js');
-exports.Stream = exports;
-exports.Readable = exports;
-exports.Writable = require('./lib/_stream_writable.js');
-exports.Duplex = require('./lib/_stream_duplex.js');
-exports.Transform = require('./lib/_stream_transform.js');
-exports.PassThrough = require('./lib/_stream_passthrough.js');
-
-},{"./lib/_stream_duplex.js":10,"./lib/_stream_passthrough.js":11,"./lib/_stream_readable.js":12,"./lib/_stream_transform.js":13,"./lib/_stream_writable.js":14}],19:[function(require,module,exports){
-/* eslint-disable node/no-deprecated-api */
-var buffer = require('buffer')
-var Buffer = buffer.Buffer
-
-// alternative to using Object.keys for old browsers
-function copyProps (src, dst) {
- for (var key in src) {
- dst[key] = src[key]
+function emitTwo(handler, isFn, self, arg1, arg2) {
+ if (isFn)
+ handler.call(self, arg1, arg2);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].call(self, arg1, arg2);
}
}
-if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
- module.exports = buffer
-} else {
- // Copy properties from require('buffer')
- copyProps(buffer, exports)
- exports.Buffer = SafeBuffer
+function emitThree(handler, isFn, self, arg1, arg2, arg3) {
+ if (isFn)
+ handler.call(self, arg1, arg2, arg3);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].call(self, arg1, arg2, arg3);
+ }
}
-function SafeBuffer (arg, encodingOrOffset, length) {
- return Buffer(arg, encodingOrOffset, length)
+function emitMany(handler, isFn, self, args) {
+ if (isFn)
+ handler.apply(self, args);
+ else {
+ var len = handler.length;
+ var listeners = arrayClone(handler, len);
+ for (var i = 0; i < len; ++i)
+ listeners[i].apply(self, args);
+ }
}
-// Copy static methods from Buffer
-copyProps(Buffer, SafeBuffer)
+EventEmitter.prototype.emit = function emit(type) {
+ var er, handler, len, args, i, events;
+ var doError = (type === 'error');
-SafeBuffer.from = function (arg, encodingOrOffset, length) {
- if (typeof arg === 'number') {
- throw new TypeError('Argument must not be a number')
- }
- return Buffer(arg, encodingOrOffset, length)
-}
+ events = this._events;
+ if (events)
+ doError = (doError && events.error == null);
+ else if (!doError)
+ return false;
-SafeBuffer.alloc = function (size, fill, encoding) {
- if (typeof size !== 'number') {
- throw new TypeError('Argument must be a number')
- }
- var buf = Buffer(size)
- if (fill !== undefined) {
- if (typeof encoding === 'string') {
- buf.fill(fill, encoding)
+ // If there is no 'error' event listener then throw.
+ if (doError) {
+ if (arguments.length > 1)
+ er = arguments[1];
+ if (er instanceof Error) {
+ throw er; // Unhandled 'error' event
} else {
- buf.fill(fill)
+ // At least give some kind of context to the user
+ var err = new Error('Unhandled "error" event. (' + er + ')');
+ err.context = er;
+ throw err;
}
- } else {
- buf.fill(0)
+ return false;
}
- return buf
-}
-SafeBuffer.allocUnsafe = function (size) {
- if (typeof size !== 'number') {
- throw new TypeError('Argument must be a number')
- }
- return Buffer(size)
-}
+ handler = events[type];
-SafeBuffer.allocUnsafeSlow = function (size) {
- if (typeof size !== 'number') {
- throw new TypeError('Argument must be a number')
- }
- return buffer.SlowBuffer(size)
-}
+ if (!handler)
+ return false;
-},{"buffer":65}],20:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-'use strict';
-
-/*<replacement>*/
-
-var Buffer = require('safe-buffer').Buffer;
-/*</replacement>*/
-
-var isEncoding = Buffer.isEncoding || function (encoding) {
- encoding = '' + encoding;
- switch (encoding && encoding.toLowerCase()) {
- case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
- return true;
- default:
- return false;
- }
-};
-
-function _normalizeEncoding(enc) {
- if (!enc) return 'utf8';
- var retried;
- while (true) {
- switch (enc) {
- case 'utf8':
- case 'utf-8':
- return 'utf8';
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return 'utf16le';
- case 'latin1':
- case 'binary':
- return 'latin1';
- case 'base64':
- case 'ascii':
- case 'hex':
- return enc;
- default:
- if (retried) return; // undefined
- enc = ('' + enc).toLowerCase();
- retried = true;
- }
- }
-};
-
-// Do not cache `Buffer.isEncoding` when checking encoding names as some
-// modules monkey-patch it to support additional encodings
-function normalizeEncoding(enc) {
- var nenc = _normalizeEncoding(enc);
- if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
- return nenc || enc;
-}
-
-// StringDecoder provides an interface for efficiently splitting a series of
-// buffers into a series of JS strings without breaking apart multi-byte
-// characters.
-exports.StringDecoder = StringDecoder;
-function StringDecoder(encoding) {
- this.encoding = normalizeEncoding(encoding);
- var nb;
- switch (this.encoding) {
- case 'utf16le':
- this.text = utf16Text;
- this.end = utf16End;
- nb = 4;
+ var isFn = typeof handler === 'function';
+ len = arguments.length;
+ switch (len) {
+ // fast cases
+ case 1:
+ emitNone(handler, isFn, this);
break;
- case 'utf8':
- this.fillLast = utf8FillLast;
- nb = 4;
+ case 2:
+ emitOne(handler, isFn, this, arguments[1]);
break;
- case 'base64':
- this.text = base64Text;
- this.end = base64End;
- nb = 3;
+ case 3:
+ emitTwo(handler, isFn, this, arguments[1], arguments[2]);
+ break;
+ case 4:
+ emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
break;
+ // slower
default:
- this.write = simpleWrite;
- this.end = simpleEnd;
- return;
+ args = new Array(len - 1);
+ for (i = 1; i < len; i++)
+ args[i - 1] = arguments[i];
+ emitMany(handler, isFn, this, args);
}
- this.lastNeed = 0;
- this.lastTotal = 0;
- this.lastChar = Buffer.allocUnsafe(nb);
-}
-StringDecoder.prototype.write = function (buf) {
- if (buf.length === 0) return '';
- var r;
- var i;
- if (this.lastNeed) {
- r = this.fillLast(buf);
- if (r === undefined) return '';
- i = this.lastNeed;
- this.lastNeed = 0;
- } else {
- i = 0;
- }
- if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
- return r || '';
+ return true;
};
-StringDecoder.prototype.end = utf8End;
-
-// Returns only complete characters in a Buffer
-StringDecoder.prototype.text = utf8Text;
+function _addListener(target, type, listener, prepend) {
+ var m;
+ var events;
+ var existing;
-// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
-StringDecoder.prototype.fillLast = function (buf) {
- if (this.lastNeed <= buf.length) {
- buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
- return this.lastChar.toString(this.encoding, 0, this.lastTotal);
- }
- buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
- this.lastNeed -= buf.length;
-};
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
-// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
-// continuation byte. If an invalid byte is detected, -2 is returned.
-function utf8CheckByte(byte) {
- if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
- return byte >> 6 === 0x02 ? -1 : -2;
-}
+ events = target._events;
+ if (!events) {
+ events = target._events = objectCreate(null);
+ target._eventsCount = 0;
+ } else {
+ // To avoid recursion in the case that type === "newListener"! Before
+ // adding it to the listeners, first emit "newListener".
+ if (events.newListener) {
+ target.emit('newListener', type,
+ listener.listener ? listener.listener : listener);
-// Checks at most 3 bytes at the end of a Buffer in order to detect an
-// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
-// needed to complete the UTF-8 character (if applicable) are returned.
-function utf8CheckIncomplete(self, buf, i) {
- var j = buf.length - 1;
- if (j < i) return 0;
- var nb = utf8CheckByte(buf[j]);
- if (nb >= 0) {
- if (nb > 0) self.lastNeed = nb - 1;
- return nb;
- }
- if (--j < i || nb === -2) return 0;
- nb = utf8CheckByte(buf[j]);
- if (nb >= 0) {
- if (nb > 0) self.lastNeed = nb - 2;
- return nb;
- }
- if (--j < i || nb === -2) return 0;
- nb = utf8CheckByte(buf[j]);
- if (nb >= 0) {
- if (nb > 0) {
- if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
+ // Re-assign `events` because a newListener handler could have caused the
+ // this._events to be assigned to a new object
+ events = target._events;
}
- return nb;
+ existing = events[type];
}
- return 0;
-}
-// Validates as many continuation bytes for a multi-byte UTF-8 character as
-// needed or are available. If we see a non-continuation byte where we expect
-// one, we "replace" the validated continuation bytes we've seen so far with
-// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
-// behavior. The continuation byte check is included three times in the case
-// where all of the continuation bytes for a character exist in the same buffer.
-// It is also done this way as a slight performance increase instead of using a
-// loop.
-function utf8CheckExtraBytes(self, buf, p) {
- if ((buf[0] & 0xC0) !== 0x80) {
- self.lastNeed = 0;
- return '\ufffd';
- }
- if (self.lastNeed > 1 && buf.length > 1) {
- if ((buf[1] & 0xC0) !== 0x80) {
- self.lastNeed = 1;
- return '\ufffd';
+ if (!existing) {
+ // Optimize the case of one listener. Don't need the extra array object.
+ existing = events[type] = listener;
+ ++target._eventsCount;
+ } else {
+ if (typeof existing === 'function') {
+ // Adding the second element, need to change to array.
+ existing = events[type] =
+ prepend ? [listener, existing] : [existing, listener];
+ } else {
+ // If we've already got an array, just append.
+ if (prepend) {
+ existing.unshift(listener);
+ } else {
+ existing.push(listener);
+ }
}
- if (self.lastNeed > 2 && buf.length > 2) {
- if ((buf[2] & 0xC0) !== 0x80) {
- self.lastNeed = 2;
- return '\ufffd';
+
+ // Check for listener leak
+ if (!existing.warned) {
+ m = $getMaxListeners(target);
+ if (m && m > 0 && existing.length > m) {
+ existing.warned = true;
+ var w = new Error('Possible EventEmitter memory leak detected. ' +
+ existing.length + ' "' + String(type) + '" listeners ' +
+ 'added. Use emitter.setMaxListeners() to ' +
+ 'increase limit.');
+ w.name = 'MaxListenersExceededWarning';
+ w.emitter = target;
+ w.type = type;
+ w.count = existing.length;
+ if (typeof console === 'object' && console.warn) {
+ console.warn('%s: %s', w.name, w.message);
+ }
}
}
}
-}
-// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
-function utf8FillLast(buf) {
- var p = this.lastTotal - this.lastNeed;
- var r = utf8CheckExtraBytes(this, buf, p);
- if (r !== undefined) return r;
- if (this.lastNeed <= buf.length) {
- buf.copy(this.lastChar, p, 0, this.lastNeed);
- return this.lastChar.toString(this.encoding, 0, this.lastTotal);
- }
- buf.copy(this.lastChar, p, 0, buf.length);
- this.lastNeed -= buf.length;
+ return target;
}
-// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
-// partial character, the character's bytes are buffered until the required
-// number of bytes are available.
-function utf8Text(buf, i) {
- var total = utf8CheckIncomplete(this, buf, i);
- if (!this.lastNeed) return buf.toString('utf8', i);
- this.lastTotal = total;
- var end = buf.length - (total - this.lastNeed);
- buf.copy(this.lastChar, 0, end);
- return buf.toString('utf8', i, end);
-}
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+ return _addListener(this, type, listener, false);
+};
-// For UTF-8, a replacement character is added when ending on a partial
-// character.
-function utf8End(buf) {
- var r = buf && buf.length ? this.write(buf) : '';
- if (this.lastNeed) return r + '\ufffd';
- return r;
-}
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-// UTF-16LE typically needs two bytes per character, but even if we have an even
-// number of bytes available, we need to check if we end on a leading/high
-// surrogate. In that case, we need to wait for the next two bytes in order to
-// decode the last character properly.
-function utf16Text(buf, i) {
- if ((buf.length - i) % 2 === 0) {
- var r = buf.toString('utf16le', i);
- if (r) {
- var c = r.charCodeAt(r.length - 1);
- if (c >= 0xD800 && c <= 0xDBFF) {
- this.lastNeed = 2;
- this.lastTotal = 4;
- this.lastChar[0] = buf[buf.length - 2];
- this.lastChar[1] = buf[buf.length - 1];
- return r.slice(0, -1);
- }
+EventEmitter.prototype.prependListener =
+ function prependListener(type, listener) {
+ return _addListener(this, type, listener, true);
+ };
+
+function onceWrapper() {
+ if (!this.fired) {
+ this.target.removeListener(this.type, this.wrapFn);
+ this.fired = true;
+ switch (arguments.length) {
+ case 0:
+ return this.listener.call(this.target);
+ case 1:
+ return this.listener.call(this.target, arguments[0]);
+ case 2:
+ return this.listener.call(this.target, arguments[0], arguments[1]);
+ case 3:
+ return this.listener.call(this.target, arguments[0], arguments[1],
+ arguments[2]);
+ default:
+ var args = new Array(arguments.length);
+ for (var i = 0; i < args.length; ++i)
+ args[i] = arguments[i];
+ this.listener.apply(this.target, args);
}
- return r;
}
- this.lastNeed = 1;
- this.lastTotal = 2;
- this.lastChar[0] = buf[buf.length - 1];
- return buf.toString('utf16le', i, buf.length - 1);
}
-// For UTF-16LE we do not explicitly append special replacement characters if we
-// end on a partial character, we simply let v8 handle that.
-function utf16End(buf) {
- var r = buf && buf.length ? this.write(buf) : '';
- if (this.lastNeed) {
- var end = this.lastTotal - this.lastNeed;
- return r + this.lastChar.toString('utf16le', 0, end);
- }
- return r;
+function _onceWrap(target, type, listener) {
+ var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+ var wrapped = bind.call(onceWrapper, state);
+ wrapped.listener = listener;
+ state.wrapFn = wrapped;
+ return wrapped;
}
-function base64Text(buf, i) {
- var n = (buf.length - i) % 3;
- if (n === 0) return buf.toString('base64', i);
- this.lastNeed = 3 - n;
- this.lastTotal = 3;
- if (n === 1) {
- this.lastChar[0] = buf[buf.length - 1];
- } else {
- this.lastChar[0] = buf[buf.length - 2];
- this.lastChar[1] = buf[buf.length - 1];
- }
- return buf.toString('base64', i, buf.length - n);
-}
+EventEmitter.prototype.once = function once(type, listener) {
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+ this.on(type, _onceWrap(this, type, listener));
+ return this;
+};
-function base64End(buf) {
- var r = buf && buf.length ? this.write(buf) : '';
- if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
- return r;
-}
+EventEmitter.prototype.prependOnceListener =
+ function prependOnceListener(type, listener) {
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
+ this.prependListener(type, _onceWrap(this, type, listener));
+ return this;
+ };
-// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
-function simpleWrite(buf) {
- return buf.toString(this.encoding);
-}
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+ function removeListener(type, listener) {
+ var list, events, position, i, originalListener;
-function simpleEnd(buf) {
- return buf && buf.length ? this.write(buf) : '';
-}
-},{"safe-buffer":19}],21:[function(require,module,exports){
-(function (global){
+ if (typeof listener !== 'function')
+ throw new TypeError('"listener" argument must be a function');
-/**
- * Module exports.
- */
+ events = this._events;
+ if (!events)
+ return this;
-module.exports = deprecate;
+ list = events[type];
+ if (!list)
+ return this;
-/**
- * Mark that a method should not be used.
- * Returns a modified function which warns once by default.
- *
- * If `localStorage.noDeprecation = true` is set, then it is a no-op.
- *
- * If `localStorage.throwDeprecation = true` is set, then deprecated functions
- * will throw an Error when invoked.
- *
- * If `localStorage.traceDeprecation = true` is set, then deprecated functions
- * will invoke `console.trace()` instead of `console.error()`.
- *
- * @param {Function} fn - the function to deprecate
- * @param {String} msg - the string to print to the console when `fn` is invoked
- * @returns {Function} a new "deprecated" version of `fn`
- * @api public
- */
+ if (list === listener || list.listener === listener) {
+ if (--this._eventsCount === 0)
+ this._events = objectCreate(null);
+ else {
+ delete events[type];
+ if (events.removeListener)
+ this.emit('removeListener', type, list.listener || listener);
+ }
+ } else if (typeof list !== 'function') {
+ position = -1;
-function deprecate (fn, msg) {
- if (config('noDeprecation')) {
- return fn;
- }
+ for (i = list.length - 1; i >= 0; i--) {
+ if (list[i] === listener || list[i].listener === listener) {
+ originalListener = list[i].listener;
+ position = i;
+ break;
+ }
+ }
- var warned = false;
- function deprecated() {
- if (!warned) {
- if (config('throwDeprecation')) {
- throw new Error(msg);
- } else if (config('traceDeprecation')) {
- console.trace(msg);
- } else {
- console.warn(msg);
+ if (position < 0)
+ return this;
+
+ if (position === 0)
+ list.shift();
+ else
+ spliceOne(list, position);
+
+ if (list.length === 1)
+ events[type] = list[0];
+
+ if (events.removeListener)
+ this.emit('removeListener', type, originalListener || listener);
}
- warned = true;
- }
- return fn.apply(this, arguments);
- }
- return deprecated;
-}
+ return this;
+ };
-/**
- * Checks `localStorage` for boolean values for the given `name`.
- *
- * @param {String} name
- * @returns {Boolean}
- * @api private
- */
+EventEmitter.prototype.removeAllListeners =
+ function removeAllListeners(type) {
+ var listeners, events, i;
-function config (name) {
- // accessing global.localStorage can trigger a DOMException in sandboxed iframes
- try {
- if (!global.localStorage) return false;
- } catch (_) {
- return false;
- }
- var val = global.localStorage[name];
- if (null == val) return false;
- return String(val).toLowerCase() === 'true';
-}
+ events = this._events;
+ if (!events)
+ return this;
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{}],22:[function(require,module,exports){
-(function (Buffer){
-const Peer = require('../../server/src/peer')
-const VideoConverter = require('./lib/dist/video-converter');
-const msgpack = require('msgpack5')();
-
-let current_data = {};
-let peer;
-let player;
-
-/**
- * Validates that the user is logged in by sending the token
- */
-checkIfLoggedIn = async () => {
- // const token = window.localStorage.getItem('token')
- // console.log(token)
- // if(!token){
- // console.log("You need to login")
- // renderLogin()
- // }else{
-
- // //Check if the token is valid
- // const response = await fetch('http://localhost:8080/auth/validation', {
- // method: 'POST',
- // headers: {'Authorization': token}
- // })
- // console.log('RESPONSE', response)
-
- // //Token is valid, show available streams
- // if(response.status === 200){
- // console.log("SUCCESS")
- renderThumbnails()
-
- // }
- // }
-}
-
-/**
- * Returns a list of available streams
- */
-getAvailableStreams = async () => {
- try{
- const streamsInJson = await fetch(`./streams`);
- const streams = await streamsInJson.json();
- console.log('AVAILABLE', streams)
- return streams;
- }catch(err){
- console.log(err)
- }
-}
-
-
-createVideoPlayer = () => {
- const containerDiv = document.getElementById('container');
- containerDiv.innerHTML = '';
- /*containerDiv.innerHTML = `<h1>Stream from source ${current_data.uri}</h1><br>
- <button onclick="renderThumbnails(); closeStream()">Go back</button>
- <button onclick="connectToStream('${current_data.uri}')">Start Stream</button><br>
- <button onclick="webSocketTest()">WebSocket Test</button><br>
- <video id="ftlab-stream-video" width="640" height="360"></video>`;
- containerDiv.innerHTML += '<br>'
- containerDiv.innerHTML += ''*/
- createPeer();
- //connectToStream();
- new FTLStream(peer, current_data.uri, containerDiv);
-}
-
-/**
- * Creates thumbnail (image) for all available streams and adds them to div class='container'
- */
-renderThumbnails = async () => {
- const thumbnails = await getAvailableStreams();
- const containerDiv = document.getElementById('container')
- containerDiv.innerHTML = '';
- containerDiv.innerHTML = `<button onClick="configs()">change configs</button>`
- containerDiv.innerHTML += `<div class="ftlab-stream-thumbnails"></div>`
- if(thumbnails.length === 0){
- containerDiv.innerHTML = `<h3>No streams running currently</h3>`
- }else{
- for(var i=0; i<thumbnails.length; i++){
- const encodedURI = encodeURIComponent(thumbnails[i])
- current_data.uri = thumbnails[i]
- try{
- const someData = await fetch(`./stream/rgb?uri=${encodedURI}`)
- if(!someData.ok){
- throw new Error('Image not found')
- }
- const myBlob = await someData.blob();
- const objectURL = URL.createObjectURL(myBlob);
- // containerDiv.innerHTML += createCard()
- containerDiv.innerHTML += createCard(objectURL, i+4)
- }catch(err){
- console.log("Couldn't create thumbnail");
- console.log(err)
- }
- }
- }
-}
-
-
-/**
- * Method to create a single thumbnail
- */
-createCard = (url, viewers) => {
- return `<div class='ftlab-card-component' >
- <img src='${url}' class="thumbnail-img" alt="Hups" width="250px"></img>
- <p>Viewers: ${viewers}</p>
- <button onclick="createVideoPlayer()">button</button>
- </div>`
-}
-
-
-createPeer = () => {
- // FOR PRODUCTION
- console.log("HOST", location.host);
- const ws = new WebSocket("ws://" + location.host + location.pathname);
- //const ws = new WebSocket("ws://localhost:8080")
- ws.binaryType = "arraybuffer";
- peer = new Peer(ws)
-}
-
-webSocketTest = () => {
- peer.send("update_cfg", "ftl://utu.fi#reconstruction_default/0/renderer/cool_effect", "true")
-}
-
-function FTLStream(peer, uri, element) {
- this.uri = uri;
- this.peer = peer;
-
- this.current = "";
- this.current_fs = 0;
- this.current_source = 0;
- this.current_channel = 0;
-
- //this.elements_ = {};
- //this.converters_ = {};
-
- //const element = document.getElementById('ftlab-stream-video');
- this.outer = element;
- this.element = document.createElement("VIDEO");
- this.element.setAttribute("width", 640);
- this.element.setAttribute("height", 360);
- this.element.setAttribute("controls", true);
- this.outer.appendChild(this.element);
- this.play_button = document.createElement("BUTTON");
- this.play_button.innerHTML = "Play";
- this.play_button.onclick = () => {
- this.start(0,0,0);
- }
- this.outer.appendChild(this.play_button);
-
- this.element.onclick = () => {
- let pose = [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];
- this.setPose(pose);
- }
-
- this.converter = null;
-
- let rxcount = 0;
- let ts = 0;
- let dts = 0;
-
- this.peer.bind(uri, (latency, streampckg, pckg) => {
- if(pckg[0] === 2){ // H264 packet.
- let id = "id-"+streampckg[1]+"-"+streampckg[2]+"-"+streampckg[3];
-
- if (this.current == id) {
- rxcount++;
- if (rxcount >= 25) {
- rxcount = 0;
- peer.send(uri, 0, [1,0,255,0],[255,7,35,0,0,Buffer.alloc(0)]);
- //peer.send(current_data.uri, 0, [255,7,35,0,0,Buffer.alloc(0)], [1,0,255,0]);
- }
-
- if (this.converter) {
- /*function decode(value){
- this.converter.appendRawData(value);
- }
- decode(pckg[5]);*/
- this.converter.appendRawData(pckg[5]);
- this.converter.play();
- } else {
- if (ts > 0) {
- dts = streampckg[0] - ts;
- console.log("Framerate = ", 1000/dts);
- this.converter = new VideoConverter.default(this.element, 30, 1);
- }
- ts = streampckg[0];
- }
- }
- } else if (pckg[0] === 103) {
- //console.log(msgpack.decode(pckg[5]));
- }
- });
-
- //this.start();
-}
-
-FTLStream.prototype.setPose = function(pose) {
- if (pose.length != 16) {
- console.error("Invalid pose");
- return;
- }
- this.peer.send(this.uri, 0, [1, this.current_fs, this.current_source, 66],
- [103, 7, 1, 0, 0, msgpack.encode(pose)]);
-}
-
-FTLStream.prototype.start = function(fs, source, channel) {
- let id = "id-"+fs+"-"+source+"-"+channel;
- this.current = id;
- this.current_fs = fs;
- this.current_source = source;
- this.current_channel = channel;
-
- if (this.found) {
- this.peer.send(this.uri, 0, [1,fs,255,channel],[255,7,35,0,0,Buffer.alloc(0)]);
- } else {
- this.peer.rpc("find_stream", (res) => {
- this.found = true;
- this.peer.send(this.uri, 0, [1,fs,255,channel],[255,7,35,0,0,Buffer.alloc(0)]);
- }, this.uri);
- }
-}
-
-
-/*connectToStream = () => {
- const element = document.getElementById('ftlab-stream-video');
- let converter = null;
-
- let rxcount = 0;
- let ts = 0;
- let dts = 0;
-
- peer.bind(current_data.uri, (latency, streampckg, pckg) => {
- if(pckg[0] === 2){
- rxcount++;
- if (rxcount >= 25) {
- rxcount = 0;
- peer.send(current_data.uri, 0, [1,0,255,0],[255,7,35,0,0,Buffer.alloc(0)]);
- //peer.send(current_data.uri, 0, [255,7,35,0,0,Buffer.alloc(0)], [1,0,255,0]);
- }
-
- if (converter) {
- function decode(value){
- converter.appendRawData(value);
- }
- decode(pckg[5]);
- converter.play();
- } else {
- if (ts > 0) {
- dts = streampckg[0] - ts;
- console.log("Framerate = ", 1000/dts);
- converter = new VideoConverter.default(element, 30, 1);
- }
- ts = streampckg[0];
- }
- } else if (pckg[0] === 103) {
- console.log(msgpack.decode(pckg[5]));
- }
- })
-
- // Start the transaction
- //peer.send("get_stream", (current_data.uri, 30, 0, current_data.uri));
-
- peer.rpc("find_stream", (res) => {
- peer.send(current_data.uri, 0, [1,0,255,0],[255,7,35,0,0,Buffer.alloc(0)]);
- //peer.send(current_data.uri, [255,7,35,0,0,Buffer.alloc(0)], [1,0,255,0]);
- }, current_data.uri);
-}*/
-
-closeStream = () => {
- peer.sock.close()
-}
-
-
-
-/**
- * **************
- * CONFIGURATIONS
- * **************
- */
-
-
-current_data.configURI = "ftl://utu.fi#reconstruction_snap8/net"
-
-configs = () => {
- const container = document.getElementById("container");
- container.innerHTML = `<div class="ftlab-configurations"></div>`;
- renderConfigOptions();
-}
-
-
-renderConfigOptions = () => {
- const input = `<p>input1</p><br>ftl://utu.fi#<input type="text">`
- const doc = document.getElementsByClassName('ftlab-configurations')[0];
- doc.innerHTML = input;
-}
-
-/**
- *
- */
-loadConfigs = async (str) => {
- const configURI = encodeURIComponent(`ftl://utu.fi#reconstruction_snap8${str}`);
- const uri = encodeURIComponent(current_data.uri)
- const rawResp = await fetch(`./stream/config?settings=${configURI}&uri=${uri}`)
- const response = await rawResp.json();
- const content = JSON.parse(response);
- container.innerHTML += `<p>${response}</p>`;
-}
-
-// current_data.configData = '{"peers": 1}';
-
-/**
- * Method to send configurations to backend
- */
-saveConfigs = async () => {
- let {uri, configURI, configData} = current_data
- const rawResp = await fetch('./stream/config', {
- method: 'POST',
- headers: {
- 'Accept': 'application/json',
- 'Content-Type': 'application/json'
- },
- body: JSON.stringify({peerURI: uri, configURI, data: configData, saveToCPP: true})
- });
- const content = await rawResp.json();
-}
-}).call(this,require("buffer").Buffer)
-},{"../../server/src/peer":57,"./lib/dist/video-converter":30,"buffer":65,"msgpack5":5}],23:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var bit_stream_1 = require("./util/bit-stream");
-var debug = require("./util/debug");
-var NALU_1 = require("./util/NALU");
-var H264Parser = (function () {
- function H264Parser(remuxer) {
- this.remuxer = remuxer;
- this.track = remuxer.mp4track;
- }
- H264Parser.prototype.parseSEI = function (sei) {
- var messages = H264Parser.readSEI(sei);
- for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
- var m = messages_1[_i];
- switch (m.type) {
- case 0:
- this.track.seiBuffering = true;
- break;
- case 5:
- return true;
- default:
- break;
- }
- }
- return false;
- };
- H264Parser.prototype.parseSPS = function (sps) {
- var config = H264Parser.readSPS(sps);
- this.track.width = config.width;
- this.track.height = config.height;
- this.track.sps = [sps];
- this.track.codec = 'avc1.';
- var codecArray = new DataView(sps.buffer, sps.byteOffset + 1, 4);
- for (var i = 0; i < 3; ++i) {
- var h = codecArray.getUint8(i).toString(16);
- if (h.length < 2) {
- h = '0' + h;
- }
- this.track.codec += h;
- }
- };
- H264Parser.prototype.parsePPS = function (pps) {
- this.track.pps = [pps];
- };
- H264Parser.prototype.parseNAL = function (unit) {
- if (!unit) {
- return false;
- }
- var push = false;
- switch (unit.type()) {
- case NALU_1.default.NDR:
- case NALU_1.default.IDR:
- push = true;
- break;
- case NALU_1.default.SEI:
- push = this.parseSEI(unit.getData().subarray(4));
- break;
- case NALU_1.default.SPS:
- if (this.track.sps.length === 0) {
- this.parseSPS(unit.getData().subarray(4));
- debug.log(" Found SPS type NALU frame.");
- if (!this.remuxer.readyToDecode && this.track.pps.length > 0 && this.track.sps.length > 0) {
- this.remuxer.readyToDecode = true;
- }
- }
- break;
- case NALU_1.default.PPS:
- if (this.track.pps.length === 0) {
- this.parsePPS(unit.getData().subarray(4));
- debug.log(" Found PPS type NALU frame.");
- if (!this.remuxer.readyToDecode && this.track.pps.length > 0 && this.track.sps.length > 0) {
- this.remuxer.readyToDecode = true;
- }
- }
- break;
- default:
- debug.log(" Found Unknown type NALU frame. type=" + unit.type());
- break;
- }
- return push;
- };
- H264Parser.skipScalingList = function (decoder, count) {
- var lastScale = 8;
- var nextScale = 8;
- for (var j = 0; j < count; j++) {
- if (nextScale !== 0) {
- var deltaScale = decoder.readEG();
- nextScale = (lastScale + deltaScale + 256) % 256;
- }
- lastScale = (nextScale === 0) ? lastScale : nextScale;
- }
- };
- H264Parser.readSPS = function (data) {
- var decoder = new bit_stream_1.default(data);
- var frameCropLeftOffset = 0;
- var frameCropRightOffset = 0;
- var frameCropTopOffset = 0;
- var frameCropBottomOffset = 0;
- var sarScale = 1;
- decoder.readUByte();
- var profileIdc = decoder.readUByte();
- decoder.skipBits(5);
- decoder.skipBits(3);
- decoder.skipBits(8);
- decoder.skipUEG();
- if (profileIdc === 100 ||
- profileIdc === 110 ||
- profileIdc === 122 ||
- profileIdc === 244 ||
- profileIdc === 44 ||
- profileIdc === 83 ||
- profileIdc === 86 ||
- profileIdc === 118 ||
- profileIdc === 128) {
- var chromaFormatIdc = decoder.readUEG();
- if (chromaFormatIdc === 3) {
- decoder.skipBits(1);
- }
- decoder.skipUEG();
- decoder.skipUEG();
- decoder.skipBits(1);
- if (decoder.readBoolean()) {
- var scalingListCount = (chromaFormatIdc !== 3) ? 8 : 12;
- for (var i = 0; i < scalingListCount; ++i) {
- if (decoder.readBoolean()) {
- if (i < 6) {
- H264Parser.skipScalingList(decoder, 16);
- }
- else {
- H264Parser.skipScalingList(decoder, 64);
- }
- }
- }
- }
- }
- decoder.skipUEG();
- var picOrderCntType = decoder.readUEG();
- if (picOrderCntType === 0) {
- decoder.readUEG();
- }
- else if (picOrderCntType === 1) {
- decoder.skipBits(1);
- decoder.skipEG();
- decoder.skipEG();
- var numRefFramesInPicOrderCntCycle = decoder.readUEG();
- for (var i = 0; i < numRefFramesInPicOrderCntCycle; ++i) {
- decoder.skipEG();
- }
- }
- decoder.skipUEG();
- decoder.skipBits(1);
- var picWidthInMbsMinus1 = decoder.readUEG();
- var picHeightInMapUnitsMinus1 = decoder.readUEG();
- var frameMbsOnlyFlag = decoder.readBits(1);
- if (frameMbsOnlyFlag === 0) {
- decoder.skipBits(1);
- }
- decoder.skipBits(1);
- if (decoder.readBoolean()) {
- frameCropLeftOffset = decoder.readUEG();
- frameCropRightOffset = decoder.readUEG();
- frameCropTopOffset = decoder.readUEG();
- frameCropBottomOffset = decoder.readUEG();
- }
- if (decoder.readBoolean()) {
- if (decoder.readBoolean()) {
- var sarRatio = void 0;
- var aspectRatioIdc = decoder.readUByte();
- switch (aspectRatioIdc) {
- case 1:
- sarRatio = [1, 1];
- break;
- case 2:
- sarRatio = [12, 11];
- break;
- case 3:
- sarRatio = [10, 11];
- break;
- case 4:
- sarRatio = [16, 11];
- break;
- case 5:
- sarRatio = [40, 33];
- break;
- case 6:
- sarRatio = [24, 11];
- break;
- case 7:
- sarRatio = [20, 11];
- break;
- case 8:
- sarRatio = [32, 11];
- break;
- case 9:
- sarRatio = [80, 33];
- break;
- case 10:
- sarRatio = [18, 11];
- break;
- case 11:
- sarRatio = [15, 11];
- break;
- case 12:
- sarRatio = [64, 33];
- break;
- case 13:
- sarRatio = [160, 99];
- break;
- case 14:
- sarRatio = [4, 3];
- break;
- case 15:
- sarRatio = [3, 2];
- break;
- case 16:
- sarRatio = [2, 1];
- break;
- case 255: {
- sarRatio = [decoder.readUByte() << 8 | decoder.readUByte(), decoder.readUByte() << 8 | decoder.readUByte()];
- break;
- }
- default: {
- debug.error(" H264: Unknown aspectRatioIdc=" + aspectRatioIdc);
- }
- }
- if (sarRatio) {
- sarScale = sarRatio[0] / sarRatio[1];
- }
- }
- if (decoder.readBoolean()) {
- decoder.skipBits(1);
- }
- if (decoder.readBoolean()) {
- decoder.skipBits(4);
- if (decoder.readBoolean()) {
- decoder.skipBits(24);
- }
- }
- if (decoder.readBoolean()) {
- decoder.skipUEG();
- decoder.skipUEG();
- }
- if (decoder.readBoolean()) {
- var unitsInTick = decoder.readUInt();
- var timeScale = decoder.readUInt();
- var fixedFrameRate = decoder.readBoolean();
- var frameDuration = timeScale / (2 * unitsInTick);
- debug.log("timescale: " + timeScale + "; unitsInTick: " + unitsInTick + "; " +
- ("fixedFramerate: " + fixedFrameRate + "; avgFrameDuration: " + frameDuration));
- }
- }
- return {
- width: Math.ceil((((picWidthInMbsMinus1 + 1) * 16) - frameCropLeftOffset * 2 - frameCropRightOffset * 2) * sarScale),
- height: ((2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16) -
- ((frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset)),
- };
- };
- H264Parser.readSEI = function (data) {
- var decoder = new bit_stream_1.default(data);
- decoder.skipBits(8);
- var result = [];
- while (decoder.bitsAvailable > 3 * 8) {
- result.push(this.readSEIMessage(decoder));
- }
- return result;
- };
- H264Parser.readSEIMessage = function (decoder) {
- function get() {
- var result = 0;
- while (true) {
- var value = decoder.readUByte();
- result += value;
- if (value !== 0xff) {
- break;
- }
- }
- return result;
- }
- var payloadType = get();
- var payloadSize = get();
- return this.readSEIPayload(decoder, payloadType, payloadSize);
- };
- H264Parser.readSEIPayload = function (decoder, type, size) {
- var result;
- switch (type) {
- default:
- result = { type: type };
- decoder.skipBits(size * 8);
- }
- decoder.skipBits(decoder.bitsAvailable % 8);
- return result;
- };
- return H264Parser;
-}());
-exports.default = H264Parser;
-
-},{"./util/NALU":26,"./util/bit-stream":27,"./util/debug":28}],24:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var h264_parser_1 = require("./h264-parser");
-var debug = require("./util/debug");
-var NALU_1 = require("./util/NALU");
-var trackId = 1;
-var H264Remuxer = (function () {
- function H264Remuxer(fps, framePerFragment, timescale) {
- this.fps = fps;
- this.framePerFragment = framePerFragment;
- this.timescale = timescale;
- this.readyToDecode = false;
- this.totalDTS = 0;
- this.stepDTS = Math.round(this.timescale / this.fps);
- this.frameCount = 0;
- this.seq = 1;
- this.mp4track = {
- id: H264Remuxer.getTrackID(),
- type: 'video',
- len: 0,
- codec: '',
- sps: [],
- pps: [],
- seiBuffering: false,
- width: 0,
- height: 0,
- timescale: timescale,
- duration: timescale,
- samples: [],
- isKeyFrame: true,
- };
- this.unitSamples = [[]];
- this.parser = new h264_parser_1.default(this);
- }
- H264Remuxer.getTrackID = function () {
- return trackId++;
- };
- Object.defineProperty(H264Remuxer.prototype, "seqNum", {
- get: function () {
- return this.seq;
- },
- enumerable: true,
- configurable: true
- });
- H264Remuxer.prototype.remux = function (nalu) {
- if (this.mp4track.seiBuffering && nalu.type() === NALU_1.default.SEI) {
- return this.createNextFrame();
- }
- if (this.parser.parseNAL(nalu)) {
- this.unitSamples[this.unitSamples.length - 1].push(nalu);
- this.mp4track.len += nalu.getSize();
- }
- if (!this.mp4track.seiBuffering && (nalu.type() === NALU_1.default.IDR || nalu.type() === NALU_1.default.NDR)) {
- return this.createNextFrame();
- }
- return;
- };
- H264Remuxer.prototype.createNextFrame = function () {
- if (this.mp4track.len > 0) {
- this.frameCount++;
- if (this.frameCount % this.framePerFragment === 0) {
- var fragment = this.getFragment();
- if (fragment) {
- var dts = this.totalDTS;
- this.totalDTS = this.stepDTS * this.frameCount;
- return [dts, fragment];
- }
- else {
- debug.log("No mp4 sample data.");
- }
- }
- this.unitSamples.push([]);
- }
- return;
- };
- H264Remuxer.prototype.flush = function () {
- this.seq++;
- this.mp4track.len = 0;
- this.mp4track.samples = [];
- this.mp4track.isKeyFrame = false;
- this.unitSamples = [[]];
- };
- H264Remuxer.prototype.getFragment = function () {
- if (!this.checkReadyToDecode()) {
- return undefined;
- }
- var payload = new Uint8Array(this.mp4track.len);
- this.mp4track.samples = [];
- var offset = 0;
- for (var i = 0, len = this.unitSamples.length; i < len; i++) {
- var units = this.unitSamples[i];
- if (units.length === 0) {
- continue;
- }
- var mp4Sample = {
- size: 0,
- cts: this.stepDTS * i,
- };
- for (var _i = 0, units_1 = units; _i < units_1.length; _i++) {
- var unit = units_1[_i];
- mp4Sample.size += unit.getSize();
- payload.set(unit.getData(), offset);
- offset += unit.getSize();
- }
- this.mp4track.samples.push(mp4Sample);
- }
- if (offset === 0) {
- return undefined;
- }
- return payload;
- };
- H264Remuxer.prototype.checkReadyToDecode = function () {
- if (!this.readyToDecode || this.unitSamples.filter(function (array) { return array.length > 0; }).length === 0) {
- debug.log("Not ready to decode! readyToDecode(" + this.readyToDecode + ") is false or units is empty.");
- return false;
- }
- return true;
- };
- return H264Remuxer;
-}());
-exports.default = H264Remuxer;
-
-},{"./h264-parser":23,"./util/NALU":26,"./util/debug":28}],25:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var MP4 = (function () {
- function MP4() {
- }
- MP4.init = function () {
- MP4.initalized = true;
- MP4.types = {
- avc1: [],
- avcC: [],
- btrt: [],
- dinf: [],
- dref: [],
- esds: [],
- ftyp: [],
- hdlr: [],
- mdat: [],
- mdhd: [],
- mdia: [],
- mfhd: [],
- minf: [],
- moof: [],
- moov: [],
- mp4a: [],
- mvex: [],
- mvhd: [],
- sdtp: [],
- stbl: [],
- stco: [],
- stsc: [],
- stsd: [],
- stsz: [],
- stts: [],
- styp: [],
- tfdt: [],
- tfhd: [],
- traf: [],
- trak: [],
- trun: [],
- trep: [],
- trex: [],
- tkhd: [],
- vmhd: [],
- smhd: [],
- };
- for (var type in MP4.types) {
- if (MP4.types.hasOwnProperty(type)) {
- MP4.types[type] = [
- type.charCodeAt(0),
- type.charCodeAt(1),
- type.charCodeAt(2),
- type.charCodeAt(3),
- ];
- }
- }
- var hdlr = new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x76, 0x69, 0x64, 0x65,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x56, 0x69, 0x64, 0x65,
- 0x6f, 0x48, 0x61, 0x6e,
- 0x64, 0x6c, 0x65, 0x72, 0x00,
- ]);
- var dref = new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x0c,
- 0x75, 0x72, 0x6c, 0x20,
- 0x00,
- 0x00, 0x00, 0x01,
- ]);
- var stco = new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- ]);
- MP4.STTS = MP4.STSC = MP4.STCO = stco;
- MP4.STSZ = new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- ]);
- MP4.VMHD = new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x01,
- 0x00, 0x00,
- 0x00, 0x00,
- 0x00, 0x00,
- 0x00, 0x00,
- ]);
- MP4.SMHD = new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00,
- 0x00, 0x00,
- ]);
- MP4.STSD = new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01
- ]);
- MP4.FTYP = MP4.box(MP4.types.ftyp, new Uint8Array([
- 0x69, 0x73, 0x6f, 0x35,
- 0x00, 0x00, 0x00, 0x01,
- 0x61, 0x76, 0x63, 0x31,
- 0x69, 0x73, 0x6f, 0x35,
- 0x64, 0x61, 0x73, 0x68,
- ]));
- MP4.STYP = MP4.box(MP4.types.styp, new Uint8Array([
- 0x6d, 0x73, 0x64, 0x68,
- 0x00, 0x00, 0x00, 0x00,
- 0x6d, 0x73, 0x64, 0x68,
- 0x6d, 0x73, 0x69, 0x78,
- ]));
- MP4.DINF = MP4.box(MP4.types.dinf, MP4.box(MP4.types.dref, dref));
- MP4.HDLR = MP4.box(MP4.types.hdlr, hdlr);
- };
- MP4.box = function (type) {
- var payload = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- payload[_i - 1] = arguments[_i];
- }
- var size = 8;
- for (var _a = 0, payload_1 = payload; _a < payload_1.length; _a++) {
- var p = payload_1[_a];
- size += p.byteLength;
- }
- var result = new Uint8Array(size);
- result[0] = (size >> 24) & 0xff;
- result[1] = (size >> 16) & 0xff;
- result[2] = (size >> 8) & 0xff;
- result[3] = size & 0xff;
- result.set(type, 4);
- size = 8;
- for (var _b = 0, payload_2 = payload; _b < payload_2.length; _b++) {
- var box = payload_2[_b];
- result.set(box, size);
- size += box.byteLength;
- }
- return result;
- };
- MP4.mdat = function (data) {
- return MP4.box(MP4.types.mdat, data);
- };
- MP4.mdhd = function (timescale) {
- return MP4.box(MP4.types.mdhd, new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x02,
- (timescale >> 24) & 0xFF,
- (timescale >> 16) & 0xFF,
- (timescale >> 8) & 0xFF,
- timescale & 0xFF,
- 0x00, 0x00, 0x00, 0x00,
- 0x55, 0xc4,
- 0x00, 0x00,
- ]));
- };
- MP4.mdia = function (track) {
- return MP4.box(MP4.types.mdia, MP4.mdhd(track.timescale), MP4.HDLR, MP4.minf(track));
- };
- MP4.mfhd = function (sequenceNumber) {
- return MP4.box(MP4.types.mfhd, new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- (sequenceNumber >> 24),
- (sequenceNumber >> 16) & 0xFF,
- (sequenceNumber >> 8) & 0xFF,
- sequenceNumber & 0xFF,
- ]));
- };
- MP4.minf = function (track) {
- return MP4.box(MP4.types.minf, MP4.box(MP4.types.vmhd, MP4.VMHD), MP4.DINF, MP4.stbl(track));
- };
- MP4.moof = function (sn, baseMediaDecodeTime, track) {
- return MP4.box(MP4.types.moof, MP4.mfhd(sn), MP4.traf(track, baseMediaDecodeTime));
- };
- MP4.moov = function (tracks, duration, timescale) {
- var boxes = [];
- for (var _i = 0, tracks_1 = tracks; _i < tracks_1.length; _i++) {
- var track = tracks_1[_i];
- boxes.push(MP4.trak(track));
- }
- return MP4.box.apply(MP4, [MP4.types.moov, MP4.mvhd(timescale, duration), MP4.mvex(tracks)].concat(boxes));
- };
- MP4.mvhd = function (timescale, duration) {
- var bytes = new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x02,
- (timescale >> 24) & 0xFF,
- (timescale >> 16) & 0xFF,
- (timescale >> 8) & 0xFF,
- timescale & 0xFF,
- (duration >> 24) & 0xFF,
- (duration >> 16) & 0xFF,
- (duration >> 8) & 0xFF,
- duration & 0xFF,
- 0x00, 0x01, 0x00, 0x00,
- 0x01, 0x00,
- 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x01, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x01, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x40, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x02,
- ]);
- return MP4.box(MP4.types.mvhd, bytes);
- };
- MP4.mvex = function (tracks) {
- var boxes = [];
- for (var _i = 0, tracks_2 = tracks; _i < tracks_2.length; _i++) {
- var track = tracks_2[_i];
- boxes.push(MP4.trex(track));
- }
- return MP4.box.apply(MP4, [MP4.types.mvex].concat(boxes, [MP4.trep()]));
- };
- MP4.trep = function () {
- return MP4.box(MP4.types.trep, new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x01,
- ]));
- };
- MP4.stbl = function (track) {
- return MP4.box(MP4.types.stbl, MP4.stsd(track), MP4.box(MP4.types.stts, MP4.STTS), MP4.box(MP4.types.stsc, MP4.STSC), MP4.box(MP4.types.stsz, MP4.STSZ), MP4.box(MP4.types.stco, MP4.STCO));
- };
- MP4.avc1 = function (track) {
- var sps = [];
- var pps = [];
- for (var _i = 0, _a = track.sps; _i < _a.length; _i++) {
- var data = _a[_i];
- var len = data.byteLength;
- sps.push((len >>> 8) & 0xFF);
- sps.push((len & 0xFF));
- sps = sps.concat(Array.prototype.slice.call(data));
- }
- for (var _b = 0, _c = track.pps; _b < _c.length; _b++) {
- var data = _c[_b];
- var len = data.byteLength;
- pps.push((len >>> 8) & 0xFF);
- pps.push((len & 0xFF));
- pps = pps.concat(Array.prototype.slice.call(data));
- }
- var avcc = MP4.box(MP4.types.avcC, new Uint8Array([
- 0x01,
- sps[3],
- sps[4],
- sps[5],
- 0xfc | 3,
- 0xE0 | track.sps.length,
- ].concat(sps).concat([
- track.pps.length,
- ]).concat(pps)));
- var width = track.width;
- var height = track.height;
- return MP4.box(MP4.types.avc1, new Uint8Array([
- 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x01,
- 0x00, 0x00,
- 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- (width >> 8) & 0xFF,
- width & 0xff,
- (height >> 8) & 0xFF,
- height & 0xff,
- 0x00, 0x48, 0x00, 0x00,
- 0x00, 0x48, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x01,
- 0x12,
- 0x62, 0x69, 0x6E, 0x65,
- 0x6C, 0x70, 0x72, 0x6F,
- 0x2E, 0x72, 0x75, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00,
- 0x00, 0x18,
- 0x11, 0x11
- ]), avcc, MP4.box(MP4.types.btrt, new Uint8Array([
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x2d, 0xc6, 0xc0,
- 0x00, 0x2d, 0xc6, 0xc0,
- ])));
- };
- MP4.stsd = function (track) {
- return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
- };
- MP4.tkhd = function (track) {
- var id = track.id;
- var width = track.width;
- var height = track.height;
- return MP4.box(MP4.types.tkhd, new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x02,
- (id >> 24) & 0xFF,
- (id >> 16) & 0xFF,
- (id >> 8) & 0xFF,
- id & 0xFF,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00,
- 0x00, 0x00,
- (track.type === 'audio' ? 0x01 : 0x00), 0x00,
- 0x00, 0x00,
- 0x00, 0x01, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x01, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x40, 0x00, 0x00, 0x00,
- (width >> 8) & 0xFF,
- width & 0xFF,
- 0x00, 0x00,
- (height >> 8) & 0xFF,
- height & 0xFF,
- 0x00, 0x00,
- ]));
- };
- MP4.traf = function (track, baseMediaDecodeTime) {
- var id = track.id;
- return MP4.box(MP4.types.traf, MP4.box(MP4.types.tfhd, new Uint8Array([
- 0x00,
- 0x02, 0x00, 0x00,
- (id >> 24),
- (id >> 16) & 0XFF,
- (id >> 8) & 0XFF,
- (id & 0xFF),
- ])), MP4.box(MP4.types.tfdt, new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- (baseMediaDecodeTime >> 24),
- (baseMediaDecodeTime >> 16) & 0XFF,
- (baseMediaDecodeTime >> 8) & 0XFF,
- (baseMediaDecodeTime & 0xFF),
- ])), MP4.trun(track, 16 +
- 16 +
- 8 +
- 16 +
- 8 +
- 8));
- };
- MP4.trak = function (track) {
- track.duration = track.duration || 0xffffffff;
- return MP4.box(MP4.types.trak, MP4.tkhd(track), MP4.mdia(track));
- };
- MP4.trex = function (track) {
- var id = track.id;
- return MP4.box(MP4.types.trex, new Uint8Array([
- 0x00,
- 0x00, 0x00, 0x00,
- (id >> 24),
- (id >> 16) & 0XFF,
- (id >> 8) & 0XFF,
- (id & 0xFF),
- 0x00, 0x00, 0x00, 0x01,
- 0x00, 0x00, 0x00, 0x3c,
- 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x01, 0x00, 0x00,
- ]));
- };
- MP4.trun = function (track, offset) {
- var samples = track.samples || [];
- var len = samples.length;
- var additionalLen = track.isKeyFrame ? 4 : 0;
- var arraylen = 12 + additionalLen + (4 * len);
- var array = new Uint8Array(arraylen);
- offset += 8 + arraylen;
- array.set([
- 0x00,
- 0x00, 0x02, (track.isKeyFrame ? 0x05 : 0x01),
- (len >>> 24) & 0xFF,
- (len >>> 16) & 0xFF,
- (len >>> 8) & 0xFF,
- len & 0xFF,
- (offset >>> 24) & 0xFF,
- (offset >>> 16) & 0xFF,
- (offset >>> 8) & 0xFF,
- offset & 0xFF,
- ], 0);
- if (track.isKeyFrame) {
- array.set([
- 0x00, 0x00, 0x00, 0x00,
- ], 12);
- }
- for (var i = 0; i < len; i++) {
- var sample = samples[i];
- var size = sample.size;
- array.set([
- (size >>> 24) & 0xFF,
- (size >>> 16) & 0xFF,
- (size >>> 8) & 0xFF,
- size & 0xFF,
- ], 12 + additionalLen + 4 * i);
- }
- return MP4.box(MP4.types.trun, array);
- };
- MP4.initSegment = function (tracks, duration, timescale) {
- if (!MP4.initalized) {
- MP4.init();
- }
- var movie = MP4.moov(tracks, duration, timescale);
- var result = new Uint8Array(MP4.FTYP.byteLength + movie.byteLength);
- result.set(MP4.FTYP);
- result.set(movie, MP4.FTYP.byteLength);
- return result;
- };
- MP4.fragmentSegment = function (sn, baseMediaDecodeTime, track, payload) {
- var moof = MP4.moof(sn, baseMediaDecodeTime, track);
- var mdat = MP4.mdat(payload);
- var result = new Uint8Array(MP4.STYP.byteLength + moof.byteLength + mdat.byteLength);
- result.set(MP4.STYP);
- result.set(moof, MP4.STYP.byteLength);
- result.set(mdat, MP4.STYP.byteLength + moof.byteLength);
- return result;
- };
- return MP4;
-}());
-MP4.types = {};
-MP4.initalized = false;
-exports.default = MP4;
-
-},{}],26:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var NALU = (function () {
- function NALU(data) {
- this.data = data;
- this.nri = (data[0] & 0x60) >> 5;
- this.ntype = data[0] & 0x1f;
- }
- Object.defineProperty(NALU, "NDR", {
- get: function () { return 1; },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(NALU, "IDR", {
- get: function () { return 5; },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(NALU, "SEI", {
- get: function () { return 6; },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(NALU, "SPS", {
- get: function () { return 7; },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(NALU, "PPS", {
- get: function () { return 8; },
- enumerable: true,
- configurable: true
- });
- Object.defineProperty(NALU, "TYPES", {
- get: function () {
- return _a = {},
- _a[NALU.IDR] = 'IDR',
- _a[NALU.SEI] = 'SEI',
- _a[NALU.SPS] = 'SPS',
- _a[NALU.PPS] = 'PPS',
- _a[NALU.NDR] = 'NDR',
- _a;
- var _a;
- },
- enumerable: true,
- configurable: true
- });
- NALU.type = function (nalu) {
- if (nalu.ntype in NALU.TYPES) {
- return NALU.TYPES[nalu.ntype];
- }
- else {
- return 'UNKNOWN';
- }
- };
- NALU.prototype.type = function () {
- return this.ntype;
- };
- NALU.prototype.isKeyframe = function () {
- return this.ntype === NALU.IDR;
- };
- NALU.prototype.getSize = function () {
- return 4 + this.data.byteLength;
- };
- NALU.prototype.getData = function () {
- var result = new Uint8Array(this.getSize());
- var view = new DataView(result.buffer);
- view.setUint32(0, this.getSize() - 4);
- result.set(this.data, 4);
- return result;
- };
- return NALU;
-}());
-exports.default = NALU;
-
-},{}],27:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var BitStream = (function () {
- function BitStream(data) {
- this.data = data;
- this.index = 0;
- this.bitLength = data.byteLength * 8;
- }
- Object.defineProperty(BitStream.prototype, "bitsAvailable", {
- get: function () {
- return this.bitLength - this.index;
- },
- enumerable: true,
- configurable: true
- });
- BitStream.prototype.skipBits = function (size) {
- if (this.bitsAvailable < size) {
- throw new Error('no bytes available');
- }
- this.index += size;
- };
- BitStream.prototype.readBits = function (size) {
- var result = this.getBits(size, this.index);
- return result;
- };
- BitStream.prototype.getBits = function (size, offsetBits, moveIndex) {
- if (moveIndex === void 0) { moveIndex = true; }
- if (this.bitsAvailable < size) {
- throw new Error('no bytes available');
- }
- var offset = offsetBits % 8;
- var byte = this.data[(offsetBits / 8) | 0] & (0xff >>> offset);
- var bits = 8 - offset;
- if (bits >= size) {
- if (moveIndex) {
- this.index += size;
- }
- return byte >> (bits - size);
- }
- else {
- if (moveIndex) {
- this.index += bits;
- }
- var nextSize = size - bits;
- return (byte << nextSize) | this.getBits(nextSize, offsetBits + bits, moveIndex);
- }
- };
- BitStream.prototype.skipLZ = function () {
- var leadingZeroCount;
- for (leadingZeroCount = 0; leadingZeroCount < this.bitLength - this.index; ++leadingZeroCount) {
- if (0 !== this.getBits(1, this.index + leadingZeroCount, false)) {
- this.index += leadingZeroCount;
- return leadingZeroCount;
- }
- }
- return leadingZeroCount;
- };
- BitStream.prototype.skipUEG = function () {
- this.skipBits(1 + this.skipLZ());
- };
- BitStream.prototype.skipEG = function () {
- this.skipBits(1 + this.skipLZ());
- };
- BitStream.prototype.readUEG = function () {
- var prefix = this.skipLZ();
- return this.readBits(prefix + 1) - 1;
- };
- BitStream.prototype.readEG = function () {
- var value = this.readUEG();
- if (0x01 & value) {
- return (1 + value) >>> 1;
- }
- else {
- return -1 * (value >>> 1);
- }
- };
- BitStream.prototype.readBoolean = function () {
- return 1 === this.readBits(1);
- };
- BitStream.prototype.readUByte = function () {
- return this.readBits(8);
- };
- BitStream.prototype.readUShort = function () {
- return this.readBits(16);
- };
- BitStream.prototype.readUInt = function () {
- return this.readBits(32);
- };
- return BitStream;
-}());
-exports.default = BitStream;
-
-},{}],28:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var logger;
-var errorLogger;
-function setLogger(log, error) {
- logger = log;
- errorLogger = error != null ? error : log;
-}
-exports.setLogger = setLogger;
-function isEnable() {
- return logger != null;
-}
-exports.isEnable = isEnable;
-function log(message) {
- var optionalParams = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- optionalParams[_i - 1] = arguments[_i];
- }
- if (logger) {
- logger.apply(void 0, [message].concat(optionalParams));
- }
-}
-exports.log = log;
-function error(message) {
- var optionalParams = [];
- for (var _i = 1; _i < arguments.length; _i++) {
- optionalParams[_i - 1] = arguments[_i];
- }
- if (errorLogger) {
- errorLogger.apply(void 0, [message].concat(optionalParams));
- }
-}
-exports.error = error;
-
-},{}],29:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var NALU_1 = require("./NALU");
-var VideoStreamBuffer = (function () {
- function VideoStreamBuffer() {
- }
- VideoStreamBuffer.prototype.clear = function () {
- this.buffer = undefined;
- };
- VideoStreamBuffer.prototype.append = function (value) {
- var nextNalHeader = function (b) {
- var i = 3;
- return function () {
- var count = 0;
- for (; i < b.length; i++) {
- switch (b[i]) {
- case 0:
- count++;
- break;
- case 1:
- if (count === 3) {
- return i - 3;
- }
- default:
- count = 0;
- }
- }
- return;
- };
- };
- var result = [];
- var buffer;
- if (this.buffer) {
- if (value[3] === 1 && value[2] === 0 && value[1] === 0 && value[0] === 0) {
- result.push(new NALU_1.default(this.buffer.subarray(4)));
- buffer = Uint8Array.from(value);
- }
- }
- if (buffer == null) {
- buffer = this.mergeBuffer(value);
- }
- var lastIndex = 0;
- var f = nextNalHeader(buffer);
- for (var index = f(); index != null; index = f()) {
- result.push(new NALU_1.default(buffer.subarray(lastIndex + 4, index)));
- lastIndex = index;
- }
- this.buffer = buffer.subarray(lastIndex);
- return result;
- };
- VideoStreamBuffer.prototype.mergeBuffer = function (value) {
- if (this.buffer == null) {
- return Uint8Array.from(value);
- }
- else {
- var newBuffer = new Uint8Array(this.buffer.byteLength + value.length);
- if (this.buffer.byteLength > 0) {
- newBuffer.set(this.buffer, 0);
- }
- newBuffer.set(value, this.buffer.byteLength);
- return newBuffer;
- }
- };
- return VideoStreamBuffer;
-}());
-exports.default = VideoStreamBuffer;
-
-},{"./NALU":26}],30:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var h264_remuxer_1 = require("./h264-remuxer");
-var mp4_generator_1 = require("./mp4-generator");
-var debug = require("./util/debug");
-var nalu_stream_buffer_1 = require("./util/nalu-stream-buffer");
-exports.mimeType = 'video/mp4; codecs="avc1.42E01E"';
-var VideoConverter = (function () {
- function VideoConverter(element, fps, fpf) {
- if (fps === void 0) { fps = 60; }
- if (fpf === void 0) { fpf = fps; }
- this.element = element;
- this.fps = fps;
- this.fpf = fpf;
- this.receiveBuffer = new nalu_stream_buffer_1.default();
- this.queue = [];
- if (!MediaSource || !MediaSource.isTypeSupported(exports.mimeType)) {
- throw new Error("Your browser is not supported: " + exports.mimeType);
- }
- this.reset();
- }
- Object.defineProperty(VideoConverter, "errorNotes", {
- get: function () {
- return _a = {},
- _a[MediaError.MEDIA_ERR_ABORTED] = 'fetching process aborted by user',
- _a[MediaError.MEDIA_ERR_NETWORK] = 'error occurred when downloading',
- _a[MediaError.MEDIA_ERR_DECODE] = 'error occurred when decoding',
- _a[MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED] = 'audio/video not supported',
- _a;
- var _a;
- },
- enumerable: true,
- configurable: true
- });
- VideoConverter.prototype.setup = function () {
- var _this = this;
- this.mediaReadyPromise = new Promise(function (resolve, _reject) {
- _this.mediaSource.addEventListener('sourceopen', function () {
- debug.log("Media Source opened.");
- _this.sourceBuffer = _this.mediaSource.addSourceBuffer(exports.mimeType);
- _this.sourceBuffer.addEventListener('updateend', function () {
- debug.log(" SourceBuffer updateend");
- debug.log(" sourceBuffer.buffered.length=" + _this.sourceBuffer.buffered.length);
- for (var i = 0, len = _this.sourceBuffer.buffered.length; i < len; i++) {
- debug.log(" sourceBuffer.buffered [" + i + "]: " +
- (_this.sourceBuffer.buffered.start(i) + ", " + _this.sourceBuffer.buffered.end(i)));
- }
- debug.log(" mediasource.duration=" + _this.mediaSource.duration);
- debug.log(" mediasource.readyState=" + _this.mediaSource.readyState);
- debug.log(" video.duration=" + _this.element.duration);
- debug.log(" video.buffered.length=" + _this.element.buffered.length);
- if (debug.isEnable()) {
- for (var i = 0, len = _this.element.buffered.length; i < len; i++) {
- debug.log(" video.buffered [" + i + "]: " + _this.element.buffered.start(i) + ", " + _this.element.buffered.end(i));
- }
- }
- debug.log(" video.currentTime=" + _this.element.currentTime);
- debug.log(" video.readyState=" + _this.element.readyState);
- var data = _this.queue.shift();
- if (data) {
- _this.writeBuffer(data);
- }
- });
- _this.sourceBuffer.addEventListener('error', function () {
- debug.error(' SourceBuffer errored!');
- });
- _this.mediaReady = true;
- resolve();
- }, false);
- _this.mediaSource.addEventListener('sourceclose', function () {
- debug.log("Media Source closed.");
- _this.mediaReady = false;
- }, false);
- _this.element.src = URL.createObjectURL(_this.mediaSource);
- });
- return this.mediaReadyPromise;
- };
- VideoConverter.prototype.play = function () {
- var _this = this;
- if (!this.element.paused) {
- return;
- }
- if (this.mediaReady && this.element.readyState >= 2) {
- this.element.play();
- }
- else {
- var handler_1 = function () {
- _this.play();
- _this.element.removeEventListener('canplaythrough', handler_1);
- };
- this.element.addEventListener('canplaythrough', handler_1);
- }
- };
- VideoConverter.prototype.pause = function () {
- if (this.element.paused) {
- return;
- }
- this.element.pause();
- };
- VideoConverter.prototype.reset = function () {
- this.receiveBuffer.clear();
- if (this.mediaSource && this.mediaSource.readyState === 'open') {
- this.mediaSource.duration = 0;
- this.mediaSource.endOfStream();
- }
- this.mediaSource = new MediaSource();
- this.remuxer = new h264_remuxer_1.default(this.fps, this.fpf, this.fps * 60);
- this.mediaReady = false;
- this.mediaReadyPromise = undefined;
- this.queue = [];
- this.isFirstFrame = true;
- this.setup();
- };
- VideoConverter.prototype.appendRawData = function (data) {
- var nalus = this.receiveBuffer.append(data);
- for (var _i = 0, nalus_1 = nalus; _i < nalus_1.length; _i++) {
- var nalu = nalus_1[_i];
- var ret = this.remuxer.remux(nalu);
- if (ret) {
- this.writeFragment(ret[0], ret[1]);
- }
- }
- };
- VideoConverter.prototype.writeFragment = function (dts, pay) {
- var remuxer = this.remuxer;
- if (remuxer.mp4track.isKeyFrame) {
- this.writeBuffer(mp4_generator_1.default.initSegment([remuxer.mp4track], Infinity, remuxer.timescale));
- }
- if (pay && pay.byteLength) {
- debug.log(" Put fragment: " + remuxer.seqNum + ", frames=" + remuxer.mp4track.samples.length + ", size=" + pay.byteLength);
- var fragment = mp4_generator_1.default.fragmentSegment(remuxer.seqNum, dts, remuxer.mp4track, pay);
- this.writeBuffer(fragment);
- remuxer.flush();
- }
- else {
- debug.error("Nothing payload!");
- }
- };
- VideoConverter.prototype.writeBuffer = function (data) {
- var _this = this;
- if (this.mediaReady) {
- if (this.sourceBuffer.updating) {
- this.queue.push(data);
- }
- else {
- this.doAppend(data);
- }
- }
- else {
- this.queue.push(data);
- if (this.mediaReadyPromise) {
- this.mediaReadyPromise.then(function () {
- if (!_this.sourceBuffer.updating) {
- var d = _this.queue.shift();
- if (d) {
- _this.writeBuffer(d);
- }
- }
- });
- this.mediaReadyPromise = undefined;
- }
- }
- };
- VideoConverter.prototype.doAppend = function (data) {
- var error = this.element.error;
- if (error) {
- debug.error("MSE Error Occured: " + VideoConverter.errorNotes[error.code]);
- this.element.pause();
- if (this.mediaSource.readyState === 'open') {
- this.mediaSource.endOfStream();
- }
- }
- else {
- try {
- this.sourceBuffer.appendBuffer(data);
- debug.log(" appended buffer: size=" + data.byteLength);
- }
- catch (err) {
- debug.error("MSE Error occured while appending buffer. " + err.name + ": " + err.message);
- }
- }
- };
- return VideoConverter;
-}());
-exports.default = VideoConverter;
-
-},{"./h264-remuxer":24,"./mp4-generator":25,"./util/debug":28,"./util/nalu-stream-buffer":29}],31:[function(require,module,exports){
-arguments[4][1][0].apply(exports,arguments)
-},{"dup":1,"readable-stream":48,"safe-buffer":49,"util":74}],32:[function(require,module,exports){
-(function (Buffer){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// NOTE: These type checking functions intentionally don't use `instanceof`
-// because it is fragile and can be easily faked with `Object.create()`.
-
-function isArray(arg) {
- if (Array.isArray) {
- return Array.isArray(arg);
- }
- return objectToString(arg) === '[object Array]';
-}
-exports.isArray = isArray;
-
-function isBoolean(arg) {
- return typeof arg === 'boolean';
-}
-exports.isBoolean = isBoolean;
-
-function isNull(arg) {
- return arg === null;
-}
-exports.isNull = isNull;
-
-function isNullOrUndefined(arg) {
- return arg == null;
-}
-exports.isNullOrUndefined = isNullOrUndefined;
-
-function isNumber(arg) {
- return typeof arg === 'number';
-}
-exports.isNumber = isNumber;
-
-function isString(arg) {
- return typeof arg === 'string';
-}
-exports.isString = isString;
-
-function isSymbol(arg) {
- return typeof arg === 'symbol';
-}
-exports.isSymbol = isSymbol;
-
-function isUndefined(arg) {
- return arg === void 0;
-}
-exports.isUndefined = isUndefined;
-
-function isRegExp(re) {
- return objectToString(re) === '[object RegExp]';
-}
-exports.isRegExp = isRegExp;
-
-function isObject(arg) {
- return typeof arg === 'object' && arg !== null;
-}
-exports.isObject = isObject;
-
-function isDate(d) {
- return objectToString(d) === '[object Date]';
-}
-exports.isDate = isDate;
-
-function isError(e) {
- return (objectToString(e) === '[object Error]' || e instanceof Error);
-}
-exports.isError = isError;
-
-function isFunction(arg) {
- return typeof arg === 'function';
-}
-exports.isFunction = isFunction;
-
-function isPrimitive(arg) {
- return arg === null ||
- typeof arg === 'boolean' ||
- typeof arg === 'number' ||
- typeof arg === 'string' ||
- typeof arg === 'symbol' || // ES6 symbol
- typeof arg === 'undefined';
-}
-exports.isPrimitive = isPrimitive;
-
-exports.isBuffer = Buffer.isBuffer;
-
-function objectToString(o) {
- return Object.prototype.toString.call(o);
-}
-
-}).call(this,{"isBuffer":require("../../../../../../../../../usr/local/lib/node_modules/browserify/node_modules/is-buffer/index.js")})
-},{"../../../../../../../../../usr/local/lib/node_modules/browserify/node_modules/is-buffer/index.js":68}],33:[function(require,module,exports){
-arguments[4][3][0].apply(exports,arguments)
-},{"dup":3}],34:[function(require,module,exports){
-arguments[4][4][0].apply(exports,arguments)
-},{"dup":4}],35:[function(require,module,exports){
-arguments[4][5][0].apply(exports,arguments)
-},{"./lib/decoder":36,"./lib/encoder":37,"./lib/streams":38,"assert":59,"bl":31,"dup":5,"safe-buffer":49}],36:[function(require,module,exports){
-arguments[4][6][0].apply(exports,arguments)
-},{"bl":31,"dup":6,"util":74}],37:[function(require,module,exports){
-arguments[4][7][0].apply(exports,arguments)
-},{"bl":31,"dup":7,"safe-buffer":49}],38:[function(require,module,exports){
-arguments[4][8][0].apply(exports,arguments)
-},{"bl":31,"dup":8,"inherits":33,"readable-stream":48}],39:[function(require,module,exports){
-(function (process){
-'use strict';
-
-if (typeof process === 'undefined' ||
- !process.version ||
- process.version.indexOf('v0.') === 0 ||
- process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
- module.exports = { nextTick: nextTick };
-} else {
- module.exports = process
-}
-
-function nextTick(fn, arg1, arg2, arg3) {
- if (typeof fn !== 'function') {
- throw new TypeError('"callback" argument must be a function');
- }
- var len = arguments.length;
- var args, i;
- switch (len) {
- case 0:
- case 1:
- return process.nextTick(fn);
- case 2:
- return process.nextTick(function afterTickOne() {
- fn.call(null, arg1);
- });
- case 3:
- return process.nextTick(function afterTickTwo() {
- fn.call(null, arg1, arg2);
- });
- case 4:
- return process.nextTick(function afterTickThree() {
- fn.call(null, arg1, arg2, arg3);
- });
- default:
- args = new Array(len - 1);
- i = 0;
- while (i < args.length) {
- args[i++] = arguments[i];
- }
- return process.nextTick(function afterTick() {
- fn.apply(null, args);
- });
- }
-}
-
-
-}).call(this,require('_process'))
-},{"_process":70}],40:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a duplex stream is just a stream that is both readable and writable.
-// Since JS doesn't have multiple prototypal inheritance, this class
-// prototypally inherits from Readable, and then parasitically from
-// Writable.
-
-'use strict';
-
-/*<replacement>*/
-
-var pna = require('process-nextick-args');
-/*</replacement>*/
-
-/*<replacement>*/
-var objectKeys = Object.keys || function (obj) {
- var keys = [];
- for (var key in obj) {
- keys.push(key);
- }return keys;
-};
-/*</replacement>*/
-
-module.exports = Duplex;
-
-/*<replacement>*/
-var util = Object.create(require('core-util-is'));
-util.inherits = require('inherits');
-/*</replacement>*/
-
-var Readable = require('./_stream_readable');
-var Writable = require('./_stream_writable');
-
-util.inherits(Duplex, Readable);
-
-{
- // avoid scope creep, the keys array can then be collected
- var keys = objectKeys(Writable.prototype);
- for (var v = 0; v < keys.length; v++) {
- var method = keys[v];
- if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
- }
-}
-
-function Duplex(options) {
- if (!(this instanceof Duplex)) return new Duplex(options);
-
- Readable.call(this, options);
- Writable.call(this, options);
-
- if (options && options.readable === false) this.readable = false;
-
- if (options && options.writable === false) this.writable = false;
-
- this.allowHalfOpen = true;
- if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
-
- this.once('end', onend);
-}
-
-Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
- // making it explicit this property is not enumerable
- // because otherwise some prototype manipulation in
- // userland will fail
- enumerable: false,
- get: function () {
- return this._writableState.highWaterMark;
- }
-});
-
-// the no-half-open enforcer
-function onend() {
- // if we allow half-open state, or if the writable side ended,
- // then we're ok.
- if (this.allowHalfOpen || this._writableState.ended) return;
-
- // no more data can be written.
- // But allow more writes to happen in this tick.
- pna.nextTick(onEndNT, this);
-}
-
-function onEndNT(self) {
- self.end();
-}
-
-Object.defineProperty(Duplex.prototype, 'destroyed', {
- get: function () {
- if (this._readableState === undefined || this._writableState === undefined) {
- return false;
- }
- return this._readableState.destroyed && this._writableState.destroyed;
- },
- set: function (value) {
- // we ignore the value if the stream
- // has not been initialized yet
- if (this._readableState === undefined || this._writableState === undefined) {
- return;
- }
-
- // backward compatibility, the user is explicitly
- // managing destroyed
- this._readableState.destroyed = value;
- this._writableState.destroyed = value;
- }
-});
-
-Duplex.prototype._destroy = function (err, cb) {
- this.push(null);
- this.end();
-
- pna.nextTick(cb, err);
-};
-},{"./_stream_readable":42,"./_stream_writable":44,"core-util-is":32,"inherits":33,"process-nextick-args":39}],41:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a passthrough stream.
-// basically just the most minimal sort of Transform stream.
-// Every written chunk gets output as-is.
-
-'use strict';
-
-module.exports = PassThrough;
-
-var Transform = require('./_stream_transform');
-
-/*<replacement>*/
-var util = Object.create(require('core-util-is'));
-util.inherits = require('inherits');
-/*</replacement>*/
-
-util.inherits(PassThrough, Transform);
-
-function PassThrough(options) {
- if (!(this instanceof PassThrough)) return new PassThrough(options);
-
- Transform.call(this, options);
-}
-
-PassThrough.prototype._transform = function (chunk, encoding, cb) {
- cb(null, chunk);
-};
-},{"./_stream_transform":43,"core-util-is":32,"inherits":33}],42:[function(require,module,exports){
-(function (process,global){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-'use strict';
-
-/*<replacement>*/
-
-var pna = require('process-nextick-args');
-/*</replacement>*/
-
-module.exports = Readable;
-
-/*<replacement>*/
-var isArray = require('isarray');
-/*</replacement>*/
-
-/*<replacement>*/
-var Duplex;
-/*</replacement>*/
-
-Readable.ReadableState = ReadableState;
-
-/*<replacement>*/
-var EE = require('events').EventEmitter;
-
-var EElistenerCount = function (emitter, type) {
- return emitter.listeners(type).length;
-};
-/*</replacement>*/
-
-/*<replacement>*/
-var Stream = require('./internal/streams/stream');
-/*</replacement>*/
-
-/*<replacement>*/
-
-var Buffer = require('safe-buffer').Buffer;
-var OurUint8Array = global.Uint8Array || function () {};
-function _uint8ArrayToBuffer(chunk) {
- return Buffer.from(chunk);
-}
-function _isUint8Array(obj) {
- return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
-}
-
-/*</replacement>*/
-
-/*<replacement>*/
-var util = Object.create(require('core-util-is'));
-util.inherits = require('inherits');
-/*</replacement>*/
-
-/*<replacement>*/
-var debugUtil = require('util');
-var debug = void 0;
-if (debugUtil && debugUtil.debuglog) {
- debug = debugUtil.debuglog('stream');
-} else {
- debug = function () {};
-}
-/*</replacement>*/
-
-var BufferList = require('./internal/streams/BufferList');
-var destroyImpl = require('./internal/streams/destroy');
-var StringDecoder;
-
-util.inherits(Readable, Stream);
-
-var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
-
-function prependListener(emitter, event, fn) {
- // Sadly this is not cacheable as some libraries bundle their own
- // event emitter implementation with them.
- if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
-
- // This is a hack to make sure that our error handler is attached before any
- // userland ones. NEVER DO THIS. This is here only because this code needs
- // to continue to work with older versions of Node.js that do not include
- // the prependListener() method. The goal is to eventually remove this hack.
- if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
-}
-
-function ReadableState(options, stream) {
- Duplex = Duplex || require('./_stream_duplex');
-
- options = options || {};
-
- // Duplex streams are both readable and writable, but share
- // the same options object.
- // However, some cases require setting options to different
- // values for the readable and the writable sides of the duplex stream.
- // These options can be provided separately as readableXXX and writableXXX.
- var isDuplex = stream instanceof Duplex;
-
- // object stream flag. Used to make read(n) ignore n and to
- // make all the buffer merging and length checks go away
- this.objectMode = !!options.objectMode;
-
- if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
-
- // the point at which it stops calling _read() to fill the buffer
- // Note: 0 is a valid value, means "don't call _read preemptively ever"
- var hwm = options.highWaterMark;
- var readableHwm = options.readableHighWaterMark;
- var defaultHwm = this.objectMode ? 16 : 16 * 1024;
-
- if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
-
- // cast to ints.
- this.highWaterMark = Math.floor(this.highWaterMark);
-
- // A linked list is used to store data chunks instead of an array because the
- // linked list can remove elements from the beginning faster than
- // array.shift()
- this.buffer = new BufferList();
- this.length = 0;
- this.pipes = null;
- this.pipesCount = 0;
- this.flowing = null;
- this.ended = false;
- this.endEmitted = false;
- this.reading = false;
-
- // a flag to be able to tell if the event 'readable'/'data' is emitted
- // immediately, or on a later tick. We set this to true at first, because
- // any actions that shouldn't happen until "later" should generally also
- // not happen before the first read call.
- this.sync = true;
-
- // whenever we return null, then we set a flag to say
- // that we're awaiting a 'readable' event emission.
- this.needReadable = false;
- this.emittedReadable = false;
- this.readableListening = false;
- this.resumeScheduled = false;
-
- // has it been destroyed
- this.destroyed = false;
-
- // Crypto is kind of old and crusty. Historically, its default string
- // encoding is 'binary' so we have to make this configurable.
- // Everything else in the universe uses 'utf8', though.
- this.defaultEncoding = options.defaultEncoding || 'utf8';
-
- // the number of writers that are awaiting a drain event in .pipe()s
- this.awaitDrain = 0;
-
- // if true, a maybeReadMore has been scheduled
- this.readingMore = false;
-
- this.decoder = null;
- this.encoding = null;
- if (options.encoding) {
- if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
- this.decoder = new StringDecoder(options.encoding);
- this.encoding = options.encoding;
- }
-}
-
-function Readable(options) {
- Duplex = Duplex || require('./_stream_duplex');
-
- if (!(this instanceof Readable)) return new Readable(options);
-
- this._readableState = new ReadableState(options, this);
-
- // legacy
- this.readable = true;
-
- if (options) {
- if (typeof options.read === 'function') this._read = options.read;
-
- if (typeof options.destroy === 'function') this._destroy = options.destroy;
- }
-
- Stream.call(this);
-}
-
-Object.defineProperty(Readable.prototype, 'destroyed', {
- get: function () {
- if (this._readableState === undefined) {
- return false;
- }
- return this._readableState.destroyed;
- },
- set: function (value) {
- // we ignore the value if the stream
- // has not been initialized yet
- if (!this._readableState) {
- return;
- }
-
- // backward compatibility, the user is explicitly
- // managing destroyed
- this._readableState.destroyed = value;
- }
-});
-
-Readable.prototype.destroy = destroyImpl.destroy;
-Readable.prototype._undestroy = destroyImpl.undestroy;
-Readable.prototype._destroy = function (err, cb) {
- this.push(null);
- cb(err);
-};
-
-// Manually shove something into the read() buffer.
-// This returns true if the highWaterMark has not been hit yet,
-// similar to how Writable.write() returns true if you should
-// write() some more.
-Readable.prototype.push = function (chunk, encoding) {
- var state = this._readableState;
- var skipChunkCheck;
-
- if (!state.objectMode) {
- if (typeof chunk === 'string') {
- encoding = encoding || state.defaultEncoding;
- if (encoding !== state.encoding) {
- chunk = Buffer.from(chunk, encoding);
- encoding = '';
- }
- skipChunkCheck = true;
- }
- } else {
- skipChunkCheck = true;
- }
-
- return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
-};
-
-// Unshift should *always* be something directly out of read()
-Readable.prototype.unshift = function (chunk) {
- return readableAddChunk(this, chunk, null, true, false);
-};
-
-function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
- var state = stream._readableState;
- if (chunk === null) {
- state.reading = false;
- onEofChunk(stream, state);
- } else {
- var er;
- if (!skipChunkCheck) er = chunkInvalid(state, chunk);
- if (er) {
- stream.emit('error', er);
- } else if (state.objectMode || chunk && chunk.length > 0) {
- if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
- chunk = _uint8ArrayToBuffer(chunk);
- }
-
- if (addToFront) {
- if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
- } else if (state.ended) {
- stream.emit('error', new Error('stream.push() after EOF'));
- } else {
- state.reading = false;
- if (state.decoder && !encoding) {
- chunk = state.decoder.write(chunk);
- if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
- } else {
- addChunk(stream, state, chunk, false);
- }
- }
- } else if (!addToFront) {
- state.reading = false;
- }
- }
-
- return needMoreData(state);
-}
-
-function addChunk(stream, state, chunk, addToFront) {
- if (state.flowing && state.length === 0 && !state.sync) {
- stream.emit('data', chunk);
- stream.read(0);
- } else {
- // update the buffer info.
- state.length += state.objectMode ? 1 : chunk.length;
- if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
-
- if (state.needReadable) emitReadable(stream);
- }
- maybeReadMore(stream, state);
-}
-
-function chunkInvalid(state, chunk) {
- var er;
- if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
- er = new TypeError('Invalid non-string/buffer chunk');
- }
- return er;
-}
-
-// if it's past the high water mark, we can push in some more.
-// Also, if we have no data yet, we can stand some
-// more bytes. This is to work around cases where hwm=0,
-// such as the repl. Also, if the push() triggered a
-// readable event, and the user called read(largeNumber) such that
-// needReadable was set, then we ought to push more, so that another
-// 'readable' event will be triggered.
-function needMoreData(state) {
- return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
-}
-
-Readable.prototype.isPaused = function () {
- return this._readableState.flowing === false;
-};
-
-// backwards compatibility.
-Readable.prototype.setEncoding = function (enc) {
- if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
- this._readableState.decoder = new StringDecoder(enc);
- this._readableState.encoding = enc;
- return this;
-};
-
-// Don't raise the hwm > 8MB
-var MAX_HWM = 0x800000;
-function computeNewHighWaterMark(n) {
- if (n >= MAX_HWM) {
- n = MAX_HWM;
- } else {
- // Get the next highest power of 2 to prevent increasing hwm excessively in
- // tiny amounts
- n--;
- n |= n >>> 1;
- n |= n >>> 2;
- n |= n >>> 4;
- n |= n >>> 8;
- n |= n >>> 16;
- n++;
- }
- return n;
-}
-
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function howMuchToRead(n, state) {
- if (n <= 0 || state.length === 0 && state.ended) return 0;
- if (state.objectMode) return 1;
- if (n !== n) {
- // Only flow one buffer at a time
- if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
- }
- // If we're asking for more than the current hwm, then raise the hwm.
- if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
- if (n <= state.length) return n;
- // Don't have enough
- if (!state.ended) {
- state.needReadable = true;
- return 0;
- }
- return state.length;
-}
-
-// you can override either this method, or the async _read(n) below.
-Readable.prototype.read = function (n) {
- debug('read', n);
- n = parseInt(n, 10);
- var state = this._readableState;
- var nOrig = n;
-
- if (n !== 0) state.emittedReadable = false;
-
- // if we're doing read(0) to trigger a readable event, but we
- // already have a bunch of data in the buffer, then just trigger
- // the 'readable' event and move on.
- if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
- debug('read: emitReadable', state.length, state.ended);
- if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
- return null;
- }
-
- n = howMuchToRead(n, state);
-
- // if we've ended, and we're now clear, then finish it up.
- if (n === 0 && state.ended) {
- if (state.length === 0) endReadable(this);
- return null;
- }
-
- // All the actual chunk generation logic needs to be
- // *below* the call to _read. The reason is that in certain
- // synthetic stream cases, such as passthrough streams, _read
- // may be a completely synchronous operation which may change
- // the state of the read buffer, providing enough data when
- // before there was *not* enough.
- //
- // So, the steps are:
- // 1. Figure out what the state of things will be after we do
- // a read from the buffer.
- //
- // 2. If that resulting state will trigger a _read, then call _read.
- // Note that this may be asynchronous, or synchronous. Yes, it is
- // deeply ugly to write APIs this way, but that still doesn't mean
- // that the Readable class should behave improperly, as streams are
- // designed to be sync/async agnostic.
- // Take note if the _read call is sync or async (ie, if the read call
- // has returned yet), so that we know whether or not it's safe to emit
- // 'readable' etc.
- //
- // 3. Actually pull the requested chunks out of the buffer and return.
-
- // if we need a readable event, then we need to do some reading.
- var doRead = state.needReadable;
- debug('need readable', doRead);
-
- // if we currently have less than the highWaterMark, then also read some
- if (state.length === 0 || state.length - n < state.highWaterMark) {
- doRead = true;
- debug('length less than watermark', doRead);
- }
-
- // however, if we've ended, then there's no point, and if we're already
- // reading, then it's unnecessary.
- if (state.ended || state.reading) {
- doRead = false;
- debug('reading or ended', doRead);
- } else if (doRead) {
- debug('do read');
- state.reading = true;
- state.sync = true;
- // if the length is currently zero, then we *need* a readable event.
- if (state.length === 0) state.needReadable = true;
- // call internal read method
- this._read(state.highWaterMark);
- state.sync = false;
- // If _read pushed data synchronously, then `reading` will be false,
- // and we need to re-evaluate how much data we can return to the user.
- if (!state.reading) n = howMuchToRead(nOrig, state);
- }
-
- var ret;
- if (n > 0) ret = fromList(n, state);else ret = null;
-
- if (ret === null) {
- state.needReadable = true;
- n = 0;
- } else {
- state.length -= n;
- }
-
- if (state.length === 0) {
- // If we have nothing in the buffer, then we want to know
- // as soon as we *do* get something into the buffer.
- if (!state.ended) state.needReadable = true;
-
- // If we tried to read() past the EOF, then emit end on the next tick.
- if (nOrig !== n && state.ended) endReadable(this);
- }
-
- if (ret !== null) this.emit('data', ret);
-
- return ret;
-};
-
-function onEofChunk(stream, state) {
- if (state.ended) return;
- if (state.decoder) {
- var chunk = state.decoder.end();
- if (chunk && chunk.length) {
- state.buffer.push(chunk);
- state.length += state.objectMode ? 1 : chunk.length;
- }
- }
- state.ended = true;
-
- // emit 'readable' now to make sure it gets picked up.
- emitReadable(stream);
-}
-
-// Don't emit readable right away in sync mode, because this can trigger
-// another read() call => stack overflow. This way, it might trigger
-// a nextTick recursion warning, but that's not so bad.
-function emitReadable(stream) {
- var state = stream._readableState;
- state.needReadable = false;
- if (!state.emittedReadable) {
- debug('emitReadable', state.flowing);
- state.emittedReadable = true;
- if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
- }
-}
-
-function emitReadable_(stream) {
- debug('emit readable');
- stream.emit('readable');
- flow(stream);
-}
-
-// at this point, the user has presumably seen the 'readable' event,
-// and called read() to consume some data. that may have triggered
-// in turn another _read(n) call, in which case reading = true if
-// it's in progress.
-// However, if we're not ended, or reading, and the length < hwm,
-// then go ahead and try to read some more preemptively.
-function maybeReadMore(stream, state) {
- if (!state.readingMore) {
- state.readingMore = true;
- pna.nextTick(maybeReadMore_, stream, state);
- }
-}
-
-function maybeReadMore_(stream, state) {
- var len = state.length;
- while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
- debug('maybeReadMore read 0');
- stream.read(0);
- if (len === state.length)
- // didn't get any data, stop spinning.
- break;else len = state.length;
- }
- state.readingMore = false;
-}
-
-// abstract method. to be overridden in specific implementation classes.
-// call cb(er, data) where data is <= n in length.
-// for virtual (non-string, non-buffer) streams, "length" is somewhat
-// arbitrary, and perhaps not very meaningful.
-Readable.prototype._read = function (n) {
- this.emit('error', new Error('_read() is not implemented'));
-};
-
-Readable.prototype.pipe = function (dest, pipeOpts) {
- var src = this;
- var state = this._readableState;
-
- switch (state.pipesCount) {
- case 0:
- state.pipes = dest;
- break;
- case 1:
- state.pipes = [state.pipes, dest];
- break;
- default:
- state.pipes.push(dest);
- break;
- }
- state.pipesCount += 1;
- debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
-
- var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
-
- var endFn = doEnd ? onend : unpipe;
- if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
-
- dest.on('unpipe', onunpipe);
- function onunpipe(readable, unpipeInfo) {
- debug('onunpipe');
- if (readable === src) {
- if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
- unpipeInfo.hasUnpiped = true;
- cleanup();
- }
- }
- }
-
- function onend() {
- debug('onend');
- dest.end();
- }
-
- // when the dest drains, it reduces the awaitDrain counter
- // on the source. This would be more elegant with a .once()
- // handler in flow(), but adding and removing repeatedly is
- // too slow.
- var ondrain = pipeOnDrain(src);
- dest.on('drain', ondrain);
-
- var cleanedUp = false;
- function cleanup() {
- debug('cleanup');
- // cleanup event handlers once the pipe is broken
- dest.removeListener('close', onclose);
- dest.removeListener('finish', onfinish);
- dest.removeListener('drain', ondrain);
- dest.removeListener('error', onerror);
- dest.removeListener('unpipe', onunpipe);
- src.removeListener('end', onend);
- src.removeListener('end', unpipe);
- src.removeListener('data', ondata);
-
- cleanedUp = true;
-
- // if the reader is waiting for a drain event from this
- // specific writer, then it would cause it to never start
- // flowing again.
- // So, if this is awaiting a drain, then we just call it now.
- // If we don't know, then assume that we are waiting for one.
- if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
- }
-
- // If the user pushes more data while we're writing to dest then we'll end up
- // in ondata again. However, we only want to increase awaitDrain once because
- // dest will only emit one 'drain' event for the multiple writes.
- // => Introduce a guard on increasing awaitDrain.
- var increasedAwaitDrain = false;
- src.on('data', ondata);
- function ondata(chunk) {
- debug('ondata');
- increasedAwaitDrain = false;
- var ret = dest.write(chunk);
- if (false === ret && !increasedAwaitDrain) {
- // If the user unpiped during `dest.write()`, it is possible
- // to get stuck in a permanently paused state if that write
- // also returned false.
- // => Check whether `dest` is still a piping destination.
- if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
- debug('false write response, pause', src._readableState.awaitDrain);
- src._readableState.awaitDrain++;
- increasedAwaitDrain = true;
- }
- src.pause();
- }
- }
-
- // if the dest has an error, then stop piping into it.
- // however, don't suppress the throwing behavior for this.
- function onerror(er) {
- debug('onerror', er);
- unpipe();
- dest.removeListener('error', onerror);
- if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
- }
-
- // Make sure our error handler is attached before userland ones.
- prependListener(dest, 'error', onerror);
-
- // Both close and finish should trigger unpipe, but only once.
- function onclose() {
- dest.removeListener('finish', onfinish);
- unpipe();
- }
- dest.once('close', onclose);
- function onfinish() {
- debug('onfinish');
- dest.removeListener('close', onclose);
- unpipe();
- }
- dest.once('finish', onfinish);
-
- function unpipe() {
- debug('unpipe');
- src.unpipe(dest);
- }
-
- // tell the dest that it's being piped to
- dest.emit('pipe', src);
-
- // start the flow if it hasn't been started already.
- if (!state.flowing) {
- debug('pipe resume');
- src.resume();
- }
-
- return dest;
-};
-
-function pipeOnDrain(src) {
- return function () {
- var state = src._readableState;
- debug('pipeOnDrain', state.awaitDrain);
- if (state.awaitDrain) state.awaitDrain--;
- if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
- state.flowing = true;
- flow(src);
- }
- };
-}
-
-Readable.prototype.unpipe = function (dest) {
- var state = this._readableState;
- var unpipeInfo = { hasUnpiped: false };
-
- // if we're not piping anywhere, then do nothing.
- if (state.pipesCount === 0) return this;
-
- // just one destination. most common case.
- if (state.pipesCount === 1) {
- // passed in one, but it's not the right one.
- if (dest && dest !== state.pipes) return this;
-
- if (!dest) dest = state.pipes;
-
- // got a match.
- state.pipes = null;
- state.pipesCount = 0;
- state.flowing = false;
- if (dest) dest.emit('unpipe', this, unpipeInfo);
- return this;
- }
-
- // slow case. multiple pipe destinations.
-
- if (!dest) {
- // remove all.
- var dests = state.pipes;
- var len = state.pipesCount;
- state.pipes = null;
- state.pipesCount = 0;
- state.flowing = false;
-
- for (var i = 0; i < len; i++) {
- dests[i].emit('unpipe', this, unpipeInfo);
- }return this;
- }
-
- // try to find the right one.
- var index = indexOf(state.pipes, dest);
- if (index === -1) return this;
-
- state.pipes.splice(index, 1);
- state.pipesCount -= 1;
- if (state.pipesCount === 1) state.pipes = state.pipes[0];
-
- dest.emit('unpipe', this, unpipeInfo);
-
- return this;
-};
-
-// set up data events if they are asked for
-// Ensure readable listeners eventually get something
-Readable.prototype.on = function (ev, fn) {
- var res = Stream.prototype.on.call(this, ev, fn);
-
- if (ev === 'data') {
- // Start flowing on next tick if stream isn't explicitly paused
- if (this._readableState.flowing !== false) this.resume();
- } else if (ev === 'readable') {
- var state = this._readableState;
- if (!state.endEmitted && !state.readableListening) {
- state.readableListening = state.needReadable = true;
- state.emittedReadable = false;
- if (!state.reading) {
- pna.nextTick(nReadingNextTick, this);
- } else if (state.length) {
- emitReadable(this);
- }
- }
- }
-
- return res;
-};
-Readable.prototype.addListener = Readable.prototype.on;
-
-function nReadingNextTick(self) {
- debug('readable nexttick read 0');
- self.read(0);
-}
-
-// pause() and resume() are remnants of the legacy readable stream API
-// If the user uses them, then switch into old mode.
-Readable.prototype.resume = function () {
- var state = this._readableState;
- if (!state.flowing) {
- debug('resume');
- state.flowing = true;
- resume(this, state);
- }
- return this;
-};
-
-function resume(stream, state) {
- if (!state.resumeScheduled) {
- state.resumeScheduled = true;
- pna.nextTick(resume_, stream, state);
- }
-}
-
-function resume_(stream, state) {
- if (!state.reading) {
- debug('resume read 0');
- stream.read(0);
- }
-
- state.resumeScheduled = false;
- state.awaitDrain = 0;
- stream.emit('resume');
- flow(stream);
- if (state.flowing && !state.reading) stream.read(0);
-}
-
-Readable.prototype.pause = function () {
- debug('call pause flowing=%j', this._readableState.flowing);
- if (false !== this._readableState.flowing) {
- debug('pause');
- this._readableState.flowing = false;
- this.emit('pause');
- }
- return this;
-};
-
-function flow(stream) {
- var state = stream._readableState;
- debug('flow', state.flowing);
- while (state.flowing && stream.read() !== null) {}
-}
-
-// wrap an old-style stream as the async data source.
-// This is *not* part of the readable stream interface.
-// It is an ugly unfortunate mess of history.
-Readable.prototype.wrap = function (stream) {
- var _this = this;
-
- var state = this._readableState;
- var paused = false;
-
- stream.on('end', function () {
- debug('wrapped end');
- if (state.decoder && !state.ended) {
- var chunk = state.decoder.end();
- if (chunk && chunk.length) _this.push(chunk);
- }
-
- _this.push(null);
- });
-
- stream.on('data', function (chunk) {
- debug('wrapped data');
- if (state.decoder) chunk = state.decoder.write(chunk);
-
- // don't skip over falsy values in objectMode
- if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
-
- var ret = _this.push(chunk);
- if (!ret) {
- paused = true;
- stream.pause();
- }
- });
-
- // proxy all the other methods.
- // important when wrapping filters and duplexes.
- for (var i in stream) {
- if (this[i] === undefined && typeof stream[i] === 'function') {
- this[i] = function (method) {
- return function () {
- return stream[method].apply(stream, arguments);
- };
- }(i);
- }
- }
-
- // proxy certain important events.
- for (var n = 0; n < kProxyEvents.length; n++) {
- stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
- }
-
- // when we try to consume some more bytes, simply unpause the
- // underlying stream.
- this._read = function (n) {
- debug('wrapped _read', n);
- if (paused) {
- paused = false;
- stream.resume();
- }
- };
-
- return this;
-};
-
-Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
- // making it explicit this property is not enumerable
- // because otherwise some prototype manipulation in
- // userland will fail
- enumerable: false,
- get: function () {
- return this._readableState.highWaterMark;
- }
-});
-
-// exposed for testing purposes only.
-Readable._fromList = fromList;
-
-// Pluck off n bytes from an array of buffers.
-// Length is the combined lengths of all the buffers in the list.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function fromList(n, state) {
- // nothing buffered
- if (state.length === 0) return null;
-
- var ret;
- if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
- // read it all, truncate the list
- if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
- state.buffer.clear();
- } else {
- // read part of list
- ret = fromListPartial(n, state.buffer, state.decoder);
- }
-
- return ret;
-}
-
-// Extracts only enough buffered data to satisfy the amount requested.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function fromListPartial(n, list, hasStrings) {
- var ret;
- if (n < list.head.data.length) {
- // slice is the same for buffers and strings
- ret = list.head.data.slice(0, n);
- list.head.data = list.head.data.slice(n);
- } else if (n === list.head.data.length) {
- // first chunk is a perfect match
- ret = list.shift();
- } else {
- // result spans more than one buffer
- ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
- }
- return ret;
-}
-
-// Copies a specified amount of characters from the list of buffered data
-// chunks.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function copyFromBufferString(n, list) {
- var p = list.head;
- var c = 1;
- var ret = p.data;
- n -= ret.length;
- while (p = p.next) {
- var str = p.data;
- var nb = n > str.length ? str.length : n;
- if (nb === str.length) ret += str;else ret += str.slice(0, n);
- n -= nb;
- if (n === 0) {
- if (nb === str.length) {
- ++c;
- if (p.next) list.head = p.next;else list.head = list.tail = null;
- } else {
- list.head = p;
- p.data = str.slice(nb);
- }
- break;
- }
- ++c;
- }
- list.length -= c;
- return ret;
-}
-
-// Copies a specified amount of bytes from the list of buffered data chunks.
-// This function is designed to be inlinable, so please take care when making
-// changes to the function body.
-function copyFromBuffer(n, list) {
- var ret = Buffer.allocUnsafe(n);
- var p = list.head;
- var c = 1;
- p.data.copy(ret);
- n -= p.data.length;
- while (p = p.next) {
- var buf = p.data;
- var nb = n > buf.length ? buf.length : n;
- buf.copy(ret, ret.length - n, 0, nb);
- n -= nb;
- if (n === 0) {
- if (nb === buf.length) {
- ++c;
- if (p.next) list.head = p.next;else list.head = list.tail = null;
- } else {
- list.head = p;
- p.data = buf.slice(nb);
- }
- break;
- }
- ++c;
- }
- list.length -= c;
- return ret;
-}
-
-function endReadable(stream) {
- var state = stream._readableState;
-
- // If we get here before consuming all the bytes, then that is a
- // bug in node. Should never happen.
- if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
-
- if (!state.endEmitted) {
- state.ended = true;
- pna.nextTick(endReadableNT, state, stream);
- }
-}
-
-function endReadableNT(state, stream) {
- // Check that we didn't get one last unshift.
- if (!state.endEmitted && state.length === 0) {
- state.endEmitted = true;
- stream.readable = false;
- stream.emit('end');
- }
-}
-
-function indexOf(xs, x) {
- for (var i = 0, l = xs.length; i < l; i++) {
- if (xs[i] === x) return i;
- }
- return -1;
-}
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./_stream_duplex":40,"./internal/streams/BufferList":45,"./internal/streams/destroy":46,"./internal/streams/stream":47,"_process":70,"core-util-is":32,"events":66,"inherits":33,"isarray":34,"process-nextick-args":39,"safe-buffer":49,"string_decoder/":50,"util":64}],43:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// a transform stream is a readable/writable stream where you do
-// something with the data. Sometimes it's called a "filter",
-// but that's not a great name for it, since that implies a thing where
-// some bits pass through, and others are simply ignored. (That would
-// be a valid example of a transform, of course.)
-//
-// While the output is causally related to the input, it's not a
-// necessarily symmetric or synchronous transformation. For example,
-// a zlib stream might take multiple plain-text writes(), and then
-// emit a single compressed chunk some time in the future.
-//
-// Here's how this works:
-//
-// The Transform stream has all the aspects of the readable and writable
-// stream classes. When you write(chunk), that calls _write(chunk,cb)
-// internally, and returns false if there's a lot of pending writes
-// buffered up. When you call read(), that calls _read(n) until
-// there's enough pending readable data buffered up.
-//
-// In a transform stream, the written data is placed in a buffer. When
-// _read(n) is called, it transforms the queued up data, calling the
-// buffered _write cb's as it consumes chunks. If consuming a single
-// written chunk would result in multiple output chunks, then the first
-// outputted bit calls the readcb, and subsequent chunks just go into
-// the read buffer, and will cause it to emit 'readable' if necessary.
-//
-// This way, back-pressure is actually determined by the reading side,
-// since _read has to be called to start processing a new chunk. However,
-// a pathological inflate type of transform can cause excessive buffering
-// here. For example, imagine a stream where every byte of input is
-// interpreted as an integer from 0-255, and then results in that many
-// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
-// 1kb of data being output. In this case, you could write a very small
-// amount of input, and end up with a very large amount of output. In
-// such a pathological inflating mechanism, there'd be no way to tell
-// the system to stop doing the transform. A single 4MB write could
-// cause the system to run out of memory.
-//
-// However, even in such a pathological case, only a single written chunk
-// would be consumed, and then the rest would wait (un-transformed) until
-// the results of the previous transformed chunk were consumed.
-
-'use strict';
-
-module.exports = Transform;
-
-var Duplex = require('./_stream_duplex');
-
-/*<replacement>*/
-var util = Object.create(require('core-util-is'));
-util.inherits = require('inherits');
-/*</replacement>*/
-
-util.inherits(Transform, Duplex);
-
-function afterTransform(er, data) {
- var ts = this._transformState;
- ts.transforming = false;
-
- var cb = ts.writecb;
-
- if (!cb) {
- return this.emit('error', new Error('write callback called multiple times'));
- }
-
- ts.writechunk = null;
- ts.writecb = null;
-
- if (data != null) // single equals check for both `null` and `undefined`
- this.push(data);
-
- cb(er);
-
- var rs = this._readableState;
- rs.reading = false;
- if (rs.needReadable || rs.length < rs.highWaterMark) {
- this._read(rs.highWaterMark);
- }
-}
-
-function Transform(options) {
- if (!(this instanceof Transform)) return new Transform(options);
-
- Duplex.call(this, options);
-
- this._transformState = {
- afterTransform: afterTransform.bind(this),
- needTransform: false,
- transforming: false,
- writecb: null,
- writechunk: null,
- writeencoding: null
- };
-
- // start out asking for a readable event once data is transformed.
- this._readableState.needReadable = true;
-
- // we have implemented the _read method, and done the other things
- // that Readable wants before the first _read call, so unset the
- // sync guard flag.
- this._readableState.sync = false;
-
- if (options) {
- if (typeof options.transform === 'function') this._transform = options.transform;
-
- if (typeof options.flush === 'function') this._flush = options.flush;
- }
-
- // When the writable side finishes, then flush out anything remaining.
- this.on('prefinish', prefinish);
-}
-
-function prefinish() {
- var _this = this;
-
- if (typeof this._flush === 'function') {
- this._flush(function (er, data) {
- done(_this, er, data);
- });
- } else {
- done(this, null, null);
- }
-}
-
-Transform.prototype.push = function (chunk, encoding) {
- this._transformState.needTransform = false;
- return Duplex.prototype.push.call(this, chunk, encoding);
-};
-
-// This is the part where you do stuff!
-// override this function in implementation classes.
-// 'chunk' is an input chunk.
-//
-// Call `push(newChunk)` to pass along transformed output
-// to the readable side. You may call 'push' zero or more times.
-//
-// Call `cb(err)` when you are done with this chunk. If you pass
-// an error, then that'll put the hurt on the whole operation. If you
-// never call cb(), then you'll never get another chunk.
-Transform.prototype._transform = function (chunk, encoding, cb) {
- throw new Error('_transform() is not implemented');
-};
-
-Transform.prototype._write = function (chunk, encoding, cb) {
- var ts = this._transformState;
- ts.writecb = cb;
- ts.writechunk = chunk;
- ts.writeencoding = encoding;
- if (!ts.transforming) {
- var rs = this._readableState;
- if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
- }
-};
-
-// Doesn't matter what the args are here.
-// _transform does all the work.
-// That we got here means that the readable side wants more data.
-Transform.prototype._read = function (n) {
- var ts = this._transformState;
-
- if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
- ts.transforming = true;
- this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
- } else {
- // mark that we need a transform, so that any data that comes in
- // will get processed, now that we've asked for it.
- ts.needTransform = true;
- }
-};
-
-Transform.prototype._destroy = function (err, cb) {
- var _this2 = this;
-
- Duplex.prototype._destroy.call(this, err, function (err2) {
- cb(err2);
- _this2.emit('close');
- });
-};
-
-function done(stream, er, data) {
- if (er) return stream.emit('error', er);
-
- if (data != null) // single equals check for both `null` and `undefined`
- stream.push(data);
-
- // if there's nothing in the write buffer, then that means
- // that nothing more will ever be provided
- if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
-
- if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
-
- return stream.push(null);
-}
-},{"./_stream_duplex":40,"core-util-is":32,"inherits":33}],44:[function(require,module,exports){
-(function (process,global,setImmediate){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// A bit simpler than readable streams.
-// Implement an async ._write(chunk, encoding, cb), and it'll handle all
-// the drain event emission and buffering.
-
-'use strict';
-
-/*<replacement>*/
-
-var pna = require('process-nextick-args');
-/*</replacement>*/
-
-module.exports = Writable;
-
-/* <replacement> */
-function WriteReq(chunk, encoding, cb) {
- this.chunk = chunk;
- this.encoding = encoding;
- this.callback = cb;
- this.next = null;
-}
-
-// It seems a linked list but it is not
-// there will be only 2 of these for each stream
-function CorkedRequest(state) {
- var _this = this;
-
- this.next = null;
- this.entry = null;
- this.finish = function () {
- onCorkedFinish(_this, state);
- };
-}
-/* </replacement> */
-
-/*<replacement>*/
-var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
-/*</replacement>*/
-
-/*<replacement>*/
-var Duplex;
-/*</replacement>*/
-
-Writable.WritableState = WritableState;
+ // not listening for removeListener, no need to emit
+ if (!events.removeListener) {
+ if (arguments.length === 0) {
+ this._events = objectCreate(null);
+ this._eventsCount = 0;
+ } else if (events[type]) {
+ if (--this._eventsCount === 0)
+ this._events = objectCreate(null);
+ else
+ delete events[type];
+ }
+ return this;
+ }
-/*<replacement>*/
-var util = Object.create(require('core-util-is'));
-util.inherits = require('inherits');
-/*</replacement>*/
+ // emit removeListener for all listeners on all events
+ if (arguments.length === 0) {
+ var keys = objectKeys(events);
+ var key;
+ for (i = 0; i < keys.length; ++i) {
+ key = keys[i];
+ if (key === 'removeListener') continue;
+ this.removeAllListeners(key);
+ }
+ this.removeAllListeners('removeListener');
+ this._events = objectCreate(null);
+ this._eventsCount = 0;
+ return this;
+ }
-/*<replacement>*/
-var internalUtil = {
- deprecate: require('util-deprecate')
-};
-/*</replacement>*/
+ listeners = events[type];
-/*<replacement>*/
-var Stream = require('./internal/streams/stream');
-/*</replacement>*/
+ if (typeof listeners === 'function') {
+ this.removeListener(type, listeners);
+ } else if (listeners) {
+ // LIFO order
+ for (i = listeners.length - 1; i >= 0; i--) {
+ this.removeListener(type, listeners[i]);
+ }
+ }
-/*<replacement>*/
+ return this;
+ };
-var Buffer = require('safe-buffer').Buffer;
-var OurUint8Array = global.Uint8Array || function () {};
-function _uint8ArrayToBuffer(chunk) {
- return Buffer.from(chunk);
-}
-function _isUint8Array(obj) {
- return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
-}
+function _listeners(target, type, unwrap) {
+ var events = target._events;
-/*</replacement>*/
+ if (!events)
+ return [];
-var destroyImpl = require('./internal/streams/destroy');
+ var evlistener = events[type];
+ if (!evlistener)
+ return [];
-util.inherits(Writable, Stream);
+ if (typeof evlistener === 'function')
+ return unwrap ? [evlistener.listener || evlistener] : [evlistener];
-function nop() {}
+ return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
-function WritableState(options, stream) {
- Duplex = Duplex || require('./_stream_duplex');
+EventEmitter.prototype.listeners = function listeners(type) {
+ return _listeners(this, type, true);
+};
- options = options || {};
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+ return _listeners(this, type, false);
+};
- // Duplex streams are both readable and writable, but share
- // the same options object.
- // However, some cases require setting options to different
- // values for the readable and the writable sides of the duplex stream.
- // These options can be provided separately as readableXXX and writableXXX.
- var isDuplex = stream instanceof Duplex;
+EventEmitter.listenerCount = function(emitter, type) {
+ if (typeof emitter.listenerCount === 'function') {
+ return emitter.listenerCount(type);
+ } else {
+ return listenerCount.call(emitter, type);
+ }
+};
- // object stream flag to indicate whether or not this stream
- // contains buffers or objects.
- this.objectMode = !!options.objectMode;
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+ var events = this._events;
- if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
+ if (events) {
+ var evlistener = events[type];
- // the point at which write() starts returning false
- // Note: 0 is a valid value, means that we always return false if
- // the entire buffer is not flushed immediately on write()
- var hwm = options.highWaterMark;
- var writableHwm = options.writableHighWaterMark;
- var defaultHwm = this.objectMode ? 16 : 16 * 1024;
+ if (typeof evlistener === 'function') {
+ return 1;
+ } else if (evlistener) {
+ return evlistener.length;
+ }
+ }
- if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
+ return 0;
+}
- // cast to ints.
- this.highWaterMark = Math.floor(this.highWaterMark);
+EventEmitter.prototype.eventNames = function eventNames() {
+ return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
+};
- // if _final has been called
- this.finalCalled = false;
+// About 1.5x faster than the two-arg version of Array#splice().
+function spliceOne(list, index) {
+ for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
+ list[i] = list[k];
+ list.pop();
+}
- // drain event flag.
- this.needDrain = false;
- // at the start of calling end()
- this.ending = false;
- // when end() has been called, and returned
- this.ended = false;
- // when 'finish' is emitted
- this.finished = false;
+function arrayClone(arr, n) {
+ var copy = new Array(n);
+ for (var i = 0; i < n; ++i)
+ copy[i] = arr[i];
+ return copy;
+}
- // has it been destroyed
- this.destroyed = false;
+function unwrapListeners(arr) {
+ var ret = new Array(arr.length);
+ for (var i = 0; i < ret.length; ++i) {
+ ret[i] = arr[i].listener || arr[i];
+ }
+ return ret;
+}
- // should we decode strings into buffers before passing to _write?
- // this is here so that some node-core streams can optimize string
- // handling at a lower level.
- var noDecode = options.decodeStrings === false;
- this.decodeStrings = !noDecode;
+function objectCreatePolyfill(proto) {
+ var F = function() {};
+ F.prototype = proto;
+ return new F;
+}
+function objectKeysPolyfill(obj) {
+ var keys = [];
+ for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
+ keys.push(k);
+ }
+ return k;
+}
+function functionBindPolyfill(context) {
+ var fn = this;
+ return function () {
+ return fn.apply(context, arguments);
+ };
+}
- // Crypto is kind of old and crusty. Historically, its default string
- // encoding is 'binary' so we have to make this configurable.
- // Everything else in the universe uses 'utf8', though.
- this.defaultEncoding = options.defaultEncoding || 'utf8';
+},{}],11:[function(require,module,exports){
+exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+ var e, m
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var nBits = -7
+ var i = isLE ? (nBytes - 1) : 0
+ var d = isLE ? -1 : 1
+ var s = buffer[offset + i]
- // not an actual buffer we keep track of, but a measurement
- // of how much we're waiting to get pushed to some underlying
- // socket or file.
- this.length = 0;
+ i += d
- // a flag to see when we're in the middle of a write.
- this.writing = false;
+ e = s & ((1 << (-nBits)) - 1)
+ s >>= (-nBits)
+ nBits += eLen
+ for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
- // when true all writes will be buffered until .uncork() call
- this.corked = 0;
+ m = e & ((1 << (-nBits)) - 1)
+ e >>= (-nBits)
+ nBits += mLen
+ for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
- // a flag to be able to tell if the onwrite cb is called immediately,
- // or on a later tick. We set this to true at first, because any
- // actions that shouldn't happen until "later" should generally also
- // not happen before the first write call.
- this.sync = true;
+ if (e === 0) {
+ e = 1 - eBias
+ } else if (e === eMax) {
+ return m ? NaN : ((s ? -1 : 1) * Infinity)
+ } else {
+ m = m + Math.pow(2, mLen)
+ e = e - eBias
+ }
+ return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+}
- // a flag to know if we're processing previously buffered items, which
- // may call the _write() callback in the same tick, so that we don't
- // end up in an overlapped onwrite situation.
- this.bufferProcessing = false;
+exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+ var e, m, c
+ var eLen = (nBytes * 8) - mLen - 1
+ var eMax = (1 << eLen) - 1
+ var eBias = eMax >> 1
+ var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+ var i = isLE ? 0 : (nBytes - 1)
+ var d = isLE ? 1 : -1
+ var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
- // the callback that's passed to _write(chunk,cb)
- this.onwrite = function (er) {
- onwrite(stream, er);
- };
+ value = Math.abs(value)
- // the callback that the user supplies to write(chunk,encoding,cb)
- this.writecb = null;
+ if (isNaN(value) || value === Infinity) {
+ m = isNaN(value) ? 1 : 0
+ e = eMax
+ } else {
+ e = Math.floor(Math.log(value) / Math.LN2)
+ if (value * (c = Math.pow(2, -e)) < 1) {
+ e--
+ c *= 2
+ }
+ if (e + eBias >= 1) {
+ value += rt / c
+ } else {
+ value += rt * Math.pow(2, 1 - eBias)
+ }
+ if (value * c >= 2) {
+ e++
+ c /= 2
+ }
- // the amount that is being written when _write is called.
- this.writelen = 0;
+ if (e + eBias >= eMax) {
+ m = 0
+ e = eMax
+ } else if (e + eBias >= 1) {
+ m = ((value * c) - 1) * Math.pow(2, mLen)
+ e = e + eBias
+ } else {
+ m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+ e = 0
+ }
+ }
- this.bufferedRequest = null;
- this.lastBufferedRequest = null;
+ for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
- // number of pending user-supplied write callbacks
- // this must be 0 before 'finish' can be emitted
- this.pendingcb = 0;
+ e = (e << mLen) | m
+ eLen += mLen
+ for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
- // emit prefinish if the only thing we're waiting for is _write cbs
- // This is relevant for synchronous Transform streams
- this.prefinished = false;
+ buffer[offset + i - d] |= s * 128
+}
- // True if the error was already emitted and should not be thrown again
- this.errorEmitted = false;
+},{}],12:[function(require,module,exports){
+arguments[4][2][0].apply(exports,arguments)
+},{"dup":2}],13:[function(require,module,exports){
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author Feross Aboukhadijeh <https://feross.org>
+ * @license MIT
+ */
- // count buffered requests
- this.bufferedRequestCount = 0;
+// The _isBuffer check is for Safari 5-7 support, because it's missing
+// Object.prototype.constructor. Remove this eventually
+module.exports = function (obj) {
+ return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
+}
- // allocate the first CorkedRequest, there is always
- // one allocated and free to use, and we maintain at most two
- this.corkedRequestsFree = new CorkedRequest(this);
+function isBuffer (obj) {
+ return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
}
-WritableState.prototype.getBuffer = function getBuffer() {
- var current = this.bufferedRequest;
- var out = [];
- while (current) {
- out.push(current);
- current = current.next;
- }
- return out;
-};
+// For Node v0.10 support. Remove this eventually.
+function isSlowBuffer (obj) {
+ return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
+}
-(function () {
- try {
- Object.defineProperty(WritableState.prototype, 'buffer', {
- get: internalUtil.deprecate(function () {
- return this.getBuffer();
- }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
- });
- } catch (_) {}
-})();
+},{}],14:[function(require,module,exports){
+var toString = {}.toString;
-// Test _writableState for inheritance to account for Duplex streams,
-// whose prototype chain only points to Readable.
-var realHasInstance;
-if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
- realHasInstance = Function.prototype[Symbol.hasInstance];
- Object.defineProperty(Writable, Symbol.hasInstance, {
- value: function (object) {
- if (realHasInstance.call(this, object)) return true;
- if (this !== Writable) return false;
+module.exports = Array.isArray || function (arr) {
+ return toString.call(arr) == '[object Array]';
+};
- return object && object._writableState instanceof WritableState;
- }
- });
-} else {
- realHasInstance = function (object) {
- return object instanceof this;
- };
-}
+},{}],15:[function(require,module,exports){
+'use strict'
-function Writable(options) {
- Duplex = Duplex || require('./_stream_duplex');
+var Buffer = require('safe-buffer').Buffer
+var assert = require('assert')
+var bl = require('bl')
+var streams = require('./lib/streams')
+var buildDecode = require('./lib/decoder')
+var buildEncode = require('./lib/encoder')
- // Writable ctor is applied to Duplexes, too.
- // `realHasInstance` is necessary because using plain `instanceof`
- // would return false, as no `_writableState` property is attached.
+function msgpack (options) {
+ var encodingTypes = []
+ var decodingTypes = []
- // Trying to use the custom `instanceof` for Writable here will also break the
- // Node.js LazyTransform implementation, which has a non-trivial getter for
- // `_writableState` that would lead to infinite recursion.
- if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
- return new Writable(options);
+ options = options || {
+ forceFloat64: false,
+ compatibilityMode: false,
+ disableTimestampEncoding: false // if true, skips encoding Dates using the msgpack timestamp ext format (-1)
}
- this._writableState = new WritableState(options, this);
+ function registerEncoder (check, encode) {
+ assert(check, 'must have an encode function')
+ assert(encode, 'must have an encode function')
- // legacy.
- this.writable = true;
+ encodingTypes.push({
+ check: check, encode: encode
+ })
- if (options) {
- if (typeof options.write === 'function') this._write = options.write;
+ return this
+ }
- if (typeof options.writev === 'function') this._writev = options.writev;
+ function registerDecoder (type, decode) {
+ assert(type >= 0, 'must have a non-negative type')
+ assert(decode, 'must have a decode function')
- if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ decodingTypes.push({
+ type: type, decode: decode
+ })
- if (typeof options.final === 'function') this._final = options.final;
+ return this
}
- Stream.call(this);
-}
+ function register (type, constructor, encode, decode) {
+ assert(constructor, 'must have a constructor')
+ assert(encode, 'must have an encode function')
+ assert(type >= 0, 'must have a non-negative type')
+ assert(decode, 'must have a decode function')
-// Otherwise people can pipe Writable streams, which is just wrong.
-Writable.prototype.pipe = function () {
- this.emit('error', new Error('Cannot pipe, not readable'));
-};
+ function check (obj) {
+ return (obj instanceof constructor)
+ }
-function writeAfterEnd(stream, cb) {
- var er = new Error('write after end');
- // TODO: defer error events consistently everywhere, not just the cb
- stream.emit('error', er);
- pna.nextTick(cb, er);
-}
+ function reEncode (obj) {
+ var buf = bl()
+ var header = Buffer.allocUnsafe(1)
-// Checks that a user-supplied chunk is valid, especially for the particular
-// mode the stream is in. Currently this means that `null` is never accepted
-// and undefined/non-string values are only allowed in object mode.
-function validChunk(stream, state, chunk, cb) {
- var valid = true;
- var er = false;
+ header.writeInt8(type, 0)
- if (chunk === null) {
- er = new TypeError('May not write null values to stream');
- } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
- er = new TypeError('Invalid non-string/buffer chunk');
- }
- if (er) {
- stream.emit('error', er);
- pna.nextTick(cb, er);
- valid = false;
- }
- return valid;
-}
+ buf.append(header)
+ buf.append(encode(obj))
-Writable.prototype.write = function (chunk, encoding, cb) {
- var state = this._writableState;
- var ret = false;
- var isBuf = !state.objectMode && _isUint8Array(chunk);
+ return buf
+ }
- if (isBuf && !Buffer.isBuffer(chunk)) {
- chunk = _uint8ArrayToBuffer(chunk);
- }
+ this.registerEncoder(check, reEncode)
+ this.registerDecoder(type, decode)
- if (typeof encoding === 'function') {
- cb = encoding;
- encoding = null;
+ return this
}
- if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
-
- if (typeof cb !== 'function') cb = nop;
-
- if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
- state.pendingcb++;
- ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+ return {
+ encode: buildEncode(encodingTypes, options.forceFloat64, options.compatibilityMode, options.disableTimestampEncoding),
+ decode: buildDecode(decodingTypes),
+ register: register,
+ registerEncoder: registerEncoder,
+ registerDecoder: registerDecoder,
+ encoder: streams.encoder,
+ decoder: streams.decoder,
+ // needed for levelup support
+ buffer: true,
+ type: 'msgpack5',
+ IncompleteBufferError: buildDecode.IncompleteBufferError
}
+}
- return ret;
-};
+module.exports = msgpack
-Writable.prototype.cork = function () {
- var state = this._writableState;
+},{"./lib/decoder":16,"./lib/encoder":17,"./lib/streams":18,"assert":1,"bl":6,"safe-buffer":32}],16:[function(require,module,exports){
+'use strict'
- state.corked++;
-};
+var bl = require('bl')
+var util = require('util')
-Writable.prototype.uncork = function () {
- var state = this._writableState;
+function IncompleteBufferError (message) {
+ Error.call(this) // super constructor
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, this.constructor) // super helper method to include stack trace in error object
+ }
+ this.name = this.constructor.name
+ this.message = message || 'unable to decode'
+}
- if (state.corked) {
- state.corked--;
+util.inherits(IncompleteBufferError, Error)
- if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
+module.exports = function buildDecode (decodingTypes) {
+ return decode
+
+ function getSize (first) {
+ switch (first) {
+ case 0xc4:
+ return 2
+ case 0xc5:
+ return 3
+ case 0xc6:
+ return 5
+ case 0xc7:
+ return 3
+ case 0xc8:
+ return 4
+ case 0xc9:
+ return 6
+ case 0xca:
+ return 5
+ case 0xcb:
+ return 9
+ case 0xcc:
+ return 2
+ case 0xcd:
+ return 3
+ case 0xce:
+ return 5
+ case 0xcf:
+ return 9
+ case 0xd0:
+ return 2
+ case 0xd1:
+ return 3
+ case 0xd2:
+ return 5
+ case 0xd3:
+ return 9
+ case 0xd4:
+ return 3
+ case 0xd5:
+ return 4
+ case 0xd6:
+ return 6
+ case 0xd7:
+ return 10
+ case 0xd8:
+ return 18
+ case 0xd9:
+ return 2
+ case 0xda:
+ return 3
+ case 0xdb:
+ return 5
+ case 0xde:
+ return 3
+ default:
+ return -1
+ }
}
-};
-Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
- // node::ParseEncoding() requires lower case.
- if (typeof encoding === 'string') encoding = encoding.toLowerCase();
- if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
- this._writableState.defaultEncoding = encoding;
- return this;
-};
+ function hasMinBufferSize (first, length) {
+ var size = getSize(first)
-function decodeChunk(state, chunk, encoding) {
- if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
- chunk = Buffer.from(chunk, encoding);
+ if (size !== -1 && length < size) {
+ return false
+ } else {
+ return true
+ }
}
- return chunk;
-}
-Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
- // making it explicit this property is not enumerable
- // because otherwise some prototype manipulation in
- // userland will fail
- enumerable: false,
- get: function () {
- return this._writableState.highWaterMark;
+ function isValidDataSize (dataLength, bufLength, headerLength) {
+ return bufLength >= headerLength + dataLength
}
-});
-// if we're already writing something, then just put this
-// in the queue, and wait our turn. Otherwise, call _write
-// If we return false, then we need a drain event, so set that flag.
-function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
- if (!isBuf) {
- var newChunk = decodeChunk(state, chunk, encoding);
- if (chunk !== newChunk) {
- isBuf = true;
- encoding = 'buffer';
- chunk = newChunk;
+ function buildDecodeResult (value, bytesConsumed) {
+ return {
+ value: value,
+ bytesConsumed: bytesConsumed
}
}
- var len = state.objectMode ? 1 : chunk.length;
-
- state.length += len;
- var ret = state.length < state.highWaterMark;
- // we must ensure that previous needDrain will not be reset to false.
- if (!ret) state.needDrain = true;
+ function decode (buf) {
+ if (!(buf instanceof bl)) {
+ buf = bl().append(buf)
+ }
- if (state.writing || state.corked) {
- var last = state.lastBufferedRequest;
- state.lastBufferedRequest = {
- chunk: chunk,
- encoding: encoding,
- isBuf: isBuf,
- callback: cb,
- next: null
- };
- if (last) {
- last.next = state.lastBufferedRequest;
+ var result = tryDecode(buf)
+ if (result) {
+ buf.consume(result.bytesConsumed)
+ return result.value
} else {
- state.bufferedRequest = state.lastBufferedRequest;
+ throw new IncompleteBufferError()
}
- state.bufferedRequestCount += 1;
- } else {
- doWrite(stream, state, false, len, chunk, encoding, cb);
}
- return ret;
-}
-
-function doWrite(stream, state, writev, len, chunk, encoding, cb) {
- state.writelen = len;
- state.writecb = cb;
- state.writing = true;
- state.sync = true;
- if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
- state.sync = false;
-}
-
-function onwriteError(stream, state, sync, er, cb) {
- --state.pendingcb;
-
- if (sync) {
- // defer the callback if we are being called synchronously
- // to avoid piling up things on the stack
- pna.nextTick(cb, er);
- // this can emit finish, and it will always happen
- // after error
- pna.nextTick(finishMaybe, stream, state);
- stream._writableState.errorEmitted = true;
- stream.emit('error', er);
- } else {
- // the caller expect this to happen before if
- // it is async
- cb(er);
- stream._writableState.errorEmitted = true;
- stream.emit('error', er);
- // this can emit finish, but finish must
- // always follow error
- finishMaybe(stream, state);
- }
-}
+ function tryDecode (buf, offset) {
+ offset = offset === undefined ? 0 : offset
+ var bufLength = buf.length - offset
+ if (bufLength <= 0) {
+ return null
+ }
-function onwriteStateUpdate(state) {
- state.writing = false;
- state.writecb = null;
- state.length -= state.writelen;
- state.writelen = 0;
-}
+ var first = buf.readUInt8(offset)
+ var length
+ var result = 0
+ var type
+ var bytePos
-function onwrite(stream, er) {
- var state = stream._writableState;
- var sync = state.sync;
- var cb = state.writecb;
+ if (!hasMinBufferSize(first, bufLength)) {
+ return null
+ }
- onwriteStateUpdate(state);
+ switch (first) {
+ case 0xc0:
+ return buildDecodeResult(null, 1)
+ case 0xc2:
+ return buildDecodeResult(false, 1)
+ case 0xc3:
+ return buildDecodeResult(true, 1)
+ case 0xcc:
+ // 1-byte unsigned int
+ result = buf.readUInt8(offset + 1)
+ return buildDecodeResult(result, 2)
+ case 0xcd:
+ // 2-bytes BE unsigned int
+ result = buf.readUInt16BE(offset + 1)
+ return buildDecodeResult(result, 3)
+ case 0xce:
+ // 4-bytes BE unsigned int
+ result = buf.readUInt32BE(offset + 1)
+ return buildDecodeResult(result, 5)
+ case 0xcf:
+ // 8-bytes BE unsigned int
+ // Read long byte by byte, big-endian
+ for (bytePos = 7; bytePos >= 0; bytePos--) {
+ result += (buf.readUInt8(offset + bytePos + 1) * Math.pow(2, (8 * (7 - bytePos))))
+ }
+ return buildDecodeResult(result, 9)
+ case 0xd0:
+ // 1-byte signed int
+ result = buf.readInt8(offset + 1)
+ return buildDecodeResult(result, 2)
+ case 0xd1:
+ // 2-bytes signed int
+ result = buf.readInt16BE(offset + 1)
+ return buildDecodeResult(result, 3)
+ case 0xd2:
+ // 4-bytes signed int
+ result = buf.readInt32BE(offset + 1)
+ return buildDecodeResult(result, 5)
+ case 0xd3:
+ result = readInt64BE(buf.slice(offset + 1, offset + 9), 0)
+ return buildDecodeResult(result, 9)
+ case 0xca:
+ // 4-bytes float
+ result = buf.readFloatBE(offset + 1)
+ return buildDecodeResult(result, 5)
+ case 0xcb:
+ // 8-bytes double
+ result = buf.readDoubleBE(offset + 1)
+ return buildDecodeResult(result, 9)
+ case 0xd9:
+ // strings up to 2^8 - 1 bytes
+ length = buf.readUInt8(offset + 1)
+ if (!isValidDataSize(length, bufLength, 2)) {
+ return null
+ }
+ result = buf.toString('utf8', offset + 2, offset + 2 + length)
+ return buildDecodeResult(result, 2 + length)
+ case 0xda:
+ // strings up to 2^16 - 2 bytes
+ length = buf.readUInt16BE(offset + 1)
+ if (!isValidDataSize(length, bufLength, 3)) {
+ return null
+ }
+ result = buf.toString('utf8', offset + 3, offset + 3 + length)
+ return buildDecodeResult(result, 3 + length)
+ case 0xdb:
+ // strings up to 2^32 - 4 bytes
+ length = buf.readUInt32BE(offset + 1)
+ if (!isValidDataSize(length, bufLength, 5)) {
+ return null
+ }
+ result = buf.toString('utf8', offset + 5, offset + 5 + length)
+ return buildDecodeResult(result, 5 + length)
+ case 0xc4:
+ // buffers up to 2^8 - 1 bytes
+ length = buf.readUInt8(offset + 1)
+ if (!isValidDataSize(length, bufLength, 2)) {
+ return null
+ }
+ result = buf.slice(offset + 2, offset + 2 + length)
+ return buildDecodeResult(result, 2 + length)
+ case 0xc5:
+ // buffers up to 2^16 - 1 bytes
+ length = buf.readUInt16BE(offset + 1)
+ if (!isValidDataSize(length, bufLength, 3)) {
+ return null
+ }
+ result = buf.slice(offset + 3, offset + 3 + length)
+ return buildDecodeResult(result, 3 + length)
+ case 0xc6:
+ // buffers up to 2^32 - 1 bytes
+ length = buf.readUInt32BE(offset + 1)
+ if (!isValidDataSize(length, bufLength, 5)) {
+ return null
+ }
+ result = buf.slice(offset + 5, offset + 5 + length)
+ return buildDecodeResult(result, 5 + length)
+ case 0xdc:
+ // array up to 2^16 elements - 2 bytes
+ if (bufLength < 3) {
+ return null
+ }
- if (er) onwriteError(stream, state, sync, er, cb);else {
- // Check if we're actually ready to finish, but don't emit yet
- var finished = needFinish(state);
+ length = buf.readUInt16BE(offset + 1)
+ return decodeArray(buf, offset, length, 3)
+ case 0xdd:
+ // array up to 2^32 elements - 4 bytes
+ if (bufLength < 5) {
+ return null
+ }
- if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
- clearBuffer(stream, state);
+ length = buf.readUInt32BE(offset + 1)
+ return decodeArray(buf, offset, length, 5)
+ case 0xde:
+ // maps up to 2^16 elements - 2 bytes
+ length = buf.readUInt16BE(offset + 1)
+ return decodeMap(buf, offset, length, 3)
+ case 0xdf:
+ length = buf.readUInt32BE(offset + 1)
+ return decodeMap(buf, offset, length, 5)
+ case 0xd4:
+ return decodeFixExt(buf, offset, 1)
+ case 0xd5:
+ return decodeFixExt(buf, offset, 2)
+ case 0xd6:
+ return decodeFixExt(buf, offset, 4)
+ case 0xd7:
+ return decodeFixExt(buf, offset, 8)
+ case 0xd8:
+ return decodeFixExt(buf, offset, 16)
+ case 0xc7:
+ // ext up to 2^8 - 1 bytes
+ length = buf.readUInt8(offset + 1)
+ type = buf.readUInt8(offset + 2)
+ if (!isValidDataSize(length, bufLength, 3)) {
+ return null
+ }
+ return decodeExt(buf, offset, type, length, 3)
+ case 0xc8:
+ // ext up to 2^16 - 1 bytes
+ length = buf.readUInt16BE(offset + 1)
+ type = buf.readUInt8(offset + 3)
+ if (!isValidDataSize(length, bufLength, 4)) {
+ return null
+ }
+ return decodeExt(buf, offset, type, length, 4)
+ case 0xc9:
+ // ext up to 2^32 - 1 bytes
+ length = buf.readUInt32BE(offset + 1)
+ type = buf.readUInt8(offset + 5)
+ if (!isValidDataSize(length, bufLength, 6)) {
+ return null
+ }
+ return decodeExt(buf, offset, type, length, 6)
}
- if (sync) {
- /*<replacement>*/
- asyncWrite(afterWrite, stream, state, finished, cb);
- /*</replacement>*/
+ if ((first & 0xf0) === 0x90) {
+ // we have an array with less than 15 elements
+ length = first & 0x0f
+ return decodeArray(buf, offset, length, 1)
+ } else if ((first & 0xf0) === 0x80) {
+ // we have a map with less than 15 elements
+ length = first & 0x0f
+ return decodeMap(buf, offset, length, 1)
+ } else if ((first & 0xe0) === 0xa0) {
+ // fixstr up to 31 bytes
+ length = first & 0x1f
+ if (isValidDataSize(length, bufLength, 1)) {
+ result = buf.toString('utf8', offset + 1, offset + length + 1)
+ return buildDecodeResult(result, length + 1)
+ } else {
+ return null
+ }
+ } else if (first >= 0xe0) {
+ // 5 bits negative ints
+ result = first - 0x100
+ return buildDecodeResult(result, 1)
+ } else if (first < 0x80) {
+ // 7-bits positive ints
+ return buildDecodeResult(first, 1)
} else {
- afterWrite(stream, state, finished, cb);
+ throw new Error('not implemented yet')
}
}
-}
-
-function afterWrite(stream, state, finished, cb) {
- if (!finished) onwriteDrain(stream, state);
- state.pendingcb--;
- cb();
- finishMaybe(stream, state);
-}
-
-// Must force callback to be called on nextTick, so that we don't
-// emit 'drain' before the write() consumer gets the 'false' return
-// value, and has a chance to attach a 'drain' listener.
-function onwriteDrain(stream, state) {
- if (state.length === 0 && state.needDrain) {
- state.needDrain = false;
- stream.emit('drain');
- }
-}
-
-// if there's something in the buffer waiting, then process it
-function clearBuffer(stream, state) {
- state.bufferProcessing = true;
- var entry = state.bufferedRequest;
- if (stream._writev && entry && entry.next) {
- // Fast case, write everything using _writev()
- var l = state.bufferedRequestCount;
- var buffer = new Array(l);
- var holder = state.corkedRequestsFree;
- holder.entry = entry;
+ function readInt64BE (buf, offset) {
+ var negate = (buf[offset] & 0x80) == 0x80 // eslint-disable-line
- var count = 0;
- var allBuffers = true;
- while (entry) {
- buffer[count] = entry;
- if (!entry.isBuf) allBuffers = false;
- entry = entry.next;
- count += 1;
+ if (negate) {
+ var carry = 1
+ for (var i = offset + 7; i >= offset; i--) {
+ var v = (buf[i] ^ 0xff) + carry
+ buf[i] = v & 0xff
+ carry = v >> 8
+ }
}
- buffer.allBuffers = allBuffers;
- doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+ var hi = buf.readUInt32BE(offset + 0)
+ var lo = buf.readUInt32BE(offset + 4)
+ return (hi * 4294967296 + lo) * (negate ? -1 : +1)
+ }
- // doWrite is almost always async, defer these to save a bit of time
- // as the hot path ends with doWrite
- state.pendingcb++;
- state.lastBufferedRequest = null;
- if (holder.next) {
- state.corkedRequestsFree = holder.next;
- holder.next = null;
- } else {
- state.corkedRequestsFree = new CorkedRequest(state);
- }
- state.bufferedRequestCount = 0;
- } else {
- // Slow case, write chunks one-by-one
- while (entry) {
- var chunk = entry.chunk;
- var encoding = entry.encoding;
- var cb = entry.callback;
- var len = state.objectMode ? 1 : chunk.length;
+ function decodeArray (buf, offset, length, headerLength) {
+ var result = []
+ var i
+ var totalBytesConsumed = 0
- doWrite(stream, state, false, len, chunk, encoding, cb);
- entry = entry.next;
- state.bufferedRequestCount--;
- // if we didn't call the onwrite immediately, then
- // it means that we need to wait until it does.
- // also, that means that the chunk and cb are currently
- // being processed, so move the buffer counter past them.
- if (state.writing) {
- break;
+ offset += headerLength
+ for (i = 0; i < length; i++) {
+ var decodeResult = tryDecode(buf, offset)
+ if (decodeResult) {
+ result.push(decodeResult.value)
+ offset += decodeResult.bytesConsumed
+ totalBytesConsumed += decodeResult.bytesConsumed
+ } else {
+ return null
}
}
-
- if (entry === null) state.lastBufferedRequest = null;
+ return buildDecodeResult(result, headerLength + totalBytesConsumed)
}
- state.bufferedRequest = entry;
- state.bufferProcessing = false;
-}
-
-Writable.prototype._write = function (chunk, encoding, cb) {
- cb(new Error('_write() is not implemented'));
-};
-
-Writable.prototype._writev = null;
+ function decodeMap (buf, offset, length, headerLength) {
+ var result = {}
+ var key
+ var i
+ var totalBytesConsumed = 0
-Writable.prototype.end = function (chunk, encoding, cb) {
- var state = this._writableState;
+ offset += headerLength
+ for (i = 0; i < length; i++) {
+ var keyResult = tryDecode(buf, offset)
+ if (keyResult) {
+ offset += keyResult.bytesConsumed
+ var valueResult = tryDecode(buf, offset)
+ if (valueResult) {
+ key = keyResult.value
+ result[key] = valueResult.value
+ offset += valueResult.bytesConsumed
+ totalBytesConsumed += (keyResult.bytesConsumed + valueResult.bytesConsumed)
+ } else {
+ return null
+ }
+ } else {
+ return null
+ }
+ }
+ return buildDecodeResult(result, headerLength + totalBytesConsumed)
+ }
- if (typeof chunk === 'function') {
- cb = chunk;
- chunk = null;
- encoding = null;
- } else if (typeof encoding === 'function') {
- cb = encoding;
- encoding = null;
+ function decodeFixExt (buf, offset, size) {
+ var type = buf.readInt8(offset + 1) // Signed
+ return decodeExt(buf, offset, type, size, 2)
}
- if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
+ function decodeTimestamp (buf, size, headerSize) {
+ var seconds
+ var nanoseconds = 0
- // .end() fully uncorks
- if (state.corked) {
- state.corked = 1;
- this.uncork();
- }
+ switch (size) {
+ case 4:
+ // timestamp 32 stores the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC in an 32-bit unsigned integer
+ seconds = buf.readUInt32BE(0)
+ break
- // ignore unnecessary end() calls.
- if (!state.ending && !state.finished) endWritable(this, state, cb);
-};
+ case 8:
+ // Timestamp 64 stores the number of seconds and nanoseconds that have elapsed
+ // since 1970-01-01 00:00:00 UTC in 32-bit unsigned integers, split 30/34 bits
+ var upper = buf.readUInt32BE(0)
+ var lower = buf.readUInt32BE(4)
+ nanoseconds = upper / 4
+ seconds = ((upper & 0x03) * Math.pow(2, 32)) + lower // If we use bitwise operators, we get truncated to 32bits
+ break
-function needFinish(state) {
- return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
-}
-function callFinal(stream, state) {
- stream._final(function (err) {
- state.pendingcb--;
- if (err) {
- stream.emit('error', err);
- }
- state.prefinished = true;
- stream.emit('prefinish');
- finishMaybe(stream, state);
- });
-}
-function prefinish(stream, state) {
- if (!state.prefinished && !state.finalCalled) {
- if (typeof stream._final === 'function') {
- state.pendingcb++;
- state.finalCalled = true;
- pna.nextTick(callFinal, stream, state);
- } else {
- state.prefinished = true;
- stream.emit('prefinish');
+ case 12:
+ throw new Error('timestamp 96 is not yet implemented')
}
+
+ var millis = (seconds * 1000) + Math.round(nanoseconds / 1E6)
+ return buildDecodeResult(new Date(millis), size + headerSize)
}
-}
-function finishMaybe(stream, state) {
- var need = needFinish(state);
- if (need) {
- prefinish(stream, state);
- if (state.pendingcb === 0) {
- state.finished = true;
- stream.emit('finish');
+ function decodeExt (buf, offset, type, size, headerSize) {
+ var i,
+ toDecode
+
+ offset += headerSize
+
+ // Pre-defined
+ if (type < 0) { // Reserved for future extensions
+ switch (type) {
+ case -1: // Tiemstamp https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type
+ toDecode = buf.slice(offset, offset + size)
+ return decodeTimestamp(toDecode, size, headerSize)
+ }
}
- }
- return need;
-}
-function endWritable(stream, state, cb) {
- state.ending = true;
- finishMaybe(stream, state);
- if (cb) {
- if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
- }
- state.ended = true;
- stream.writable = false;
-}
+ for (i = 0; i < decodingTypes.length; i++) {
+ if (type === decodingTypes[i].type) {
+ toDecode = buf.slice(offset, offset + size)
+ var value = decodingTypes[i].decode(toDecode)
+ return buildDecodeResult(value, headerSize + size)
+ }
+ }
-function onCorkedFinish(corkReq, state, err) {
- var entry = corkReq.entry;
- corkReq.entry = null;
- while (entry) {
- var cb = entry.callback;
- state.pendingcb--;
- cb(err);
- entry = entry.next;
- }
- if (state.corkedRequestsFree) {
- state.corkedRequestsFree.next = corkReq;
- } else {
- state.corkedRequestsFree = corkReq;
+ throw new Error('unable to find ext type ' + type)
}
}
-Object.defineProperty(Writable.prototype, 'destroyed', {
- get: function () {
- if (this._writableState === undefined) {
- return false;
+module.exports.IncompleteBufferError = IncompleteBufferError
+
+},{"bl":6,"util":37}],17:[function(require,module,exports){
+'use strict'
+
+var Buffer = require('safe-buffer').Buffer
+var bl = require('bl')
+
+module.exports = function buildEncode (encodingTypes, forceFloat64, compatibilityMode, disableTimestampEncoding) {
+ function encode (obj, avoidSlice) {
+ var buf
+ var len
+
+ if (obj === undefined) {
+ throw new Error('undefined is not encodable in msgpack!')
+ } else if (isNaN(obj)) {
+ throw new Error('NaN is not encodable in msgpack!')
+ } else if (obj === null) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0xc0
+ } else if (obj === true) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0xc3
+ } else if (obj === false) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0xc2
+ } else if (typeof obj === 'string') {
+ len = Buffer.byteLength(obj)
+ if (len < 32) {
+ buf = Buffer.allocUnsafe(1 + len)
+ buf[0] = 0xa0 | len
+ if (len > 0) {
+ buf.write(obj, 1)
+ }
+ } else if (len <= 0xff && !compatibilityMode) {
+ // str8, but only when not in compatibility mode
+ buf = Buffer.allocUnsafe(2 + len)
+ buf[0] = 0xd9
+ buf[1] = len
+ buf.write(obj, 2)
+ } else if (len <= 0xffff) {
+ buf = Buffer.allocUnsafe(3 + len)
+ buf[0] = 0xda
+ buf.writeUInt16BE(len, 1)
+ buf.write(obj, 3)
+ } else {
+ buf = Buffer.allocUnsafe(5 + len)
+ buf[0] = 0xdb
+ buf.writeUInt32BE(len, 1)
+ buf.write(obj, 5)
+ }
+ } else if (obj && (obj.readUInt32LE || obj instanceof Uint8Array)) {
+ if (obj instanceof Uint8Array) {
+ obj = Buffer.from(obj)
+ }
+ // weird hack to support Buffer
+ // and Buffer-like objects
+ if (obj.length <= 0xff) {
+ buf = Buffer.allocUnsafe(2)
+ buf[0] = 0xc4
+ buf[1] = obj.length
+ } else if (obj.length <= 0xffff) {
+ buf = Buffer.allocUnsafe(3)
+ buf[0] = 0xc5
+ buf.writeUInt16BE(obj.length, 1)
+ } else {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xc6
+ buf.writeUInt32BE(obj.length, 1)
+ }
+
+ buf = bl([buf, obj])
+ } else if (Array.isArray(obj)) {
+ if (obj.length < 16) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0x90 | obj.length
+ } else if (obj.length < 65536) {
+ buf = Buffer.allocUnsafe(3)
+ buf[0] = 0xdc
+ buf.writeUInt16BE(obj.length, 1)
+ } else {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xdd
+ buf.writeUInt32BE(obj.length, 1)
+ }
+
+ buf = obj.reduce(function (acc, obj) {
+ acc.append(encode(obj, true))
+ return acc
+ }, bl().append(buf))
+ } else if (!disableTimestampEncoding && typeof obj.getDate === 'function') {
+ return encodeDate(obj)
+ } else if (typeof obj === 'object') {
+ buf = encodeExt(obj) || encodeObject(obj)
+ } else if (typeof obj === 'number') {
+ if (isFloat(obj)) {
+ return encodeFloat(obj, forceFloat64)
+ } else if (obj >= 0) {
+ if (obj < 128) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = obj
+ } else if (obj < 256) {
+ buf = Buffer.allocUnsafe(2)
+ buf[0] = 0xcc
+ buf[1] = obj
+ } else if (obj < 65536) {
+ buf = Buffer.allocUnsafe(3)
+ buf[0] = 0xcd
+ buf.writeUInt16BE(obj, 1)
+ } else if (obj <= 0xffffffff) {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xce
+ buf.writeUInt32BE(obj, 1)
+ } else if (obj <= 9007199254740991) {
+ buf = Buffer.allocUnsafe(9)
+ buf[0] = 0xcf
+ write64BitUint(buf, obj)
+ } else {
+ return encodeFloat(obj, true)
+ }
+ } else {
+ if (obj >= -32) {
+ buf = Buffer.allocUnsafe(1)
+ buf[0] = 0x100 + obj
+ } else if (obj >= -128) {
+ buf = Buffer.allocUnsafe(2)
+ buf[0] = 0xd0
+ buf.writeInt8(obj, 1)
+ } else if (obj >= -32768) {
+ buf = Buffer.allocUnsafe(3)
+ buf[0] = 0xd1
+ buf.writeInt16BE(obj, 1)
+ } else if (obj > -214748365) {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xd2
+ buf.writeInt32BE(obj, 1)
+ } else if (obj >= -9007199254740991) {
+ buf = Buffer.allocUnsafe(9)
+ buf[0] = 0xd3
+ write64BitInt(buf, 1, obj)
+ } else {
+ return encodeFloat(obj, true)
+ }
+ }
}
- return this._writableState.destroyed;
- },
- set: function (value) {
- // we ignore the value if the stream
- // has not been initialized yet
- if (!this._writableState) {
- return;
+
+ if (!buf) {
+ throw new Error('not implemented yet')
}
- // backward compatibility, the user is explicitly
- // managing destroyed
- this._writableState.destroyed = value;
+ if (avoidSlice) {
+ return buf
+ } else {
+ return buf.slice()
+ }
}
-});
-Writable.prototype.destroy = destroyImpl.destroy;
-Writable.prototype._undestroy = destroyImpl.undestroy;
-Writable.prototype._destroy = function (err, cb) {
- this.end();
- cb(err);
-};
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
-},{"./_stream_duplex":40,"./internal/streams/destroy":46,"./internal/streams/stream":47,"_process":70,"core-util-is":32,"inherits":33,"process-nextick-args":39,"safe-buffer":49,"timers":71,"util-deprecate":51}],45:[function(require,module,exports){
-arguments[4][15][0].apply(exports,arguments)
-},{"dup":15,"safe-buffer":49,"util":64}],46:[function(require,module,exports){
-arguments[4][16][0].apply(exports,arguments)
-},{"dup":16,"process-nextick-args":39}],47:[function(require,module,exports){
-arguments[4][17][0].apply(exports,arguments)
-},{"dup":17,"events":66}],48:[function(require,module,exports){
-arguments[4][18][0].apply(exports,arguments)
-},{"./lib/_stream_duplex.js":40,"./lib/_stream_passthrough.js":41,"./lib/_stream_readable.js":42,"./lib/_stream_transform.js":43,"./lib/_stream_writable.js":44,"dup":18}],49:[function(require,module,exports){
-arguments[4][19][0].apply(exports,arguments)
-},{"buffer":65,"dup":19}],50:[function(require,module,exports){
-arguments[4][20][0].apply(exports,arguments)
-},{"dup":20,"safe-buffer":49}],51:[function(require,module,exports){
-arguments[4][21][0].apply(exports,arguments)
-},{"dup":21}],52:[function(require,module,exports){
-var v1 = require('./v1');
-var v4 = require('./v4');
+ function encodeDate (dt) {
+ var encoded
+ var millis = dt * 1
+ var seconds = Math.floor(millis / 1000)
+ var nanos = (millis - (seconds * 1000)) * 1E6
-var uuid = v4;
-uuid.v1 = v1;
-uuid.v4 = v4;
+ if (nanos || seconds > 0xFFFFFFFF) {
+ // Timestamp64
+ encoded = Buffer.allocUnsafe(10)
+ encoded[0] = 0xd7
+ encoded[1] = -1
+
+ var upperNanos = ((nanos * 4))
+ var upperSeconds = seconds / Math.pow(2, 32)
+ var upper = (upperNanos + upperSeconds) & 0xFFFFFFFF
+ var lower = seconds & 0xFFFFFFFF
+
+ encoded.writeInt32BE(upper, 2)
+ encoded.writeInt32BE(lower, 6)
+ } else {
+ // Timestamp32
+ encoded = Buffer.allocUnsafe(6)
+ encoded[0] = 0xd6
+ encoded[1] = -1
+ encoded.writeUInt32BE(Math.floor(millis / 1000), 2)
+ }
+ return bl().append(encoded)
+ }
-module.exports = uuid;
+ function encodeExt (obj) {
+ var i
+ var encoded
+ var length = -1
+ var headers = []
-},{"./v1":55,"./v4":56}],53:[function(require,module,exports){
-/**
- * Convert array of 16 byte values to UUID string format of the form:
- * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
- */
-var byteToHex = [];
-for (var i = 0; i < 256; ++i) {
- byteToHex[i] = (i + 0x100).toString(16).substr(1);
-}
+ for (i = 0; i < encodingTypes.length; i++) {
+ if (encodingTypes[i].check(obj)) {
+ encoded = encodingTypes[i].encode(obj)
+ break
+ }
+ }
-function bytesToUuid(buf, offset) {
- var i = offset || 0;
- var bth = byteToHex;
- // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
- return ([
- bth[buf[i++]], bth[buf[i++]],
- bth[buf[i++]], bth[buf[i++]], '-',
- bth[buf[i++]], bth[buf[i++]], '-',
- bth[buf[i++]], bth[buf[i++]], '-',
- bth[buf[i++]], bth[buf[i++]], '-',
- bth[buf[i++]], bth[buf[i++]],
- bth[buf[i++]], bth[buf[i++]],
- bth[buf[i++]], bth[buf[i++]]
- ]).join('');
-}
+ if (!encoded) {
+ return null
+ }
-module.exports = bytesToUuid;
+ // we subtract 1 because the length does not
+ // include the type
+ length = encoded.length - 1
-},{}],54:[function(require,module,exports){
-// Unique ID creation requires a high quality random # generator. In the
-// browser this is a little complicated due to unknown quality of Math.random()
-// and inconsistent support for the `crypto` API. We do the best we can via
-// feature-detection
+ if (length === 1) {
+ headers.push(0xd4)
+ } else if (length === 2) {
+ headers.push(0xd5)
+ } else if (length === 4) {
+ headers.push(0xd6)
+ } else if (length === 8) {
+ headers.push(0xd7)
+ } else if (length === 16) {
+ headers.push(0xd8)
+ } else if (length < 256) {
+ headers.push(0xc7)
+ headers.push(length)
+ } else if (length < 0x10000) {
+ headers.push(0xc8)
+ headers.push(length >> 8)
+ headers.push(length & 0x00ff)
+ } else {
+ headers.push(0xc9)
+ headers.push(length >> 24)
+ headers.push((length >> 16) & 0x000000ff)
+ headers.push((length >> 8) & 0x000000ff)
+ headers.push(length & 0x000000ff)
+ }
-// getRandomValues needs to be invoked in a context where "this" is a Crypto
-// implementation. Also, find the complete implementation of crypto on IE11.
-var getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||
- (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));
+ return bl().append(Buffer.from(headers)).append(encoded)
+ }
-if (getRandomValues) {
- // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
- var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef
+ function encodeObject (obj) {
+ var acc = []
+ var length = 0
+ var key
+ var header
- module.exports = function whatwgRNG() {
- getRandomValues(rnds8);
- return rnds8;
- };
-} else {
- // Math.random()-based (RNG)
- //
- // If all else fails, use Math.random(). It's fast, but is of unspecified
- // quality.
- var rnds = new Array(16);
+ for (key in obj) {
+ if (obj.hasOwnProperty(key) &&
+ obj[key] !== undefined &&
+ typeof obj[key] !== 'function') {
+ ++length
+ acc.push(encode(key, true))
+ acc.push(encode(obj[key], true))
+ }
+ }
- module.exports = function mathRNG() {
- for (var i = 0, r; i < 16; i++) {
- if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
- rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
+ if (length < 16) {
+ header = Buffer.allocUnsafe(1)
+ header[0] = 0x80 | length
+ } else if (length < 0xFFFF) {
+ header = Buffer.allocUnsafe(3)
+ header[0] = 0xde
+ header.writeUInt16BE(length, 1)
+ } else {
+ header = Buffer.allocUnsafe(5)
+ header[0] = 0xdf
+ header.writeUInt32BE(length, 1)
}
- return rnds;
- };
-}
+ acc.unshift(header)
-},{}],55:[function(require,module,exports){
-var rng = require('./lib/rng');
-var bytesToUuid = require('./lib/bytesToUuid');
+ var result = acc.reduce(function (list, buf) {
+ return list.append(buf)
+ }, bl())
-// **`v1()` - Generate time-based UUID**
-//
-// Inspired by https://github.com/LiosK/UUID.js
-// and http://docs.python.org/library/uuid.html
+ return result
+ }
-var _nodeId;
-var _clockseq;
+ return encode
+}
-// Previous uuid creation time
-var _lastMSecs = 0;
-var _lastNSecs = 0;
+function write64BitUint (buf, obj) {
+ // Write long byte by byte, in big-endian order
+ for (var currByte = 7; currByte >= 0; currByte--) {
+ buf[currByte + 1] = (obj & 0xff)
+ obj = obj / 256
+ }
+}
-// See https://github.com/uuidjs/uuid for API details
-function v1(options, buf, offset) {
- var i = buf && offset || 0;
- var b = buf || [];
+function write64BitInt (buf, offset, num) {
+ var negate = num < 0
- options = options || {};
- var node = options.node || _nodeId;
- var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;
+ if (negate) {
+ num = Math.abs(num)
+ }
- // node and clockseq need to be initialized to random values if they're not
- // specified. We do this lazily to minimize issues related to insufficient
- // system entropy. See #189
- if (node == null || clockseq == null) {
- var seedBytes = rng();
- if (node == null) {
- // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
- node = _nodeId = [
- seedBytes[0] | 0x01,
- seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]
- ];
- }
- if (clockseq == null) {
- // Per 4.2.2, randomize (14 bit) clockseq
- clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
+ var lo = num % 4294967296
+ var hi = num / 4294967296
+ buf.writeUInt32BE(Math.floor(hi), offset + 0)
+ buf.writeUInt32BE(lo, offset + 4)
+
+ if (negate) {
+ var carry = 1
+ for (var i = offset + 7; i >= offset; i--) {
+ var v = (buf[i] ^ 0xff) + carry
+ buf[i] = v & 0xff
+ carry = v >> 8
}
}
+}
- // UUID timestamps are 100 nano-second units since the Gregorian epoch,
- // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
- // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
- // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
- var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();
+function isFloat (n) {
+ return n % 1 !== 0
+}
- // Per 4.2.1.2, use count of uuid's generated during the current clock
- // cycle to simulate higher resolution clock
- var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;
+function isNaN (n) {
+ /* eslint-disable no-self-compare */
+ return n !== n && typeof n === 'number'
+ /* eslint-enable no-self-compare */
+}
- // Time since last uuid creation (in msecs)
- var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
+function encodeFloat (obj, forceFloat64) {
+ var useDoublePrecision = true
- // Per 4.2.1.2, Bump clockseq on clock regression
- if (dt < 0 && options.clockseq === undefined) {
- clockseq = clockseq + 1 & 0x3fff;
+ // If `fround` is supported, we can check if a float
+ // is double or single precision by rounding the object
+ // to single precision and comparing the difference.
+ // If it's not supported, it's safer to use a 64 bit
+ // float so we don't lose precision without meaning to.
+ if (Math.fround) {
+ useDoublePrecision = Math.fround(obj) !== obj
}
- // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
- // time interval
- if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
- nsecs = 0;
+ if (forceFloat64) {
+ useDoublePrecision = true
}
- // Per 4.2.1.2 Throw error if too many uuids are requested
- if (nsecs >= 10000) {
- throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
+ var buf
+
+ if (useDoublePrecision) {
+ buf = Buffer.allocUnsafe(9)
+ buf[0] = 0xcb
+ buf.writeDoubleBE(obj, 1)
+ } else {
+ buf = Buffer.allocUnsafe(5)
+ buf[0] = 0xca
+ buf.writeFloatBE(obj, 1)
}
- _lastMSecs = msecs;
- _lastNSecs = nsecs;
- _clockseq = clockseq;
+ return buf
+}
- // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
- msecs += 12219292800000;
+},{"bl":6,"safe-buffer":32}],18:[function(require,module,exports){
+'use strict'
- // `time_low`
- var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
- b[i++] = tl >>> 24 & 0xff;
- b[i++] = tl >>> 16 & 0xff;
- b[i++] = tl >>> 8 & 0xff;
- b[i++] = tl & 0xff;
+var Transform = require('readable-stream').Transform
+var inherits = require('inherits')
+var bl = require('bl')
- // `time_mid`
- var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
- b[i++] = tmh >>> 8 & 0xff;
- b[i++] = tmh & 0xff;
+function Base (opts) {
+ opts = opts || {}
- // `time_high_and_version`
- b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
- b[i++] = tmh >>> 16 & 0xff;
+ opts.objectMode = true
+ opts.highWaterMark = 16
- // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
- b[i++] = clockseq >>> 8 | 0x80;
+ Transform.call(this, opts)
- // `clock_seq_low`
- b[i++] = clockseq & 0xff;
+ this._msgpack = opts.msgpack
+}
- // `node`
- for (var n = 0; n < 6; ++n) {
- b[i + n] = node[n];
+inherits(Base, Transform)
+
+function Encoder (opts) {
+ if (!(this instanceof Encoder)) {
+ opts = opts || {}
+ opts.msgpack = this
+ return new Encoder(opts)
}
- return buf ? buf : bytesToUuid(b);
+ Base.call(this, opts)
+ this._wrap = ('wrap' in opts) && opts.wrap
}
-module.exports = v1;
+inherits(Encoder, Base)
-},{"./lib/bytesToUuid":53,"./lib/rng":54}],56:[function(require,module,exports){
-var rng = require('./lib/rng');
-var bytesToUuid = require('./lib/bytesToUuid');
+Encoder.prototype._transform = function (obj, enc, done) {
+ var buf = null
-function v4(options, buf, offset) {
- var i = buf && offset || 0;
+ try {
+ buf = this._msgpack.encode(this._wrap ? obj.value : obj).slice(0)
+ } catch (err) {
+ this.emit('error', err)
+ return done()
+ }
- if (typeof(options) == 'string') {
- buf = options === 'binary' ? new Array(16) : null;
- options = null;
+ this.push(buf)
+ done()
+}
+
+function Decoder (opts) {
+ if (!(this instanceof Decoder)) {
+ opts = opts || {}
+ opts.msgpack = this
+ return new Decoder(opts)
}
- options = options || {};
- var rnds = options.random || (options.rng || rng)();
+ Base.call(this, opts)
- // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
- rnds[6] = (rnds[6] & 0x0f) | 0x40;
- rnds[8] = (rnds[8] & 0x3f) | 0x80;
+ this._chunks = bl()
+ this._wrap = ('wrap' in opts) && opts.wrap
+}
- // Copy bytes to buffer, if provided
+inherits(Decoder, Base)
+
+Decoder.prototype._transform = function (buf, enc, done) {
if (buf) {
- for (var ii = 0; ii < 16; ++ii) {
- buf[i + ii] = rnds[ii];
+ this._chunks.append(buf)
+ }
+
+ try {
+ var result = this._msgpack.decode(this._chunks)
+ if (this._wrap) {
+ result = {value: result}
+ }
+ this.push(result)
+ } catch (err) {
+ if (err instanceof this._msgpack.IncompleteBufferError) {
+ done()
+ } else {
+ this.emit('error', err)
}
+ return
}
- return buf || bytesToUuid(rnds);
+ if (this._chunks.length > 0) {
+ this._transform(null, enc, done)
+ } else {
+ done()
+ }
}
-module.exports = v4;
-
-},{"./lib/bytesToUuid":53,"./lib/rng":54}],57:[function(require,module,exports){
-(function (Buffer){
-const msgpack = require('msgpack5')()
- , encode = msgpack.encode
- , decode = msgpack.decode;
-const uuidv4 = require('uuid') //Deprecated method, should use require('uuid/v4')
-const uuidParser = require('./utils/uuidParser')
-
-const kConnecting = 1;
-const kConnected = 2;
-const kDisconnected = 3;
-
-// Generate a unique id for this webservice
-let uuid = uuidv4();
-let my_uuid = uuidParser.parse(uuid)
-my_uuid = new Uint8Array(my_uuid);
-// my_uuid[0] = 44;
-// console.log(my_uuid)
-my_uuid = Buffer.from(my_uuid);
+module.exports.decoder = Decoder
+module.exports.encoder = Encoder
-const kMagic = 0x0009340053640912;
-const kVersion = 0;
+},{"bl":6,"inherits":12,"readable-stream":30}],19:[function(require,module,exports){
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+'use strict';
+/* eslint-disable no-unused-vars */
+var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var propIsEnumerable = Object.prototype.propertyIsEnumerable;
-/**
- * Wrap a web socket with a MsgPack RCP protocol that works with our C++ version.
- * @param {websocket} ws Websocket object
- */
-function Peer(ws) {
- this.sock = ws;
- this.status = kConnecting;
- this.id = null;
- this.string_id = "";
- this.bindings = {};
- this.proxies = {};
- this.events = {};
- this.callbacks = {};
- this.cbid = 0;
+function toObject(val) {
+ if (val === null || val === undefined) {
+ throw new TypeError('Object.assign cannot be called with null or undefined');
+ }
- this.uri = "unknown";
- this.name = "unknown";
- this.master = false;
+ return Object(val);
+}
- let message = (raw) => {
- //Gets right data for client
- if(this.sock.on === undefined){
- raw = raw.data;
- }
- let msg = decode(raw);
- // console.log('MSG', msg)
- if (this.status == kConnecting) {
- if (msg[1] != "__handshake__") {
- console.log("Bad handshake");
- this.close();
- }
- }
- if (msg[0] == 0) {
- // console.log("MSG...", msg[2]);
- // Notification
- if (msg.length == 3) {
- this._dispatchNotification(msg[1], msg[2]);
- // Call
- } else {
- this._dispatchCall(msg[2], msg[1], msg[3]);
- }
- } else if (msg[0] == 1) {
- this._dispatchResponse(msg[1], msg[3]);
+function shouldUseNative() {
+ try {
+ if (!Object.assign) {
+ return false;
}
- }
-
- let close = () => {
- this.status = kDisconnected;
- this._notify("disconnect", this);
- }
- let error = () => {
- console.error("Socket error");
- this.sock.close();
- this.status = kDisconnected;
- }
+ // Detect buggy property enumeration order in older V8 versions.
- //if undefined, peer is being used by client
- if(this.sock.on === undefined){
- this.sock.onmessage = message;
- this.sock.onclose = close;
- this.sock.onopen = (event) => {
- this.send("__handshake__", kMagic, kVersion, [my_uuid]);
+ // https://bugs.chromium.org/p/v8/issues/detail?id=4118
+ var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
+ test1[5] = 'de';
+ if (Object.getOwnPropertyNames(test1)[0] === '5') {
+ return false;
}
- //else peer is being used by server
- }else{
- this.sock.on("message", message);
- this.sock.on("close", close);
- this.sock.on("error", error);
- }
- this.bind("__handshake__", (magic, version, id) => {
- if (magic == kMagic) {
- console.log("Handshake received");
- this.status = kConnected;
- this.id = id.buffer;
- this.string_id = id.toString('hex');
- this._notify("connect", this);
- // if(this.sock.on === undefined){
- // this.send("__handshake__", kMagic, kVersion, [my_uuid]);
- // }
- } else {
- console.log("Magic does not match");
- this.close();
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+ var test2 = {};
+ for (var i = 0; i < 10; i++) {
+ test2['_' + String.fromCharCode(i)] = i;
+ }
+ var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+ return test2[n];
+ });
+ if (order2.join('') !== '0123456789') {
+ return false;
}
- });
- this.send("__handshake__", kMagic, kVersion, [my_uuid]);
-}
-
-
-Peer.uuid = my_uuid;
-/**
- * @private
- */
-Peer.prototype._dispatchNotification = function(name, args) {
- if (this.bindings.hasOwnProperty(name)) {
- //console.log("Notification for: ", name);
- this.bindings[name].apply(this, args);
- } else {
- console.log("Missing handler for: ", name);
+ // https://bugs.chromium.org/p/v8/issues/detail?id=3056
+ var test3 = {};
+ 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+ test3[letter] = letter;
+ });
+ if (Object.keys(Object.assign({}, test3)).join('') !==
+ 'abcdefghijklmnopqrst') {
+ return false;
+ }
+
+ return true;
+ } catch (err) {
+ // We don't expect any of the above to throw, but better to be safe.
+ return false;
}
}
-/**
- * @private
- */
-Peer.prototype._dispatchCall = function(name, id, args) {
- console.log("DISPATCHCALL", name, id, args)
- if (this.bindings.hasOwnProperty(name)) {
- //console.log("Call for:", name, id);
+module.exports = shouldUseNative() ? Object.assign : function (target, source) {
+ var from;
+ var to = toObject(target);
+ var symbols;
- try {
- let res = this.bindings[name].apply(this, args);
- this.sock.send(encode([1,id,name,res]));
- } catch(e) {
- console.error("Could to dispatch or return call", e);
- this.close();
+ for (var s = 1; s < arguments.length; s++) {
+ from = Object(arguments[s]);
+
+ for (var key in from) {
+ if (hasOwnProperty.call(from, key)) {
+ to[key] = from[key];
+ }
}
- } else if (this.proxies.hasOwnProperty(name)) {
- //console.log("Proxy for:", name, id);
- args.unshift((res) => {
- try {
- this.sock.send(encode([1,id,name,res]));
- } catch(e) {
- console.log("ERROR")
- this.close();
+
+ if (getOwnPropertySymbols) {
+ symbols = getOwnPropertySymbols(from);
+ for (var i = 0; i < symbols.length; i++) {
+ if (propIsEnumerable.call(from, symbols[i])) {
+ to[symbols[i]] = from[symbols[i]];
+ }
}
- });
- this.proxies[name].apply(this, args);
- } else {
- console.log("Missing handler for: ", name);
+ }
}
-}
-/**
- * @private
- */
-Peer.prototype._dispatchResponse = function(id, res) {
- if (this.callbacks.hasOwnProperty(id)) {
- this.callbacks[id].call(this, res);
- delete this.callbacks[id];
- } else {
- console.log("Missing callback");
- }
-}
+ return to;
+};
-/**
- * Register an RPC handler that will be called from a remote machine. Remotely
- * passed arguments are provided to the given function as normal arguments, and
- * if the function returns a value, it will be returned over the network also.
- *
- * @param {string} name The name of the function
- * @param {function} f A function or lambda to be callable remotely
- */
-Peer.prototype.bind = function(name, f) {
- if (this.bindings.hasOwnProperty(name)) {
- //console.error("Duplicate bind to same procedure");
- this.bindings[name] = f;
- } else {
- this.bindings[name] = f;
- }
-}
+},{}],20:[function(require,module,exports){
+(function (process){
+'use strict';
-Peer.prototype.isBound = function(name) {
- return this.bindings.hasOwnProperty(name) || this.proxies.hasOwnProperty(name);
+if (typeof process === 'undefined' ||
+ !process.version ||
+ process.version.indexOf('v0.') === 0 ||
+ process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {
+ module.exports = { nextTick: nextTick };
+} else {
+ module.exports = process
}
-/**
- * Allow an RPC call to pass through to another machine with minimal local
- * processing.
- */
-Peer.prototype.proxy = function(name, f) {
- if (this.proxies.hasOwnProperty(name)) {
- //console.error("Duplicate proxy to same procedure");
- this.proxies[name] = f;
- } else {
- this.proxies[name] = f;
- }
+function nextTick(fn, arg1, arg2, arg3) {
+ if (typeof fn !== 'function') {
+ throw new TypeError('"callback" argument must be a function');
+ }
+ var len = arguments.length;
+ var args, i;
+ switch (len) {
+ case 0:
+ case 1:
+ return process.nextTick(fn);
+ case 2:
+ return process.nextTick(function afterTickOne() {
+ fn.call(null, arg1);
+ });
+ case 3:
+ return process.nextTick(function afterTickTwo() {
+ fn.call(null, arg1, arg2);
+ });
+ case 4:
+ return process.nextTick(function afterTickThree() {
+ fn.call(null, arg1, arg2, arg3);
+ });
+ default:
+ args = new Array(len - 1);
+ i = 0;
+ while (i < args.length) {
+ args[i++] = arguments[i];
+ }
+ return process.nextTick(function afterTick() {
+ fn.apply(null, args);
+ });
+ }
}
-/**
- * Call a procedure on a remote machine.
- *
- * @param {string} name Name of the procedure
- * @param {function} cb Callback to receive return value as argument
- * @param {...} args Any number of arguments to also pass to remote procedure
- */
-Peer.prototype.rpc = function(name, cb, ...args) {
- let id = this.cbid++;
- this.callbacks[id] = cb;
-
- try {
- this.sock.send(encode([0, id, name, args]));
- } catch(e) {
- this.close();
- }
-}
-Peer.prototype.sendB = function(name, args) {
- try {
- this.sock.send(encode([0, name, args]));
- } catch(e) {
- this.close();
- }
-}
+}).call(this,require('_process'))
+},{"_process":21}],21:[function(require,module,exports){
+// shim for using process in browser
+var process = module.exports = {};
-/**
- * Call a remote procedure but with no return value expected.
- *
- * @param {string} name Name of the procedure
- * @param {...} args Any number of arguments to also pass to remote procedure
- */
-Peer.prototype.send = function(name, ...args) {
- try {
- this.sock.send(encode([0, name, args]));
- } catch(e) {
- this.close();
- }
-}
+// cached from whatever global is present so that test runners that stub it
+// don't break things. But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals. It's inside a
+// function because try/catches deoptimize in certain engines.
-/**
- * Closes the socket
- */
-Peer.prototype.close = function() {
- if(this.sock.on !== undefined){
- this.sock.close();
- }
- this.status = kDisconnected;
-}
+var cachedSetTimeout;
+var cachedClearTimeout;
-/**
- * @private
- */
-Peer.prototype._notify = function(evt, ...args) {
- if (this.events.hasOwnProperty(evt)) {
- for (let i=0; i<this.events[evt].length; i++) {
- let f = this.events[evt][i];
- f.apply(this, args);
- }
- }
+function defaultSetTimout() {
+ throw new Error('setTimeout has not been defined');
}
-
-/**
- * Register a callback for socket events. Events include: 'connect',
- * 'disconnect' and 'error'.
- *
- * @param {string} evt Event name
- * @param {function} f Callback on event
- */
-Peer.prototype.on = function(evt, f) {
- if (!this.events.hasOwnProperty(evt)) {
- this.events[evt] = [];
- }
- this.events[evt].push(f);
+function defaultClearTimeout () {
+ throw new Error('clearTimeout has not been defined');
}
+(function () {
+ try {
+ if (typeof setTimeout === 'function') {
+ cachedSetTimeout = setTimeout;
+ } else {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ } catch (e) {
+ cachedSetTimeout = defaultSetTimout;
+ }
+ try {
+ if (typeof clearTimeout === 'function') {
+ cachedClearTimeout = clearTimeout;
+ } else {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+ } catch (e) {
+ cachedClearTimeout = defaultClearTimeout;
+ }
+} ())
+function runTimeout(fun) {
+ if (cachedSetTimeout === setTimeout) {
+ //normal enviroments in sane situations
+ return setTimeout(fun, 0);
+ }
+ // if setTimeout wasn't available but was latter defined
+ if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+ cachedSetTimeout = setTimeout;
+ return setTimeout(fun, 0);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedSetTimeout(fun, 0);
+ } catch(e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedSetTimeout.call(null, fun, 0);
+ } catch(e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+ return cachedSetTimeout.call(this, fun, 0);
+ }
+ }
-Peer.prototype.getUuid = function() {
- return uuid;
}
+function runClearTimeout(marker) {
+ if (cachedClearTimeout === clearTimeout) {
+ //normal enviroments in sane situations
+ return clearTimeout(marker);
+ }
+ // if clearTimeout wasn't available but was latter defined
+ if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+ cachedClearTimeout = clearTimeout;
+ return clearTimeout(marker);
+ }
+ try {
+ // when when somebody has screwed with setTimeout but no I.E. maddness
+ return cachedClearTimeout(marker);
+ } catch (e){
+ try {
+ // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+ return cachedClearTimeout.call(null, marker);
+ } catch (e){
+ // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+ // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+ return cachedClearTimeout.call(this, marker);
+ }
+ }
-module.exports = Peer;
-}).call(this,require("buffer").Buffer)
-},{"./utils/uuidParser":58,"buffer":65,"msgpack5":35,"uuid":52}],58:[function(require,module,exports){
-// Maps for number <-> hex string conversion
-var _byteToHex = [];
-var _hexToByte = {};
-for (var i = 0; i < 256; i++) {
- _byteToHex[i] = (i + 0x100).toString(16).substr(1);
- _hexToByte[_byteToHex[i]] = i;
-}
-/**
- * `parse()` - Parse a UUID into it's component bytes
- *
- * Turns UUID into Buffer
- **/
-function parse(s, buf, offset) {
- var i = (buf && offset) || 0;
- var ii = 0;
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
- buf = buf || [];
- s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
- if (ii < 16) { // Don't overflow!
- buf[i + ii++] = _hexToByte[oct];
+function cleanUpNextTick() {
+ if (!draining || !currentQueue) {
+ return;
+ }
+ draining = false;
+ if (currentQueue.length) {
+ queue = currentQueue.concat(queue);
+ } else {
+ queueIndex = -1;
+ }
+ if (queue.length) {
+ drainQueue();
}
- });
-
- // Zero out remaining bytes if string was short
- while (ii < 16) {
- buf[i + ii++] = 0;
- }
-
- return buf;
}
-/**
- * `unparse()` - Convert UUID byte array (ala parse()) into a string
- *
- * Turns Buffer into UUID
- * */
-function unparse(buf, offset) {
- var i = offset || 0;
- var bth = _byteToHex;
- return bth[buf[i++]] + bth[buf[i++]] +
- bth[buf[i++]] + bth[buf[i++]] + '-' +
- bth[buf[i++]] + bth[buf[i++]] + '-' +
- bth[buf[i++]] + bth[buf[i++]] + '-' +
- bth[buf[i++]] + bth[buf[i++]] + '-' +
- bth[buf[i++]] + bth[buf[i++]] +
- bth[buf[i++]] + bth[buf[i++]] +
- bth[buf[i++]] + bth[buf[i++]];
+function drainQueue() {
+ if (draining) {
+ return;
+ }
+ var timeout = runTimeout(cleanUpNextTick);
+ draining = true;
+
+ var len = queue.length;
+ while(len) {
+ currentQueue = queue;
+ queue = [];
+ while (++queueIndex < len) {
+ if (currentQueue) {
+ currentQueue[queueIndex].run();
+ }
+ }
+ queueIndex = -1;
+ len = queue.length;
+ }
+ currentQueue = null;
+ draining = false;
+ runClearTimeout(timeout);
}
-module.exports = {
- parse: parse,
- unparse: unparse
+process.nextTick = function (fun) {
+ var args = new Array(arguments.length - 1);
+ if (arguments.length > 1) {
+ for (var i = 1; i < arguments.length; i++) {
+ args[i - 1] = arguments[i];
+ }
+ }
+ queue.push(new Item(fun, args));
+ if (queue.length === 1 && !draining) {
+ runTimeout(drainQueue);
+ }
};
-},{}],59:[function(require,module,exports){
-(function (global){
-'use strict';
-
-var objectAssign = require('object-assign');
-
-// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
-// original notice:
-
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
- * @license MIT
- */
-function compare(a, b) {
- if (a === b) {
- return 0;
- }
- var x = a.length;
- var y = b.length;
+// v8 likes predictible objects
+function Item(fun, array) {
+ this.fun = fun;
+ this.array = array;
+}
+Item.prototype.run = function () {
+ this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
- for (var i = 0, len = Math.min(x, y); i < len; ++i) {
- if (a[i] !== b[i]) {
- x = a[i];
- y = b[i];
- break;
- }
- }
+function noop() {}
- if (x < y) {
- return -1;
- }
- if (y < x) {
- return 1;
- }
- return 0;
-}
-function isBuffer(b) {
- if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {
- return global.Buffer.isBuffer(b);
- }
- return !!(b != null && b._isBuffer);
-}
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
-// based on node assert, original notice:
-// NB: The URL to the CommonJS spec is kept just for tradition.
-// node-assert has evolved a lot since then, both in API and behavior.
+process.listeners = function (name) { return [] }
-// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
-//
-// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
-//
-// Originally from narwhal.js (http://narwhaljs.org)
-// Copyright (c) 2009 Thomas Robinson <280north.com>
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the 'Software'), to
-// deal in the Software without restriction, including without limitation the
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-// sell copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+process.binding = function (name) {
+ throw new Error('process.binding is not supported');
+};
-var util = require('util/');
-var hasOwn = Object.prototype.hasOwnProperty;
-var pSlice = Array.prototype.slice;
-var functionsHaveNames = (function () {
- return function foo() {}.name === 'foo';
-}());
-function pToString (obj) {
- return Object.prototype.toString.call(obj);
-}
-function isView(arrbuf) {
- if (isBuffer(arrbuf)) {
- return false;
- }
- if (typeof global.ArrayBuffer !== 'function') {
- return false;
- }
- if (typeof ArrayBuffer.isView === 'function') {
- return ArrayBuffer.isView(arrbuf);
- }
- if (!arrbuf) {
- return false;
- }
- if (arrbuf instanceof DataView) {
- return true;
- }
- if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {
- return true;
- }
- return false;
-}
-// 1. The assert module provides functions that throw
-// AssertionError's when particular conditions are not met. The
-// assert module must conform to the following interface.
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+ throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };
-var assert = module.exports = ok;
+},{}],22:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
-// 2. The AssertionError is defined in assert.
-// new assert.AssertionError({ message: message,
-// actual: actual,
-// expected: expected })
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
-var regex = /\s*function\s+([^\(\s]*)\s*/;
-// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js
-function getName(func) {
- if (!util.isFunction(func)) {
- return;
- }
- if (functionsHaveNames) {
- return func.name;
- }
- var str = func.toString();
- var match = str.match(regex);
- return match && match[1];
-}
-assert.AssertionError = function AssertionError(options) {
- this.name = 'AssertionError';
- this.actual = options.actual;
- this.expected = options.expected;
- this.operator = options.operator;
- if (options.message) {
- this.message = options.message;
- this.generatedMessage = false;
- } else {
- this.message = getMessage(this);
- this.generatedMessage = true;
- }
- var stackStartFunction = options.stackStartFunction || fail;
- if (Error.captureStackTrace) {
- Error.captureStackTrace(this, stackStartFunction);
- } else {
- // non v8 browsers so we can have a stacktrace
- var err = new Error();
- if (err.stack) {
- var out = err.stack;
+'use strict';
- // try to strip useless frames
- var fn_name = getName(stackStartFunction);
- var idx = out.indexOf('\n' + fn_name);
- if (idx >= 0) {
- // once we have located the function frame
- // we need to strip out everything before it (and its line)
- var next_line = out.indexOf('\n', idx + 1);
- out = out.substring(next_line + 1);
- }
+/*<replacement>*/
- this.stack = out;
- }
- }
+var pna = require('process-nextick-args');
+/*</replacement>*/
+
+/*<replacement>*/
+var objectKeys = Object.keys || function (obj) {
+ var keys = [];
+ for (var key in obj) {
+ keys.push(key);
+ }return keys;
};
+/*</replacement>*/
-// assert.AssertionError instanceof Error
-util.inherits(assert.AssertionError, Error);
+module.exports = Duplex;
-function truncate(s, n) {
- if (typeof s === 'string') {
- return s.length < n ? s : s.slice(0, n);
- } else {
- return s;
- }
-}
-function inspect(something) {
- if (functionsHaveNames || !util.isFunction(something)) {
- return util.inspect(something);
+/*<replacement>*/
+var util = Object.create(require('core-util-is'));
+util.inherits = require('inherits');
+/*</replacement>*/
+
+var Readable = require('./_stream_readable');
+var Writable = require('./_stream_writable');
+
+util.inherits(Duplex, Readable);
+
+{
+ // avoid scope creep, the keys array can then be collected
+ var keys = objectKeys(Writable.prototype);
+ for (var v = 0; v < keys.length; v++) {
+ var method = keys[v];
+ if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
}
- var rawname = getName(something);
- var name = rawname ? ': ' + rawname : '';
- return '[Function' + name + ']';
-}
-function getMessage(self) {
- return truncate(inspect(self.actual), 128) + ' ' +
- self.operator + ' ' +
- truncate(inspect(self.expected), 128);
}
-// At present only the three keys mentioned above are used and
-// understood by the spec. Implementations or sub modules can pass
-// other keys to the AssertionError's constructor - they will be
-// ignored.
+function Duplex(options) {
+ if (!(this instanceof Duplex)) return new Duplex(options);
-// 3. All of the following functions must throw an AssertionError
-// when a corresponding condition is not met, with a message that
-// may be undefined if not provided. All assertion methods provide
-// both the actual and expected values to the assertion error for
-// display purposes.
+ Readable.call(this, options);
+ Writable.call(this, options);
-function fail(actual, expected, message, operator, stackStartFunction) {
- throw new assert.AssertionError({
- message: message,
- actual: actual,
- expected: expected,
- operator: operator,
- stackStartFunction: stackStartFunction
- });
-}
+ if (options && options.readable === false) this.readable = false;
-// EXTENSION! allows for well behaved errors defined elsewhere.
-assert.fail = fail;
+ if (options && options.writable === false) this.writable = false;
-// 4. Pure assertion tests whether a value is truthy, as determined
-// by !!guard.
-// assert.ok(guard, message_opt);
-// This statement is equivalent to assert.equal(true, !!guard,
-// message_opt);. To test strictly for the value true, use
-// assert.strictEqual(true, guard, message_opt);.
+ this.allowHalfOpen = true;
+ if (options && options.allowHalfOpen === false) this.allowHalfOpen = false;
-function ok(value, message) {
- if (!value) fail(value, true, message, '==', assert.ok);
+ this.once('end', onend);
}
-assert.ok = ok;
-// 5. The equality assertion tests shallow, coercive equality with
-// ==.
-// assert.equal(actual, expected, message_opt);
+Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._writableState.highWaterMark;
+ }
+});
-assert.equal = function equal(actual, expected, message) {
- if (actual != expected) fail(actual, expected, message, '==', assert.equal);
-};
+// the no-half-open enforcer
+function onend() {
+ // if we allow half-open state, or if the writable side ended,
+ // then we're ok.
+ if (this.allowHalfOpen || this._writableState.ended) return;
-// 6. The non-equality assertion tests for whether two objects are not equal
-// with != assert.notEqual(actual, expected, message_opt);
+ // no more data can be written.
+ // But allow more writes to happen in this tick.
+ pna.nextTick(onEndNT, this);
+}
-assert.notEqual = function notEqual(actual, expected, message) {
- if (actual == expected) {
- fail(actual, expected, message, '!=', assert.notEqual);
- }
-};
+function onEndNT(self) {
+ self.end();
+}
-// 7. The equivalence assertion tests a deep equality relation.
-// assert.deepEqual(actual, expected, message_opt);
+Object.defineProperty(Duplex.prototype, 'destroyed', {
+ get: function () {
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return false;
+ }
+ return this._readableState.destroyed && this._writableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (this._readableState === undefined || this._writableState === undefined) {
+ return;
+ }
-assert.deepEqual = function deepEqual(actual, expected, message) {
- if (!_deepEqual(actual, expected, false)) {
- fail(actual, expected, message, 'deepEqual', assert.deepEqual);
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._readableState.destroyed = value;
+ this._writableState.destroyed = value;
}
-};
+});
-assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
- if (!_deepEqual(actual, expected, true)) {
- fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
- }
-};
+Duplex.prototype._destroy = function (err, cb) {
+ this.push(null);
+ this.end();
-function _deepEqual(actual, expected, strict, memos) {
- // 7.1. All identical values are equivalent, as determined by ===.
- if (actual === expected) {
- return true;
- } else if (isBuffer(actual) && isBuffer(expected)) {
- return compare(actual, expected) === 0;
+ pna.nextTick(cb, err);
+};
+},{"./_stream_readable":24,"./_stream_writable":26,"core-util-is":9,"inherits":12,"process-nextick-args":20}],23:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
- // 7.2. If the expected value is a Date object, the actual value is
- // equivalent if it is also a Date object that refers to the same time.
- } else if (util.isDate(actual) && util.isDate(expected)) {
- return actual.getTime() === expected.getTime();
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
- // 7.3 If the expected value is a RegExp object, the actual value is
- // equivalent if it is also a RegExp object with the same source and
- // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
- } else if (util.isRegExp(actual) && util.isRegExp(expected)) {
- return actual.source === expected.source &&
- actual.global === expected.global &&
- actual.multiline === expected.multiline &&
- actual.lastIndex === expected.lastIndex &&
- actual.ignoreCase === expected.ignoreCase;
+'use strict';
- // 7.4. Other pairs that do not both pass typeof value == 'object',
- // equivalence is determined by ==.
- } else if ((actual === null || typeof actual !== 'object') &&
- (expected === null || typeof expected !== 'object')) {
- return strict ? actual === expected : actual == expected;
+module.exports = PassThrough;
- // If both values are instances of typed arrays, wrap their underlying
- // ArrayBuffers in a Buffer each to increase performance
- // This optimization requires the arrays to have the same type as checked by
- // Object.prototype.toString (aka pToString). Never perform binary
- // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their
- // bit patterns are not identical.
- } else if (isView(actual) && isView(expected) &&
- pToString(actual) === pToString(expected) &&
- !(actual instanceof Float32Array ||
- actual instanceof Float64Array)) {
- return compare(new Uint8Array(actual.buffer),
- new Uint8Array(expected.buffer)) === 0;
+var Transform = require('./_stream_transform');
- // 7.5 For all other Object pairs, including Array objects, equivalence is
- // determined by having the same number of owned properties (as verified
- // with Object.prototype.hasOwnProperty.call), the same set of keys
- // (although not necessarily the same order), equivalent values for every
- // corresponding key, and an identical 'prototype' property. Note: this
- // accounts for both named and indexed properties on Arrays.
- } else if (isBuffer(actual) !== isBuffer(expected)) {
- return false;
- } else {
- memos = memos || {actual: [], expected: []};
+/*<replacement>*/
+var util = Object.create(require('core-util-is'));
+util.inherits = require('inherits');
+/*</replacement>*/
- var actualIndex = memos.actual.indexOf(actual);
- if (actualIndex !== -1) {
- if (actualIndex === memos.expected.indexOf(expected)) {
- return true;
- }
- }
+util.inherits(PassThrough, Transform);
- memos.actual.push(actual);
- memos.expected.push(expected);
+function PassThrough(options) {
+ if (!(this instanceof PassThrough)) return new PassThrough(options);
- return objEquiv(actual, expected, strict, memos);
- }
+ Transform.call(this, options);
}
-function isArguments(object) {
- return Object.prototype.toString.call(object) == '[object Arguments]';
-}
+PassThrough.prototype._transform = function (chunk, encoding, cb) {
+ cb(null, chunk);
+};
+},{"./_stream_transform":25,"core-util-is":9,"inherits":12}],24:[function(require,module,exports){
+(function (process,global){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
-function objEquiv(a, b, strict, actualVisitedObjects) {
- if (a === null || a === undefined || b === null || b === undefined)
- return false;
- // if one is a primitive, the other must be same
- if (util.isPrimitive(a) || util.isPrimitive(b))
- return a === b;
- if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))
- return false;
- var aIsArgs = isArguments(a);
- var bIsArgs = isArguments(b);
- if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
- return false;
- if (aIsArgs) {
- a = pSlice.call(a);
- b = pSlice.call(b);
- return _deepEqual(a, b, strict);
- }
- var ka = objectKeys(a);
- var kb = objectKeys(b);
- var key, i;
- // having the same number of owned properties (keys incorporates
- // hasOwnProperty)
- if (ka.length !== kb.length)
- return false;
- //the same set of keys (although not necessarily the same order),
- ka.sort();
- kb.sort();
- //~~~cheap key test
- for (i = ka.length - 1; i >= 0; i--) {
- if (ka[i] !== kb[i])
- return false;
- }
- //equivalent values for every corresponding key, and
- //~~~possibly expensive deep test
- for (i = ka.length - 1; i >= 0; i--) {
- key = ka[i];
- if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))
- return false;
- }
- return true;
-}
+'use strict';
-// 8. The non-equivalence assertion tests for any deep inequality.
-// assert.notDeepEqual(actual, expected, message_opt);
+/*<replacement>*/
-assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
- if (_deepEqual(actual, expected, false)) {
- fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
- }
-};
+var pna = require('process-nextick-args');
+/*</replacement>*/
-assert.notDeepStrictEqual = notDeepStrictEqual;
-function notDeepStrictEqual(actual, expected, message) {
- if (_deepEqual(actual, expected, true)) {
- fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
- }
-}
+module.exports = Readable;
+/*<replacement>*/
+var isArray = require('isarray');
+/*</replacement>*/
-// 9. The strict equality assertion tests strict equality, as determined by ===.
-// assert.strictEqual(actual, expected, message_opt);
+/*<replacement>*/
+var Duplex;
+/*</replacement>*/
-assert.strictEqual = function strictEqual(actual, expected, message) {
- if (actual !== expected) {
- fail(actual, expected, message, '===', assert.strictEqual);
- }
-};
+Readable.ReadableState = ReadableState;
-// 10. The strict non-equality assertion tests for strict inequality, as
-// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
+/*<replacement>*/
+var EE = require('events').EventEmitter;
-assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
- if (actual === expected) {
- fail(actual, expected, message, '!==', assert.notStrictEqual);
- }
+var EElistenerCount = function (emitter, type) {
+ return emitter.listeners(type).length;
};
+/*</replacement>*/
-function expectedException(actual, expected) {
- if (!actual || !expected) {
- return false;
- }
+/*<replacement>*/
+var Stream = require('./internal/streams/stream');
+/*</replacement>*/
- if (Object.prototype.toString.call(expected) == '[object RegExp]') {
- return expected.test(actual);
- }
+/*<replacement>*/
- try {
- if (actual instanceof expected) {
- return true;
- }
- } catch (e) {
- // Ignore. The instanceof check doesn't work for arrow functions.
- }
+var Buffer = require('safe-buffer').Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
+}
- if (Error.isPrototypeOf(expected)) {
- return false;
- }
+/*</replacement>*/
- return expected.call({}, actual) === true;
-}
+/*<replacement>*/
+var util = Object.create(require('core-util-is'));
+util.inherits = require('inherits');
+/*</replacement>*/
-function _tryBlock(block) {
- var error;
- try {
- block();
- } catch (e) {
- error = e;
- }
- return error;
+/*<replacement>*/
+var debugUtil = require('util');
+var debug = void 0;
+if (debugUtil && debugUtil.debuglog) {
+ debug = debugUtil.debuglog('stream');
+} else {
+ debug = function () {};
}
+/*</replacement>*/
-function _throws(shouldThrow, block, expected, message) {
- var actual;
-
- if (typeof block !== 'function') {
- throw new TypeError('"block" argument must be a function');
- }
+var BufferList = require('./internal/streams/BufferList');
+var destroyImpl = require('./internal/streams/destroy');
+var StringDecoder;
- if (typeof expected === 'string') {
- message = expected;
- expected = null;
- }
+util.inherits(Readable, Stream);
- actual = _tryBlock(block);
+var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
- message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
- (message ? ' ' + message : '.');
+function prependListener(emitter, event, fn) {
+ // Sadly this is not cacheable as some libraries bundle their own
+ // event emitter implementation with them.
+ if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn);
- if (shouldThrow && !actual) {
- fail(actual, expected, 'Missing expected exception' + message);
- }
+ // This is a hack to make sure that our error handler is attached before any
+ // userland ones. NEVER DO THIS. This is here only because this code needs
+ // to continue to work with older versions of Node.js that do not include
+ // the prependListener() method. The goal is to eventually remove this hack.
+ if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
+}
- var userProvidedMessage = typeof message === 'string';
- var isUnwantedException = !shouldThrow && util.isError(actual);
- var isUnexpectedException = !shouldThrow && actual && !expected;
+function ReadableState(options, stream) {
+ Duplex = Duplex || require('./_stream_duplex');
- if ((isUnwantedException &&
- userProvidedMessage &&
- expectedException(actual, expected)) ||
- isUnexpectedException) {
- fail(actual, expected, 'Got unwanted exception' + message);
- }
+ options = options || {};
- if ((shouldThrow && actual && expected &&
- !expectedException(actual, expected)) || (!shouldThrow && actual)) {
- throw actual;
- }
-}
+ // Duplex streams are both readable and writable, but share
+ // the same options object.
+ // However, some cases require setting options to different
+ // values for the readable and the writable sides of the duplex stream.
+ // These options can be provided separately as readableXXX and writableXXX.
+ var isDuplex = stream instanceof Duplex;
-// 11. Expected to throw an error:
-// assert.throws(block, Error_opt, message_opt);
+ // object stream flag. Used to make read(n) ignore n and to
+ // make all the buffer merging and length checks go away
+ this.objectMode = !!options.objectMode;
-assert.throws = function(block, /*optional*/error, /*optional*/message) {
- _throws(true, block, error, message);
-};
+ if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode;
-// EXTENSION! This is annoying to write outside this module.
-assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
- _throws(false, block, error, message);
-};
+ // the point at which it stops calling _read() to fill the buffer
+ // Note: 0 is a valid value, means "don't call _read preemptively ever"
+ var hwm = options.highWaterMark;
+ var readableHwm = options.readableHighWaterMark;
+ var defaultHwm = this.objectMode ? 16 : 16 * 1024;
-assert.ifError = function(err) { if (err) throw err; };
+ if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm;
-// Expose a strict only variant of assert
-function strict(value, message) {
- if (!value) fail(value, true, message, '==', strict);
-}
-assert.strict = objectAssign(strict, assert, {
- equal: assert.strictEqual,
- deepEqual: assert.deepStrictEqual,
- notEqual: assert.notStrictEqual,
- notDeepEqual: assert.notDeepStrictEqual
-});
-assert.strict.strict = assert.strict;
+ // cast to ints.
+ this.highWaterMark = Math.floor(this.highWaterMark);
-var objectKeys = Object.keys || function (obj) {
- var keys = [];
- for (var key in obj) {
- if (hasOwn.call(obj, key)) keys.push(key);
- }
- return keys;
-};
+ // A linked list is used to store data chunks instead of an array because the
+ // linked list can remove elements from the beginning faster than
+ // array.shift()
+ this.buffer = new BufferList();
+ this.length = 0;
+ this.pipes = null;
+ this.pipesCount = 0;
+ this.flowing = null;
+ this.ended = false;
+ this.endEmitted = false;
+ this.reading = false;
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"object-assign":69,"util/":62}],60:[function(require,module,exports){
-arguments[4][3][0].apply(exports,arguments)
-},{"dup":3}],61:[function(require,module,exports){
-module.exports = function isBuffer(arg) {
- return arg && typeof arg === 'object'
- && typeof arg.copy === 'function'
- && typeof arg.fill === 'function'
- && typeof arg.readUInt8 === 'function';
-}
-},{}],62:[function(require,module,exports){
-(function (process,global){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+ // a flag to be able to tell if the event 'readable'/'data' is emitted
+ // immediately, or on a later tick. We set this to true at first, because
+ // any actions that shouldn't happen until "later" should generally also
+ // not happen before the first read call.
+ this.sync = true;
-var formatRegExp = /%[sdj%]/g;
-exports.format = function(f) {
- if (!isString(f)) {
- var objects = [];
- for (var i = 0; i < arguments.length; i++) {
- objects.push(inspect(arguments[i]));
- }
- return objects.join(' ');
- }
+ // whenever we return null, then we set a flag to say
+ // that we're awaiting a 'readable' event emission.
+ this.needReadable = false;
+ this.emittedReadable = false;
+ this.readableListening = false;
+ this.resumeScheduled = false;
- var i = 1;
- var args = arguments;
- var len = args.length;
- var str = String(f).replace(formatRegExp, function(x) {
- if (x === '%%') return '%';
- if (i >= len) return x;
- switch (x) {
- case '%s': return String(args[i++]);
- case '%d': return Number(args[i++]);
- case '%j':
- try {
- return JSON.stringify(args[i++]);
- } catch (_) {
- return '[Circular]';
- }
- default:
- return x;
- }
- });
- for (var x = args[i]; i < len; x = args[++i]) {
- if (isNull(x) || !isObject(x)) {
- str += ' ' + x;
- } else {
- str += ' ' + inspect(x);
- }
- }
- return str;
-};
+ // has it been destroyed
+ this.destroyed = false;
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
-// Mark that a method should not be used.
-// Returns a modified function which warns once by default.
-// If --no-deprecation is set, then it is a no-op.
-exports.deprecate = function(fn, msg) {
- // Allow for deprecating things in the process of starting up.
- if (isUndefined(global.process)) {
- return function() {
- return exports.deprecate(fn, msg).apply(this, arguments);
- };
- }
+ // the number of writers that are awaiting a drain event in .pipe()s
+ this.awaitDrain = 0;
- if (process.noDeprecation === true) {
- return fn;
- }
+ // if true, a maybeReadMore has been scheduled
+ this.readingMore = false;
- var warned = false;
- function deprecated() {
- if (!warned) {
- if (process.throwDeprecation) {
- throw new Error(msg);
- } else if (process.traceDeprecation) {
- console.trace(msg);
- } else {
- console.error(msg);
- }
- warned = true;
- }
- return fn.apply(this, arguments);
+ this.decoder = null;
+ this.encoding = null;
+ if (options.encoding) {
+ if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+ this.decoder = new StringDecoder(options.encoding);
+ this.encoding = options.encoding;
}
+}
- return deprecated;
-};
+function Readable(options) {
+ Duplex = Duplex || require('./_stream_duplex');
+ if (!(this instanceof Readable)) return new Readable(options);
-var debugs = {};
-var debugEnviron;
-exports.debuglog = function(set) {
- if (isUndefined(debugEnviron))
- debugEnviron = process.env.NODE_DEBUG || '';
- set = set.toUpperCase();
- if (!debugs[set]) {
- if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
- var pid = process.pid;
- debugs[set] = function() {
- var msg = exports.format.apply(exports, arguments);
- console.error('%s %d: %s', set, pid, msg);
- };
- } else {
- debugs[set] = function() {};
- }
- }
- return debugs[set];
-};
+ this._readableState = new ReadableState(options, this);
+ // legacy
+ this.readable = true;
-/**
- * Echos the value of a value. Trys to print the value out
- * in the best way possible given the different types.
- *
- * @param {Object} obj The object to print out.
- * @param {Object} opts Optional options object that alters the output.
- */
-/* legacy: obj, showHidden, depth, colors*/
-function inspect(obj, opts) {
- // default options
- var ctx = {
- seen: [],
- stylize: stylizeNoColor
- };
- // legacy...
- if (arguments.length >= 3) ctx.depth = arguments[2];
- if (arguments.length >= 4) ctx.colors = arguments[3];
- if (isBoolean(opts)) {
- // legacy...
- ctx.showHidden = opts;
- } else if (opts) {
- // got an "options" object
- exports._extend(ctx, opts);
- }
- // set default options
- if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
- if (isUndefined(ctx.depth)) ctx.depth = 2;
- if (isUndefined(ctx.colors)) ctx.colors = false;
- if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
- if (ctx.colors) ctx.stylize = stylizeWithColor;
- return formatValue(ctx, obj, ctx.depth);
+ if (options) {
+ if (typeof options.read === 'function') this._read = options.read;
+
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+ }
+
+ Stream.call(this);
}
-exports.inspect = inspect;
+Object.defineProperty(Readable.prototype, 'destroyed', {
+ get: function () {
+ if (this._readableState === undefined) {
+ return false;
+ }
+ return this._readableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._readableState) {
+ return;
+ }
-// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
-inspect.colors = {
- 'bold' : [1, 22],
- 'italic' : [3, 23],
- 'underline' : [4, 24],
- 'inverse' : [7, 27],
- 'white' : [37, 39],
- 'grey' : [90, 39],
- 'black' : [30, 39],
- 'blue' : [34, 39],
- 'cyan' : [36, 39],
- 'green' : [32, 39],
- 'magenta' : [35, 39],
- 'red' : [31, 39],
- 'yellow' : [33, 39]
-};
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._readableState.destroyed = value;
+ }
+});
-// Don't use 'blue' not visible on cmd.exe
-inspect.styles = {
- 'special': 'cyan',
- 'number': 'yellow',
- 'boolean': 'yellow',
- 'undefined': 'grey',
- 'null': 'bold',
- 'string': 'green',
- 'date': 'magenta',
- // "name": intentionally not styling
- 'regexp': 'red'
+Readable.prototype.destroy = destroyImpl.destroy;
+Readable.prototype._undestroy = destroyImpl.undestroy;
+Readable.prototype._destroy = function (err, cb) {
+ this.push(null);
+ cb(err);
};
+// Manually shove something into the read() buffer.
+// This returns true if the highWaterMark has not been hit yet,
+// similar to how Writable.write() returns true if you should
+// write() some more.
+Readable.prototype.push = function (chunk, encoding) {
+ var state = this._readableState;
+ var skipChunkCheck;
-function stylizeWithColor(str, styleType) {
- var style = inspect.styles[styleType];
-
- if (style) {
- return '\u001b[' + inspect.colors[style][0] + 'm' + str +
- '\u001b[' + inspect.colors[style][1] + 'm';
+ if (!state.objectMode) {
+ if (typeof chunk === 'string') {
+ encoding = encoding || state.defaultEncoding;
+ if (encoding !== state.encoding) {
+ chunk = Buffer.from(chunk, encoding);
+ encoding = '';
+ }
+ skipChunkCheck = true;
+ }
} else {
- return str;
+ skipChunkCheck = true;
}
-}
-
-function stylizeNoColor(str, styleType) {
- return str;
-}
+ return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+};
+// Unshift should *always* be something directly out of read()
+Readable.prototype.unshift = function (chunk) {
+ return readableAddChunk(this, chunk, null, true, false);
+};
-function arrayToHash(array) {
- var hash = {};
+function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+ var state = stream._readableState;
+ if (chunk === null) {
+ state.reading = false;
+ onEofChunk(stream, state);
+ } else {
+ var er;
+ if (!skipChunkCheck) er = chunkInvalid(state, chunk);
+ if (er) {
+ stream.emit('error', er);
+ } else if (state.objectMode || chunk && chunk.length > 0) {
+ if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
+ chunk = _uint8ArrayToBuffer(chunk);
+ }
- array.forEach(function(val, idx) {
- hash[val] = true;
- });
+ if (addToFront) {
+ if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true);
+ } else if (state.ended) {
+ stream.emit('error', new Error('stream.push() after EOF'));
+ } else {
+ state.reading = false;
+ if (state.decoder && !encoding) {
+ chunk = state.decoder.write(chunk);
+ if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
+ } else {
+ addChunk(stream, state, chunk, false);
+ }
+ }
+ } else if (!addToFront) {
+ state.reading = false;
+ }
+ }
- return hash;
+ return needMoreData(state);
}
+function addChunk(stream, state, chunk, addToFront) {
+ if (state.flowing && state.length === 0 && !state.sync) {
+ stream.emit('data', chunk);
+ stream.read(0);
+ } else {
+ // update the buffer info.
+ state.length += state.objectMode ? 1 : chunk.length;
+ if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
-function formatValue(ctx, value, recurseTimes) {
- // Provide a hook for user-specified inspect functions.
- // Check that value is an object with an inspect function on it
- if (ctx.customInspect &&
- value &&
- isFunction(value.inspect) &&
- // Filter out the util module, it's inspect function is special
- value.inspect !== exports.inspect &&
- // Also filter out any prototype objects using the circular check.
- !(value.constructor && value.constructor.prototype === value)) {
- var ret = value.inspect(recurseTimes, ctx);
- if (!isString(ret)) {
- ret = formatValue(ctx, ret, recurseTimes);
- }
- return ret;
+ if (state.needReadable) emitReadable(stream);
}
+ maybeReadMore(stream, state);
+}
- // Primitive types cannot have properties
- var primitive = formatPrimitive(ctx, value);
- if (primitive) {
- return primitive;
+function chunkInvalid(state, chunk) {
+ var er;
+ if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ er = new TypeError('Invalid non-string/buffer chunk');
}
+ return er;
+}
- // Look up the keys of the object.
- var keys = Object.keys(value);
- var visibleKeys = arrayToHash(keys);
+// if it's past the high water mark, we can push in some more.
+// Also, if we have no data yet, we can stand some
+// more bytes. This is to work around cases where hwm=0,
+// such as the repl. Also, if the push() triggered a
+// readable event, and the user called read(largeNumber) such that
+// needReadable was set, then we ought to push more, so that another
+// 'readable' event will be triggered.
+function needMoreData(state) {
+ return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
+}
- if (ctx.showHidden) {
- keys = Object.getOwnPropertyNames(value);
- }
+Readable.prototype.isPaused = function () {
+ return this._readableState.flowing === false;
+};
- // IE doesn't make error fields non-enumerable
- // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
- if (isError(value)
- && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
- return formatError(value);
+// backwards compatibility.
+Readable.prototype.setEncoding = function (enc) {
+ if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;
+ this._readableState.decoder = new StringDecoder(enc);
+ this._readableState.encoding = enc;
+ return this;
+};
+
+// Don't raise the hwm > 8MB
+var MAX_HWM = 0x800000;
+function computeNewHighWaterMark(n) {
+ if (n >= MAX_HWM) {
+ n = MAX_HWM;
+ } else {
+ // Get the next highest power of 2 to prevent increasing hwm excessively in
+ // tiny amounts
+ n--;
+ n |= n >>> 1;
+ n |= n >>> 2;
+ n |= n >>> 4;
+ n |= n >>> 8;
+ n |= n >>> 16;
+ n++;
}
+ return n;
+}
- // Some type of object without properties can be shortcutted.
- if (keys.length === 0) {
- if (isFunction(value)) {
- var name = value.name ? ': ' + value.name : '';
- return ctx.stylize('[Function' + name + ']', 'special');
- }
- if (isRegExp(value)) {
- return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
- }
- if (isDate(value)) {
- return ctx.stylize(Date.prototype.toString.call(value), 'date');
- }
- if (isError(value)) {
- return formatError(value);
- }
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function howMuchToRead(n, state) {
+ if (n <= 0 || state.length === 0 && state.ended) return 0;
+ if (state.objectMode) return 1;
+ if (n !== n) {
+ // Only flow one buffer at a time
+ if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
+ }
+ // If we're asking for more than the current hwm, then raise the hwm.
+ if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
+ if (n <= state.length) return n;
+ // Don't have enough
+ if (!state.ended) {
+ state.needReadable = true;
+ return 0;
}
+ return state.length;
+}
+
+// you can override either this method, or the async _read(n) below.
+Readable.prototype.read = function (n) {
+ debug('read', n);
+ n = parseInt(n, 10);
+ var state = this._readableState;
+ var nOrig = n;
- var base = '', array = false, braces = ['{', '}'];
+ if (n !== 0) state.emittedReadable = false;
- // Make Array say that they are Array
- if (isArray(value)) {
- array = true;
- braces = ['[', ']'];
+ // if we're doing read(0) to trigger a readable event, but we
+ // already have a bunch of data in the buffer, then just trigger
+ // the 'readable' event and move on.
+ if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) {
+ debug('read: emitReadable', state.length, state.ended);
+ if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
+ return null;
}
- // Make functions say that they are functions
- if (isFunction(value)) {
- var n = value.name ? ': ' + value.name : '';
- base = ' [Function' + n + ']';
- }
+ n = howMuchToRead(n, state);
- // Make RegExps say that they are RegExps
- if (isRegExp(value)) {
- base = ' ' + RegExp.prototype.toString.call(value);
+ // if we've ended, and we're now clear, then finish it up.
+ if (n === 0 && state.ended) {
+ if (state.length === 0) endReadable(this);
+ return null;
}
- // Make dates with properties first say the date
- if (isDate(value)) {
- base = ' ' + Date.prototype.toUTCString.call(value);
- }
+ // All the actual chunk generation logic needs to be
+ // *below* the call to _read. The reason is that in certain
+ // synthetic stream cases, such as passthrough streams, _read
+ // may be a completely synchronous operation which may change
+ // the state of the read buffer, providing enough data when
+ // before there was *not* enough.
+ //
+ // So, the steps are:
+ // 1. Figure out what the state of things will be after we do
+ // a read from the buffer.
+ //
+ // 2. If that resulting state will trigger a _read, then call _read.
+ // Note that this may be asynchronous, or synchronous. Yes, it is
+ // deeply ugly to write APIs this way, but that still doesn't mean
+ // that the Readable class should behave improperly, as streams are
+ // designed to be sync/async agnostic.
+ // Take note if the _read call is sync or async (ie, if the read call
+ // has returned yet), so that we know whether or not it's safe to emit
+ // 'readable' etc.
+ //
+ // 3. Actually pull the requested chunks out of the buffer and return.
- // Make error with message first say the error
- if (isError(value)) {
- base = ' ' + formatError(value);
- }
+ // if we need a readable event, then we need to do some reading.
+ var doRead = state.needReadable;
+ debug('need readable', doRead);
- if (keys.length === 0 && (!array || value.length == 0)) {
- return braces[0] + base + braces[1];
+ // if we currently have less than the highWaterMark, then also read some
+ if (state.length === 0 || state.length - n < state.highWaterMark) {
+ doRead = true;
+ debug('length less than watermark', doRead);
}
- if (recurseTimes < 0) {
- if (isRegExp(value)) {
- return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
- } else {
- return ctx.stylize('[Object]', 'special');
- }
+ // however, if we've ended, then there's no point, and if we're already
+ // reading, then it's unnecessary.
+ if (state.ended || state.reading) {
+ doRead = false;
+ debug('reading or ended', doRead);
+ } else if (doRead) {
+ debug('do read');
+ state.reading = true;
+ state.sync = true;
+ // if the length is currently zero, then we *need* a readable event.
+ if (state.length === 0) state.needReadable = true;
+ // call internal read method
+ this._read(state.highWaterMark);
+ state.sync = false;
+ // If _read pushed data synchronously, then `reading` will be false,
+ // and we need to re-evaluate how much data we can return to the user.
+ if (!state.reading) n = howMuchToRead(nOrig, state);
}
- ctx.seen.push(value);
+ var ret;
+ if (n > 0) ret = fromList(n, state);else ret = null;
- var output;
- if (array) {
- output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+ if (ret === null) {
+ state.needReadable = true;
+ n = 0;
} else {
- output = keys.map(function(key) {
- return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
- });
+ state.length -= n;
}
- ctx.seen.pop();
+ if (state.length === 0) {
+ // If we have nothing in the buffer, then we want to know
+ // as soon as we *do* get something into the buffer.
+ if (!state.ended) state.needReadable = true;
- return reduceToSingleString(output, base, braces);
-}
+ // If we tried to read() past the EOF, then emit end on the next tick.
+ if (nOrig !== n && state.ended) endReadable(this);
+ }
+ if (ret !== null) this.emit('data', ret);
-function formatPrimitive(ctx, value) {
- if (isUndefined(value))
- return ctx.stylize('undefined', 'undefined');
- if (isString(value)) {
- var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
- .replace(/'/g, "\\'")
- .replace(/\\"/g, '"') + '\'';
- return ctx.stylize(simple, 'string');
+ return ret;
+};
+
+function onEofChunk(stream, state) {
+ if (state.ended) return;
+ if (state.decoder) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) {
+ state.buffer.push(chunk);
+ state.length += state.objectMode ? 1 : chunk.length;
+ }
}
- if (isNumber(value))
- return ctx.stylize('' + value, 'number');
- if (isBoolean(value))
- return ctx.stylize('' + value, 'boolean');
- // For some reason typeof null is "object", so special case here.
- if (isNull(value))
- return ctx.stylize('null', 'null');
+ state.ended = true;
+
+ // emit 'readable' now to make sure it gets picked up.
+ emitReadable(stream);
}
+// Don't emit readable right away in sync mode, because this can trigger
+// another read() call => stack overflow. This way, it might trigger
+// a nextTick recursion warning, but that's not so bad.
+function emitReadable(stream) {
+ var state = stream._readableState;
+ state.needReadable = false;
+ if (!state.emittedReadable) {
+ debug('emitReadable', state.flowing);
+ state.emittedReadable = true;
+ if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream);
+ }
+}
-function formatError(value) {
- return '[' + Error.prototype.toString.call(value) + ']';
+function emitReadable_(stream) {
+ debug('emit readable');
+ stream.emit('readable');
+ flow(stream);
}
+// at this point, the user has presumably seen the 'readable' event,
+// and called read() to consume some data. that may have triggered
+// in turn another _read(n) call, in which case reading = true if
+// it's in progress.
+// However, if we're not ended, or reading, and the length < hwm,
+// then go ahead and try to read some more preemptively.
+function maybeReadMore(stream, state) {
+ if (!state.readingMore) {
+ state.readingMore = true;
+ pna.nextTick(maybeReadMore_, stream, state);
+ }
+}
-function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
- var output = [];
- for (var i = 0, l = value.length; i < l; ++i) {
- if (hasOwnProperty(value, String(i))) {
- output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
- String(i), true));
- } else {
- output.push('');
- }
+function maybeReadMore_(stream, state) {
+ var len = state.length;
+ while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) {
+ debug('maybeReadMore read 0');
+ stream.read(0);
+ if (len === state.length)
+ // didn't get any data, stop spinning.
+ break;else len = state.length;
}
- keys.forEach(function(key) {
- if (!key.match(/^\d+$/)) {
- output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
- key, true));
- }
- });
- return output;
+ state.readingMore = false;
}
+// abstract method. to be overridden in specific implementation classes.
+// call cb(er, data) where data is <= n in length.
+// for virtual (non-string, non-buffer) streams, "length" is somewhat
+// arbitrary, and perhaps not very meaningful.
+Readable.prototype._read = function (n) {
+ this.emit('error', new Error('_read() is not implemented'));
+};
-function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
- var name, str, desc;
- desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
- if (desc.get) {
- if (desc.set) {
- str = ctx.stylize('[Getter/Setter]', 'special');
- } else {
- str = ctx.stylize('[Getter]', 'special');
- }
- } else {
- if (desc.set) {
- str = ctx.stylize('[Setter]', 'special');
- }
- }
- if (!hasOwnProperty(visibleKeys, key)) {
- name = '[' + key + ']';
- }
- if (!str) {
- if (ctx.seen.indexOf(desc.value) < 0) {
- if (isNull(recurseTimes)) {
- str = formatValue(ctx, desc.value, null);
- } else {
- str = formatValue(ctx, desc.value, recurseTimes - 1);
- }
- if (str.indexOf('\n') > -1) {
- if (array) {
- str = str.split('\n').map(function(line) {
- return ' ' + line;
- }).join('\n').substr(2);
- } else {
- str = '\n' + str.split('\n').map(function(line) {
- return ' ' + line;
- }).join('\n');
- }
- }
- } else {
- str = ctx.stylize('[Circular]', 'special');
- }
- }
- if (isUndefined(name)) {
- if (array && key.match(/^\d+$/)) {
- return str;
- }
- name = JSON.stringify('' + key);
- if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
- name = name.substr(1, name.length - 2);
- name = ctx.stylize(name, 'name');
- } else {
- name = name.replace(/'/g, "\\'")
- .replace(/\\"/g, '"')
- .replace(/(^"|"$)/g, "'");
- name = ctx.stylize(name, 'string');
- }
+Readable.prototype.pipe = function (dest, pipeOpts) {
+ var src = this;
+ var state = this._readableState;
+
+ switch (state.pipesCount) {
+ case 0:
+ state.pipes = dest;
+ break;
+ case 1:
+ state.pipes = [state.pipes, dest];
+ break;
+ default:
+ state.pipes.push(dest);
+ break;
}
+ state.pipesCount += 1;
+ debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
- return name + ': ' + str;
-}
+ var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+ var endFn = doEnd ? onend : unpipe;
+ if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn);
-function reduceToSingleString(output, base, braces) {
- var numLinesEst = 0;
- var length = output.reduce(function(prev, cur) {
- numLinesEst++;
- if (cur.indexOf('\n') >= 0) numLinesEst++;
- return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
- }, 0);
+ dest.on('unpipe', onunpipe);
+ function onunpipe(readable, unpipeInfo) {
+ debug('onunpipe');
+ if (readable === src) {
+ if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+ unpipeInfo.hasUnpiped = true;
+ cleanup();
+ }
+ }
+ }
- if (length > 60) {
- return braces[0] +
- (base === '' ? '' : base + '\n ') +
- ' ' +
- output.join(',\n ') +
- ' ' +
- braces[1];
+ function onend() {
+ debug('onend');
+ dest.end();
}
- return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
-}
+ // when the dest drains, it reduces the awaitDrain counter
+ // on the source. This would be more elegant with a .once()
+ // handler in flow(), but adding and removing repeatedly is
+ // too slow.
+ var ondrain = pipeOnDrain(src);
+ dest.on('drain', ondrain);
+ var cleanedUp = false;
+ function cleanup() {
+ debug('cleanup');
+ // cleanup event handlers once the pipe is broken
+ dest.removeListener('close', onclose);
+ dest.removeListener('finish', onfinish);
+ dest.removeListener('drain', ondrain);
+ dest.removeListener('error', onerror);
+ dest.removeListener('unpipe', onunpipe);
+ src.removeListener('end', onend);
+ src.removeListener('end', unpipe);
+ src.removeListener('data', ondata);
-// NOTE: These type checking functions intentionally don't use `instanceof`
-// because it is fragile and can be easily faked with `Object.create()`.
-function isArray(ar) {
- return Array.isArray(ar);
-}
-exports.isArray = isArray;
+ cleanedUp = true;
-function isBoolean(arg) {
- return typeof arg === 'boolean';
-}
-exports.isBoolean = isBoolean;
+ // if the reader is waiting for a drain event from this
+ // specific writer, then it would cause it to never start
+ // flowing again.
+ // So, if this is awaiting a drain, then we just call it now.
+ // If we don't know, then assume that we are waiting for one.
+ if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
+ }
-function isNull(arg) {
- return arg === null;
-}
-exports.isNull = isNull;
+ // If the user pushes more data while we're writing to dest then we'll end up
+ // in ondata again. However, we only want to increase awaitDrain once because
+ // dest will only emit one 'drain' event for the multiple writes.
+ // => Introduce a guard on increasing awaitDrain.
+ var increasedAwaitDrain = false;
+ src.on('data', ondata);
+ function ondata(chunk) {
+ debug('ondata');
+ increasedAwaitDrain = false;
+ var ret = dest.write(chunk);
+ if (false === ret && !increasedAwaitDrain) {
+ // If the user unpiped during `dest.write()`, it is possible
+ // to get stuck in a permanently paused state if that write
+ // also returned false.
+ // => Check whether `dest` is still a piping destination.
+ if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+ debug('false write response, pause', src._readableState.awaitDrain);
+ src._readableState.awaitDrain++;
+ increasedAwaitDrain = true;
+ }
+ src.pause();
+ }
+ }
-function isNullOrUndefined(arg) {
- return arg == null;
-}
-exports.isNullOrUndefined = isNullOrUndefined;
+ // if the dest has an error, then stop piping into it.
+ // however, don't suppress the throwing behavior for this.
+ function onerror(er) {
+ debug('onerror', er);
+ unpipe();
+ dest.removeListener('error', onerror);
+ if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er);
+ }
-function isNumber(arg) {
- return typeof arg === 'number';
-}
-exports.isNumber = isNumber;
+ // Make sure our error handler is attached before userland ones.
+ prependListener(dest, 'error', onerror);
-function isString(arg) {
- return typeof arg === 'string';
-}
-exports.isString = isString;
+ // Both close and finish should trigger unpipe, but only once.
+ function onclose() {
+ dest.removeListener('finish', onfinish);
+ unpipe();
+ }
+ dest.once('close', onclose);
+ function onfinish() {
+ debug('onfinish');
+ dest.removeListener('close', onclose);
+ unpipe();
+ }
+ dest.once('finish', onfinish);
-function isSymbol(arg) {
- return typeof arg === 'symbol';
-}
-exports.isSymbol = isSymbol;
+ function unpipe() {
+ debug('unpipe');
+ src.unpipe(dest);
+ }
-function isUndefined(arg) {
- return arg === void 0;
-}
-exports.isUndefined = isUndefined;
+ // tell the dest that it's being piped to
+ dest.emit('pipe', src);
-function isRegExp(re) {
- return isObject(re) && objectToString(re) === '[object RegExp]';
-}
-exports.isRegExp = isRegExp;
+ // start the flow if it hasn't been started already.
+ if (!state.flowing) {
+ debug('pipe resume');
+ src.resume();
+ }
-function isObject(arg) {
- return typeof arg === 'object' && arg !== null;
-}
-exports.isObject = isObject;
+ return dest;
+};
-function isDate(d) {
- return isObject(d) && objectToString(d) === '[object Date]';
+function pipeOnDrain(src) {
+ return function () {
+ var state = src._readableState;
+ debug('pipeOnDrain', state.awaitDrain);
+ if (state.awaitDrain) state.awaitDrain--;
+ if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
+ state.flowing = true;
+ flow(src);
+ }
+ };
}
-exports.isDate = isDate;
-function isError(e) {
- return isObject(e) &&
- (objectToString(e) === '[object Error]' || e instanceof Error);
-}
-exports.isError = isError;
+Readable.prototype.unpipe = function (dest) {
+ var state = this._readableState;
+ var unpipeInfo = { hasUnpiped: false };
-function isFunction(arg) {
- return typeof arg === 'function';
-}
-exports.isFunction = isFunction;
+ // if we're not piping anywhere, then do nothing.
+ if (state.pipesCount === 0) return this;
-function isPrimitive(arg) {
- return arg === null ||
- typeof arg === 'boolean' ||
- typeof arg === 'number' ||
- typeof arg === 'string' ||
- typeof arg === 'symbol' || // ES6 symbol
- typeof arg === 'undefined';
-}
-exports.isPrimitive = isPrimitive;
+ // just one destination. most common case.
+ if (state.pipesCount === 1) {
+ // passed in one, but it's not the right one.
+ if (dest && dest !== state.pipes) return this;
-exports.isBuffer = require('./support/isBuffer');
+ if (!dest) dest = state.pipes;
-function objectToString(o) {
- return Object.prototype.toString.call(o);
-}
+ // got a match.
+ state.pipes = null;
+ state.pipesCount = 0;
+ state.flowing = false;
+ if (dest) dest.emit('unpipe', this, unpipeInfo);
+ return this;
+ }
+ // slow case. multiple pipe destinations.
-function pad(n) {
- return n < 10 ? '0' + n.toString(10) : n.toString(10);
-}
+ if (!dest) {
+ // remove all.
+ var dests = state.pipes;
+ var len = state.pipesCount;
+ state.pipes = null;
+ state.pipesCount = 0;
+ state.flowing = false;
+ for (var i = 0; i < len; i++) {
+ dests[i].emit('unpipe', this, unpipeInfo);
+ }return this;
+ }
-var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
- 'Oct', 'Nov', 'Dec'];
+ // try to find the right one.
+ var index = indexOf(state.pipes, dest);
+ if (index === -1) return this;
-// 26 Feb 16:19:34
-function timestamp() {
- var d = new Date();
- var time = [pad(d.getHours()),
- pad(d.getMinutes()),
- pad(d.getSeconds())].join(':');
- return [d.getDate(), months[d.getMonth()], time].join(' ');
-}
+ state.pipes.splice(index, 1);
+ state.pipesCount -= 1;
+ if (state.pipesCount === 1) state.pipes = state.pipes[0];
+ dest.emit('unpipe', this, unpipeInfo);
-// log is just a thin wrapper to console.log that prepends a timestamp
-exports.log = function() {
- console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
+ return this;
};
+// set up data events if they are asked for
+// Ensure readable listeners eventually get something
+Readable.prototype.on = function (ev, fn) {
+ var res = Stream.prototype.on.call(this, ev, fn);
-/**
- * Inherit the prototype methods from one constructor into another.
- *
- * The Function.prototype.inherits from lang.js rewritten as a standalone
- * function (not on Function.prototype). NOTE: If this file is to be loaded
- * during bootstrapping this function needs to be rewritten using some native
- * functions as prototype setup using normal JavaScript does not work as
- * expected during bootstrapping (see mirror.js in r114903).
- *
- * @param {function} ctor Constructor function which needs to inherit the
- * prototype.
- * @param {function} superCtor Constructor function to inherit prototype from.
- */
-exports.inherits = require('inherits');
+ if (ev === 'data') {
+ // Start flowing on next tick if stream isn't explicitly paused
+ if (this._readableState.flowing !== false) this.resume();
+ } else if (ev === 'readable') {
+ var state = this._readableState;
+ if (!state.endEmitted && !state.readableListening) {
+ state.readableListening = state.needReadable = true;
+ state.emittedReadable = false;
+ if (!state.reading) {
+ pna.nextTick(nReadingNextTick, this);
+ } else if (state.length) {
+ emitReadable(this);
+ }
+ }
+ }
-exports._extend = function(origin, add) {
- // Don't do anything if add isn't an object
- if (!add || !isObject(add)) return origin;
+ return res;
+};
+Readable.prototype.addListener = Readable.prototype.on;
- var keys = Object.keys(add);
- var i = keys.length;
- while (i--) {
- origin[keys[i]] = add[keys[i]];
+function nReadingNextTick(self) {
+ debug('readable nexttick read 0');
+ self.read(0);
+}
+
+// pause() and resume() are remnants of the legacy readable stream API
+// If the user uses them, then switch into old mode.
+Readable.prototype.resume = function () {
+ var state = this._readableState;
+ if (!state.flowing) {
+ debug('resume');
+ state.flowing = true;
+ resume(this, state);
}
- return origin;
+ return this;
};
-function hasOwnProperty(obj, prop) {
- return Object.prototype.hasOwnProperty.call(obj, prop);
+function resume(stream, state) {
+ if (!state.resumeScheduled) {
+ state.resumeScheduled = true;
+ pna.nextTick(resume_, stream, state);
+ }
}
-}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{"./support/isBuffer":61,"_process":70,"inherits":60}],63:[function(require,module,exports){
-'use strict'
+function resume_(stream, state) {
+ if (!state.reading) {
+ debug('resume read 0');
+ stream.read(0);
+ }
-exports.byteLength = byteLength
-exports.toByteArray = toByteArray
-exports.fromByteArray = fromByteArray
+ state.resumeScheduled = false;
+ state.awaitDrain = 0;
+ stream.emit('resume');
+ flow(stream);
+ if (state.flowing && !state.reading) stream.read(0);
+}
-var lookup = []
-var revLookup = []
-var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+Readable.prototype.pause = function () {
+ debug('call pause flowing=%j', this._readableState.flowing);
+ if (false !== this._readableState.flowing) {
+ debug('pause');
+ this._readableState.flowing = false;
+ this.emit('pause');
+ }
+ return this;
+};
-var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-for (var i = 0, len = code.length; i < len; ++i) {
- lookup[i] = code[i]
- revLookup[code.charCodeAt(i)] = i
+function flow(stream) {
+ var state = stream._readableState;
+ debug('flow', state.flowing);
+ while (state.flowing && stream.read() !== null) {}
}
-// Support decoding URL-safe base64 strings, as Node.js does.
-// See: https://en.wikipedia.org/wiki/Base64#URL_applications
-revLookup['-'.charCodeAt(0)] = 62
-revLookup['_'.charCodeAt(0)] = 63
-
-function getLens (b64) {
- var len = b64.length
+// wrap an old-style stream as the async data source.
+// This is *not* part of the readable stream interface.
+// It is an ugly unfortunate mess of history.
+Readable.prototype.wrap = function (stream) {
+ var _this = this;
- if (len % 4 > 0) {
- throw new Error('Invalid string. Length must be a multiple of 4')
- }
+ var state = this._readableState;
+ var paused = false;
- // Trim off extra bytes after placeholder bytes are found
- // See: https://github.com/beatgammit/base64-js/issues/42
- var validLen = b64.indexOf('=')
- if (validLen === -1) validLen = len
+ stream.on('end', function () {
+ debug('wrapped end');
+ if (state.decoder && !state.ended) {
+ var chunk = state.decoder.end();
+ if (chunk && chunk.length) _this.push(chunk);
+ }
- var placeHoldersLen = validLen === len
- ? 0
- : 4 - (validLen % 4)
+ _this.push(null);
+ });
- return [validLen, placeHoldersLen]
-}
+ stream.on('data', function (chunk) {
+ debug('wrapped data');
+ if (state.decoder) chunk = state.decoder.write(chunk);
-// base64 is 4/3 + up to two characters of the original data
-function byteLength (b64) {
- var lens = getLens(b64)
- var validLen = lens[0]
- var placeHoldersLen = lens[1]
- return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
-}
+ // don't skip over falsy values in objectMode
+ if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
-function _byteLength (b64, validLen, placeHoldersLen) {
- return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
-}
+ var ret = _this.push(chunk);
+ if (!ret) {
+ paused = true;
+ stream.pause();
+ }
+ });
-function toByteArray (b64) {
- var tmp
- var lens = getLens(b64)
- var validLen = lens[0]
- var placeHoldersLen = lens[1]
+ // proxy all the other methods.
+ // important when wrapping filters and duplexes.
+ for (var i in stream) {
+ if (this[i] === undefined && typeof stream[i] === 'function') {
+ this[i] = function (method) {
+ return function () {
+ return stream[method].apply(stream, arguments);
+ };
+ }(i);
+ }
+ }
- var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+ // proxy certain important events.
+ for (var n = 0; n < kProxyEvents.length; n++) {
+ stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+ }
- var curByte = 0
+ // when we try to consume some more bytes, simply unpause the
+ // underlying stream.
+ this._read = function (n) {
+ debug('wrapped _read', n);
+ if (paused) {
+ paused = false;
+ stream.resume();
+ }
+ };
- // if there are placeholders, only get up to the last complete 4 chars
- var len = placeHoldersLen > 0
- ? validLen - 4
- : validLen
+ return this;
+};
- var i
- for (i = 0; i < len; i += 4) {
- tmp =
- (revLookup[b64.charCodeAt(i)] << 18) |
- (revLookup[b64.charCodeAt(i + 1)] << 12) |
- (revLookup[b64.charCodeAt(i + 2)] << 6) |
- revLookup[b64.charCodeAt(i + 3)]
- arr[curByte++] = (tmp >> 16) & 0xFF
- arr[curByte++] = (tmp >> 8) & 0xFF
- arr[curByte++] = tmp & 0xFF
+Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._readableState.highWaterMark;
}
+});
- if (placeHoldersLen === 2) {
- tmp =
- (revLookup[b64.charCodeAt(i)] << 2) |
- (revLookup[b64.charCodeAt(i + 1)] >> 4)
- arr[curByte++] = tmp & 0xFF
+// exposed for testing purposes only.
+Readable._fromList = fromList;
+
+// Pluck off n bytes from an array of buffers.
+// Length is the combined lengths of all the buffers in the list.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromList(n, state) {
+ // nothing buffered
+ if (state.length === 0) return null;
+
+ var ret;
+ if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
+ // read it all, truncate the list
+ if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length);
+ state.buffer.clear();
+ } else {
+ // read part of list
+ ret = fromListPartial(n, state.buffer, state.decoder);
}
- if (placeHoldersLen === 1) {
- tmp =
- (revLookup[b64.charCodeAt(i)] << 10) |
- (revLookup[b64.charCodeAt(i + 1)] << 4) |
- (revLookup[b64.charCodeAt(i + 2)] >> 2)
- arr[curByte++] = (tmp >> 8) & 0xFF
- arr[curByte++] = tmp & 0xFF
+ return ret;
+}
+
+// Extracts only enough buffered data to satisfy the amount requested.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function fromListPartial(n, list, hasStrings) {
+ var ret;
+ if (n < list.head.data.length) {
+ // slice is the same for buffers and strings
+ ret = list.head.data.slice(0, n);
+ list.head.data = list.head.data.slice(n);
+ } else if (n === list.head.data.length) {
+ // first chunk is a perfect match
+ ret = list.shift();
+ } else {
+ // result spans more than one buffer
+ ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list);
}
-
- return arr
+ return ret;
}
-function tripletToBase64 (num) {
- return lookup[num >> 18 & 0x3F] +
- lookup[num >> 12 & 0x3F] +
- lookup[num >> 6 & 0x3F] +
- lookup[num & 0x3F]
+// Copies a specified amount of characters from the list of buffered data
+// chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBufferString(n, list) {
+ var p = list.head;
+ var c = 1;
+ var ret = p.data;
+ n -= ret.length;
+ while (p = p.next) {
+ var str = p.data;
+ var nb = n > str.length ? str.length : n;
+ if (nb === str.length) ret += str;else ret += str.slice(0, n);
+ n -= nb;
+ if (n === 0) {
+ if (nb === str.length) {
+ ++c;
+ if (p.next) list.head = p.next;else list.head = list.tail = null;
+ } else {
+ list.head = p;
+ p.data = str.slice(nb);
+ }
+ break;
+ }
+ ++c;
+ }
+ list.length -= c;
+ return ret;
}
-function encodeChunk (uint8, start, end) {
- var tmp
- var output = []
- for (var i = start; i < end; i += 3) {
- tmp =
- ((uint8[i] << 16) & 0xFF0000) +
- ((uint8[i + 1] << 8) & 0xFF00) +
- (uint8[i + 2] & 0xFF)
- output.push(tripletToBase64(tmp))
+// Copies a specified amount of bytes from the list of buffered data chunks.
+// This function is designed to be inlinable, so please take care when making
+// changes to the function body.
+function copyFromBuffer(n, list) {
+ var ret = Buffer.allocUnsafe(n);
+ var p = list.head;
+ var c = 1;
+ p.data.copy(ret);
+ n -= p.data.length;
+ while (p = p.next) {
+ var buf = p.data;
+ var nb = n > buf.length ? buf.length : n;
+ buf.copy(ret, ret.length - n, 0, nb);
+ n -= nb;
+ if (n === 0) {
+ if (nb === buf.length) {
+ ++c;
+ if (p.next) list.head = p.next;else list.head = list.tail = null;
+ } else {
+ list.head = p;
+ p.data = buf.slice(nb);
+ }
+ break;
+ }
+ ++c;
}
- return output.join('')
+ list.length -= c;
+ return ret;
}
-function fromByteArray (uint8) {
- var tmp
- var len = uint8.length
- var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
- var parts = []
- var maxChunkLength = 16383 // must be multiple of 3
+function endReadable(stream) {
+ var state = stream._readableState;
- // go through the array every three bytes, we'll deal with trailing stuff later
- for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
- parts.push(encodeChunk(
- uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
- ))
- }
+ // If we get here before consuming all the bytes, then that is a
+ // bug in node. Should never happen.
+ if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream');
- // pad the end with zeros, but make sure to not forget the extra bytes
- if (extraBytes === 1) {
- tmp = uint8[len - 1]
- parts.push(
- lookup[tmp >> 2] +
- lookup[(tmp << 4) & 0x3F] +
- '=='
- )
- } else if (extraBytes === 2) {
- tmp = (uint8[len - 2] << 8) + uint8[len - 1]
- parts.push(
- lookup[tmp >> 10] +
- lookup[(tmp >> 4) & 0x3F] +
- lookup[(tmp << 2) & 0x3F] +
- '='
- )
+ if (!state.endEmitted) {
+ state.ended = true;
+ pna.nextTick(endReadableNT, state, stream);
}
-
- return parts.join('')
}
-},{}],64:[function(require,module,exports){
+function endReadableNT(state, stream) {
+ // Check that we didn't get one last unshift.
+ if (!state.endEmitted && state.length === 0) {
+ state.endEmitted = true;
+ stream.readable = false;
+ stream.emit('end');
+ }
+}
-},{}],65:[function(require,module,exports){
-(function (Buffer){
-/*!
- * The buffer module from node.js, for the browser.
- *
- * @author Feross Aboukhadijeh <https://feross.org>
- * @license MIT
- */
-/* eslint-disable no-proto */
+function indexOf(xs, x) {
+ for (var i = 0, l = xs.length; i < l; i++) {
+ if (xs[i] === x) return i;
+ }
+ return -1;
+}
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{"./_stream_duplex":22,"./internal/streams/BufferList":27,"./internal/streams/destroy":28,"./internal/streams/stream":29,"_process":21,"core-util-is":9,"events":10,"inherits":12,"isarray":14,"process-nextick-args":20,"safe-buffer":32,"string_decoder/":33,"util":7}],25:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
-'use strict'
+// a transform stream is a readable/writable stream where you do
+// something with the data. Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored. (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation. For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes. When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up. When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer. When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks. If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk. However,
+// a pathological inflate type of transform can cause excessive buffering
+// here. For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output. In this case, you could write a very small
+// amount of input, and end up with a very large amount of output. In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform. A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
-var base64 = require('base64-js')
-var ieee754 = require('ieee754')
+'use strict';
-exports.Buffer = Buffer
-exports.SlowBuffer = SlowBuffer
-exports.INSPECT_MAX_BYTES = 50
+module.exports = Transform;
-var K_MAX_LENGTH = 0x7fffffff
-exports.kMaxLength = K_MAX_LENGTH
+var Duplex = require('./_stream_duplex');
-/**
- * If `Buffer.TYPED_ARRAY_SUPPORT`:
- * === true Use Uint8Array implementation (fastest)
- * === false Print warning and recommend using `buffer` v4.x which has an Object
- * implementation (most compatible, even IE6)
- *
- * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
- * Opera 11.6+, iOS 4.2+.
- *
- * We report that the browser does not support typed arrays if the are not subclassable
- * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
- * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
- * for __proto__ and has a buggy typed array implementation.
- */
-Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
+/*<replacement>*/
+var util = Object.create(require('core-util-is'));
+util.inherits = require('inherits');
+/*</replacement>*/
-if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
- typeof console.error === 'function') {
- console.error(
- 'This browser lacks typed array (Uint8Array) support which is required by ' +
- '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
- )
-}
+util.inherits(Transform, Duplex);
-function typedArraySupport () {
- // Can typed array instances can be augmented?
- try {
- var arr = new Uint8Array(1)
- arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
- return arr.foo() === 42
- } catch (e) {
- return false
- }
-}
+function afterTransform(er, data) {
+ var ts = this._transformState;
+ ts.transforming = false;
-Object.defineProperty(Buffer.prototype, 'parent', {
- enumerable: true,
- get: function () {
- if (!Buffer.isBuffer(this)) return undefined
- return this.buffer
- }
-})
+ var cb = ts.writecb;
-Object.defineProperty(Buffer.prototype, 'offset', {
- enumerable: true,
- get: function () {
- if (!Buffer.isBuffer(this)) return undefined
- return this.byteOffset
+ if (!cb) {
+ return this.emit('error', new Error('write callback called multiple times'));
}
-})
-function createBuffer (length) {
- if (length > K_MAX_LENGTH) {
- throw new RangeError('The value "' + length + '" is invalid for option "size"')
- }
- // Return an augmented `Uint8Array` instance
- var buf = new Uint8Array(length)
- buf.__proto__ = Buffer.prototype
- return buf
-}
+ ts.writechunk = null;
+ ts.writecb = null;
-/**
- * The Buffer constructor returns instances of `Uint8Array` that have their
- * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
- * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
- * and the `Uint8Array` methods. Square bracket notation works as expected -- it
- * returns a single octet.
- *
- * The `Uint8Array` prototype remains unmodified.
- */
+ if (data != null) // single equals check for both `null` and `undefined`
+ this.push(data);
-function Buffer (arg, encodingOrOffset, length) {
- // Common case.
- if (typeof arg === 'number') {
- if (typeof encodingOrOffset === 'string') {
- throw new TypeError(
- 'The "string" argument must be of type string. Received type number'
- )
- }
- return allocUnsafe(arg)
+ cb(er);
+
+ var rs = this._readableState;
+ rs.reading = false;
+ if (rs.needReadable || rs.length < rs.highWaterMark) {
+ this._read(rs.highWaterMark);
}
- return from(arg, encodingOrOffset, length)
}
-// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
-if (typeof Symbol !== 'undefined' && Symbol.species != null &&
- Buffer[Symbol.species] === Buffer) {
- Object.defineProperty(Buffer, Symbol.species, {
- value: null,
- configurable: true,
- enumerable: false,
- writable: false
- })
-}
+function Transform(options) {
+ if (!(this instanceof Transform)) return new Transform(options);
-Buffer.poolSize = 8192 // not used by this implementation
+ Duplex.call(this, options);
-function from (value, encodingOrOffset, length) {
- if (typeof value === 'string') {
- return fromString(value, encodingOrOffset)
- }
+ this._transformState = {
+ afterTransform: afterTransform.bind(this),
+ needTransform: false,
+ transforming: false,
+ writecb: null,
+ writechunk: null,
+ writeencoding: null
+ };
- if (ArrayBuffer.isView(value)) {
- return fromArrayLike(value)
- }
+ // start out asking for a readable event once data is transformed.
+ this._readableState.needReadable = true;
- if (value == null) {
- throw TypeError(
- 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
- 'or Array-like Object. Received type ' + (typeof value)
- )
- }
+ // we have implemented the _read method, and done the other things
+ // that Readable wants before the first _read call, so unset the
+ // sync guard flag.
+ this._readableState.sync = false;
- if (isInstance(value, ArrayBuffer) ||
- (value && isInstance(value.buffer, ArrayBuffer))) {
- return fromArrayBuffer(value, encodingOrOffset, length)
- }
+ if (options) {
+ if (typeof options.transform === 'function') this._transform = options.transform;
- if (typeof value === 'number') {
- throw new TypeError(
- 'The "value" argument must not be of type number. Received type number'
- )
+ if (typeof options.flush === 'function') this._flush = options.flush;
}
- var valueOf = value.valueOf && value.valueOf()
- if (valueOf != null && valueOf !== value) {
- return Buffer.from(valueOf, encodingOrOffset, length)
- }
+ // When the writable side finishes, then flush out anything remaining.
+ this.on('prefinish', prefinish);
+}
- var b = fromObject(value)
- if (b) return b
+function prefinish() {
+ var _this = this;
- if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
- typeof value[Symbol.toPrimitive] === 'function') {
- return Buffer.from(
- value[Symbol.toPrimitive]('string'), encodingOrOffset, length
- )
+ if (typeof this._flush === 'function') {
+ this._flush(function (er, data) {
+ done(_this, er, data);
+ });
+ } else {
+ done(this, null, null);
}
-
- throw new TypeError(
- 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
- 'or Array-like Object. Received type ' + (typeof value)
- )
}
-/**
- * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
- * if value is a number.
- * Buffer.from(str[, encoding])
- * Buffer.from(array)
- * Buffer.from(buffer)
- * Buffer.from(arrayBuffer[, byteOffset[, length]])
- **/
-Buffer.from = function (value, encodingOrOffset, length) {
- return from(value, encodingOrOffset, length)
-}
+Transform.prototype.push = function (chunk, encoding) {
+ this._transformState.needTransform = false;
+ return Duplex.prototype.push.call(this, chunk, encoding);
+};
-// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
-// https://github.com/feross/buffer/pull/148
-Buffer.prototype.__proto__ = Uint8Array.prototype
-Buffer.__proto__ = Uint8Array
+// This is the part where you do stuff!
+// override this function in implementation classes.
+// 'chunk' is an input chunk.
+//
+// Call `push(newChunk)` to pass along transformed output
+// to the readable side. You may call 'push' zero or more times.
+//
+// Call `cb(err)` when you are done with this chunk. If you pass
+// an error, then that'll put the hurt on the whole operation. If you
+// never call cb(), then you'll never get another chunk.
+Transform.prototype._transform = function (chunk, encoding, cb) {
+ throw new Error('_transform() is not implemented');
+};
-function assertSize (size) {
- if (typeof size !== 'number') {
- throw new TypeError('"size" argument must be of type number')
- } else if (size < 0) {
- throw new RangeError('The value "' + size + '" is invalid for option "size"')
+Transform.prototype._write = function (chunk, encoding, cb) {
+ var ts = this._transformState;
+ ts.writecb = cb;
+ ts.writechunk = chunk;
+ ts.writeencoding = encoding;
+ if (!ts.transforming) {
+ var rs = this._readableState;
+ if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
}
-}
+};
-function alloc (size, fill, encoding) {
- assertSize(size)
- if (size <= 0) {
- return createBuffer(size)
- }
- if (fill !== undefined) {
- // Only pay attention to encoding if it's a string. This
- // prevents accidentally sending in a number that would
- // be interpretted as a start offset.
- return typeof encoding === 'string'
- ? createBuffer(size).fill(fill, encoding)
- : createBuffer(size).fill(fill)
+// Doesn't matter what the args are here.
+// _transform does all the work.
+// That we got here means that the readable side wants more data.
+Transform.prototype._read = function (n) {
+ var ts = this._transformState;
+
+ if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
+ ts.transforming = true;
+ this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
+ } else {
+ // mark that we need a transform, so that any data that comes in
+ // will get processed, now that we've asked for it.
+ ts.needTransform = true;
}
- return createBuffer(size)
-}
+};
-/**
- * Creates a new filled Buffer instance.
- * alloc(size[, fill[, encoding]])
- **/
-Buffer.alloc = function (size, fill, encoding) {
- return alloc(size, fill, encoding)
-}
+Transform.prototype._destroy = function (err, cb) {
+ var _this2 = this;
-function allocUnsafe (size) {
- assertSize(size)
- return createBuffer(size < 0 ? 0 : checked(size) | 0)
-}
+ Duplex.prototype._destroy.call(this, err, function (err2) {
+ cb(err2);
+ _this2.emit('close');
+ });
+};
-/**
- * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
- * */
-Buffer.allocUnsafe = function (size) {
- return allocUnsafe(size)
-}
-/**
- * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
- */
-Buffer.allocUnsafeSlow = function (size) {
- return allocUnsafe(size)
-}
+function done(stream, er, data) {
+ if (er) return stream.emit('error', er);
-function fromString (string, encoding) {
- if (typeof encoding !== 'string' || encoding === '') {
- encoding = 'utf8'
- }
+ if (data != null) // single equals check for both `null` and `undefined`
+ stream.push(data);
- if (!Buffer.isEncoding(encoding)) {
- throw new TypeError('Unknown encoding: ' + encoding)
- }
+ // if there's nothing in the write buffer, then that means
+ // that nothing more will ever be provided
+ if (stream._writableState.length) throw new Error('Calling transform done when ws.length != 0');
+
+ if (stream._transformState.transforming) throw new Error('Calling transform done when still transforming');
- var length = byteLength(string, encoding) | 0
- var buf = createBuffer(length)
+ return stream.push(null);
+}
+},{"./_stream_duplex":22,"core-util-is":9,"inherits":12}],26:[function(require,module,exports){
+(function (process,global,setImmediate){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
- var actual = buf.write(string, encoding)
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
- if (actual !== length) {
- // Writing a hex string, for example, that contains invalid characters will
- // cause everything after the first invalid character to be ignored. (e.g.
- // 'abxxcd' will be treated as 'ab')
- buf = buf.slice(0, actual)
- }
+'use strict';
- return buf
-}
+/*<replacement>*/
-function fromArrayLike (array) {
- var length = array.length < 0 ? 0 : checked(array.length) | 0
- var buf = createBuffer(length)
- for (var i = 0; i < length; i += 1) {
- buf[i] = array[i] & 255
- }
- return buf
-}
+var pna = require('process-nextick-args');
+/*</replacement>*/
-function fromArrayBuffer (array, byteOffset, length) {
- if (byteOffset < 0 || array.byteLength < byteOffset) {
- throw new RangeError('"offset" is outside of buffer bounds')
- }
+module.exports = Writable;
- if (array.byteLength < byteOffset + (length || 0)) {
- throw new RangeError('"length" is outside of buffer bounds')
- }
+/* <replacement> */
+function WriteReq(chunk, encoding, cb) {
+ this.chunk = chunk;
+ this.encoding = encoding;
+ this.callback = cb;
+ this.next = null;
+}
- var buf
- if (byteOffset === undefined && length === undefined) {
- buf = new Uint8Array(array)
- } else if (length === undefined) {
- buf = new Uint8Array(array, byteOffset)
- } else {
- buf = new Uint8Array(array, byteOffset, length)
- }
+// It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function CorkedRequest(state) {
+ var _this = this;
- // Return an augmented `Uint8Array` instance
- buf.__proto__ = Buffer.prototype
- return buf
+ this.next = null;
+ this.entry = null;
+ this.finish = function () {
+ onCorkedFinish(_this, state);
+ };
}
+/* </replacement> */
-function fromObject (obj) {
- if (Buffer.isBuffer(obj)) {
- var len = checked(obj.length) | 0
- var buf = createBuffer(len)
+/*<replacement>*/
+var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
+/*</replacement>*/
- if (buf.length === 0) {
- return buf
- }
+/*<replacement>*/
+var Duplex;
+/*</replacement>*/
- obj.copy(buf, 0, 0, len)
- return buf
- }
+Writable.WritableState = WritableState;
- if (obj.length !== undefined) {
- if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
- return createBuffer(0)
- }
- return fromArrayLike(obj)
- }
+/*<replacement>*/
+var util = Object.create(require('core-util-is'));
+util.inherits = require('inherits');
+/*</replacement>*/
- if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
- return fromArrayLike(obj.data)
- }
-}
+/*<replacement>*/
+var internalUtil = {
+ deprecate: require('util-deprecate')
+};
+/*</replacement>*/
-function checked (length) {
- // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
- // length is NaN (which is otherwise coerced to zero.)
- if (length >= K_MAX_LENGTH) {
- throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
- 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
- }
- return length | 0
-}
+/*<replacement>*/
+var Stream = require('./internal/streams/stream');
+/*</replacement>*/
-function SlowBuffer (length) {
- if (+length != length) { // eslint-disable-line eqeqeq
- length = 0
- }
- return Buffer.alloc(+length)
-}
+/*<replacement>*/
-Buffer.isBuffer = function isBuffer (b) {
- return b != null && b._isBuffer === true &&
- b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
+var Buffer = require('safe-buffer').Buffer;
+var OurUint8Array = global.Uint8Array || function () {};
+function _uint8ArrayToBuffer(chunk) {
+ return Buffer.from(chunk);
+}
+function _isUint8Array(obj) {
+ return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
}
-Buffer.compare = function compare (a, b) {
- if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
- if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
- if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
- throw new TypeError(
- 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
- )
- }
-
- if (a === b) return 0
+/*</replacement>*/
- var x = a.length
- var y = b.length
+var destroyImpl = require('./internal/streams/destroy');
- for (var i = 0, len = Math.min(x, y); i < len; ++i) {
- if (a[i] !== b[i]) {
- x = a[i]
- y = b[i]
- break
- }
- }
+util.inherits(Writable, Stream);
- if (x < y) return -1
- if (y < x) return 1
- return 0
-}
+function nop() {}
-Buffer.isEncoding = function isEncoding (encoding) {
- switch (String(encoding).toLowerCase()) {
- case 'hex':
- case 'utf8':
- case 'utf-8':
- case 'ascii':
- case 'latin1':
- case 'binary':
- case 'base64':
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return true
- default:
- return false
- }
-}
+function WritableState(options, stream) {
+ Duplex = Duplex || require('./_stream_duplex');
-Buffer.concat = function concat (list, length) {
- if (!Array.isArray(list)) {
- throw new TypeError('"list" argument must be an Array of Buffers')
- }
+ options = options || {};
- if (list.length === 0) {
- return Buffer.alloc(0)
- }
+ // Duplex streams are both readable and writable, but share
+ // the same options object.
+ // However, some cases require setting options to different
+ // values for the readable and the writable sides of the duplex stream.
+ // These options can be provided separately as readableXXX and writableXXX.
+ var isDuplex = stream instanceof Duplex;
- var i
- if (length === undefined) {
- length = 0
- for (i = 0; i < list.length; ++i) {
- length += list[i].length
- }
- }
+ // object stream flag to indicate whether or not this stream
+ // contains buffers or objects.
+ this.objectMode = !!options.objectMode;
- var buffer = Buffer.allocUnsafe(length)
- var pos = 0
- for (i = 0; i < list.length; ++i) {
- var buf = list[i]
- if (isInstance(buf, Uint8Array)) {
- buf = Buffer.from(buf)
- }
- if (!Buffer.isBuffer(buf)) {
- throw new TypeError('"list" argument must be an Array of Buffers')
- }
- buf.copy(buffer, pos)
- pos += buf.length
- }
- return buffer
-}
+ if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
-function byteLength (string, encoding) {
- if (Buffer.isBuffer(string)) {
- return string.length
- }
- if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
- return string.byteLength
- }
- if (typeof string !== 'string') {
- throw new TypeError(
- 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
- 'Received type ' + typeof string
- )
- }
+ // the point at which write() starts returning false
+ // Note: 0 is a valid value, means that we always return false if
+ // the entire buffer is not flushed immediately on write()
+ var hwm = options.highWaterMark;
+ var writableHwm = options.writableHighWaterMark;
+ var defaultHwm = this.objectMode ? 16 : 16 * 1024;
- var len = string.length
- var mustMatch = (arguments.length > 2 && arguments[2] === true)
- if (!mustMatch && len === 0) return 0
+ if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
- // Use a for loop to avoid recursion
- var loweredCase = false
- for (;;) {
- switch (encoding) {
- case 'ascii':
- case 'latin1':
- case 'binary':
- return len
- case 'utf8':
- case 'utf-8':
- return utf8ToBytes(string).length
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return len * 2
- case 'hex':
- return len >>> 1
- case 'base64':
- return base64ToBytes(string).length
- default:
- if (loweredCase) {
- return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
- }
- encoding = ('' + encoding).toLowerCase()
- loweredCase = true
- }
- }
-}
-Buffer.byteLength = byteLength
+ // cast to ints.
+ this.highWaterMark = Math.floor(this.highWaterMark);
-function slowToString (encoding, start, end) {
- var loweredCase = false
+ // if _final has been called
+ this.finalCalled = false;
- // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
- // property of a typed array.
+ // drain event flag.
+ this.needDrain = false;
+ // at the start of calling end()
+ this.ending = false;
+ // when end() has been called, and returned
+ this.ended = false;
+ // when 'finish' is emitted
+ this.finished = false;
- // This behaves neither like String nor Uint8Array in that we set start/end
- // to their upper/lower bounds if the value passed is out of range.
- // undefined is handled specially as per ECMA-262 6th Edition,
- // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
- if (start === undefined || start < 0) {
- start = 0
- }
- // Return early if start > this.length. Done here to prevent potential uint32
- // coercion fail below.
- if (start > this.length) {
- return ''
- }
+ // has it been destroyed
+ this.destroyed = false;
- if (end === undefined || end > this.length) {
- end = this.length
- }
+ // should we decode strings into buffers before passing to _write?
+ // this is here so that some node-core streams can optimize string
+ // handling at a lower level.
+ var noDecode = options.decodeStrings === false;
+ this.decodeStrings = !noDecode;
- if (end <= 0) {
- return ''
- }
+ // Crypto is kind of old and crusty. Historically, its default string
+ // encoding is 'binary' so we have to make this configurable.
+ // Everything else in the universe uses 'utf8', though.
+ this.defaultEncoding = options.defaultEncoding || 'utf8';
- // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
- end >>>= 0
- start >>>= 0
+ // not an actual buffer we keep track of, but a measurement
+ // of how much we're waiting to get pushed to some underlying
+ // socket or file.
+ this.length = 0;
- if (end <= start) {
- return ''
- }
+ // a flag to see when we're in the middle of a write.
+ this.writing = false;
- if (!encoding) encoding = 'utf8'
+ // when true all writes will be buffered until .uncork() call
+ this.corked = 0;
- while (true) {
- switch (encoding) {
- case 'hex':
- return hexSlice(this, start, end)
+ // a flag to be able to tell if the onwrite cb is called immediately,
+ // or on a later tick. We set this to true at first, because any
+ // actions that shouldn't happen until "later" should generally also
+ // not happen before the first write call.
+ this.sync = true;
- case 'utf8':
- case 'utf-8':
- return utf8Slice(this, start, end)
+ // a flag to know if we're processing previously buffered items, which
+ // may call the _write() callback in the same tick, so that we don't
+ // end up in an overlapped onwrite situation.
+ this.bufferProcessing = false;
- case 'ascii':
- return asciiSlice(this, start, end)
+ // the callback that's passed to _write(chunk,cb)
+ this.onwrite = function (er) {
+ onwrite(stream, er);
+ };
- case 'latin1':
- case 'binary':
- return latin1Slice(this, start, end)
+ // the callback that the user supplies to write(chunk,encoding,cb)
+ this.writecb = null;
- case 'base64':
- return base64Slice(this, start, end)
+ // the amount that is being written when _write is called.
+ this.writelen = 0;
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return utf16leSlice(this, start, end)
+ this.bufferedRequest = null;
+ this.lastBufferedRequest = null;
- default:
- if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
- encoding = (encoding + '').toLowerCase()
- loweredCase = true
- }
- }
-}
+ // number of pending user-supplied write callbacks
+ // this must be 0 before 'finish' can be emitted
+ this.pendingcb = 0;
-// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
-// to detect a Buffer instance. It's not possible to use `instanceof Buffer`
-// reliably in a browserify context because there could be multiple different
-// copies of the 'buffer' package in use. This method works even for Buffer
-// instances that were created from another copy of the `buffer` package.
-// See: https://github.com/feross/buffer/issues/154
-Buffer.prototype._isBuffer = true
+ // emit prefinish if the only thing we're waiting for is _write cbs
+ // This is relevant for synchronous Transform streams
+ this.prefinished = false;
-function swap (b, n, m) {
- var i = b[n]
- b[n] = b[m]
- b[m] = i
-}
+ // True if the error was already emitted and should not be thrown again
+ this.errorEmitted = false;
-Buffer.prototype.swap16 = function swap16 () {
- var len = this.length
- if (len % 2 !== 0) {
- throw new RangeError('Buffer size must be a multiple of 16-bits')
- }
- for (var i = 0; i < len; i += 2) {
- swap(this, i, i + 1)
- }
- return this
+ // count buffered requests
+ this.bufferedRequestCount = 0;
+
+ // allocate the first CorkedRequest, there is always
+ // one allocated and free to use, and we maintain at most two
+ this.corkedRequestsFree = new CorkedRequest(this);
}
-Buffer.prototype.swap32 = function swap32 () {
- var len = this.length
- if (len % 4 !== 0) {
- throw new RangeError('Buffer size must be a multiple of 32-bits')
- }
- for (var i = 0; i < len; i += 4) {
- swap(this, i, i + 3)
- swap(this, i + 1, i + 2)
+WritableState.prototype.getBuffer = function getBuffer() {
+ var current = this.bufferedRequest;
+ var out = [];
+ while (current) {
+ out.push(current);
+ current = current.next;
}
- return this
+ return out;
+};
+
+(function () {
+ try {
+ Object.defineProperty(WritableState.prototype, 'buffer', {
+ get: internalUtil.deprecate(function () {
+ return this.getBuffer();
+ }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
+ });
+ } catch (_) {}
+})();
+
+// Test _writableState for inheritance to account for Duplex streams,
+// whose prototype chain only points to Readable.
+var realHasInstance;
+if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
+ realHasInstance = Function.prototype[Symbol.hasInstance];
+ Object.defineProperty(Writable, Symbol.hasInstance, {
+ value: function (object) {
+ if (realHasInstance.call(this, object)) return true;
+ if (this !== Writable) return false;
+
+ return object && object._writableState instanceof WritableState;
+ }
+ });
+} else {
+ realHasInstance = function (object) {
+ return object instanceof this;
+ };
}
-Buffer.prototype.swap64 = function swap64 () {
- var len = this.length
- if (len % 8 !== 0) {
- throw new RangeError('Buffer size must be a multiple of 64-bits')
+function Writable(options) {
+ Duplex = Duplex || require('./_stream_duplex');
+
+ // Writable ctor is applied to Duplexes, too.
+ // `realHasInstance` is necessary because using plain `instanceof`
+ // would return false, as no `_writableState` property is attached.
+
+ // Trying to use the custom `instanceof` for Writable here will also break the
+ // Node.js LazyTransform implementation, which has a non-trivial getter for
+ // `_writableState` that would lead to infinite recursion.
+ if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {
+ return new Writable(options);
}
- for (var i = 0; i < len; i += 8) {
- swap(this, i, i + 7)
- swap(this, i + 1, i + 6)
- swap(this, i + 2, i + 5)
- swap(this, i + 3, i + 4)
+
+ this._writableState = new WritableState(options, this);
+
+ // legacy.
+ this.writable = true;
+
+ if (options) {
+ if (typeof options.write === 'function') this._write = options.write;
+
+ if (typeof options.writev === 'function') this._writev = options.writev;
+
+ if (typeof options.destroy === 'function') this._destroy = options.destroy;
+
+ if (typeof options.final === 'function') this._final = options.final;
}
- return this
-}
-Buffer.prototype.toString = function toString () {
- var length = this.length
- if (length === 0) return ''
- if (arguments.length === 0) return utf8Slice(this, 0, length)
- return slowToString.apply(this, arguments)
+ Stream.call(this);
}
-Buffer.prototype.toLocaleString = Buffer.prototype.toString
+// Otherwise people can pipe Writable streams, which is just wrong.
+Writable.prototype.pipe = function () {
+ this.emit('error', new Error('Cannot pipe, not readable'));
+};
-Buffer.prototype.equals = function equals (b) {
- if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
- if (this === b) return true
- return Buffer.compare(this, b) === 0
+function writeAfterEnd(stream, cb) {
+ var er = new Error('write after end');
+ // TODO: defer error events consistently everywhere, not just the cb
+ stream.emit('error', er);
+ pna.nextTick(cb, er);
}
-Buffer.prototype.inspect = function inspect () {
- var str = ''
- var max = exports.INSPECT_MAX_BYTES
- str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
- if (this.length > max) str += ' ... '
- return '<Buffer ' + str + '>'
-}
+// Checks that a user-supplied chunk is valid, especially for the particular
+// mode the stream is in. Currently this means that `null` is never accepted
+// and undefined/non-string values are only allowed in object mode.
+function validChunk(stream, state, chunk, cb) {
+ var valid = true;
+ var er = false;
-Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
- if (isInstance(target, Uint8Array)) {
- target = Buffer.from(target, target.offset, target.byteLength)
+ if (chunk === null) {
+ er = new TypeError('May not write null values to stream');
+ } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
+ er = new TypeError('Invalid non-string/buffer chunk');
}
- if (!Buffer.isBuffer(target)) {
- throw new TypeError(
- 'The "target" argument must be one of type Buffer or Uint8Array. ' +
- 'Received type ' + (typeof target)
- )
+ if (er) {
+ stream.emit('error', er);
+ pna.nextTick(cb, er);
+ valid = false;
}
+ return valid;
+}
- if (start === undefined) {
- start = 0
- }
- if (end === undefined) {
- end = target ? target.length : 0
- }
- if (thisStart === undefined) {
- thisStart = 0
- }
- if (thisEnd === undefined) {
- thisEnd = this.length
+Writable.prototype.write = function (chunk, encoding, cb) {
+ var state = this._writableState;
+ var ret = false;
+ var isBuf = !state.objectMode && _isUint8Array(chunk);
+
+ if (isBuf && !Buffer.isBuffer(chunk)) {
+ chunk = _uint8ArrayToBuffer(chunk);
}
- if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
- throw new RangeError('out of range index')
+ if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
}
- if (thisStart >= thisEnd && start >= end) {
- return 0
+ if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
+
+ if (typeof cb !== 'function') cb = nop;
+
+ if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
+ state.pendingcb++;
+ ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
}
- if (thisStart >= thisEnd) {
- return -1
+
+ return ret;
+};
+
+Writable.prototype.cork = function () {
+ var state = this._writableState;
+
+ state.corked++;
+};
+
+Writable.prototype.uncork = function () {
+ var state = this._writableState;
+
+ if (state.corked) {
+ state.corked--;
+
+ if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
}
- if (start >= end) {
- return 1
+};
+
+Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+ // node::ParseEncoding() requires lower case.
+ if (typeof encoding === 'string') encoding = encoding.toLowerCase();
+ if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding);
+ this._writableState.defaultEncoding = encoding;
+ return this;
+};
+
+function decodeChunk(state, chunk, encoding) {
+ if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
+ chunk = Buffer.from(chunk, encoding);
}
+ return chunk;
+}
- start >>>= 0
- end >>>= 0
- thisStart >>>= 0
- thisEnd >>>= 0
+Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
+ // making it explicit this property is not enumerable
+ // because otherwise some prototype manipulation in
+ // userland will fail
+ enumerable: false,
+ get: function () {
+ return this._writableState.highWaterMark;
+ }
+});
- if (this === target) return 0
+// if we're already writing something, then just put this
+// in the queue, and wait our turn. Otherwise, call _write
+// If we return false, then we need a drain event, so set that flag.
+function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+ if (!isBuf) {
+ var newChunk = decodeChunk(state, chunk, encoding);
+ if (chunk !== newChunk) {
+ isBuf = true;
+ encoding = 'buffer';
+ chunk = newChunk;
+ }
+ }
+ var len = state.objectMode ? 1 : chunk.length;
- var x = thisEnd - thisStart
- var y = end - start
- var len = Math.min(x, y)
+ state.length += len;
- var thisCopy = this.slice(thisStart, thisEnd)
- var targetCopy = target.slice(start, end)
+ var ret = state.length < state.highWaterMark;
+ // we must ensure that previous needDrain will not be reset to false.
+ if (!ret) state.needDrain = true;
- for (var i = 0; i < len; ++i) {
- if (thisCopy[i] !== targetCopy[i]) {
- x = thisCopy[i]
- y = targetCopy[i]
- break
+ if (state.writing || state.corked) {
+ var last = state.lastBufferedRequest;
+ state.lastBufferedRequest = {
+ chunk: chunk,
+ encoding: encoding,
+ isBuf: isBuf,
+ callback: cb,
+ next: null
+ };
+ if (last) {
+ last.next = state.lastBufferedRequest;
+ } else {
+ state.bufferedRequest = state.lastBufferedRequest;
}
+ state.bufferedRequestCount += 1;
+ } else {
+ doWrite(stream, state, false, len, chunk, encoding, cb);
}
- if (x < y) return -1
- if (y < x) return 1
- return 0
+ return ret;
}
-// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
-// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
-//
-// Arguments:
-// - buffer - a Buffer to search
-// - val - a string, Buffer, or number
-// - byteOffset - an index into `buffer`; will be clamped to an int32
-// - encoding - an optional encoding, relevant is val is a string
-// - dir - true for indexOf, false for lastIndexOf
-function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
- // Empty buffer means no match
- if (buffer.length === 0) return -1
+function doWrite(stream, state, writev, len, chunk, encoding, cb) {
+ state.writelen = len;
+ state.writecb = cb;
+ state.writing = true;
+ state.sync = true;
+ if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
+ state.sync = false;
+}
- // Normalize byteOffset
- if (typeof byteOffset === 'string') {
- encoding = byteOffset
- byteOffset = 0
- } else if (byteOffset > 0x7fffffff) {
- byteOffset = 0x7fffffff
- } else if (byteOffset < -0x80000000) {
- byteOffset = -0x80000000
- }
- byteOffset = +byteOffset // Coerce to Number.
- if (numberIsNaN(byteOffset)) {
- // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
- byteOffset = dir ? 0 : (buffer.length - 1)
- }
+function onwriteError(stream, state, sync, er, cb) {
+ --state.pendingcb;
- // Normalize byteOffset: negative offsets start from the end of the buffer
- if (byteOffset < 0) byteOffset = buffer.length + byteOffset
- if (byteOffset >= buffer.length) {
- if (dir) return -1
- else byteOffset = buffer.length - 1
- } else if (byteOffset < 0) {
- if (dir) byteOffset = 0
- else return -1
+ if (sync) {
+ // defer the callback if we are being called synchronously
+ // to avoid piling up things on the stack
+ pna.nextTick(cb, er);
+ // this can emit finish, and it will always happen
+ // after error
+ pna.nextTick(finishMaybe, stream, state);
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+ } else {
+ // the caller expect this to happen before if
+ // it is async
+ cb(er);
+ stream._writableState.errorEmitted = true;
+ stream.emit('error', er);
+ // this can emit finish, but finish must
+ // always follow error
+ finishMaybe(stream, state);
}
+}
+
+function onwriteStateUpdate(state) {
+ state.writing = false;
+ state.writecb = null;
+ state.length -= state.writelen;
+ state.writelen = 0;
+}
+
+function onwrite(stream, er) {
+ var state = stream._writableState;
+ var sync = state.sync;
+ var cb = state.writecb;
+
+ onwriteStateUpdate(state);
- // Normalize val
- if (typeof val === 'string') {
- val = Buffer.from(val, encoding)
- }
+ if (er) onwriteError(stream, state, sync, er, cb);else {
+ // Check if we're actually ready to finish, but don't emit yet
+ var finished = needFinish(state);
- // Finally, search either indexOf (if dir is true) or lastIndexOf
- if (Buffer.isBuffer(val)) {
- // Special case: looking for empty string/buffer always fails
- if (val.length === 0) {
- return -1
+ if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+ clearBuffer(stream, state);
}
- return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
- } else if (typeof val === 'number') {
- val = val & 0xFF // Search for a byte value [0-255]
- if (typeof Uint8Array.prototype.indexOf === 'function') {
- if (dir) {
- return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
- } else {
- return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
- }
+
+ if (sync) {
+ /*<replacement>*/
+ asyncWrite(afterWrite, stream, state, finished, cb);
+ /*</replacement>*/
+ } else {
+ afterWrite(stream, state, finished, cb);
}
- return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
}
-
- throw new TypeError('val must be string, number or Buffer')
}
-function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
- var indexSize = 1
- var arrLength = arr.length
- var valLength = val.length
+function afterWrite(stream, state, finished, cb) {
+ if (!finished) onwriteDrain(stream, state);
+ state.pendingcb--;
+ cb();
+ finishMaybe(stream, state);
+}
- if (encoding !== undefined) {
- encoding = String(encoding).toLowerCase()
- if (encoding === 'ucs2' || encoding === 'ucs-2' ||
- encoding === 'utf16le' || encoding === 'utf-16le') {
- if (arr.length < 2 || val.length < 2) {
- return -1
- }
- indexSize = 2
- arrLength /= 2
- valLength /= 2
- byteOffset /= 2
- }
+// Must force callback to be called on nextTick, so that we don't
+// emit 'drain' before the write() consumer gets the 'false' return
+// value, and has a chance to attach a 'drain' listener.
+function onwriteDrain(stream, state) {
+ if (state.length === 0 && state.needDrain) {
+ state.needDrain = false;
+ stream.emit('drain');
}
+}
- function read (buf, i) {
- if (indexSize === 1) {
- return buf[i]
- } else {
- return buf.readUInt16BE(i * indexSize)
+// if there's something in the buffer waiting, then process it
+function clearBuffer(stream, state) {
+ state.bufferProcessing = true;
+ var entry = state.bufferedRequest;
+
+ if (stream._writev && entry && entry.next) {
+ // Fast case, write everything using _writev()
+ var l = state.bufferedRequestCount;
+ var buffer = new Array(l);
+ var holder = state.corkedRequestsFree;
+ holder.entry = entry;
+
+ var count = 0;
+ var allBuffers = true;
+ while (entry) {
+ buffer[count] = entry;
+ if (!entry.isBuf) allBuffers = false;
+ entry = entry.next;
+ count += 1;
}
- }
+ buffer.allBuffers = allBuffers;
- var i
- if (dir) {
- var foundIndex = -1
- for (i = byteOffset; i < arrLength; i++) {
- if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
- if (foundIndex === -1) foundIndex = i
- if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
- } else {
- if (foundIndex !== -1) i -= i - foundIndex
- foundIndex = -1
- }
+ doWrite(stream, state, true, state.length, buffer, '', holder.finish);
+
+ // doWrite is almost always async, defer these to save a bit of time
+ // as the hot path ends with doWrite
+ state.pendingcb++;
+ state.lastBufferedRequest = null;
+ if (holder.next) {
+ state.corkedRequestsFree = holder.next;
+ holder.next = null;
+ } else {
+ state.corkedRequestsFree = new CorkedRequest(state);
}
+ state.bufferedRequestCount = 0;
} else {
- if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
- for (i = byteOffset; i >= 0; i--) {
- var found = true
- for (var j = 0; j < valLength; j++) {
- if (read(arr, i + j) !== read(val, j)) {
- found = false
- break
- }
+ // Slow case, write chunks one-by-one
+ while (entry) {
+ var chunk = entry.chunk;
+ var encoding = entry.encoding;
+ var cb = entry.callback;
+ var len = state.objectMode ? 1 : chunk.length;
+
+ doWrite(stream, state, false, len, chunk, encoding, cb);
+ entry = entry.next;
+ state.bufferedRequestCount--;
+ // if we didn't call the onwrite immediately, then
+ // it means that we need to wait until it does.
+ // also, that means that the chunk and cb are currently
+ // being processed, so move the buffer counter past them.
+ if (state.writing) {
+ break;
}
- if (found) return i
}
+
+ if (entry === null) state.lastBufferedRequest = null;
}
- return -1
+ state.bufferedRequest = entry;
+ state.bufferProcessing = false;
}
-Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
- return this.indexOf(val, byteOffset, encoding) !== -1
-}
+Writable.prototype._write = function (chunk, encoding, cb) {
+ cb(new Error('_write() is not implemented'));
+};
-Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
- return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
-}
+Writable.prototype._writev = null;
-Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
- return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
-}
+Writable.prototype.end = function (chunk, encoding, cb) {
+ var state = this._writableState;
-function hexWrite (buf, string, offset, length) {
- offset = Number(offset) || 0
- var remaining = buf.length - offset
- if (!length) {
- length = remaining
- } else {
- length = Number(length)
- if (length > remaining) {
- length = remaining
- }
+ if (typeof chunk === 'function') {
+ cb = chunk;
+ chunk = null;
+ encoding = null;
+ } else if (typeof encoding === 'function') {
+ cb = encoding;
+ encoding = null;
}
- var strLen = string.length
+ if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
- if (length > strLen / 2) {
- length = strLen / 2
- }
- for (var i = 0; i < length; ++i) {
- var parsed = parseInt(string.substr(i * 2, 2), 16)
- if (numberIsNaN(parsed)) return i
- buf[offset + i] = parsed
+ // .end() fully uncorks
+ if (state.corked) {
+ state.corked = 1;
+ this.uncork();
}
- return i
-}
-
-function utf8Write (buf, string, offset, length) {
- return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
-}
-function asciiWrite (buf, string, offset, length) {
- return blitBuffer(asciiToBytes(string), buf, offset, length)
-}
+ // ignore unnecessary end() calls.
+ if (!state.ending && !state.finished) endWritable(this, state, cb);
+};
-function latin1Write (buf, string, offset, length) {
- return asciiWrite(buf, string, offset, length)
+function needFinish(state) {
+ return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
}
-
-function base64Write (buf, string, offset, length) {
- return blitBuffer(base64ToBytes(string), buf, offset, length)
+function callFinal(stream, state) {
+ stream._final(function (err) {
+ state.pendingcb--;
+ if (err) {
+ stream.emit('error', err);
+ }
+ state.prefinished = true;
+ stream.emit('prefinish');
+ finishMaybe(stream, state);
+ });
}
-
-function ucs2Write (buf, string, offset, length) {
- return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+function prefinish(stream, state) {
+ if (!state.prefinished && !state.finalCalled) {
+ if (typeof stream._final === 'function') {
+ state.pendingcb++;
+ state.finalCalled = true;
+ pna.nextTick(callFinal, stream, state);
+ } else {
+ state.prefinished = true;
+ stream.emit('prefinish');
+ }
+ }
}
-Buffer.prototype.write = function write (string, offset, length, encoding) {
- // Buffer#write(string)
- if (offset === undefined) {
- encoding = 'utf8'
- length = this.length
- offset = 0
- // Buffer#write(string, encoding)
- } else if (length === undefined && typeof offset === 'string') {
- encoding = offset
- length = this.length
- offset = 0
- // Buffer#write(string, offset[, length][, encoding])
- } else if (isFinite(offset)) {
- offset = offset >>> 0
- if (isFinite(length)) {
- length = length >>> 0
- if (encoding === undefined) encoding = 'utf8'
- } else {
- encoding = length
- length = undefined
+function finishMaybe(stream, state) {
+ var need = needFinish(state);
+ if (need) {
+ prefinish(stream, state);
+ if (state.pendingcb === 0) {
+ state.finished = true;
+ stream.emit('finish');
}
- } else {
- throw new Error(
- 'Buffer.write(string, encoding, offset[, length]) is no longer supported'
- )
}
+ return need;
+}
- var remaining = this.length - offset
- if (length === undefined || length > remaining) length = remaining
-
- if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
- throw new RangeError('Attempt to write outside buffer bounds')
+function endWritable(stream, state, cb) {
+ state.ending = true;
+ finishMaybe(stream, state);
+ if (cb) {
+ if (state.finished) pna.nextTick(cb);else stream.once('finish', cb);
}
+ state.ended = true;
+ stream.writable = false;
+}
- if (!encoding) encoding = 'utf8'
-
- var loweredCase = false
- for (;;) {
- switch (encoding) {
- case 'hex':
- return hexWrite(this, string, offset, length)
+function onCorkedFinish(corkReq, state, err) {
+ var entry = corkReq.entry;
+ corkReq.entry = null;
+ while (entry) {
+ var cb = entry.callback;
+ state.pendingcb--;
+ cb(err);
+ entry = entry.next;
+ }
+ if (state.corkedRequestsFree) {
+ state.corkedRequestsFree.next = corkReq;
+ } else {
+ state.corkedRequestsFree = corkReq;
+ }
+}
- case 'utf8':
- case 'utf-8':
- return utf8Write(this, string, offset, length)
+Object.defineProperty(Writable.prototype, 'destroyed', {
+ get: function () {
+ if (this._writableState === undefined) {
+ return false;
+ }
+ return this._writableState.destroyed;
+ },
+ set: function (value) {
+ // we ignore the value if the stream
+ // has not been initialized yet
+ if (!this._writableState) {
+ return;
+ }
- case 'ascii':
- return asciiWrite(this, string, offset, length)
+ // backward compatibility, the user is explicitly
+ // managing destroyed
+ this._writableState.destroyed = value;
+ }
+});
- case 'latin1':
- case 'binary':
- return latin1Write(this, string, offset, length)
+Writable.prototype.destroy = destroyImpl.destroy;
+Writable.prototype._undestroy = destroyImpl.undestroy;
+Writable.prototype._destroy = function (err, cb) {
+ this.end();
+ cb(err);
+};
+}).call(this,require('_process'),typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {},require("timers").setImmediate)
+},{"./_stream_duplex":22,"./internal/streams/destroy":28,"./internal/streams/stream":29,"_process":21,"core-util-is":9,"inherits":12,"process-nextick-args":20,"safe-buffer":32,"timers":34,"util-deprecate":35}],27:[function(require,module,exports){
+'use strict';
- case 'base64':
- // Warning: maxLength not taken into account in base64Write
- return base64Write(this, string, offset, length)
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
- case 'ucs2':
- case 'ucs-2':
- case 'utf16le':
- case 'utf-16le':
- return ucs2Write(this, string, offset, length)
+var Buffer = require('safe-buffer').Buffer;
+var util = require('util');
- default:
- if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
- encoding = ('' + encoding).toLowerCase()
- loweredCase = true
- }
- }
+function copyBuffer(src, target, offset) {
+ src.copy(target, offset);
}
-Buffer.prototype.toJSON = function toJSON () {
- return {
- type: 'Buffer',
- data: Array.prototype.slice.call(this._arr || this, 0)
- }
-}
+module.exports = function () {
+ function BufferList() {
+ _classCallCheck(this, BufferList);
-function base64Slice (buf, start, end) {
- if (start === 0 && end === buf.length) {
- return base64.fromByteArray(buf)
- } else {
- return base64.fromByteArray(buf.slice(start, end))
+ this.head = null;
+ this.tail = null;
+ this.length = 0;
}
-}
-function utf8Slice (buf, start, end) {
- end = Math.min(buf.length, end)
- var res = []
+ BufferList.prototype.push = function push(v) {
+ var entry = { data: v, next: null };
+ if (this.length > 0) this.tail.next = entry;else this.head = entry;
+ this.tail = entry;
+ ++this.length;
+ };
- var i = start
- while (i < end) {
- var firstByte = buf[i]
- var codePoint = null
- var bytesPerSequence = (firstByte > 0xEF) ? 4
- : (firstByte > 0xDF) ? 3
- : (firstByte > 0xBF) ? 2
- : 1
+ BufferList.prototype.unshift = function unshift(v) {
+ var entry = { data: v, next: this.head };
+ if (this.length === 0) this.tail = entry;
+ this.head = entry;
+ ++this.length;
+ };
- if (i + bytesPerSequence <= end) {
- var secondByte, thirdByte, fourthByte, tempCodePoint
+ BufferList.prototype.shift = function shift() {
+ if (this.length === 0) return;
+ var ret = this.head.data;
+ if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
+ --this.length;
+ return ret;
+ };
- switch (bytesPerSequence) {
- case 1:
- if (firstByte < 0x80) {
- codePoint = firstByte
- }
- break
- case 2:
- secondByte = buf[i + 1]
- if ((secondByte & 0xC0) === 0x80) {
- tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
- if (tempCodePoint > 0x7F) {
- codePoint = tempCodePoint
- }
- }
- break
- case 3:
- secondByte = buf[i + 1]
- thirdByte = buf[i + 2]
- if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
- tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
- if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
- codePoint = tempCodePoint
- }
- }
- break
- case 4:
- secondByte = buf[i + 1]
- thirdByte = buf[i + 2]
- fourthByte = buf[i + 3]
- if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
- tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
- if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
- codePoint = tempCodePoint
- }
- }
- }
- }
+ BufferList.prototype.clear = function clear() {
+ this.head = this.tail = null;
+ this.length = 0;
+ };
- if (codePoint === null) {
- // we did not generate a valid codePoint so insert a
- // replacement char (U+FFFD) and advance only 1 byte
- codePoint = 0xFFFD
- bytesPerSequence = 1
- } else if (codePoint > 0xFFFF) {
- // encode to utf16 (surrogate pair dance)
- codePoint -= 0x10000
- res.push(codePoint >>> 10 & 0x3FF | 0xD800)
- codePoint = 0xDC00 | codePoint & 0x3FF
+ BufferList.prototype.join = function join(s) {
+ if (this.length === 0) return '';
+ var p = this.head;
+ var ret = '' + p.data;
+ while (p = p.next) {
+ ret += s + p.data;
+ }return ret;
+ };
+
+ BufferList.prototype.concat = function concat(n) {
+ if (this.length === 0) return Buffer.alloc(0);
+ if (this.length === 1) return this.head.data;
+ var ret = Buffer.allocUnsafe(n >>> 0);
+ var p = this.head;
+ var i = 0;
+ while (p) {
+ copyBuffer(p.data, ret, i);
+ i += p.data.length;
+ p = p.next;
}
+ return ret;
+ };
- res.push(codePoint)
- i += bytesPerSequence
- }
+ return BufferList;
+}();
- return decodeCodePointsArray(res)
+if (util && util.inspect && util.inspect.custom) {
+ module.exports.prototype[util.inspect.custom] = function () {
+ var obj = util.inspect({ length: this.length });
+ return this.constructor.name + ' ' + obj;
+ };
}
+},{"safe-buffer":32,"util":7}],28:[function(require,module,exports){
+'use strict';
-// Based on http://stackoverflow.com/a/22747272/680742, the browser with
-// the lowest limit is Chrome, with 0x10000 args.
-// We go 1 magnitude less, for safety
-var MAX_ARGUMENTS_LENGTH = 0x1000
+/*<replacement>*/
-function decodeCodePointsArray (codePoints) {
- var len = codePoints.length
- if (len <= MAX_ARGUMENTS_LENGTH) {
- return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
- }
+var pna = require('process-nextick-args');
+/*</replacement>*/
- // Decode in chunks to avoid "call stack size exceeded".
- var res = ''
- var i = 0
- while (i < len) {
- res += String.fromCharCode.apply(
- String,
- codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
- )
- }
- return res
-}
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+ var _this = this;
-function asciiSlice (buf, start, end) {
- var ret = ''
- end = Math.min(buf.length, end)
+ var readableDestroyed = this._readableState && this._readableState.destroyed;
+ var writableDestroyed = this._writableState && this._writableState.destroyed;
- for (var i = start; i < end; ++i) {
- ret += String.fromCharCode(buf[i] & 0x7F)
+ if (readableDestroyed || writableDestroyed) {
+ if (cb) {
+ cb(err);
+ } else if (err && (!this._writableState || !this._writableState.errorEmitted)) {
+ pna.nextTick(emitErrorNT, this, err);
+ }
+ return this;
}
- return ret
-}
-function latin1Slice (buf, start, end) {
- var ret = ''
- end = Math.min(buf.length, end)
+ // we set destroyed to true before firing error callbacks in order
+ // to make it re-entrance safe in case destroy() is called within callbacks
- for (var i = start; i < end; ++i) {
- ret += String.fromCharCode(buf[i])
+ if (this._readableState) {
+ this._readableState.destroyed = true;
}
- return ret
-}
-function hexSlice (buf, start, end) {
- var len = buf.length
+ // if this is a duplex stream mark the writable part as destroyed as well
+ if (this._writableState) {
+ this._writableState.destroyed = true;
+ }
- if (!start || start < 0) start = 0
- if (!end || end < 0 || end > len) end = len
+ this._destroy(err || null, function (err) {
+ if (!cb && err) {
+ pna.nextTick(emitErrorNT, _this, err);
+ if (_this._writableState) {
+ _this._writableState.errorEmitted = true;
+ }
+ } else if (cb) {
+ cb(err);
+ }
+ });
- var out = ''
- for (var i = start; i < end; ++i) {
- out += toHex(buf[i])
- }
- return out
+ return this;
}
-function utf16leSlice (buf, start, end) {
- var bytes = buf.slice(start, end)
- var res = ''
- for (var i = 0; i < bytes.length; i += 2) {
- res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
+function undestroy() {
+ if (this._readableState) {
+ this._readableState.destroyed = false;
+ this._readableState.reading = false;
+ this._readableState.ended = false;
+ this._readableState.endEmitted = false;
}
- return res
-}
-Buffer.prototype.slice = function slice (start, end) {
- var len = this.length
- start = ~~start
- end = end === undefined ? len : ~~end
-
- if (start < 0) {
- start += len
- if (start < 0) start = 0
- } else if (start > len) {
- start = len
+ if (this._writableState) {
+ this._writableState.destroyed = false;
+ this._writableState.ended = false;
+ this._writableState.ending = false;
+ this._writableState.finished = false;
+ this._writableState.errorEmitted = false;
}
+}
- if (end < 0) {
- end += len
- if (end < 0) end = 0
- } else if (end > len) {
- end = len
- }
+function emitErrorNT(self, err) {
+ self.emit('error', err);
+}
- if (end < start) end = start
+module.exports = {
+ destroy: destroy,
+ undestroy: undestroy
+};
+},{"process-nextick-args":20}],29:[function(require,module,exports){
+module.exports = require('events').EventEmitter;
- var newBuf = this.subarray(start, end)
- // Return an augmented `Uint8Array` instance
- newBuf.__proto__ = Buffer.prototype
- return newBuf
-}
+},{"events":10}],30:[function(require,module,exports){
+exports = module.exports = require('./lib/_stream_readable.js');
+exports.Stream = exports;
+exports.Readable = exports;
+exports.Writable = require('./lib/_stream_writable.js');
+exports.Duplex = require('./lib/_stream_duplex.js');
+exports.Transform = require('./lib/_stream_transform.js');
+exports.PassThrough = require('./lib/_stream_passthrough.js');
-/*
- * Need to make sure that buffer isn't trying to write out of bounds.
- */
-function checkOffset (offset, ext, length) {
- if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
- if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
-}
+},{"./lib/_stream_duplex.js":22,"./lib/_stream_passthrough.js":23,"./lib/_stream_readable.js":24,"./lib/_stream_transform.js":25,"./lib/_stream_writable.js":26}],31:[function(require,module,exports){
+/*! @license Rematrix v0.7.0
-Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
- offset = offset >>> 0
- byteLength = byteLength >>> 0
- if (!noAssert) checkOffset(offset, byteLength, this.length)
+ Copyright 2020 Julian Lloyd.
- var val = this[offset]
- var mul = 1
- var i = 0
- while (++i < byteLength && (mul *= 0x100)) {
- val += this[offset + i] * mul
- }
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
- return val
-}
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
-Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
- offset = offset >>> 0
- byteLength = byteLength >>> 0
- if (!noAssert) {
- checkOffset(offset, byteLength, this.length)
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+*/
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+ typeof define === 'function' && define.amd ? define(['exports'], factory) :
+ (global = global || self, factory(global.Rematrix = {}));
+}(this, (function (exports) { 'use strict';
+
+ function format(source) {
+ if (source && source.constructor === Array) {
+ var values = source
+ .filter(function (value) { return typeof value === 'number'; })
+ .filter(function (value) { return !isNaN(value); });
+
+ if (source.length === 6 && values.length === 6) {
+ var matrix = identity();
+ matrix[0] = values[0];
+ matrix[1] = values[1];
+ matrix[4] = values[2];
+ matrix[5] = values[3];
+ matrix[12] = values[4];
+ matrix[13] = values[5];
+ return matrix
+ } else if (source.length === 16 && values.length === 16) {
+ return source
+ }
+ }
+ throw new TypeError('Expected a `number[]` with length 6 or 16.')
}
- var val = this[offset + --byteLength]
- var mul = 1
- while (byteLength > 0 && (mul *= 0x100)) {
- val += this[offset + --byteLength] * mul
+ function fromString(source) {
+ if (typeof source === 'string') {
+ var match = source.match(/matrix(3d)?\(([^)]+)\)/);
+ if (match) {
+ var raw = match[2].split(', ').map(parseFloat);
+ return format(raw)
+ }
+ }
+ throw new TypeError('Expected a string containing `matrix()` or `matrix3d()')
}
- return val
-}
+ function identity() {
+ var matrix = [];
+ for (var i = 0; i < 16; i++) {
+ i % 5 == 0 ? matrix.push(1) : matrix.push(0);
+ }
+ return matrix
+ }
-Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 1, this.length)
- return this[offset]
-}
+ function inverse(source) {
+ var m = format(source);
-Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 2, this.length)
- return this[offset] | (this[offset + 1] << 8)
-}
+ var s0 = m[0] * m[5] - m[4] * m[1];
+ var s1 = m[0] * m[6] - m[4] * m[2];
+ var s2 = m[0] * m[7] - m[4] * m[3];
+ var s3 = m[1] * m[6] - m[5] * m[2];
+ var s4 = m[1] * m[7] - m[5] * m[3];
+ var s5 = m[2] * m[7] - m[6] * m[3];
-Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 2, this.length)
- return (this[offset] << 8) | this[offset + 1]
-}
+ var c5 = m[10] * m[15] - m[14] * m[11];
+ var c4 = m[9] * m[15] - m[13] * m[11];
+ var c3 = m[9] * m[14] - m[13] * m[10];
+ var c2 = m[8] * m[15] - m[12] * m[11];
+ var c1 = m[8] * m[14] - m[12] * m[10];
+ var c0 = m[8] * m[13] - m[12] * m[9];
-Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 4, this.length)
+ var determinant = 1 / (s0 * c5 - s1 * c4 + s2 * c3 + s3 * c2 - s4 * c1 + s5 * c0);
- return ((this[offset]) |
- (this[offset + 1] << 8) |
- (this[offset + 2] << 16)) +
- (this[offset + 3] * 0x1000000)
-}
+ if (isNaN(determinant) || determinant === Infinity) {
+ throw new Error('Inverse determinant attempted to divide by zero.')
+ }
-Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 4, this.length)
+ return [
+ (m[5] * c5 - m[6] * c4 + m[7] * c3) * determinant,
+ (-m[1] * c5 + m[2] * c4 - m[3] * c3) * determinant,
+ (m[13] * s5 - m[14] * s4 + m[15] * s3) * determinant,
+ (-m[9] * s5 + m[10] * s4 - m[11] * s3) * determinant,
- return (this[offset] * 0x1000000) +
- ((this[offset + 1] << 16) |
- (this[offset + 2] << 8) |
- this[offset + 3])
-}
+ (-m[4] * c5 + m[6] * c2 - m[7] * c1) * determinant,
+ (m[0] * c5 - m[2] * c2 + m[3] * c1) * determinant,
+ (-m[12] * s5 + m[14] * s2 - m[15] * s1) * determinant,
+ (m[8] * s5 - m[10] * s2 + m[11] * s1) * determinant,
-Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
- offset = offset >>> 0
- byteLength = byteLength >>> 0
- if (!noAssert) checkOffset(offset, byteLength, this.length)
+ (m[4] * c4 - m[5] * c2 + m[7] * c0) * determinant,
+ (-m[0] * c4 + m[1] * c2 - m[3] * c0) * determinant,
+ (m[12] * s4 - m[13] * s2 + m[15] * s0) * determinant,
+ (-m[8] * s4 + m[9] * s2 - m[11] * s0) * determinant,
- var val = this[offset]
- var mul = 1
- var i = 0
- while (++i < byteLength && (mul *= 0x100)) {
- val += this[offset + i] * mul
+ (-m[4] * c3 + m[5] * c1 - m[6] * c0) * determinant,
+ (m[0] * c3 - m[1] * c1 + m[2] * c0) * determinant,
+ (-m[12] * s3 + m[13] * s1 - m[14] * s0) * determinant,
+ (m[8] * s3 - m[9] * s1 + m[10] * s0) * determinant ]
}
- mul *= 0x80
- if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+ function multiply(matrixA, matrixB) {
+ var fma = format(matrixA);
+ var fmb = format(matrixB);
+ var product = [];
- return val
-}
+ for (var i = 0; i < 4; i++) {
+ var row = [fma[i], fma[i + 4], fma[i + 8], fma[i + 12]];
+ for (var j = 0; j < 4; j++) {
+ var k = j * 4;
+ var col = [fmb[k], fmb[k + 1], fmb[k + 2], fmb[k + 3]];
+ var result = row[0] * col[0] + row[1] * col[1] + row[2] * col[2] + row[3] * col[3];
-Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
- offset = offset >>> 0
- byteLength = byteLength >>> 0
- if (!noAssert) checkOffset(offset, byteLength, this.length)
+ product[i + k] = result;
+ }
+ }
- var i = byteLength
- var mul = 1
- var val = this[offset + --i]
- while (i > 0 && (mul *= 0x100)) {
- val += this[offset + --i] * mul
+ return product
}
- mul *= 0x80
-
- if (val >= mul) val -= Math.pow(2, 8 * byteLength)
-
- return val
-}
-
-Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 1, this.length)
- if (!(this[offset] & 0x80)) return (this[offset])
- return ((0xff - this[offset] + 1) * -1)
-}
-
-Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 2, this.length)
- var val = this[offset] | (this[offset + 1] << 8)
- return (val & 0x8000) ? val | 0xFFFF0000 : val
-}
-Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 2, this.length)
- var val = this[offset + 1] | (this[offset] << 8)
- return (val & 0x8000) ? val | 0xFFFF0000 : val
-}
+ function perspective(distance) {
+ var matrix = identity();
+ matrix[11] = -1 / distance;
+ return matrix
+ }
-Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 4, this.length)
+ function rotate(angle) {
+ return rotateZ(angle)
+ }
- return (this[offset]) |
- (this[offset + 1] << 8) |
- (this[offset + 2] << 16) |
- (this[offset + 3] << 24)
-}
+ function rotateX(angle) {
+ var theta = (Math.PI / 180) * angle;
+ var matrix = identity();
-Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 4, this.length)
+ matrix[5] = matrix[10] = Math.cos(theta);
+ matrix[6] = matrix[9] = Math.sin(theta);
+ matrix[9] *= -1;
- return (this[offset] << 24) |
- (this[offset + 1] << 16) |
- (this[offset + 2] << 8) |
- (this[offset + 3])
-}
+ return matrix
+ }
-Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 4, this.length)
- return ieee754.read(this, offset, true, 23, 4)
-}
+ function rotateY(angle) {
+ var theta = (Math.PI / 180) * angle;
+ var matrix = identity();
-Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 4, this.length)
- return ieee754.read(this, offset, false, 23, 4)
-}
+ matrix[0] = matrix[10] = Math.cos(theta);
+ matrix[2] = matrix[8] = Math.sin(theta);
+ matrix[2] *= -1;
-Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 8, this.length)
- return ieee754.read(this, offset, true, 52, 8)
-}
+ return matrix
+ }
-Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
- offset = offset >>> 0
- if (!noAssert) checkOffset(offset, 8, this.length)
- return ieee754.read(this, offset, false, 52, 8)
-}
+ function rotateZ(angle) {
+ var theta = (Math.PI / 180) * angle;
+ var matrix = identity();
-function checkInt (buf, value, offset, ext, max, min) {
- if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
- if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
- if (offset + ext > buf.length) throw new RangeError('Index out of range')
-}
+ matrix[0] = matrix[5] = Math.cos(theta);
+ matrix[1] = matrix[4] = Math.sin(theta);
+ matrix[4] *= -1;
-Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
- value = +value
- offset = offset >>> 0
- byteLength = byteLength >>> 0
- if (!noAssert) {
- var maxBytes = Math.pow(2, 8 * byteLength) - 1
- checkInt(this, value, offset, byteLength, maxBytes, 0)
+ return matrix
}
- var mul = 1
- var i = 0
- this[offset] = value & 0xFF
- while (++i < byteLength && (mul *= 0x100)) {
- this[offset + i] = (value / mul) & 0xFF
+ function scale(scalar, scalarY) {
+ var matrix = identity();
+
+ matrix[0] = scalar;
+ matrix[5] = typeof scalarY === 'number' ? scalarY : scalar;
+
+ return matrix
}
- return offset + byteLength
-}
+ function scaleX(scalar) {
+ var matrix = identity();
+ matrix[0] = scalar;
+ return matrix
+ }
-Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
- value = +value
- offset = offset >>> 0
- byteLength = byteLength >>> 0
- if (!noAssert) {
- var maxBytes = Math.pow(2, 8 * byteLength) - 1
- checkInt(this, value, offset, byteLength, maxBytes, 0)
+ function scaleY(scalar) {
+ var matrix = identity();
+ matrix[5] = scalar;
+ return matrix
}
- var i = byteLength - 1
- var mul = 1
- this[offset + i] = value & 0xFF
- while (--i >= 0 && (mul *= 0x100)) {
- this[offset + i] = (value / mul) & 0xFF
+ function scaleZ(scalar) {
+ var matrix = identity();
+ matrix[10] = scalar;
+ return matrix
}
- return offset + byteLength
-}
+ function skew(angleX, angleY) {
+ var thetaX = (Math.PI / 180) * angleX;
+ var matrix = identity();
-Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
- this[offset] = (value & 0xff)
- return offset + 1
-}
+ matrix[4] = Math.tan(thetaX);
-Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
- this[offset] = (value & 0xff)
- this[offset + 1] = (value >>> 8)
- return offset + 2
-}
+ if (angleY) {
+ var thetaY = (Math.PI / 180) * angleY;
+ matrix[1] = Math.tan(thetaY);
+ }
-Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
- this[offset] = (value >>> 8)
- this[offset + 1] = (value & 0xff)
- return offset + 2
-}
+ return matrix
+ }
-Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
- this[offset + 3] = (value >>> 24)
- this[offset + 2] = (value >>> 16)
- this[offset + 1] = (value >>> 8)
- this[offset] = (value & 0xff)
- return offset + 4
-}
+ function skewX(angle) {
+ var theta = (Math.PI / 180) * angle;
+ var matrix = identity();
-Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
- this[offset] = (value >>> 24)
- this[offset + 1] = (value >>> 16)
- this[offset + 2] = (value >>> 8)
- this[offset + 3] = (value & 0xff)
- return offset + 4
-}
+ matrix[4] = Math.tan(theta);
-Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) {
- var limit = Math.pow(2, (8 * byteLength) - 1)
+ return matrix
+ }
- checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ function skewY(angle) {
+ var theta = (Math.PI / 180) * angle;
+ var matrix = identity();
+
+ matrix[1] = Math.tan(theta);
+
+ return matrix
}
- var i = 0
- var mul = 1
- var sub = 0
- this[offset] = value & 0xFF
- while (++i < byteLength && (mul *= 0x100)) {
- if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
- sub = 1
- }
- this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ function toString(source) {
+ return ("matrix3d(" + (format(source).join(', ')) + ")")
}
- return offset + byteLength
-}
+ function translate(distanceX, distanceY) {
+ var matrix = identity();
+ matrix[12] = distanceX;
-Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) {
- var limit = Math.pow(2, (8 * byteLength) - 1)
+ if (distanceY) {
+ matrix[13] = distanceY;
+ }
- checkInt(this, value, offset, byteLength, limit - 1, -limit)
+ return matrix
}
- var i = byteLength - 1
- var mul = 1
- var sub = 0
- this[offset + i] = value & 0xFF
- while (--i >= 0 && (mul *= 0x100)) {
- if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
- sub = 1
+ function translate3d(distanceX, distanceY, distanceZ) {
+ var matrix = identity();
+ if (distanceX !== undefined && distanceY !== undefined && distanceZ !== undefined) {
+ matrix[12] = distanceX;
+ matrix[13] = distanceY;
+ matrix[14] = distanceZ;
}
- this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+ return matrix
}
- return offset + byteLength
-}
+ function translateX(distance) {
+ var matrix = identity();
+ matrix[12] = distance;
+ return matrix
+ }
-Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
- if (value < 0) value = 0xff + value + 1
- this[offset] = (value & 0xff)
- return offset + 1
-}
+ function translateY(distance) {
+ var matrix = identity();
+ matrix[13] = distance;
+ return matrix
+ }
-Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
- this[offset] = (value & 0xff)
- this[offset + 1] = (value >>> 8)
- return offset + 2
+ function translateZ(distance) {
+ var matrix = identity();
+ matrix[14] = distance;
+ return matrix
+ }
+
+ exports.format = format;
+ exports.fromString = fromString;
+ exports.identity = identity;
+ exports.inverse = inverse;
+ exports.multiply = multiply;
+ exports.perspective = perspective;
+ exports.rotate = rotate;
+ exports.rotateX = rotateX;
+ exports.rotateY = rotateY;
+ exports.rotateZ = rotateZ;
+ exports.scale = scale;
+ exports.scaleX = scaleX;
+ exports.scaleY = scaleY;
+ exports.scaleZ = scaleZ;
+ exports.skew = skew;
+ exports.skewX = skewX;
+ exports.skewY = skewY;
+ exports.toString = toString;
+ exports.translate = translate;
+ exports.translate3d = translate3d;
+ exports.translateX = translateX;
+ exports.translateY = translateY;
+ exports.translateZ = translateZ;
+
+ Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+},{}],32:[function(require,module,exports){
+/* eslint-disable node/no-deprecated-api */
+var buffer = require('buffer')
+var Buffer = buffer.Buffer
+
+// alternative to using Object.keys for old browsers
+function copyProps (src, dst) {
+ for (var key in src) {
+ dst[key] = src[key]
+ }
+}
+if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+ module.exports = buffer
+} else {
+ // Copy properties from require('buffer')
+ copyProps(buffer, exports)
+ exports.Buffer = SafeBuffer
}
-Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
- this[offset] = (value >>> 8)
- this[offset + 1] = (value & 0xff)
- return offset + 2
+function SafeBuffer (arg, encodingOrOffset, length) {
+ return Buffer(arg, encodingOrOffset, length)
}
-Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
- this[offset] = (value & 0xff)
- this[offset + 1] = (value >>> 8)
- this[offset + 2] = (value >>> 16)
- this[offset + 3] = (value >>> 24)
- return offset + 4
+// Copy static methods from Buffer
+copyProps(Buffer, SafeBuffer)
+
+SafeBuffer.from = function (arg, encodingOrOffset, length) {
+ if (typeof arg === 'number') {
+ throw new TypeError('Argument must not be a number')
+ }
+ return Buffer(arg, encodingOrOffset, length)
}
-Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
- if (value < 0) value = 0xffffffff + value + 1
- this[offset] = (value >>> 24)
- this[offset + 1] = (value >>> 16)
- this[offset + 2] = (value >>> 8)
- this[offset + 3] = (value & 0xff)
- return offset + 4
+SafeBuffer.alloc = function (size, fill, encoding) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ var buf = Buffer(size)
+ if (fill !== undefined) {
+ if (typeof encoding === 'string') {
+ buf.fill(fill, encoding)
+ } else {
+ buf.fill(fill)
+ }
+ } else {
+ buf.fill(0)
+ }
+ return buf
}
-function checkIEEE754 (buf, value, offset, ext, max, min) {
- if (offset + ext > buf.length) throw new RangeError('Index out of range')
- if (offset < 0) throw new RangeError('Index out of range')
+SafeBuffer.allocUnsafe = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
+ }
+ return Buffer(size)
}
-function writeFloat (buf, value, offset, littleEndian, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) {
- checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+SafeBuffer.allocUnsafeSlow = function (size) {
+ if (typeof size !== 'number') {
+ throw new TypeError('Argument must be a number')
}
- ieee754.write(buf, value, offset, littleEndian, 23, 4)
- return offset + 4
+ return buffer.SlowBuffer(size)
}
-Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
- return writeFloat(this, value, offset, true, noAssert)
-}
+},{"buffer":8}],33:[function(require,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+'use strict';
-Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
- return writeFloat(this, value, offset, false, noAssert)
-}
+/*<replacement>*/
-function writeDouble (buf, value, offset, littleEndian, noAssert) {
- value = +value
- offset = offset >>> 0
- if (!noAssert) {
- checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+var Buffer = require('safe-buffer').Buffer;
+/*</replacement>*/
+
+var isEncoding = Buffer.isEncoding || function (encoding) {
+ encoding = '' + encoding;
+ switch (encoding && encoding.toLowerCase()) {
+ case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':
+ return true;
+ default:
+ return false;
}
- ieee754.write(buf, value, offset, littleEndian, 52, 8)
- return offset + 8
-}
+};
-Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
- return writeDouble(this, value, offset, true, noAssert)
+function _normalizeEncoding(enc) {
+ if (!enc) return 'utf8';
+ var retried;
+ while (true) {
+ switch (enc) {
+ case 'utf8':
+ case 'utf-8':
+ return 'utf8';
+ case 'ucs2':
+ case 'ucs-2':
+ case 'utf16le':
+ case 'utf-16le':
+ return 'utf16le';
+ case 'latin1':
+ case 'binary':
+ return 'latin1';
+ case 'base64':
+ case 'ascii':
+ case 'hex':
+ return enc;
+ default:
+ if (retried) return; // undefined
+ enc = ('' + enc).toLowerCase();
+ retried = true;
+ }
+ }
+};
+
+// Do not cache `Buffer.isEncoding` when checking encoding names as some
+// modules monkey-patch it to support additional encodings
+function normalizeEncoding(enc) {
+ var nenc = _normalizeEncoding(enc);
+ if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);
+ return nenc || enc;
}
-Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
- return writeDouble(this, value, offset, false, noAssert)
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters.
+exports.StringDecoder = StringDecoder;
+function StringDecoder(encoding) {
+ this.encoding = normalizeEncoding(encoding);
+ var nb;
+ switch (this.encoding) {
+ case 'utf16le':
+ this.text = utf16Text;
+ this.end = utf16End;
+ nb = 4;
+ break;
+ case 'utf8':
+ this.fillLast = utf8FillLast;
+ nb = 4;
+ break;
+ case 'base64':
+ this.text = base64Text;
+ this.end = base64End;
+ nb = 3;
+ break;
+ default:
+ this.write = simpleWrite;
+ this.end = simpleEnd;
+ return;
+ }
+ this.lastNeed = 0;
+ this.lastTotal = 0;
+ this.lastChar = Buffer.allocUnsafe(nb);
}
-// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
-Buffer.prototype.copy = function copy (target, targetStart, start, end) {
- if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
- if (!start) start = 0
- if (!end && end !== 0) end = this.length
- if (targetStart >= target.length) targetStart = target.length
- if (!targetStart) targetStart = 0
- if (end > 0 && end < start) end = start
+StringDecoder.prototype.write = function (buf) {
+ if (buf.length === 0) return '';
+ var r;
+ var i;
+ if (this.lastNeed) {
+ r = this.fillLast(buf);
+ if (r === undefined) return '';
+ i = this.lastNeed;
+ this.lastNeed = 0;
+ } else {
+ i = 0;
+ }
+ if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+ return r || '';
+};
- // Copy 0 bytes; we're done
- if (end === start) return 0
- if (target.length === 0 || this.length === 0) return 0
+StringDecoder.prototype.end = utf8End;
- // Fatal error conditions
- if (targetStart < 0) {
- throw new RangeError('targetStart out of bounds')
- }
- if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
- if (end < 0) throw new RangeError('sourceEnd out of bounds')
+// Returns only complete characters in a Buffer
+StringDecoder.prototype.text = utf8Text;
- // Are we oob?
- if (end > this.length) end = this.length
- if (target.length - targetStart < end - start) {
- end = target.length - targetStart + start
+// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+StringDecoder.prototype.fillLast = function (buf) {
+ if (this.lastNeed <= buf.length) {
+ buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+ return this.lastChar.toString(this.encoding, 0, this.lastTotal);
}
+ buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+ this.lastNeed -= buf.length;
+};
- var len = end - start
+// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+// continuation byte. If an invalid byte is detected, -2 is returned.
+function utf8CheckByte(byte) {
+ if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;
+ return byte >> 6 === 0x02 ? -1 : -2;
+}
- if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
- // Use built-in when available, missing from IE11
- this.copyWithin(targetStart, start, end)
- } else if (this === target && start < targetStart && targetStart < end) {
- // descending copy from end
- for (var i = len - 1; i >= 0; --i) {
- target[i + targetStart] = this[i + start]
+// Checks at most 3 bytes at the end of a Buffer in order to detect an
+// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+// needed to complete the UTF-8 character (if applicable) are returned.
+function utf8CheckIncomplete(self, buf, i) {
+ var j = buf.length - 1;
+ if (j < i) return 0;
+ var nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) self.lastNeed = nb - 1;
+ return nb;
+ }
+ if (--j < i || nb === -2) return 0;
+ nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) self.lastNeed = nb - 2;
+ return nb;
+ }
+ if (--j < i || nb === -2) return 0;
+ nb = utf8CheckByte(buf[j]);
+ if (nb >= 0) {
+ if (nb > 0) {
+ if (nb === 2) nb = 0;else self.lastNeed = nb - 3;
}
- } else {
- Uint8Array.prototype.set.call(
- target,
- this.subarray(start, end),
- targetStart
- )
+ return nb;
}
-
- return len
+ return 0;
}
-// Usage:
-// buffer.fill(number[, offset[, end]])
-// buffer.fill(buffer[, offset[, end]])
-// buffer.fill(string[, offset[, end]][, encoding])
-Buffer.prototype.fill = function fill (val, start, end, encoding) {
- // Handle string cases:
- if (typeof val === 'string') {
- if (typeof start === 'string') {
- encoding = start
- start = 0
- end = this.length
- } else if (typeof end === 'string') {
- encoding = end
- end = this.length
- }
- if (encoding !== undefined && typeof encoding !== 'string') {
- throw new TypeError('encoding must be a string')
+// Validates as many continuation bytes for a multi-byte UTF-8 character as
+// needed or are available. If we see a non-continuation byte where we expect
+// one, we "replace" the validated continuation bytes we've seen so far with
+// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+// behavior. The continuation byte check is included three times in the case
+// where all of the continuation bytes for a character exist in the same buffer.
+// It is also done this way as a slight performance increase instead of using a
+// loop.
+function utf8CheckExtraBytes(self, buf, p) {
+ if ((buf[0] & 0xC0) !== 0x80) {
+ self.lastNeed = 0;
+ return '\ufffd';
+ }
+ if (self.lastNeed > 1 && buf.length > 1) {
+ if ((buf[1] & 0xC0) !== 0x80) {
+ self.lastNeed = 1;
+ return '\ufffd';
}
- if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
- throw new TypeError('Unknown encoding: ' + encoding)
+ if (self.lastNeed > 2 && buf.length > 2) {
+ if ((buf[2] & 0xC0) !== 0x80) {
+ self.lastNeed = 2;
+ return '\ufffd';
+ }
}
- if (val.length === 1) {
- var code = val.charCodeAt(0)
- if ((encoding === 'utf8' && code < 128) ||
- encoding === 'latin1') {
- // Fast path: If `val` fits into a single byte, use that numeric value.
- val = code
+ }
+}
+
+// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+function utf8FillLast(buf) {
+ var p = this.lastTotal - this.lastNeed;
+ var r = utf8CheckExtraBytes(this, buf, p);
+ if (r !== undefined) return r;
+ if (this.lastNeed <= buf.length) {
+ buf.copy(this.lastChar, p, 0, this.lastNeed);
+ return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+ }
+ buf.copy(this.lastChar, p, 0, buf.length);
+ this.lastNeed -= buf.length;
+}
+
+// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+// partial character, the character's bytes are buffered until the required
+// number of bytes are available.
+function utf8Text(buf, i) {
+ var total = utf8CheckIncomplete(this, buf, i);
+ if (!this.lastNeed) return buf.toString('utf8', i);
+ this.lastTotal = total;
+ var end = buf.length - (total - this.lastNeed);
+ buf.copy(this.lastChar, 0, end);
+ return buf.toString('utf8', i, end);
+}
+
+// For UTF-8, a replacement character is added when ending on a partial
+// character.
+function utf8End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) return r + '\ufffd';
+ return r;
+}
+
+// UTF-16LE typically needs two bytes per character, but even if we have an even
+// number of bytes available, we need to check if we end on a leading/high
+// surrogate. In that case, we need to wait for the next two bytes in order to
+// decode the last character properly.
+function utf16Text(buf, i) {
+ if ((buf.length - i) % 2 === 0) {
+ var r = buf.toString('utf16le', i);
+ if (r) {
+ var c = r.charCodeAt(r.length - 1);
+ if (c >= 0xD800 && c <= 0xDBFF) {
+ this.lastNeed = 2;
+ this.lastTotal = 4;
+ this.lastChar[0] = buf[buf.length - 2];
+ this.lastChar[1] = buf[buf.length - 1];
+ return r.slice(0, -1);
}
}
- } else if (typeof val === 'number') {
- val = val & 255
+ return r;
}
+ this.lastNeed = 1;
+ this.lastTotal = 2;
+ this.lastChar[0] = buf[buf.length - 1];
+ return buf.toString('utf16le', i, buf.length - 1);
+}
- // Invalid ranges are not set to a default, so can range check early.
- if (start < 0 || this.length < start || this.length < end) {
- throw new RangeError('Out of range index')
+// For UTF-16LE we do not explicitly append special replacement characters if we
+// end on a partial character, we simply let v8 handle that.
+function utf16End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) {
+ var end = this.lastTotal - this.lastNeed;
+ return r + this.lastChar.toString('utf16le', 0, end);
}
+ return r;
+}
- if (end <= start) {
- return this
+function base64Text(buf, i) {
+ var n = (buf.length - i) % 3;
+ if (n === 0) return buf.toString('base64', i);
+ this.lastNeed = 3 - n;
+ this.lastTotal = 3;
+ if (n === 1) {
+ this.lastChar[0] = buf[buf.length - 1];
+ } else {
+ this.lastChar[0] = buf[buf.length - 2];
+ this.lastChar[1] = buf[buf.length - 1];
}
+ return buf.toString('base64', i, buf.length - n);
+}
- start = start >>> 0
- end = end === undefined ? this.length : end >>> 0
-
- if (!val) val = 0
+function base64End(buf) {
+ var r = buf && buf.length ? this.write(buf) : '';
+ if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
+ return r;
+}
- var i
- if (typeof val === 'number') {
- for (i = start; i < end; ++i) {
- this[i] = val
- }
- } else {
- var bytes = Buffer.isBuffer(val)
- ? val
- : Buffer.from(val, encoding)
- var len = bytes.length
- if (len === 0) {
- throw new TypeError('The value "' + val +
- '" is invalid for argument "value"')
- }
- for (i = 0; i < end - start; ++i) {
- this[i + start] = bytes[i % len]
- }
- }
+// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
+function simpleWrite(buf) {
+ return buf.toString(this.encoding);
+}
- return this
+function simpleEnd(buf) {
+ return buf && buf.length ? this.write(buf) : '';
}
+},{"safe-buffer":32}],34:[function(require,module,exports){
+(function (setImmediate,clearImmediate){
+var nextTick = require('process/browser.js').nextTick;
+var apply = Function.prototype.apply;
+var slice = Array.prototype.slice;
+var immediateIds = {};
+var nextImmediateId = 0;
-// HELPER FUNCTIONS
-// ================
+// DOM APIs, for completeness
-var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
+exports.setTimeout = function() {
+ return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
+};
+exports.setInterval = function() {
+ return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
+};
+exports.clearTimeout =
+exports.clearInterval = function(timeout) { timeout.close(); };
-function base64clean (str) {
- // Node takes equal signs as end of the Base64 encoding
- str = str.split('=')[0]
- // Node strips out invalid characters like \n and \t from the string, base64-js does not
- str = str.trim().replace(INVALID_BASE64_RE, '')
- // Node converts strings with length < 2 to ''
- if (str.length < 2) return ''
- // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
- while (str.length % 4 !== 0) {
- str = str + '='
- }
- return str
+function Timeout(id, clearFn) {
+ this._id = id;
+ this._clearFn = clearFn;
}
+Timeout.prototype.unref = Timeout.prototype.ref = function() {};
+Timeout.prototype.close = function() {
+ this._clearFn.call(window, this._id);
+};
-function toHex (n) {
- if (n < 16) return '0' + n.toString(16)
- return n.toString(16)
-}
+// Does not start the time, just sets up the members needed.
+exports.enroll = function(item, msecs) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = msecs;
+};
-function utf8ToBytes (string, units) {
- units = units || Infinity
- var codePoint
- var length = string.length
- var leadSurrogate = null
- var bytes = []
+exports.unenroll = function(item) {
+ clearTimeout(item._idleTimeoutId);
+ item._idleTimeout = -1;
+};
- for (var i = 0; i < length; ++i) {
- codePoint = string.charCodeAt(i)
+exports._unrefActive = exports.active = function(item) {
+ clearTimeout(item._idleTimeoutId);
- // is surrogate component
- if (codePoint > 0xD7FF && codePoint < 0xE000) {
- // last char was a lead
- if (!leadSurrogate) {
- // no lead yet
- if (codePoint > 0xDBFF) {
- // unexpected trail
- if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
- continue
- } else if (i + 1 === length) {
- // unpaired lead
- if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
- continue
- }
+ var msecs = item._idleTimeout;
+ if (msecs >= 0) {
+ item._idleTimeoutId = setTimeout(function onTimeout() {
+ if (item._onTimeout)
+ item._onTimeout();
+ }, msecs);
+ }
+};
- // valid lead
- leadSurrogate = codePoint
+// That's not how node.js implements it but the exposed api is the same.
+exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
+ var id = nextImmediateId++;
+ var args = arguments.length < 2 ? false : slice.call(arguments, 1);
- continue
- }
+ immediateIds[id] = true;
- // 2 leads in a row
- if (codePoint < 0xDC00) {
- if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
- leadSurrogate = codePoint
- continue
+ nextTick(function onNextTick() {
+ if (immediateIds[id]) {
+ // fn.call() is faster so we optimize for the common use-case
+ // @see http://jsperf.com/call-apply-segu
+ if (args) {
+ fn.apply(null, args);
+ } else {
+ fn.call(null);
}
-
- // valid surrogate pair
- codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
- } else if (leadSurrogate) {
- // valid bmp char, but last char was a lead
- if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+ // Prevent ids from leaking
+ exports.clearImmediate(id);
}
+ });
- leadSurrogate = null
+ return id;
+};
- // encode utf8
- if (codePoint < 0x80) {
- if ((units -= 1) < 0) break
- bytes.push(codePoint)
- } else if (codePoint < 0x800) {
- if ((units -= 2) < 0) break
- bytes.push(
- codePoint >> 0x6 | 0xC0,
- codePoint & 0x3F | 0x80
- )
- } else if (codePoint < 0x10000) {
- if ((units -= 3) < 0) break
- bytes.push(
- codePoint >> 0xC | 0xE0,
- codePoint >> 0x6 & 0x3F | 0x80,
- codePoint & 0x3F | 0x80
- )
- } else if (codePoint < 0x110000) {
- if ((units -= 4) < 0) break
- bytes.push(
- codePoint >> 0x12 | 0xF0,
- codePoint >> 0xC & 0x3F | 0x80,
- codePoint >> 0x6 & 0x3F | 0x80,
- codePoint & 0x3F | 0x80
- )
- } else {
- throw new Error('Invalid code point')
+exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
+ delete immediateIds[id];
+};
+}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
+},{"process/browser.js":21,"timers":34}],35:[function(require,module,exports){
+(function (global){
+
+/**
+ * Module exports.
+ */
+
+module.exports = deprecate;
+
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
+
+function deprecate (fn, msg) {
+ if (config('noDeprecation')) {
+ return fn;
+ }
+
+ var warned = false;
+ function deprecated() {
+ if (!warned) {
+ if (config('throwDeprecation')) {
+ throw new Error(msg);
+ } else if (config('traceDeprecation')) {
+ console.trace(msg);
+ } else {
+ console.warn(msg);
+ }
+ warned = true;
}
+ return fn.apply(this, arguments);
}
- return bytes
+ return deprecated;
}
-function asciiToBytes (str) {
- var byteArray = []
- for (var i = 0; i < str.length; ++i) {
- // Node's code seems to be doing this and not & 0x7F..
- byteArray.push(str.charCodeAt(i) & 0xFF)
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
+
+function config (name) {
+ // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+ try {
+ if (!global.localStorage) return false;
+ } catch (_) {
+ return false;
}
- return byteArray
+ var val = global.localStorage[name];
+ if (null == val) return false;
+ return String(val).toLowerCase() === 'true';
}
-function utf16leToBytes (str, units) {
- var c, hi, lo
- var byteArray = []
- for (var i = 0; i < str.length; ++i) {
- if ((units -= 2) < 0) break
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}],36:[function(require,module,exports){
+arguments[4][3][0].apply(exports,arguments)
+},{"dup":3}],37:[function(require,module,exports){
+arguments[4][4][0].apply(exports,arguments)
+},{"./support/isBuffer":36,"_process":21,"dup":4,"inherits":12}],38:[function(require,module,exports){
+var v1 = require('./v1');
+var v4 = require('./v4');
- c = str.charCodeAt(i)
- hi = c >> 8
- lo = c % 256
- byteArray.push(lo)
- byteArray.push(hi)
- }
+var uuid = v4;
+uuid.v1 = v1;
+uuid.v4 = v4;
- return byteArray
-}
+module.exports = uuid;
-function base64ToBytes (str) {
- return base64.toByteArray(base64clean(str))
+},{"./v1":41,"./v4":42}],39:[function(require,module,exports){
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+var byteToHex = [];
+for (var i = 0; i < 256; ++i) {
+ byteToHex[i] = (i + 0x100).toString(16).substr(1);
}
-function blitBuffer (src, dst, offset, length) {
- for (var i = 0; i < length; ++i) {
- if ((i + offset >= dst.length) || (i >= src.length)) break
- dst[i + offset] = src[i]
- }
- return i
+function bytesToUuid(buf, offset) {
+ var i = offset || 0;
+ var bth = byteToHex;
+ // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
+ return ([
+ bth[buf[i++]], bth[buf[i++]],
+ bth[buf[i++]], bth[buf[i++]], '-',
+ bth[buf[i++]], bth[buf[i++]], '-',
+ bth[buf[i++]], bth[buf[i++]], '-',
+ bth[buf[i++]], bth[buf[i++]], '-',
+ bth[buf[i++]], bth[buf[i++]],
+ bth[buf[i++]], bth[buf[i++]],
+ bth[buf[i++]], bth[buf[i++]]
+ ]).join('');
}
-// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
-// the `instanceof` check but they should be treated as of that type.
-// See: https://github.com/feross/buffer/issues/166
-function isInstance (obj, type) {
- return obj instanceof type ||
- (obj != null && obj.constructor != null && obj.constructor.name != null &&
- obj.constructor.name === type.name)
-}
-function numberIsNaN (obj) {
- // For IE11 support
- return obj !== obj // eslint-disable-line no-self-compare
-}
+module.exports = bytesToUuid;
-}).call(this,require("buffer").Buffer)
-},{"base64-js":63,"buffer":65,"ieee754":67}],66:[function(require,module,exports){
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
+},{}],40:[function(require,module,exports){
+// Unique ID creation requires a high quality random # generator. In the
+// browser this is a little complicated due to unknown quality of Math.random()
+// and inconsistent support for the `crypto` API. We do the best we can via
+// feature-detection
-var objectCreate = Object.create || objectCreatePolyfill
-var objectKeys = Object.keys || objectKeysPolyfill
-var bind = Function.prototype.bind || functionBindPolyfill
+// getRandomValues needs to be invoked in a context where "this" is a Crypto
+// implementation. Also, find the complete implementation of crypto on IE11.
+var getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||
+ (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));
-function EventEmitter() {
- if (!this._events || !Object.prototype.hasOwnProperty.call(this, '_events')) {
- this._events = objectCreate(null);
- this._eventsCount = 0;
- }
+if (getRandomValues) {
+ // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
+ var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef
- this._maxListeners = this._maxListeners || undefined;
+ module.exports = function whatwgRNG() {
+ getRandomValues(rnds8);
+ return rnds8;
+ };
+} else {
+ // Math.random()-based (RNG)
+ //
+ // If all else fails, use Math.random(). It's fast, but is of unspecified
+ // quality.
+ var rnds = new Array(16);
+
+ module.exports = function mathRNG() {
+ for (var i = 0, r; i < 16; i++) {
+ if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
+ rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
+ }
+
+ return rnds;
+ };
}
-module.exports = EventEmitter;
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+},{}],41:[function(require,module,exports){
+var rng = require('./lib/rng');
+var bytesToUuid = require('./lib/bytesToUuid');
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._maxListeners = undefined;
+// **`v1()` - Generate time-based UUID**
+//
+// Inspired by https://github.com/LiosK/UUID.js
+// and http://docs.python.org/library/uuid.html
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-var defaultMaxListeners = 10;
+var _nodeId;
+var _clockseq;
-var hasDefineProperty;
-try {
- var o = {};
- if (Object.defineProperty) Object.defineProperty(o, 'x', { value: 0 });
- hasDefineProperty = o.x === 0;
-} catch (err) { hasDefineProperty = false }
-if (hasDefineProperty) {
- Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
- enumerable: true,
- get: function() {
- return defaultMaxListeners;
- },
- set: function(arg) {
- // check whether the input is a positive number (whose value is zero or
- // greater and not a NaN).
- if (typeof arg !== 'number' || arg < 0 || arg !== arg)
- throw new TypeError('"defaultMaxListeners" must be a positive number');
- defaultMaxListeners = arg;
- }
- });
-} else {
- EventEmitter.defaultMaxListeners = defaultMaxListeners;
-}
+// Previous uuid creation time
+var _lastMSecs = 0;
+var _lastNSecs = 0;
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
- if (typeof n !== 'number' || n < 0 || isNaN(n))
- throw new TypeError('"n" argument must be a positive number');
- this._maxListeners = n;
- return this;
-};
+// See https://github.com/uuidjs/uuid for API details
+function v1(options, buf, offset) {
+ var i = buf && offset || 0;
+ var b = buf || [];
+
+ options = options || {};
+ var node = options.node || _nodeId;
+ var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq;
+
+ // node and clockseq need to be initialized to random values if they're not
+ // specified. We do this lazily to minimize issues related to insufficient
+ // system entropy. See #189
+ if (node == null || clockseq == null) {
+ var seedBytes = rng();
+ if (node == null) {
+ // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+ node = _nodeId = [
+ seedBytes[0] | 0x01,
+ seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]
+ ];
+ }
+ if (clockseq == null) {
+ // Per 4.2.2, randomize (14 bit) clockseq
+ clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
+ }
+ }
-function $getMaxListeners(that) {
- if (that._maxListeners === undefined)
- return EventEmitter.defaultMaxListeners;
- return that._maxListeners;
-}
+ // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+ // (1582-10-15 00:00). JSNumbers aren't precise enough for this, so
+ // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+ // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+ var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime();
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
- return $getMaxListeners(this);
-};
+ // Per 4.2.1.2, use count of uuid's generated during the current clock
+ // cycle to simulate higher resolution clock
+ var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1;
-// These standalone emit* functions are used to optimize calling of event
-// handlers for fast cases because emit() itself often has a variable number of
-// arguments and can be deoptimized because of that. These functions always have
-// the same number of arguments and thus do not get deoptimized, so the code
-// inside them can execute faster.
-function emitNone(handler, isFn, self) {
- if (isFn)
- handler.call(self);
- else {
- var len = handler.length;
- var listeners = arrayClone(handler, len);
- for (var i = 0; i < len; ++i)
- listeners[i].call(self);
- }
-}
-function emitOne(handler, isFn, self, arg1) {
- if (isFn)
- handler.call(self, arg1);
- else {
- var len = handler.length;
- var listeners = arrayClone(handler, len);
- for (var i = 0; i < len; ++i)
- listeners[i].call(self, arg1);
+ // Time since last uuid creation (in msecs)
+ var dt = (msecs - _lastMSecs) + (nsecs - _lastNSecs)/10000;
+
+ // Per 4.2.1.2, Bump clockseq on clock regression
+ if (dt < 0 && options.clockseq === undefined) {
+ clockseq = clockseq + 1 & 0x3fff;
}
-}
-function emitTwo(handler, isFn, self, arg1, arg2) {
- if (isFn)
- handler.call(self, arg1, arg2);
- else {
- var len = handler.length;
- var listeners = arrayClone(handler, len);
- for (var i = 0; i < len; ++i)
- listeners[i].call(self, arg1, arg2);
+
+ // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+ // time interval
+ if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
+ nsecs = 0;
}
-}
-function emitThree(handler, isFn, self, arg1, arg2, arg3) {
- if (isFn)
- handler.call(self, arg1, arg2, arg3);
- else {
- var len = handler.length;
- var listeners = arrayClone(handler, len);
- for (var i = 0; i < len; ++i)
- listeners[i].call(self, arg1, arg2, arg3);
+
+ // Per 4.2.1.2 Throw error if too many uuids are requested
+ if (nsecs >= 10000) {
+ throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
}
-}
-function emitMany(handler, isFn, self, args) {
- if (isFn)
- handler.apply(self, args);
- else {
- var len = handler.length;
- var listeners = arrayClone(handler, len);
- for (var i = 0; i < len; ++i)
- listeners[i].apply(self, args);
+ _lastMSecs = msecs;
+ _lastNSecs = nsecs;
+ _clockseq = clockseq;
+
+ // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+ msecs += 12219292800000;
+
+ // `time_low`
+ var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+ b[i++] = tl >>> 24 & 0xff;
+ b[i++] = tl >>> 16 & 0xff;
+ b[i++] = tl >>> 8 & 0xff;
+ b[i++] = tl & 0xff;
+
+ // `time_mid`
+ var tmh = (msecs / 0x100000000 * 10000) & 0xfffffff;
+ b[i++] = tmh >>> 8 & 0xff;
+ b[i++] = tmh & 0xff;
+
+ // `time_high_and_version`
+ b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+ b[i++] = tmh >>> 16 & 0xff;
+
+ // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+ b[i++] = clockseq >>> 8 | 0x80;
+
+ // `clock_seq_low`
+ b[i++] = clockseq & 0xff;
+
+ // `node`
+ for (var n = 0; n < 6; ++n) {
+ b[i + n] = node[n];
}
+
+ return buf ? buf : bytesToUuid(b);
}
-EventEmitter.prototype.emit = function emit(type) {
- var er, handler, len, args, i, events;
- var doError = (type === 'error');
+module.exports = v1;
- events = this._events;
- if (events)
- doError = (doError && events.error == null);
- else if (!doError)
- return false;
+},{"./lib/bytesToUuid":39,"./lib/rng":40}],42:[function(require,module,exports){
+var rng = require('./lib/rng');
+var bytesToUuid = require('./lib/bytesToUuid');
- // If there is no 'error' event listener then throw.
- if (doError) {
- if (arguments.length > 1)
- er = arguments[1];
- if (er instanceof Error) {
- throw er; // Unhandled 'error' event
- } else {
- // At least give some kind of context to the user
- var err = new Error('Unhandled "error" event. (' + er + ')');
- err.context = er;
- throw err;
- }
- return false;
+function v4(options, buf, offset) {
+ var i = buf && offset || 0;
+
+ if (typeof(options) == 'string') {
+ buf = options === 'binary' ? new Array(16) : null;
+ options = null;
}
+ options = options || {};
- handler = events[type];
+ var rnds = options.random || (options.rng || rng)();
- if (!handler)
- return false;
+ // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+ rnds[6] = (rnds[6] & 0x0f) | 0x40;
+ rnds[8] = (rnds[8] & 0x3f) | 0x80;
- var isFn = typeof handler === 'function';
- len = arguments.length;
- switch (len) {
- // fast cases
- case 1:
- emitNone(handler, isFn, this);
- break;
- case 2:
- emitOne(handler, isFn, this, arguments[1]);
- break;
- case 3:
- emitTwo(handler, isFn, this, arguments[1], arguments[2]);
- break;
- case 4:
- emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
- break;
- // slower
- default:
- args = new Array(len - 1);
- for (i = 1; i < len; i++)
- args[i - 1] = arguments[i];
- emitMany(handler, isFn, this, args);
+ // Copy bytes to buffer, if provided
+ if (buf) {
+ for (var ii = 0; ii < 16; ++ii) {
+ buf[i + ii] = rnds[ii];
+ }
}
- return true;
-};
-
-function _addListener(target, type, listener, prepend) {
- var m;
- var events;
- var existing;
+ return buf || bytesToUuid(rnds);
+}
- if (typeof listener !== 'function')
- throw new TypeError('"listener" argument must be a function');
+module.exports = v4;
- events = target._events;
- if (!events) {
- events = target._events = objectCreate(null);
- target._eventsCount = 0;
- } else {
- // To avoid recursion in the case that type === "newListener"! Before
- // adding it to the listeners, first emit "newListener".
- if (events.newListener) {
- target.emit('newListener', type,
- listener.listener ? listener.listener : listener);
+},{"./lib/bytesToUuid":39,"./lib/rng":40}],43:[function(require,module,exports){
+(function (Buffer){
+const Peer = require('../../server/src/peer')
+const VideoConverter = require('./lib/dist/video-converter');
+const msgpack = require('msgpack5')();
+const rematrix = require('rematrix');
+
+let current_data = {};
+let peer;
+let player;
+
+/**
+ * Validates that the user is logged in by sending the token
+ */
+checkIfLoggedIn = async () => {
+ // const token = window.localStorage.getItem('token')
+ // console.log(token)
+ // if(!token){
+ // console.log("You need to login")
+ // renderLogin()
+ // }else{
+
+ // //Check if the token is valid
+ // const response = await fetch('http://localhost:8080/auth/validation', {
+ // method: 'POST',
+ // headers: {'Authorization': token}
+ // })
+ // console.log('RESPONSE', response)
+
+ // //Token is valid, show available streams
+ // if(response.status === 200){
+ // console.log("SUCCESS")
+ renderThumbnails()
+
+ // }
+ // }
+}
+
+/**
+ * Returns a list of available streams
+ */
+getAvailableStreams = async () => {
+ try{
+ const streamsInJson = await fetch(`./streams`);
+ const streams = await streamsInJson.json();
+ console.log('AVAILABLE', streams)
+ return streams;
+ }catch(err){
+ console.log(err)
+ }
+}
+
+
+createVideoPlayer = () => {
+ const containerDiv = document.getElementById('container');
+ containerDiv.innerHTML = '';
+ /*containerDiv.innerHTML = `<h1>Stream from source ${current_data.uri}</h1><br>
+ <button onclick="renderThumbnails(); closeStream()">Go back</button>
+ <button onclick="connectToStream('${current_data.uri}')">Start Stream</button><br>
+ <button onclick="webSocketTest()">WebSocket Test</button><br>
+ <video id="ftlab-stream-video" width="640" height="360"></video>`;
+ containerDiv.innerHTML += '<br>'
+ containerDiv.innerHTML += ''*/
+ createPeer();
+ //connectToStream();
+ new FTLStream(peer, current_data.uri, containerDiv);
+}
+
+/**
+ * Creates thumbnail (image) for all available streams and adds them to div class='container'
+ */
+renderThumbnails = async () => {
+ const thumbnails = await getAvailableStreams();
+ const containerDiv = document.getElementById('container')
+ containerDiv.innerHTML = '';
+ containerDiv.innerHTML = `<button onClick="configs()">change configs</button>`
+ containerDiv.innerHTML += `<div class="ftlab-stream-thumbnails"></div>`
+ if(thumbnails.length === 0){
+ containerDiv.innerHTML = `<h3>No streams running currently</h3>`
+ }else{
+ for(var i=0; i<thumbnails.length; i++){
+ const encodedURI = encodeURIComponent(thumbnails[i])
+ current_data.uri = thumbnails[i]
+ try{
+ const someData = await fetch(`./stream/rgb?uri=${encodedURI}`)
+ if(!someData.ok){
+ throw new Error('Image not found')
+ }
+ const myBlob = await someData.blob();
+ const objectURL = URL.createObjectURL(myBlob);
+ // containerDiv.innerHTML += createCard()
+ containerDiv.innerHTML += createCard(objectURL, i+4)
+ }catch(err){
+ console.log("Couldn't create thumbnail");
+ console.log(err)
+ }
+ }
+ }
+}
+
+
+/**
+ * Method to create a single thumbnail
+ */
+createCard = (url, viewers) => {
+ return `<div class='ftlab-card-component' >
+ <img src='${url}' class="thumbnail-img" alt="Hups" width="250px"></img>
+ <p>Viewers: ${viewers}</p>
+ <button onclick="createVideoPlayer()">button</button>
+ </div>`
+}
+
+
+createPeer = () => {
+ // FOR PRODUCTION
+ console.log("HOST", location.host);
+ const ws = new WebSocket("ws://" + location.host + location.pathname);
+ //const ws = new WebSocket("ws://localhost:8080")
+ ws.binaryType = "arraybuffer";
+ peer = new Peer(ws)
+}
+
+webSocketTest = () => {
+ peer.send("update_cfg", "ftl://utu.fi#reconstruction_default/0/renderer/cool_effect", "true")
+}
+
+function FTLStream(peer, uri, element) {
+ this.uri = uri;
+ this.peer = peer;
+
+ this.current = "";
+ this.current_fs = 0;
+ this.current_source = 0;
+ this.current_channel = 0;
+
+ //this.elements_ = {};
+ //this.converters_ = {};
+
+ //const element = document.getElementById('ftlab-stream-video');
+ this.outer = element;
+ this.element = document.createElement("VIDEO");
+ this.element.setAttribute("width", 640);
+ this.element.setAttribute("height", 360);
+ this.element.setAttribute("controls", true);
+ this.outer.appendChild(this.element);
+ this.play_button = document.createElement("BUTTON");
+ this.play_button.innerHTML = "Play";
+ this.play_button.onclick = () => {
+ this.start(0,0,0);
+ }
+ this.outer.appendChild(this.play_button);
+
+ this.element.onclick = () => {
+ //let pose = [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];
+ let pose = rematrix.rotateZ(45);
+ this.setPose(pose);
+ }
+
+ this.converter = null;
+
+ let rxcount = 0;
+ let ts = 0;
+ let dts = 0;
+
+ this.peer.bind(uri, (latency, streampckg, pckg) => {
+ if(pckg[0] === 2){ // H264 packet.
+ let id = "id-"+streampckg[1]+"-"+streampckg[2]+"-"+streampckg[3];
+
+ if (this.current == id) {
+ rxcount++;
+ if (rxcount >= 25) {
+ rxcount = 0;
+ peer.send(uri, 0, [1,0,255,0],[255,7,35,0,0,Buffer.alloc(0)]);
+ //peer.send(current_data.uri, 0, [255,7,35,0,0,Buffer.alloc(0)], [1,0,255,0]);
+ }
+
+ if (this.converter) {
+ /*function decode(value){
+ this.converter.appendRawData(value);
+ }
+ decode(pckg[5]);*/
+ this.converter.appendRawData(pckg[5]);
+ this.converter.play();
+ } else {
+ if (ts > 0) {
+ dts = streampckg[0] - ts;
+ console.log("Framerate = ", 1000/dts);
+ this.converter = new VideoConverter.default(this.element, 30, 1);
+ }
+ ts = streampckg[0];
+ }
+ }
+ } else if (pckg[0] === 103) {
+ //console.log(msgpack.decode(pckg[5]));
+ }
+ });
+
+ //this.start();
+}
+
+FTLStream.prototype.setPose = function(pose) {
+ if (pose.length != 16) {
+ console.error("Invalid pose");
+ return;
+ }
+ this.peer.send(this.uri, 0, [1, this.current_fs, this.current_source, 66],
+ [103, 7, 1, 0, 0, msgpack.encode(pose)]);
+}
+
+FTLStream.prototype.start = function(fs, source, channel) {
+ let id = "id-"+fs+"-"+source+"-"+channel;
+ this.current = id;
+ this.current_fs = fs;
+ this.current_source = source;
+ this.current_channel = channel;
+
+ if (this.found) {
+ this.peer.send(this.uri, 0, [1,fs,255,channel],[255,7,35,0,0,Buffer.alloc(0)]);
+ } else {
+ this.peer.rpc("find_stream", (res) => {
+ this.found = true;
+ this.peer.send(this.uri, 0, [1,fs,255,channel],[255,7,35,0,0,Buffer.alloc(0)]);
+ }, this.uri);
+ }
+}
+
+
+/*connectToStream = () => {
+ const element = document.getElementById('ftlab-stream-video');
+ let converter = null;
+
+ let rxcount = 0;
+ let ts = 0;
+ let dts = 0;
+
+ peer.bind(current_data.uri, (latency, streampckg, pckg) => {
+ if(pckg[0] === 2){
+ rxcount++;
+ if (rxcount >= 25) {
+ rxcount = 0;
+ peer.send(current_data.uri, 0, [1,0,255,0],[255,7,35,0,0,Buffer.alloc(0)]);
+ //peer.send(current_data.uri, 0, [255,7,35,0,0,Buffer.alloc(0)], [1,0,255,0]);
+ }
+
+ if (converter) {
+ function decode(value){
+ converter.appendRawData(value);
+ }
+ decode(pckg[5]);
+ converter.play();
+ } else {
+ if (ts > 0) {
+ dts = streampckg[0] - ts;
+ console.log("Framerate = ", 1000/dts);
+ converter = new VideoConverter.default(element, 30, 1);
+ }
+ ts = streampckg[0];
+ }
+ } else if (pckg[0] === 103) {
+ console.log(msgpack.decode(pckg[5]));
+ }
+ })
+
+ // Start the transaction
+ //peer.send("get_stream", (current_data.uri, 30, 0, current_data.uri));
+
+ peer.rpc("find_stream", (res) => {
+ peer.send(current_data.uri, 0, [1,0,255,0],[255,7,35,0,0,Buffer.alloc(0)]);
+ //peer.send(current_data.uri, [255,7,35,0,0,Buffer.alloc(0)], [1,0,255,0]);
+ }, current_data.uri);
+}*/
+
+closeStream = () => {
+ peer.sock.close()
+}
+
+
+
+/**
+ * **************
+ * CONFIGURATIONS
+ * **************
+ */
+
+
+current_data.configURI = "ftl://utu.fi#reconstruction_snap8/net"
+
+configs = () => {
+ const container = document.getElementById("container");
+ container.innerHTML = `<div class="ftlab-configurations"></div>`;
+ renderConfigOptions();
+}
+
+
+renderConfigOptions = () => {
+ const input = `<p>input1</p><br>ftl://utu.fi#<input type="text">`
+ const doc = document.getElementsByClassName('ftlab-configurations')[0];
+ doc.innerHTML = input;
+}
+
+/**
+ *
+ */
+loadConfigs = async (str) => {
+ const configURI = encodeURIComponent(`ftl://utu.fi#reconstruction_snap8${str}`);
+ const uri = encodeURIComponent(current_data.uri)
+ const rawResp = await fetch(`./stream/config?settings=${configURI}&uri=${uri}`)
+ const response = await rawResp.json();
+ const content = JSON.parse(response);
+ container.innerHTML += `<p>${response}</p>`;
+}
+
+// current_data.configData = '{"peers": 1}';
+
+/**
+ * Method to send configurations to backend
+ */
+saveConfigs = async () => {
+ let {uri, configURI, configData} = current_data
+ const rawResp = await fetch('./stream/config', {
+ method: 'POST',
+ headers: {
+ 'Accept': 'application/json',
+ 'Content-Type': 'application/json'
+ },
+ body: JSON.stringify({peerURI: uri, configURI, data: configData, saveToCPP: true})
+ });
+ const content = await rawResp.json();
+}
+}).call(this,require("buffer").Buffer)
+},{"../../server/src/peer":52,"./lib/dist/video-converter":51,"buffer":8,"msgpack5":15,"rematrix":31}],44:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var bit_stream_1 = require("./util/bit-stream");
+var debug = require("./util/debug");
+var NALU_1 = require("./util/NALU");
+var H264Parser = (function () {
+ function H264Parser(remuxer) {
+ this.remuxer = remuxer;
+ this.track = remuxer.mp4track;
+ }
+ H264Parser.prototype.parseSEI = function (sei) {
+ var messages = H264Parser.readSEI(sei);
+ for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) {
+ var m = messages_1[_i];
+ switch (m.type) {
+ case 0:
+ this.track.seiBuffering = true;
+ break;
+ case 5:
+ return true;
+ default:
+ break;
+ }
+ }
+ return false;
+ };
+ H264Parser.prototype.parseSPS = function (sps) {
+ var config = H264Parser.readSPS(sps);
+ this.track.width = config.width;
+ this.track.height = config.height;
+ this.track.sps = [sps];
+ this.track.codec = 'avc1.';
+ var codecArray = new DataView(sps.buffer, sps.byteOffset + 1, 4);
+ for (var i = 0; i < 3; ++i) {
+ var h = codecArray.getUint8(i).toString(16);
+ if (h.length < 2) {
+ h = '0' + h;
+ }
+ this.track.codec += h;
+ }
+ };
+ H264Parser.prototype.parsePPS = function (pps) {
+ this.track.pps = [pps];
+ };
+ H264Parser.prototype.parseNAL = function (unit) {
+ if (!unit) {
+ return false;
+ }
+ var push = false;
+ switch (unit.type()) {
+ case NALU_1.default.NDR:
+ case NALU_1.default.IDR:
+ push = true;
+ break;
+ case NALU_1.default.SEI:
+ push = this.parseSEI(unit.getData().subarray(4));
+ break;
+ case NALU_1.default.SPS:
+ if (this.track.sps.length === 0) {
+ this.parseSPS(unit.getData().subarray(4));
+ debug.log(" Found SPS type NALU frame.");
+ if (!this.remuxer.readyToDecode && this.track.pps.length > 0 && this.track.sps.length > 0) {
+ this.remuxer.readyToDecode = true;
+ }
+ }
+ break;
+ case NALU_1.default.PPS:
+ if (this.track.pps.length === 0) {
+ this.parsePPS(unit.getData().subarray(4));
+ debug.log(" Found PPS type NALU frame.");
+ if (!this.remuxer.readyToDecode && this.track.pps.length > 0 && this.track.sps.length > 0) {
+ this.remuxer.readyToDecode = true;
+ }
+ }
+ break;
+ default:
+ debug.log(" Found Unknown type NALU frame. type=" + unit.type());
+ break;
+ }
+ return push;
+ };
+ H264Parser.skipScalingList = function (decoder, count) {
+ var lastScale = 8;
+ var nextScale = 8;
+ for (var j = 0; j < count; j++) {
+ if (nextScale !== 0) {
+ var deltaScale = decoder.readEG();
+ nextScale = (lastScale + deltaScale + 256) % 256;
+ }
+ lastScale = (nextScale === 0) ? lastScale : nextScale;
+ }
+ };
+ H264Parser.readSPS = function (data) {
+ var decoder = new bit_stream_1.default(data);
+ var frameCropLeftOffset = 0;
+ var frameCropRightOffset = 0;
+ var frameCropTopOffset = 0;
+ var frameCropBottomOffset = 0;
+ var sarScale = 1;
+ decoder.readUByte();
+ var profileIdc = decoder.readUByte();
+ decoder.skipBits(5);
+ decoder.skipBits(3);
+ decoder.skipBits(8);
+ decoder.skipUEG();
+ if (profileIdc === 100 ||
+ profileIdc === 110 ||
+ profileIdc === 122 ||
+ profileIdc === 244 ||
+ profileIdc === 44 ||
+ profileIdc === 83 ||
+ profileIdc === 86 ||
+ profileIdc === 118 ||
+ profileIdc === 128) {
+ var chromaFormatIdc = decoder.readUEG();
+ if (chromaFormatIdc === 3) {
+ decoder.skipBits(1);
+ }
+ decoder.skipUEG();
+ decoder.skipUEG();
+ decoder.skipBits(1);
+ if (decoder.readBoolean()) {
+ var scalingListCount = (chromaFormatIdc !== 3) ? 8 : 12;
+ for (var i = 0; i < scalingListCount; ++i) {
+ if (decoder.readBoolean()) {
+ if (i < 6) {
+ H264Parser.skipScalingList(decoder, 16);
+ }
+ else {
+ H264Parser.skipScalingList(decoder, 64);
+ }
+ }
+ }
+ }
+ }
+ decoder.skipUEG();
+ var picOrderCntType = decoder.readUEG();
+ if (picOrderCntType === 0) {
+ decoder.readUEG();
+ }
+ else if (picOrderCntType === 1) {
+ decoder.skipBits(1);
+ decoder.skipEG();
+ decoder.skipEG();
+ var numRefFramesInPicOrderCntCycle = decoder.readUEG();
+ for (var i = 0; i < numRefFramesInPicOrderCntCycle; ++i) {
+ decoder.skipEG();
+ }
+ }
+ decoder.skipUEG();
+ decoder.skipBits(1);
+ var picWidthInMbsMinus1 = decoder.readUEG();
+ var picHeightInMapUnitsMinus1 = decoder.readUEG();
+ var frameMbsOnlyFlag = decoder.readBits(1);
+ if (frameMbsOnlyFlag === 0) {
+ decoder.skipBits(1);
+ }
+ decoder.skipBits(1);
+ if (decoder.readBoolean()) {
+ frameCropLeftOffset = decoder.readUEG();
+ frameCropRightOffset = decoder.readUEG();
+ frameCropTopOffset = decoder.readUEG();
+ frameCropBottomOffset = decoder.readUEG();
+ }
+ if (decoder.readBoolean()) {
+ if (decoder.readBoolean()) {
+ var sarRatio = void 0;
+ var aspectRatioIdc = decoder.readUByte();
+ switch (aspectRatioIdc) {
+ case 1:
+ sarRatio = [1, 1];
+ break;
+ case 2:
+ sarRatio = [12, 11];
+ break;
+ case 3:
+ sarRatio = [10, 11];
+ break;
+ case 4:
+ sarRatio = [16, 11];
+ break;
+ case 5:
+ sarRatio = [40, 33];
+ break;
+ case 6:
+ sarRatio = [24, 11];
+ break;
+ case 7:
+ sarRatio = [20, 11];
+ break;
+ case 8:
+ sarRatio = [32, 11];
+ break;
+ case 9:
+ sarRatio = [80, 33];
+ break;
+ case 10:
+ sarRatio = [18, 11];
+ break;
+ case 11:
+ sarRatio = [15, 11];
+ break;
+ case 12:
+ sarRatio = [64, 33];
+ break;
+ case 13:
+ sarRatio = [160, 99];
+ break;
+ case 14:
+ sarRatio = [4, 3];
+ break;
+ case 15:
+ sarRatio = [3, 2];
+ break;
+ case 16:
+ sarRatio = [2, 1];
+ break;
+ case 255: {
+ sarRatio = [decoder.readUByte() << 8 | decoder.readUByte(), decoder.readUByte() << 8 | decoder.readUByte()];
+ break;
+ }
+ default: {
+ debug.error(" H264: Unknown aspectRatioIdc=" + aspectRatioIdc);
+ }
+ }
+ if (sarRatio) {
+ sarScale = sarRatio[0] / sarRatio[1];
+ }
+ }
+ if (decoder.readBoolean()) {
+ decoder.skipBits(1);
+ }
+ if (decoder.readBoolean()) {
+ decoder.skipBits(4);
+ if (decoder.readBoolean()) {
+ decoder.skipBits(24);
+ }
+ }
+ if (decoder.readBoolean()) {
+ decoder.skipUEG();
+ decoder.skipUEG();
+ }
+ if (decoder.readBoolean()) {
+ var unitsInTick = decoder.readUInt();
+ var timeScale = decoder.readUInt();
+ var fixedFrameRate = decoder.readBoolean();
+ var frameDuration = timeScale / (2 * unitsInTick);
+ debug.log("timescale: " + timeScale + "; unitsInTick: " + unitsInTick + "; " +
+ ("fixedFramerate: " + fixedFrameRate + "; avgFrameDuration: " + frameDuration));
+ }
+ }
+ return {
+ width: Math.ceil((((picWidthInMbsMinus1 + 1) * 16) - frameCropLeftOffset * 2 - frameCropRightOffset * 2) * sarScale),
+ height: ((2 - frameMbsOnlyFlag) * (picHeightInMapUnitsMinus1 + 1) * 16) -
+ ((frameMbsOnlyFlag ? 2 : 4) * (frameCropTopOffset + frameCropBottomOffset)),
+ };
+ };
+ H264Parser.readSEI = function (data) {
+ var decoder = new bit_stream_1.default(data);
+ decoder.skipBits(8);
+ var result = [];
+ while (decoder.bitsAvailable > 3 * 8) {
+ result.push(this.readSEIMessage(decoder));
+ }
+ return result;
+ };
+ H264Parser.readSEIMessage = function (decoder) {
+ function get() {
+ var result = 0;
+ while (true) {
+ var value = decoder.readUByte();
+ result += value;
+ if (value !== 0xff) {
+ break;
+ }
+ }
+ return result;
+ }
+ var payloadType = get();
+ var payloadSize = get();
+ return this.readSEIPayload(decoder, payloadType, payloadSize);
+ };
+ H264Parser.readSEIPayload = function (decoder, type, size) {
+ var result;
+ switch (type) {
+ default:
+ result = { type: type };
+ decoder.skipBits(size * 8);
+ }
+ decoder.skipBits(decoder.bitsAvailable % 8);
+ return result;
+ };
+ return H264Parser;
+}());
+exports.default = H264Parser;
- // Re-assign `events` because a newListener handler could have caused the
- // this._events to be assigned to a new object
- events = target._events;
+},{"./util/NALU":47,"./util/bit-stream":48,"./util/debug":49}],45:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var h264_parser_1 = require("./h264-parser");
+var debug = require("./util/debug");
+var NALU_1 = require("./util/NALU");
+var trackId = 1;
+var H264Remuxer = (function () {
+ function H264Remuxer(fps, framePerFragment, timescale) {
+ this.fps = fps;
+ this.framePerFragment = framePerFragment;
+ this.timescale = timescale;
+ this.readyToDecode = false;
+ this.totalDTS = 0;
+ this.stepDTS = Math.round(this.timescale / this.fps);
+ this.frameCount = 0;
+ this.seq = 1;
+ this.mp4track = {
+ id: H264Remuxer.getTrackID(),
+ type: 'video',
+ len: 0,
+ codec: '',
+ sps: [],
+ pps: [],
+ seiBuffering: false,
+ width: 0,
+ height: 0,
+ timescale: timescale,
+ duration: timescale,
+ samples: [],
+ isKeyFrame: true,
+ };
+ this.unitSamples = [[]];
+ this.parser = new h264_parser_1.default(this);
}
- existing = events[type];
- }
+ H264Remuxer.getTrackID = function () {
+ return trackId++;
+ };
+ Object.defineProperty(H264Remuxer.prototype, "seqNum", {
+ get: function () {
+ return this.seq;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ H264Remuxer.prototype.remux = function (nalu) {
+ if (this.mp4track.seiBuffering && nalu.type() === NALU_1.default.SEI) {
+ return this.createNextFrame();
+ }
+ if (this.parser.parseNAL(nalu)) {
+ this.unitSamples[this.unitSamples.length - 1].push(nalu);
+ this.mp4track.len += nalu.getSize();
+ }
+ if (!this.mp4track.seiBuffering && (nalu.type() === NALU_1.default.IDR || nalu.type() === NALU_1.default.NDR)) {
+ return this.createNextFrame();
+ }
+ return;
+ };
+ H264Remuxer.prototype.createNextFrame = function () {
+ if (this.mp4track.len > 0) {
+ this.frameCount++;
+ if (this.frameCount % this.framePerFragment === 0) {
+ var fragment = this.getFragment();
+ if (fragment) {
+ var dts = this.totalDTS;
+ this.totalDTS = this.stepDTS * this.frameCount;
+ return [dts, fragment];
+ }
+ else {
+ debug.log("No mp4 sample data.");
+ }
+ }
+ this.unitSamples.push([]);
+ }
+ return;
+ };
+ H264Remuxer.prototype.flush = function () {
+ this.seq++;
+ this.mp4track.len = 0;
+ this.mp4track.samples = [];
+ this.mp4track.isKeyFrame = false;
+ this.unitSamples = [[]];
+ };
+ H264Remuxer.prototype.getFragment = function () {
+ if (!this.checkReadyToDecode()) {
+ return undefined;
+ }
+ var payload = new Uint8Array(this.mp4track.len);
+ this.mp4track.samples = [];
+ var offset = 0;
+ for (var i = 0, len = this.unitSamples.length; i < len; i++) {
+ var units = this.unitSamples[i];
+ if (units.length === 0) {
+ continue;
+ }
+ var mp4Sample = {
+ size: 0,
+ cts: this.stepDTS * i,
+ };
+ for (var _i = 0, units_1 = units; _i < units_1.length; _i++) {
+ var unit = units_1[_i];
+ mp4Sample.size += unit.getSize();
+ payload.set(unit.getData(), offset);
+ offset += unit.getSize();
+ }
+ this.mp4track.samples.push(mp4Sample);
+ }
+ if (offset === 0) {
+ return undefined;
+ }
+ return payload;
+ };
+ H264Remuxer.prototype.checkReadyToDecode = function () {
+ if (!this.readyToDecode || this.unitSamples.filter(function (array) { return array.length > 0; }).length === 0) {
+ debug.log("Not ready to decode! readyToDecode(" + this.readyToDecode + ") is false or units is empty.");
+ return false;
+ }
+ return true;
+ };
+ return H264Remuxer;
+}());
+exports.default = H264Remuxer;
- if (!existing) {
- // Optimize the case of one listener. Don't need the extra array object.
- existing = events[type] = listener;
- ++target._eventsCount;
- } else {
- if (typeof existing === 'function') {
- // Adding the second element, need to change to array.
- existing = events[type] =
- prepend ? [listener, existing] : [existing, listener];
- } else {
- // If we've already got an array, just append.
- if (prepend) {
- existing.unshift(listener);
- } else {
- existing.push(listener);
- }
+},{"./h264-parser":44,"./util/NALU":47,"./util/debug":49}],46:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var MP4 = (function () {
+ function MP4() {
}
-
- // Check for listener leak
- if (!existing.warned) {
- m = $getMaxListeners(target);
- if (m && m > 0 && existing.length > m) {
- existing.warned = true;
- var w = new Error('Possible EventEmitter memory leak detected. ' +
- existing.length + ' "' + String(type) + '" listeners ' +
- 'added. Use emitter.setMaxListeners() to ' +
- 'increase limit.');
- w.name = 'MaxListenersExceededWarning';
- w.emitter = target;
- w.type = type;
- w.count = existing.length;
- if (typeof console === 'object' && console.warn) {
- console.warn('%s: %s', w.name, w.message);
+ MP4.init = function () {
+ MP4.initalized = true;
+ MP4.types = {
+ avc1: [],
+ avcC: [],
+ btrt: [],
+ dinf: [],
+ dref: [],
+ esds: [],
+ ftyp: [],
+ hdlr: [],
+ mdat: [],
+ mdhd: [],
+ mdia: [],
+ mfhd: [],
+ minf: [],
+ moof: [],
+ moov: [],
+ mp4a: [],
+ mvex: [],
+ mvhd: [],
+ sdtp: [],
+ stbl: [],
+ stco: [],
+ stsc: [],
+ stsd: [],
+ stsz: [],
+ stts: [],
+ styp: [],
+ tfdt: [],
+ tfhd: [],
+ traf: [],
+ trak: [],
+ trun: [],
+ trep: [],
+ trex: [],
+ tkhd: [],
+ vmhd: [],
+ smhd: [],
+ };
+ for (var type in MP4.types) {
+ if (MP4.types.hasOwnProperty(type)) {
+ MP4.types[type] = [
+ type.charCodeAt(0),
+ type.charCodeAt(1),
+ type.charCodeAt(2),
+ type.charCodeAt(3),
+ ];
+ }
+ }
+ var hdlr = new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x76, 0x69, 0x64, 0x65,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x56, 0x69, 0x64, 0x65,
+ 0x6f, 0x48, 0x61, 0x6e,
+ 0x64, 0x6c, 0x65, 0x72, 0x00,
+ ]);
+ var dref = new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x0c,
+ 0x75, 0x72, 0x6c, 0x20,
+ 0x00,
+ 0x00, 0x00, 0x01,
+ ]);
+ var stco = new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ ]);
+ MP4.STTS = MP4.STSC = MP4.STCO = stco;
+ MP4.STSZ = new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ ]);
+ MP4.VMHD = new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x01,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ ]);
+ MP4.SMHD = new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ ]);
+ MP4.STSD = new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x01
+ ]);
+ MP4.FTYP = MP4.box(MP4.types.ftyp, new Uint8Array([
+ 0x69, 0x73, 0x6f, 0x35,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x61, 0x76, 0x63, 0x31,
+ 0x69, 0x73, 0x6f, 0x35,
+ 0x64, 0x61, 0x73, 0x68,
+ ]));
+ MP4.STYP = MP4.box(MP4.types.styp, new Uint8Array([
+ 0x6d, 0x73, 0x64, 0x68,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x6d, 0x73, 0x64, 0x68,
+ 0x6d, 0x73, 0x69, 0x78,
+ ]));
+ MP4.DINF = MP4.box(MP4.types.dinf, MP4.box(MP4.types.dref, dref));
+ MP4.HDLR = MP4.box(MP4.types.hdlr, hdlr);
+ };
+ MP4.box = function (type) {
+ var payload = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ payload[_i - 1] = arguments[_i];
+ }
+ var size = 8;
+ for (var _a = 0, payload_1 = payload; _a < payload_1.length; _a++) {
+ var p = payload_1[_a];
+ size += p.byteLength;
+ }
+ var result = new Uint8Array(size);
+ result[0] = (size >> 24) & 0xff;
+ result[1] = (size >> 16) & 0xff;
+ result[2] = (size >> 8) & 0xff;
+ result[3] = size & 0xff;
+ result.set(type, 4);
+ size = 8;
+ for (var _b = 0, payload_2 = payload; _b < payload_2.length; _b++) {
+ var box = payload_2[_b];
+ result.set(box, size);
+ size += box.byteLength;
+ }
+ return result;
+ };
+ MP4.mdat = function (data) {
+ return MP4.box(MP4.types.mdat, data);
+ };
+ MP4.mdhd = function (timescale) {
+ return MP4.box(MP4.types.mdhd, new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x02,
+ (timescale >> 24) & 0xFF,
+ (timescale >> 16) & 0xFF,
+ (timescale >> 8) & 0xFF,
+ timescale & 0xFF,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x55, 0xc4,
+ 0x00, 0x00,
+ ]));
+ };
+ MP4.mdia = function (track) {
+ return MP4.box(MP4.types.mdia, MP4.mdhd(track.timescale), MP4.HDLR, MP4.minf(track));
+ };
+ MP4.mfhd = function (sequenceNumber) {
+ return MP4.box(MP4.types.mfhd, new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ (sequenceNumber >> 24),
+ (sequenceNumber >> 16) & 0xFF,
+ (sequenceNumber >> 8) & 0xFF,
+ sequenceNumber & 0xFF,
+ ]));
+ };
+ MP4.minf = function (track) {
+ return MP4.box(MP4.types.minf, MP4.box(MP4.types.vmhd, MP4.VMHD), MP4.DINF, MP4.stbl(track));
+ };
+ MP4.moof = function (sn, baseMediaDecodeTime, track) {
+ return MP4.box(MP4.types.moof, MP4.mfhd(sn), MP4.traf(track, baseMediaDecodeTime));
+ };
+ MP4.moov = function (tracks, duration, timescale) {
+ var boxes = [];
+ for (var _i = 0, tracks_1 = tracks; _i < tracks_1.length; _i++) {
+ var track = tracks_1[_i];
+ boxes.push(MP4.trak(track));
+ }
+ return MP4.box.apply(MP4, [MP4.types.moov, MP4.mvhd(timescale, duration), MP4.mvex(tracks)].concat(boxes));
+ };
+ MP4.mvhd = function (timescale, duration) {
+ var bytes = new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x02,
+ (timescale >> 24) & 0xFF,
+ (timescale >> 16) & 0xFF,
+ (timescale >> 8) & 0xFF,
+ timescale & 0xFF,
+ (duration >> 24) & 0xFF,
+ (duration >> 16) & 0xFF,
+ (duration >> 8) & 0xFF,
+ duration & 0xFF,
+ 0x00, 0x01, 0x00, 0x00,
+ 0x01, 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x40, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x02,
+ ]);
+ return MP4.box(MP4.types.mvhd, bytes);
+ };
+ MP4.mvex = function (tracks) {
+ var boxes = [];
+ for (var _i = 0, tracks_2 = tracks; _i < tracks_2.length; _i++) {
+ var track = tracks_2[_i];
+ boxes.push(MP4.trex(track));
+ }
+ return MP4.box.apply(MP4, [MP4.types.mvex].concat(boxes, [MP4.trep()]));
+ };
+ MP4.trep = function () {
+ return MP4.box(MP4.types.trep, new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x01,
+ ]));
+ };
+ MP4.stbl = function (track) {
+ return MP4.box(MP4.types.stbl, MP4.stsd(track), MP4.box(MP4.types.stts, MP4.STTS), MP4.box(MP4.types.stsc, MP4.STSC), MP4.box(MP4.types.stsz, MP4.STSZ), MP4.box(MP4.types.stco, MP4.STCO));
+ };
+ MP4.avc1 = function (track) {
+ var sps = [];
+ var pps = [];
+ for (var _i = 0, _a = track.sps; _i < _a.length; _i++) {
+ var data = _a[_i];
+ var len = data.byteLength;
+ sps.push((len >>> 8) & 0xFF);
+ sps.push((len & 0xFF));
+ sps = sps.concat(Array.prototype.slice.call(data));
+ }
+ for (var _b = 0, _c = track.pps; _b < _c.length; _b++) {
+ var data = _c[_b];
+ var len = data.byteLength;
+ pps.push((len >>> 8) & 0xFF);
+ pps.push((len & 0xFF));
+ pps = pps.concat(Array.prototype.slice.call(data));
+ }
+ var avcc = MP4.box(MP4.types.avcC, new Uint8Array([
+ 0x01,
+ sps[3],
+ sps[4],
+ sps[5],
+ 0xfc | 3,
+ 0xE0 | track.sps.length,
+ ].concat(sps).concat([
+ track.pps.length,
+ ]).concat(pps)));
+ var width = track.width;
+ var height = track.height;
+ return MP4.box(MP4.types.avc1, new Uint8Array([
+ 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x01,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ (width >> 8) & 0xFF,
+ width & 0xff,
+ (height >> 8) & 0xFF,
+ height & 0xff,
+ 0x00, 0x48, 0x00, 0x00,
+ 0x00, 0x48, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01,
+ 0x12,
+ 0x62, 0x69, 0x6E, 0x65,
+ 0x6C, 0x70, 0x72, 0x6F,
+ 0x2E, 0x72, 0x75, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00,
+ 0x00, 0x18,
+ 0x11, 0x11
+ ]), avcc, MP4.box(MP4.types.btrt, new Uint8Array([
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x2d, 0xc6, 0xc0,
+ 0x00, 0x2d, 0xc6, 0xc0,
+ ])));
+ };
+ MP4.stsd = function (track) {
+ return MP4.box(MP4.types.stsd, MP4.STSD, MP4.avc1(track));
+ };
+ MP4.tkhd = function (track) {
+ var id = track.id;
+ var width = track.width;
+ var height = track.height;
+ return MP4.box(MP4.types.tkhd, new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x02,
+ (id >> 24) & 0xFF,
+ (id >> 16) & 0xFF,
+ (id >> 8) & 0xFF,
+ id & 0xFF,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00,
+ 0x00, 0x00,
+ (track.type === 'audio' ? 0x01 : 0x00), 0x00,
+ 0x00, 0x00,
+ 0x00, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x40, 0x00, 0x00, 0x00,
+ (width >> 8) & 0xFF,
+ width & 0xFF,
+ 0x00, 0x00,
+ (height >> 8) & 0xFF,
+ height & 0xFF,
+ 0x00, 0x00,
+ ]));
+ };
+ MP4.traf = function (track, baseMediaDecodeTime) {
+ var id = track.id;
+ return MP4.box(MP4.types.traf, MP4.box(MP4.types.tfhd, new Uint8Array([
+ 0x00,
+ 0x02, 0x00, 0x00,
+ (id >> 24),
+ (id >> 16) & 0XFF,
+ (id >> 8) & 0XFF,
+ (id & 0xFF),
+ ])), MP4.box(MP4.types.tfdt, new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ (baseMediaDecodeTime >> 24),
+ (baseMediaDecodeTime >> 16) & 0XFF,
+ (baseMediaDecodeTime >> 8) & 0XFF,
+ (baseMediaDecodeTime & 0xFF),
+ ])), MP4.trun(track, 16 +
+ 16 +
+ 8 +
+ 16 +
+ 8 +
+ 8));
+ };
+ MP4.trak = function (track) {
+ track.duration = track.duration || 0xffffffff;
+ return MP4.box(MP4.types.trak, MP4.tkhd(track), MP4.mdia(track));
+ };
+ MP4.trex = function (track) {
+ var id = track.id;
+ return MP4.box(MP4.types.trex, new Uint8Array([
+ 0x00,
+ 0x00, 0x00, 0x00,
+ (id >> 24),
+ (id >> 16) & 0XFF,
+ (id >> 8) & 0XFF,
+ (id & 0xFF),
+ 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x3c,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x01, 0x00, 0x00,
+ ]));
+ };
+ MP4.trun = function (track, offset) {
+ var samples = track.samples || [];
+ var len = samples.length;
+ var additionalLen = track.isKeyFrame ? 4 : 0;
+ var arraylen = 12 + additionalLen + (4 * len);
+ var array = new Uint8Array(arraylen);
+ offset += 8 + arraylen;
+ array.set([
+ 0x00,
+ 0x00, 0x02, (track.isKeyFrame ? 0x05 : 0x01),
+ (len >>> 24) & 0xFF,
+ (len >>> 16) & 0xFF,
+ (len >>> 8) & 0xFF,
+ len & 0xFF,
+ (offset >>> 24) & 0xFF,
+ (offset >>> 16) & 0xFF,
+ (offset >>> 8) & 0xFF,
+ offset & 0xFF,
+ ], 0);
+ if (track.isKeyFrame) {
+ array.set([
+ 0x00, 0x00, 0x00, 0x00,
+ ], 12);
}
- }
- }
- }
-
- return target;
-}
-
-EventEmitter.prototype.addListener = function addListener(type, listener) {
- return _addListener(this, type, listener, false);
-};
-
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-EventEmitter.prototype.prependListener =
- function prependListener(type, listener) {
- return _addListener(this, type, listener, true);
+ for (var i = 0; i < len; i++) {
+ var sample = samples[i];
+ var size = sample.size;
+ array.set([
+ (size >>> 24) & 0xFF,
+ (size >>> 16) & 0xFF,
+ (size >>> 8) & 0xFF,
+ size & 0xFF,
+ ], 12 + additionalLen + 4 * i);
+ }
+ return MP4.box(MP4.types.trun, array);
};
-
-function onceWrapper() {
- if (!this.fired) {
- this.target.removeListener(this.type, this.wrapFn);
- this.fired = true;
- switch (arguments.length) {
- case 0:
- return this.listener.call(this.target);
- case 1:
- return this.listener.call(this.target, arguments[0]);
- case 2:
- return this.listener.call(this.target, arguments[0], arguments[1]);
- case 3:
- return this.listener.call(this.target, arguments[0], arguments[1],
- arguments[2]);
- default:
- var args = new Array(arguments.length);
- for (var i = 0; i < args.length; ++i)
- args[i] = arguments[i];
- this.listener.apply(this.target, args);
- }
- }
-}
-
-function _onceWrap(target, type, listener) {
- var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
- var wrapped = bind.call(onceWrapper, state);
- wrapped.listener = listener;
- state.wrapFn = wrapped;
- return wrapped;
-}
-
-EventEmitter.prototype.once = function once(type, listener) {
- if (typeof listener !== 'function')
- throw new TypeError('"listener" argument must be a function');
- this.on(type, _onceWrap(this, type, listener));
- return this;
-};
-
-EventEmitter.prototype.prependOnceListener =
- function prependOnceListener(type, listener) {
- if (typeof listener !== 'function')
- throw new TypeError('"listener" argument must be a function');
- this.prependListener(type, _onceWrap(this, type, listener));
- return this;
+ MP4.initSegment = function (tracks, duration, timescale) {
+ if (!MP4.initalized) {
+ MP4.init();
+ }
+ var movie = MP4.moov(tracks, duration, timescale);
+ var result = new Uint8Array(MP4.FTYP.byteLength + movie.byteLength);
+ result.set(MP4.FTYP);
+ result.set(movie, MP4.FTYP.byteLength);
+ return result;
};
+ MP4.fragmentSegment = function (sn, baseMediaDecodeTime, track, payload) {
+ var moof = MP4.moof(sn, baseMediaDecodeTime, track);
+ var mdat = MP4.mdat(payload);
+ var result = new Uint8Array(MP4.STYP.byteLength + moof.byteLength + mdat.byteLength);
+ result.set(MP4.STYP);
+ result.set(moof, MP4.STYP.byteLength);
+ result.set(mdat, MP4.STYP.byteLength + moof.byteLength);
+ return result;
+ };
+ return MP4;
+}());
+MP4.types = {};
+MP4.initalized = false;
+exports.default = MP4;
-// Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
- function removeListener(type, listener) {
- var list, events, position, i, originalListener;
-
- if (typeof listener !== 'function')
- throw new TypeError('"listener" argument must be a function');
-
- events = this._events;
- if (!events)
- return this;
-
- list = events[type];
- if (!list)
- return this;
-
- if (list === listener || list.listener === listener) {
- if (--this._eventsCount === 0)
- this._events = objectCreate(null);
+},{}],47:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var NALU = (function () {
+ function NALU(data) {
+ this.data = data;
+ this.nri = (data[0] & 0x60) >> 5;
+ this.ntype = data[0] & 0x1f;
+ }
+ Object.defineProperty(NALU, "NDR", {
+ get: function () { return 1; },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(NALU, "IDR", {
+ get: function () { return 5; },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(NALU, "SEI", {
+ get: function () { return 6; },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(NALU, "SPS", {
+ get: function () { return 7; },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(NALU, "PPS", {
+ get: function () { return 8; },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(NALU, "TYPES", {
+ get: function () {
+ return _a = {},
+ _a[NALU.IDR] = 'IDR',
+ _a[NALU.SEI] = 'SEI',
+ _a[NALU.SPS] = 'SPS',
+ _a[NALU.PPS] = 'PPS',
+ _a[NALU.NDR] = 'NDR',
+ _a;
+ var _a;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ NALU.type = function (nalu) {
+ if (nalu.ntype in NALU.TYPES) {
+ return NALU.TYPES[nalu.ntype];
+ }
else {
- delete events[type];
- if (events.removeListener)
- this.emit('removeListener', type, list.listener || listener);
+ return 'UNKNOWN';
}
- } else if (typeof list !== 'function') {
- position = -1;
+ };
+ NALU.prototype.type = function () {
+ return this.ntype;
+ };
+ NALU.prototype.isKeyframe = function () {
+ return this.ntype === NALU.IDR;
+ };
+ NALU.prototype.getSize = function () {
+ return 4 + this.data.byteLength;
+ };
+ NALU.prototype.getData = function () {
+ var result = new Uint8Array(this.getSize());
+ var view = new DataView(result.buffer);
+ view.setUint32(0, this.getSize() - 4);
+ result.set(this.data, 4);
+ return result;
+ };
+ return NALU;
+}());
+exports.default = NALU;
- for (i = list.length - 1; i >= 0; i--) {
- if (list[i] === listener || list[i].listener === listener) {
- originalListener = list[i].listener;
- position = i;
- break;
- }
+},{}],48:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BitStream = (function () {
+ function BitStream(data) {
+ this.data = data;
+ this.index = 0;
+ this.bitLength = data.byteLength * 8;
+ }
+ Object.defineProperty(BitStream.prototype, "bitsAvailable", {
+ get: function () {
+ return this.bitLength - this.index;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ BitStream.prototype.skipBits = function (size) {
+ if (this.bitsAvailable < size) {
+ throw new Error('no bytes available');
}
-
- if (position < 0)
- return this;
-
- if (position === 0)
- list.shift();
- else
- spliceOne(list, position);
-
- if (list.length === 1)
- events[type] = list[0];
-
- if (events.removeListener)
- this.emit('removeListener', type, originalListener || listener);
- }
-
- return this;
+ this.index += size;
};
-
-EventEmitter.prototype.removeAllListeners =
- function removeAllListeners(type) {
- var listeners, events, i;
-
- events = this._events;
- if (!events)
- return this;
-
- // not listening for removeListener, no need to emit
- if (!events.removeListener) {
- if (arguments.length === 0) {
- this._events = objectCreate(null);
- this._eventsCount = 0;
- } else if (events[type]) {
- if (--this._eventsCount === 0)
- this._events = objectCreate(null);
- else
- delete events[type];
+ BitStream.prototype.readBits = function (size) {
+ var result = this.getBits(size, this.index);
+ return result;
+ };
+ BitStream.prototype.getBits = function (size, offsetBits, moveIndex) {
+ if (moveIndex === void 0) { moveIndex = true; }
+ if (this.bitsAvailable < size) {
+ throw new Error('no bytes available');
}
- return this;
- }
-
- // emit removeListener for all listeners on all events
- if (arguments.length === 0) {
- var keys = objectKeys(events);
- var key;
- for (i = 0; i < keys.length; ++i) {
- key = keys[i];
- if (key === 'removeListener') continue;
- this.removeAllListeners(key);
+ var offset = offsetBits % 8;
+ var byte = this.data[(offsetBits / 8) | 0] & (0xff >>> offset);
+ var bits = 8 - offset;
+ if (bits >= size) {
+ if (moveIndex) {
+ this.index += size;
+ }
+ return byte >> (bits - size);
}
- this.removeAllListeners('removeListener');
- this._events = objectCreate(null);
- this._eventsCount = 0;
- return this;
- }
-
- listeners = events[type];
-
- if (typeof listeners === 'function') {
- this.removeListener(type, listeners);
- } else if (listeners) {
- // LIFO order
- for (i = listeners.length - 1; i >= 0; i--) {
- this.removeListener(type, listeners[i]);
+ else {
+ if (moveIndex) {
+ this.index += bits;
+ }
+ var nextSize = size - bits;
+ return (byte << nextSize) | this.getBits(nextSize, offsetBits + bits, moveIndex);
}
- }
-
- return this;
};
+ BitStream.prototype.skipLZ = function () {
+ var leadingZeroCount;
+ for (leadingZeroCount = 0; leadingZeroCount < this.bitLength - this.index; ++leadingZeroCount) {
+ if (0 !== this.getBits(1, this.index + leadingZeroCount, false)) {
+ this.index += leadingZeroCount;
+ return leadingZeroCount;
+ }
+ }
+ return leadingZeroCount;
+ };
+ BitStream.prototype.skipUEG = function () {
+ this.skipBits(1 + this.skipLZ());
+ };
+ BitStream.prototype.skipEG = function () {
+ this.skipBits(1 + this.skipLZ());
+ };
+ BitStream.prototype.readUEG = function () {
+ var prefix = this.skipLZ();
+ return this.readBits(prefix + 1) - 1;
+ };
+ BitStream.prototype.readEG = function () {
+ var value = this.readUEG();
+ if (0x01 & value) {
+ return (1 + value) >>> 1;
+ }
+ else {
+ return -1 * (value >>> 1);
+ }
+ };
+ BitStream.prototype.readBoolean = function () {
+ return 1 === this.readBits(1);
+ };
+ BitStream.prototype.readUByte = function () {
+ return this.readBits(8);
+ };
+ BitStream.prototype.readUShort = function () {
+ return this.readBits(16);
+ };
+ BitStream.prototype.readUInt = function () {
+ return this.readBits(32);
+ };
+ return BitStream;
+}());
+exports.default = BitStream;
-function _listeners(target, type, unwrap) {
- var events = target._events;
-
- if (!events)
- return [];
-
- var evlistener = events[type];
- if (!evlistener)
- return [];
-
- if (typeof evlistener === 'function')
- return unwrap ? [evlistener.listener || evlistener] : [evlistener];
-
- return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-}
-
-EventEmitter.prototype.listeners = function listeners(type) {
- return _listeners(this, type, true);
-};
-
-EventEmitter.prototype.rawListeners = function rawListeners(type) {
- return _listeners(this, type, false);
-};
-
-EventEmitter.listenerCount = function(emitter, type) {
- if (typeof emitter.listenerCount === 'function') {
- return emitter.listenerCount(type);
- } else {
- return listenerCount.call(emitter, type);
- }
-};
-
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
- var events = this._events;
-
- if (events) {
- var evlistener = events[type];
-
- if (typeof evlistener === 'function') {
- return 1;
- } else if (evlistener) {
- return evlistener.length;
- }
- }
-
- return 0;
-}
-
-EventEmitter.prototype.eventNames = function eventNames() {
- return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
-};
-
-// About 1.5x faster than the two-arg version of Array#splice().
-function spliceOne(list, index) {
- for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
- list[i] = list[k];
- list.pop();
-}
-
-function arrayClone(arr, n) {
- var copy = new Array(n);
- for (var i = 0; i < n; ++i)
- copy[i] = arr[i];
- return copy;
-}
-
-function unwrapListeners(arr) {
- var ret = new Array(arr.length);
- for (var i = 0; i < ret.length; ++i) {
- ret[i] = arr[i].listener || arr[i];
- }
- return ret;
-}
-
-function objectCreatePolyfill(proto) {
- var F = function() {};
- F.prototype = proto;
- return new F;
-}
-function objectKeysPolyfill(obj) {
- var keys = [];
- for (var k in obj) if (Object.prototype.hasOwnProperty.call(obj, k)) {
- keys.push(k);
- }
- return k;
-}
-function functionBindPolyfill(context) {
- var fn = this;
- return function () {
- return fn.apply(context, arguments);
- };
+},{}],49:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var logger;
+var errorLogger;
+function setLogger(log, error) {
+ logger = log;
+ errorLogger = error != null ? error : log;
}
-
-},{}],67:[function(require,module,exports){
-exports.read = function (buffer, offset, isLE, mLen, nBytes) {
- var e, m
- var eLen = (nBytes * 8) - mLen - 1
- var eMax = (1 << eLen) - 1
- var eBias = eMax >> 1
- var nBits = -7
- var i = isLE ? (nBytes - 1) : 0
- var d = isLE ? -1 : 1
- var s = buffer[offset + i]
-
- i += d
-
- e = s & ((1 << (-nBits)) - 1)
- s >>= (-nBits)
- nBits += eLen
- for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
-
- m = e & ((1 << (-nBits)) - 1)
- e >>= (-nBits)
- nBits += mLen
- for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
-
- if (e === 0) {
- e = 1 - eBias
- } else if (e === eMax) {
- return m ? NaN : ((s ? -1 : 1) * Infinity)
- } else {
- m = m + Math.pow(2, mLen)
- e = e - eBias
- }
- return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+exports.setLogger = setLogger;
+function isEnable() {
+ return logger != null;
}
-
-exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
- var e, m, c
- var eLen = (nBytes * 8) - mLen - 1
- var eMax = (1 << eLen) - 1
- var eBias = eMax >> 1
- var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
- var i = isLE ? 0 : (nBytes - 1)
- var d = isLE ? 1 : -1
- var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
-
- value = Math.abs(value)
-
- if (isNaN(value) || value === Infinity) {
- m = isNaN(value) ? 1 : 0
- e = eMax
- } else {
- e = Math.floor(Math.log(value) / Math.LN2)
- if (value * (c = Math.pow(2, -e)) < 1) {
- e--
- c *= 2
+exports.isEnable = isEnable;
+function log(message) {
+ var optionalParams = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ optionalParams[_i - 1] = arguments[_i];
}
- if (e + eBias >= 1) {
- value += rt / c
- } else {
- value += rt * Math.pow(2, 1 - eBias)
+ if (logger) {
+ logger.apply(void 0, [message].concat(optionalParams));
}
- if (value * c >= 2) {
- e++
- c /= 2
+}
+exports.log = log;
+function error(message) {
+ var optionalParams = [];
+ for (var _i = 1; _i < arguments.length; _i++) {
+ optionalParams[_i - 1] = arguments[_i];
}
-
- if (e + eBias >= eMax) {
- m = 0
- e = eMax
- } else if (e + eBias >= 1) {
- m = ((value * c) - 1) * Math.pow(2, mLen)
- e = e + eBias
- } else {
- m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
- e = 0
+ if (errorLogger) {
+ errorLogger.apply(void 0, [message].concat(optionalParams));
}
- }
-
- for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
-
- e = (e << mLen) | m
- eLen += mLen
- for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
-
- buffer[offset + i - d] |= s * 128
-}
-
-},{}],68:[function(require,module,exports){
-/*!
- * Determine if an object is a Buffer
- *
- * @author Feross Aboukhadijeh <https://feross.org>
- * @license MIT
- */
-
-// The _isBuffer check is for Safari 5-7 support, because it's missing
-// Object.prototype.constructor. Remove this eventually
-module.exports = function (obj) {
- return obj != null && (isBuffer(obj) || isSlowBuffer(obj) || !!obj._isBuffer)
-}
-
-function isBuffer (obj) {
- return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
-}
-
-// For Node v0.10 support. Remove this eventually.
-function isSlowBuffer (obj) {
- return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isBuffer(obj.slice(0, 0))
}
+exports.error = error;
-},{}],69:[function(require,module,exports){
-/*
-object-assign
-(c) Sindre Sorhus
-@license MIT
-*/
-
-'use strict';
-/* eslint-disable no-unused-vars */
-var getOwnPropertySymbols = Object.getOwnPropertySymbols;
-var hasOwnProperty = Object.prototype.hasOwnProperty;
-var propIsEnumerable = Object.prototype.propertyIsEnumerable;
-
-function toObject(val) {
- if (val === null || val === undefined) {
- throw new TypeError('Object.assign cannot be called with null or undefined');
- }
-
- return Object(val);
-}
+},{}],50:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var NALU_1 = require("./NALU");
+var VideoStreamBuffer = (function () {
+ function VideoStreamBuffer() {
+ }
+ VideoStreamBuffer.prototype.clear = function () {
+ this.buffer = undefined;
+ };
+ VideoStreamBuffer.prototype.append = function (value) {
+ var nextNalHeader = function (b) {
+ var i = 3;
+ return function () {
+ var count = 0;
+ for (; i < b.length; i++) {
+ switch (b[i]) {
+ case 0:
+ count++;
+ break;
+ case 1:
+ if (count === 3) {
+ return i - 3;
+ }
+ default:
+ count = 0;
+ }
+ }
+ return;
+ };
+ };
+ var result = [];
+ var buffer;
+ if (this.buffer) {
+ if (value[3] === 1 && value[2] === 0 && value[1] === 0 && value[0] === 0) {
+ result.push(new NALU_1.default(this.buffer.subarray(4)));
+ buffer = Uint8Array.from(value);
+ }
+ }
+ if (buffer == null) {
+ buffer = this.mergeBuffer(value);
+ }
+ var lastIndex = 0;
+ var f = nextNalHeader(buffer);
+ for (var index = f(); index != null; index = f()) {
+ result.push(new NALU_1.default(buffer.subarray(lastIndex + 4, index)));
+ lastIndex = index;
+ }
+ this.buffer = buffer.subarray(lastIndex);
+ return result;
+ };
+ VideoStreamBuffer.prototype.mergeBuffer = function (value) {
+ if (this.buffer == null) {
+ return Uint8Array.from(value);
+ }
+ else {
+ var newBuffer = new Uint8Array(this.buffer.byteLength + value.length);
+ if (this.buffer.byteLength > 0) {
+ newBuffer.set(this.buffer, 0);
+ }
+ newBuffer.set(value, this.buffer.byteLength);
+ return newBuffer;
+ }
+ };
+ return VideoStreamBuffer;
+}());
+exports.default = VideoStreamBuffer;
-function shouldUseNative() {
- try {
- if (!Object.assign) {
- return false;
- }
+},{"./NALU":47}],51:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var h264_remuxer_1 = require("./h264-remuxer");
+var mp4_generator_1 = require("./mp4-generator");
+var debug = require("./util/debug");
+var nalu_stream_buffer_1 = require("./util/nalu-stream-buffer");
+exports.mimeType = 'video/mp4; codecs="avc1.42E01E"';
+var VideoConverter = (function () {
+ function VideoConverter(element, fps, fpf) {
+ if (fps === void 0) { fps = 60; }
+ if (fpf === void 0) { fpf = fps; }
+ this.element = element;
+ this.fps = fps;
+ this.fpf = fpf;
+ this.receiveBuffer = new nalu_stream_buffer_1.default();
+ this.queue = [];
+ if (!MediaSource || !MediaSource.isTypeSupported(exports.mimeType)) {
+ throw new Error("Your browser is not supported: " + exports.mimeType);
+ }
+ this.reset();
+ }
+ Object.defineProperty(VideoConverter, "errorNotes", {
+ get: function () {
+ return _a = {},
+ _a[MediaError.MEDIA_ERR_ABORTED] = 'fetching process aborted by user',
+ _a[MediaError.MEDIA_ERR_NETWORK] = 'error occurred when downloading',
+ _a[MediaError.MEDIA_ERR_DECODE] = 'error occurred when decoding',
+ _a[MediaError.MEDIA_ERR_SRC_NOT_SUPPORTED] = 'audio/video not supported',
+ _a;
+ var _a;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ VideoConverter.prototype.setup = function () {
+ var _this = this;
+ this.mediaReadyPromise = new Promise(function (resolve, _reject) {
+ _this.mediaSource.addEventListener('sourceopen', function () {
+ debug.log("Media Source opened.");
+ _this.sourceBuffer = _this.mediaSource.addSourceBuffer(exports.mimeType);
+ _this.sourceBuffer.addEventListener('updateend', function () {
+ debug.log(" SourceBuffer updateend");
+ debug.log(" sourceBuffer.buffered.length=" + _this.sourceBuffer.buffered.length);
+ for (var i = 0, len = _this.sourceBuffer.buffered.length; i < len; i++) {
+ debug.log(" sourceBuffer.buffered [" + i + "]: " +
+ (_this.sourceBuffer.buffered.start(i) + ", " + _this.sourceBuffer.buffered.end(i)));
+ }
+ debug.log(" mediasource.duration=" + _this.mediaSource.duration);
+ debug.log(" mediasource.readyState=" + _this.mediaSource.readyState);
+ debug.log(" video.duration=" + _this.element.duration);
+ debug.log(" video.buffered.length=" + _this.element.buffered.length);
+ if (debug.isEnable()) {
+ for (var i = 0, len = _this.element.buffered.length; i < len; i++) {
+ debug.log(" video.buffered [" + i + "]: " + _this.element.buffered.start(i) + ", " + _this.element.buffered.end(i));
+ }
+ }
+ debug.log(" video.currentTime=" + _this.element.currentTime);
+ debug.log(" video.readyState=" + _this.element.readyState);
+ var data = _this.queue.shift();
+ if (data) {
+ _this.writeBuffer(data);
+ }
+ });
+ _this.sourceBuffer.addEventListener('error', function () {
+ debug.error(' SourceBuffer errored!');
+ });
+ _this.mediaReady = true;
+ resolve();
+ }, false);
+ _this.mediaSource.addEventListener('sourceclose', function () {
+ debug.log("Media Source closed.");
+ _this.mediaReady = false;
+ }, false);
+ _this.element.src = URL.createObjectURL(_this.mediaSource);
+ });
+ return this.mediaReadyPromise;
+ };
+ VideoConverter.prototype.play = function () {
+ var _this = this;
+ if (!this.element.paused) {
+ return;
+ }
+ if (this.mediaReady && this.element.readyState >= 2) {
+ this.element.play();
+ }
+ else {
+ var handler_1 = function () {
+ _this.play();
+ _this.element.removeEventListener('canplaythrough', handler_1);
+ };
+ this.element.addEventListener('canplaythrough', handler_1);
+ }
+ };
+ VideoConverter.prototype.pause = function () {
+ if (this.element.paused) {
+ return;
+ }
+ this.element.pause();
+ };
+ VideoConverter.prototype.reset = function () {
+ this.receiveBuffer.clear();
+ if (this.mediaSource && this.mediaSource.readyState === 'open') {
+ this.mediaSource.duration = 0;
+ this.mediaSource.endOfStream();
+ }
+ this.mediaSource = new MediaSource();
+ this.remuxer = new h264_remuxer_1.default(this.fps, this.fpf, this.fps * 60);
+ this.mediaReady = false;
+ this.mediaReadyPromise = undefined;
+ this.queue = [];
+ this.isFirstFrame = true;
+ this.setup();
+ };
+ VideoConverter.prototype.appendRawData = function (data) {
+ var nalus = this.receiveBuffer.append(data);
+ for (var _i = 0, nalus_1 = nalus; _i < nalus_1.length; _i++) {
+ var nalu = nalus_1[_i];
+ var ret = this.remuxer.remux(nalu);
+ if (ret) {
+ this.writeFragment(ret[0], ret[1]);
+ }
+ }
+ };
+ VideoConverter.prototype.writeFragment = function (dts, pay) {
+ var remuxer = this.remuxer;
+ if (remuxer.mp4track.isKeyFrame) {
+ this.writeBuffer(mp4_generator_1.default.initSegment([remuxer.mp4track], Infinity, remuxer.timescale));
+ }
+ if (pay && pay.byteLength) {
+ debug.log(" Put fragment: " + remuxer.seqNum + ", frames=" + remuxer.mp4track.samples.length + ", size=" + pay.byteLength);
+ var fragment = mp4_generator_1.default.fragmentSegment(remuxer.seqNum, dts, remuxer.mp4track, pay);
+ this.writeBuffer(fragment);
+ remuxer.flush();
+ }
+ else {
+ debug.error("Nothing payload!");
+ }
+ };
+ VideoConverter.prototype.writeBuffer = function (data) {
+ var _this = this;
+ if (this.mediaReady) {
+ if (this.sourceBuffer.updating) {
+ this.queue.push(data);
+ }
+ else {
+ this.doAppend(data);
+ }
+ }
+ else {
+ this.queue.push(data);
+ if (this.mediaReadyPromise) {
+ this.mediaReadyPromise.then(function () {
+ if (!_this.sourceBuffer.updating) {
+ var d = _this.queue.shift();
+ if (d) {
+ _this.writeBuffer(d);
+ }
+ }
+ });
+ this.mediaReadyPromise = undefined;
+ }
+ }
+ };
+ VideoConverter.prototype.doAppend = function (data) {
+ var error = this.element.error;
+ if (error) {
+ debug.error("MSE Error Occured: " + VideoConverter.errorNotes[error.code]);
+ this.element.pause();
+ if (this.mediaSource.readyState === 'open') {
+ this.mediaSource.endOfStream();
+ }
+ }
+ else {
+ try {
+ this.sourceBuffer.appendBuffer(data);
+ debug.log(" appended buffer: size=" + data.byteLength);
+ }
+ catch (err) {
+ debug.error("MSE Error occured while appending buffer. " + err.name + ": " + err.message);
+ }
+ }
+ };
+ return VideoConverter;
+}());
+exports.default = VideoConverter;
- // Detect buggy property enumeration order in older V8 versions.
+},{"./h264-remuxer":45,"./mp4-generator":46,"./util/debug":49,"./util/nalu-stream-buffer":50}],52:[function(require,module,exports){
+(function (Buffer){
+const msgpack = require('msgpack5')()
+ , encode = msgpack.encode
+ , decode = msgpack.decode;
+const uuidv4 = require('uuid') //Deprecated method, should use require('uuid/v4')
+const uuidParser = require('./utils/uuidParser')
- // https://bugs.chromium.org/p/v8/issues/detail?id=4118
- var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
- test1[5] = 'de';
- if (Object.getOwnPropertyNames(test1)[0] === '5') {
- return false;
- }
+const kConnecting = 1;
+const kConnected = 2;
+const kDisconnected = 3;
- // https://bugs.chromium.org/p/v8/issues/detail?id=3056
- var test2 = {};
- for (var i = 0; i < 10; i++) {
- test2['_' + String.fromCharCode(i)] = i;
- }
- var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
- return test2[n];
- });
- if (order2.join('') !== '0123456789') {
- return false;
- }
+// Generate a unique id for this webservice
+let uuid = uuidv4();
+let my_uuid = uuidParser.parse(uuid)
+my_uuid = new Uint8Array(my_uuid);
+// my_uuid[0] = 44;
+// console.log(my_uuid)
+my_uuid = Buffer.from(my_uuid);
- // https://bugs.chromium.org/p/v8/issues/detail?id=3056
- var test3 = {};
- 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
- test3[letter] = letter;
- });
- if (Object.keys(Object.assign({}, test3)).join('') !==
- 'abcdefghijklmnopqrst') {
- return false;
- }
+const kMagic = 0x0009340053640912;
+const kVersion = 0;
- return true;
- } catch (err) {
- // We don't expect any of the above to throw, but better to be safe.
- return false;
- }
-}
-module.exports = shouldUseNative() ? Object.assign : function (target, source) {
- var from;
- var to = toObject(target);
- var symbols;
+/**
+ * Wrap a web socket with a MsgPack RCP protocol that works with our C++ version.
+ * @param {websocket} ws Websocket object
+ */
+function Peer(ws) {
+ this.sock = ws;
+ this.status = kConnecting;
+ this.id = null;
+ this.string_id = "";
+ this.bindings = {};
+ this.proxies = {};
+ this.events = {};
+ this.callbacks = {};
+ this.cbid = 0;
- for (var s = 1; s < arguments.length; s++) {
- from = Object(arguments[s]);
+ this.uri = "unknown";
+ this.name = "unknown";
+ this.master = false;
- for (var key in from) {
- if (hasOwnProperty.call(from, key)) {
- to[key] = from[key];
+ let message = (raw) => {
+ //Gets right data for client
+ if(this.sock.on === undefined){
+ raw = raw.data;
+ }
+ let msg = decode(raw);
+ // console.log('MSG', msg)
+ if (this.status == kConnecting) {
+ if (msg[1] != "__handshake__") {
+ console.log("Bad handshake");
+ this.close();
}
}
-
- if (getOwnPropertySymbols) {
- symbols = getOwnPropertySymbols(from);
- for (var i = 0; i < symbols.length; i++) {
- if (propIsEnumerable.call(from, symbols[i])) {
- to[symbols[i]] = from[symbols[i]];
- }
+ if (msg[0] == 0) {
+ // console.log("MSG...", msg[2]);
+ // Notification
+ if (msg.length == 3) {
+ this._dispatchNotification(msg[1], msg[2]);
+ // Call
+ } else {
+ this._dispatchCall(msg[2], msg[1], msg[3]);
}
+ } else if (msg[0] == 1) {
+ this._dispatchResponse(msg[1], msg[3]);
}
}
- return to;
-};
-
-},{}],70:[function(require,module,exports){
-// shim for using process in browser
-var process = module.exports = {};
-
-// cached from whatever global is present so that test runners that stub it
-// don't break things. But we need to wrap it in a try catch in case it is
-// wrapped in strict mode code which doesn't define any globals. It's inside a
-// function because try/catches deoptimize in certain engines.
-
-var cachedSetTimeout;
-var cachedClearTimeout;
-
-function defaultSetTimout() {
- throw new Error('setTimeout has not been defined');
-}
-function defaultClearTimeout () {
- throw new Error('clearTimeout has not been defined');
-}
-(function () {
- try {
- if (typeof setTimeout === 'function') {
- cachedSetTimeout = setTimeout;
- } else {
- cachedSetTimeout = defaultSetTimout;
- }
- } catch (e) {
- cachedSetTimeout = defaultSetTimout;
- }
- try {
- if (typeof clearTimeout === 'function') {
- cachedClearTimeout = clearTimeout;
- } else {
- cachedClearTimeout = defaultClearTimeout;
- }
- } catch (e) {
- cachedClearTimeout = defaultClearTimeout;
- }
-} ())
-function runTimeout(fun) {
- if (cachedSetTimeout === setTimeout) {
- //normal enviroments in sane situations
- return setTimeout(fun, 0);
- }
- // if setTimeout wasn't available but was latter defined
- if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
- cachedSetTimeout = setTimeout;
- return setTimeout(fun, 0);
- }
- try {
- // when when somebody has screwed with setTimeout but no I.E. maddness
- return cachedSetTimeout(fun, 0);
- } catch(e){
- try {
- // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
- return cachedSetTimeout.call(null, fun, 0);
- } catch(e){
- // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
- return cachedSetTimeout.call(this, fun, 0);
- }
- }
+ let close = () => {
+ this.status = kDisconnected;
+ this._notify("disconnect", this);
+ }
+ let error = () => {
+ console.error("Socket error");
+ this.sock.close();
+ this.status = kDisconnected;
+ }
-}
-function runClearTimeout(marker) {
- if (cachedClearTimeout === clearTimeout) {
- //normal enviroments in sane situations
- return clearTimeout(marker);
- }
- // if clearTimeout wasn't available but was latter defined
- if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
- cachedClearTimeout = clearTimeout;
- return clearTimeout(marker);
- }
- try {
- // when when somebody has screwed with setTimeout but no I.E. maddness
- return cachedClearTimeout(marker);
- } catch (e){
- try {
- // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
- return cachedClearTimeout.call(null, marker);
- } catch (e){
- // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
- // Some versions of I.E. have different rules for clearTimeout vs setTimeout
- return cachedClearTimeout.call(this, marker);
- }
- }
+ //if undefined, peer is being used by client
+ if(this.sock.on === undefined){
+ this.sock.onmessage = message;
+ this.sock.onclose = close;
+ this.sock.onopen = (event) => {
+ this.send("__handshake__", kMagic, kVersion, [my_uuid]);
+ }
+ //else peer is being used by server
+ }else{
+ this.sock.on("message", message);
+ this.sock.on("close", close);
+ this.sock.on("error", error);
+ }
+ this.bind("__handshake__", (magic, version, id) => {
+ if (magic == kMagic) {
+ console.log("Handshake received");
+ this.status = kConnected;
+ this.id = id.buffer;
+ this.string_id = id.toString('hex');
+ this._notify("connect", this);
+ // if(this.sock.on === undefined){
+ // this.send("__handshake__", kMagic, kVersion, [my_uuid]);
+ // }
+ } else {
+ console.log("Magic does not match");
+ this.close();
+ }
+ });
+ this.send("__handshake__", kMagic, kVersion, [my_uuid]);
+}
-}
-var queue = [];
-var draining = false;
-var currentQueue;
-var queueIndex = -1;
+Peer.uuid = my_uuid;
-function cleanUpNextTick() {
- if (!draining || !currentQueue) {
- return;
- }
- draining = false;
- if (currentQueue.length) {
- queue = currentQueue.concat(queue);
- } else {
- queueIndex = -1;
- }
- if (queue.length) {
- drainQueue();
- }
+/**
+ * @private
+ */
+Peer.prototype._dispatchNotification = function(name, args) {
+ if (this.bindings.hasOwnProperty(name)) {
+ //console.log("Notification for: ", name);
+ this.bindings[name].apply(this, args);
+ } else {
+ console.log("Missing handler for: ", name);
+ }
}
-function drainQueue() {
- if (draining) {
- return;
- }
- var timeout = runTimeout(cleanUpNextTick);
- draining = true;
+/**
+ * @private
+ */
+Peer.prototype._dispatchCall = function(name, id, args) {
+ console.log("DISPATCHCALL", name, id, args)
+ if (this.bindings.hasOwnProperty(name)) {
+ //console.log("Call for:", name, id);
- var len = queue.length;
- while(len) {
- currentQueue = queue;
- queue = [];
- while (++queueIndex < len) {
- if (currentQueue) {
- currentQueue[queueIndex].run();
- }
- }
- queueIndex = -1;
- len = queue.length;
- }
- currentQueue = null;
- draining = false;
- runClearTimeout(timeout);
+ try {
+ let res = this.bindings[name].apply(this, args);
+ this.sock.send(encode([1,id,name,res]));
+ } catch(e) {
+ console.error("Could to dispatch or return call", e);
+ this.close();
+ }
+ } else if (this.proxies.hasOwnProperty(name)) {
+ //console.log("Proxy for:", name, id);
+ args.unshift((res) => {
+ try {
+ this.sock.send(encode([1,id,name,res]));
+ } catch(e) {
+ console.log("ERROR")
+ this.close();
+ }
+ });
+ this.proxies[name].apply(this, args);
+ } else {
+ console.log("Missing handler for: ", name);
+ }
}
-process.nextTick = function (fun) {
- var args = new Array(arguments.length - 1);
- if (arguments.length > 1) {
- for (var i = 1; i < arguments.length; i++) {
- args[i - 1] = arguments[i];
- }
- }
- queue.push(new Item(fun, args));
- if (queue.length === 1 && !draining) {
- runTimeout(drainQueue);
- }
-};
-
-// v8 likes predictible objects
-function Item(fun, array) {
- this.fun = fun;
- this.array = array;
+/**
+ * @private
+ */
+Peer.prototype._dispatchResponse = function(id, res) {
+ if (this.callbacks.hasOwnProperty(id)) {
+ this.callbacks[id].call(this, res);
+ delete this.callbacks[id];
+ } else {
+ console.log("Missing callback");
+ }
}
-Item.prototype.run = function () {
- this.fun.apply(null, this.array);
-};
-process.title = 'browser';
-process.browser = true;
-process.env = {};
-process.argv = [];
-process.version = ''; // empty string to avoid regexp issues
-process.versions = {};
-function noop() {}
+/**
+ * Register an RPC handler that will be called from a remote machine. Remotely
+ * passed arguments are provided to the given function as normal arguments, and
+ * if the function returns a value, it will be returned over the network also.
+ *
+ * @param {string} name The name of the function
+ * @param {function} f A function or lambda to be callable remotely
+ */
+Peer.prototype.bind = function(name, f) {
+ if (this.bindings.hasOwnProperty(name)) {
+ //console.error("Duplicate bind to same procedure");
+ this.bindings[name] = f;
+ } else {
+ this.bindings[name] = f;
+ }
+}
-process.on = noop;
-process.addListener = noop;
-process.once = noop;
-process.off = noop;
-process.removeListener = noop;
-process.removeAllListeners = noop;
-process.emit = noop;
-process.prependListener = noop;
-process.prependOnceListener = noop;
+Peer.prototype.isBound = function(name) {
+ return this.bindings.hasOwnProperty(name) || this.proxies.hasOwnProperty(name);
+}
-process.listeners = function (name) { return [] }
+/**
+ * Allow an RPC call to pass through to another machine with minimal local
+ * processing.
+ */
+Peer.prototype.proxy = function(name, f) {
+ if (this.proxies.hasOwnProperty(name)) {
+ //console.error("Duplicate proxy to same procedure");
+ this.proxies[name] = f;
+ } else {
+ this.proxies[name] = f;
+ }
+}
-process.binding = function (name) {
- throw new Error('process.binding is not supported');
-};
+/**
+ * Call a procedure on a remote machine.
+ *
+ * @param {string} name Name of the procedure
+ * @param {function} cb Callback to receive return value as argument
+ * @param {...} args Any number of arguments to also pass to remote procedure
+ */
+Peer.prototype.rpc = function(name, cb, ...args) {
+ let id = this.cbid++;
+ this.callbacks[id] = cb;
-process.cwd = function () { return '/' };
-process.chdir = function (dir) {
- throw new Error('process.chdir is not supported');
-};
-process.umask = function() { return 0; };
+ try {
+ this.sock.send(encode([0, id, name, args]));
+ } catch(e) {
+ this.close();
+ }
+}
-},{}],71:[function(require,module,exports){
-(function (setImmediate,clearImmediate){
-var nextTick = require('process/browser.js').nextTick;
-var apply = Function.prototype.apply;
-var slice = Array.prototype.slice;
-var immediateIds = {};
-var nextImmediateId = 0;
+Peer.prototype.sendB = function(name, args) {
+ try {
+ this.sock.send(encode([0, name, args]));
+ } catch(e) {
+ this.close();
+ }
+}
-// DOM APIs, for completeness
+/**
+ * Call a remote procedure but with no return value expected.
+ *
+ * @param {string} name Name of the procedure
+ * @param {...} args Any number of arguments to also pass to remote procedure
+ */
+Peer.prototype.send = function(name, ...args) {
+ try {
+ this.sock.send(encode([0, name, args]));
+ } catch(e) {
+ this.close();
+ }
+}
-exports.setTimeout = function() {
- return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);
-};
-exports.setInterval = function() {
- return new Timeout(apply.call(setInterval, window, arguments), clearInterval);
-};
-exports.clearTimeout =
-exports.clearInterval = function(timeout) { timeout.close(); };
+/**
+ * Closes the socket
+ */
+Peer.prototype.close = function() {
+ if(this.sock.on !== undefined){
+ this.sock.close();
+ }
+ this.status = kDisconnected;
+}
-function Timeout(id, clearFn) {
- this._id = id;
- this._clearFn = clearFn;
+/**
+ * @private
+ */
+Peer.prototype._notify = function(evt, ...args) {
+ if (this.events.hasOwnProperty(evt)) {
+ for (let i=0; i<this.events[evt].length; i++) {
+ let f = this.events[evt][i];
+ f.apply(this, args);
+ }
+ }
}
-Timeout.prototype.unref = Timeout.prototype.ref = function() {};
-Timeout.prototype.close = function() {
- this._clearFn.call(window, this._id);
-};
-// Does not start the time, just sets up the members needed.
-exports.enroll = function(item, msecs) {
- clearTimeout(item._idleTimeoutId);
- item._idleTimeout = msecs;
-};
+/**
+ * Register a callback for socket events. Events include: 'connect',
+ * 'disconnect' and 'error'.
+ *
+ * @param {string} evt Event name
+ * @param {function} f Callback on event
+ */
+Peer.prototype.on = function(evt, f) {
+ if (!this.events.hasOwnProperty(evt)) {
+ this.events[evt] = [];
+ }
+ this.events[evt].push(f);
+}
-exports.unenroll = function(item) {
- clearTimeout(item._idleTimeoutId);
- item._idleTimeout = -1;
-};
-exports._unrefActive = exports.active = function(item) {
- clearTimeout(item._idleTimeoutId);
+Peer.prototype.getUuid = function() {
+ return uuid;
+}
- var msecs = item._idleTimeout;
- if (msecs >= 0) {
- item._idleTimeoutId = setTimeout(function onTimeout() {
- if (item._onTimeout)
- item._onTimeout();
- }, msecs);
- }
-};
+module.exports = Peer;
-// That's not how node.js implements it but the exposed api is the same.
-exports.setImmediate = typeof setImmediate === "function" ? setImmediate : function(fn) {
- var id = nextImmediateId++;
- var args = arguments.length < 2 ? false : slice.call(arguments, 1);
+}).call(this,require("buffer").Buffer)
+},{"./utils/uuidParser":53,"buffer":8,"msgpack5":15,"uuid":38}],53:[function(require,module,exports){
+// Maps for number <-> hex string conversion
+var _byteToHex = [];
+var _hexToByte = {};
+for (var i = 0; i < 256; i++) {
+ _byteToHex[i] = (i + 0x100).toString(16).substr(1);
+ _hexToByte[_byteToHex[i]] = i;
+}
- immediateIds[id] = true;
+/**
+ * `parse()` - Parse a UUID into it's component bytes
+ *
+ * Turns UUID into Buffer
+ **/
+function parse(s, buf, offset) {
+ var i = (buf && offset) || 0;
+ var ii = 0;
- nextTick(function onNextTick() {
- if (immediateIds[id]) {
- // fn.call() is faster so we optimize for the common use-case
- // @see http://jsperf.com/call-apply-segu
- if (args) {
- fn.apply(null, args);
- } else {
- fn.call(null);
- }
- // Prevent ids from leaking
- exports.clearImmediate(id);
+ buf = buf || [];
+ s.toLowerCase().replace(/[0-9a-f]{2}/g, function(oct) {
+ if (ii < 16) { // Don't overflow!
+ buf[i + ii++] = _hexToByte[oct];
}
});
- return id;
-};
+ // Zero out remaining bytes if string was short
+ while (ii < 16) {
+ buf[i + ii++] = 0;
+ }
-exports.clearImmediate = typeof clearImmediate === "function" ? clearImmediate : function(id) {
- delete immediateIds[id];
+ return buf;
+}
+
+/**
+ * `unparse()` - Convert UUID byte array (ala parse()) into a string
+ *
+ * Turns Buffer into UUID
+ * */
+function unparse(buf, offset) {
+ var i = offset || 0;
+ var bth = _byteToHex;
+ return bth[buf[i++]] + bth[buf[i++]] +
+ bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] + '-' +
+ bth[buf[i++]] + bth[buf[i++]] +
+ bth[buf[i++]] + bth[buf[i++]] +
+ bth[buf[i++]] + bth[buf[i++]];
+}
+
+module.exports = {
+ parse: parse,
+ unparse: unparse
};
-}).call(this,require("timers").setImmediate,require("timers").clearImmediate)
-},{"process/browser.js":70,"timers":71}],72:[function(require,module,exports){
-arguments[4][3][0].apply(exports,arguments)
-},{"dup":3}],73:[function(require,module,exports){
-arguments[4][61][0].apply(exports,arguments)
-},{"dup":61}],74:[function(require,module,exports){
-arguments[4][62][0].apply(exports,arguments)
-},{"./support/isBuffer":73,"_process":70,"dup":62,"inherits":72}]},{},[22]);
+},{}]},{},[43]);
diff --git a/web-service/public/js/index.js b/web-service/public/js/index.js
index 70b7c1006916a88382bc5098c3dd72999698496f..144c371bbc645ddc8873a8b0ab0cbe0fb8ee6970 100644
--- a/web-service/public/js/index.js
+++ b/web-service/public/js/index.js
@@ -1,6 +1,7 @@
const Peer = require('../../server/src/peer')
const VideoConverter = require('./lib/dist/video-converter');
const msgpack = require('msgpack5')();
+const rematrix = require('rematrix');
let current_data = {};
let peer;
@@ -148,7 +149,8 @@ function FTLStream(peer, uri, element) {
this.outer.appendChild(this.play_button);
this.element.onclick = () => {
- let pose = [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];
+ //let pose = [1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];
+ let pose = rematrix.rotateZ(45);
this.setPose(pose);
}