11974 lines
314 KiB
JavaScript
11974 lines
314 KiB
JavaScript
/******/ (function(modules) { // webpackBootstrap
|
||
/******/ // The module cache
|
||
/******/ var installedModules = {};
|
||
/******/
|
||
/******/ // The require function
|
||
/******/ function __webpack_require__(moduleId) {
|
||
/******/
|
||
/******/ // Check if module is in cache
|
||
/******/ if(installedModules[moduleId]) {
|
||
/******/ return installedModules[moduleId].exports;
|
||
/******/ }
|
||
/******/ // Create a new module (and put it into the cache)
|
||
/******/ var module = installedModules[moduleId] = {
|
||
/******/ i: moduleId,
|
||
/******/ l: false,
|
||
/******/ exports: {}
|
||
/******/ };
|
||
/******/
|
||
/******/ // Execute the module function
|
||
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/******/
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.l = true;
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/******/
|
||
/******/ // expose the modules object (__webpack_modules__)
|
||
/******/ __webpack_require__.m = modules;
|
||
/******/
|
||
/******/ // expose the module cache
|
||
/******/ __webpack_require__.c = installedModules;
|
||
/******/
|
||
/******/ // define getter function for harmony exports
|
||
/******/ __webpack_require__.d = function(exports, name, getter) {
|
||
/******/ if(!__webpack_require__.o(exports, name)) {
|
||
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
|
||
/******/ }
|
||
/******/ };
|
||
/******/
|
||
/******/ // define __esModule on exports
|
||
/******/ __webpack_require__.r = function(exports) {
|
||
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
|
||
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
|
||
/******/ }
|
||
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
||
/******/ };
|
||
/******/
|
||
/******/ // create a fake namespace object
|
||
/******/ // mode & 1: value is a module id, require it
|
||
/******/ // mode & 2: merge all properties of value into the ns
|
||
/******/ // mode & 4: return value when already ns object
|
||
/******/ // mode & 8|1: behave like require
|
||
/******/ __webpack_require__.t = function(value, mode) {
|
||
/******/ if(mode & 1) value = __webpack_require__(value);
|
||
/******/ if(mode & 8) return value;
|
||
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
|
||
/******/ var ns = Object.create(null);
|
||
/******/ __webpack_require__.r(ns);
|
||
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
|
||
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
|
||
/******/ return ns;
|
||
/******/ };
|
||
/******/
|
||
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
||
/******/ __webpack_require__.n = function(module) {
|
||
/******/ var getter = module && module.__esModule ?
|
||
/******/ function getDefault() { return module['default']; } :
|
||
/******/ function getModuleExports() { return module; };
|
||
/******/ __webpack_require__.d(getter, 'a', getter);
|
||
/******/ return getter;
|
||
/******/ };
|
||
/******/
|
||
/******/ // Object.prototype.hasOwnProperty.call
|
||
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
||
/******/
|
||
/******/ // __webpack_public_path__
|
||
/******/ __webpack_require__.p = "";
|
||
/******/
|
||
/******/
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(__webpack_require__.s = 418);
|
||
/******/ })
|
||
/************************************************************************/
|
||
/******/ ({
|
||
|
||
/***/ 10:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
try {
|
||
var util = __webpack_require__(7);
|
||
if (typeof util.inherits !== 'function') throw '';
|
||
module.exports = util.inherits;
|
||
} catch (e) {
|
||
module.exports = __webpack_require__(11);
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 108:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) ||
|
||
(typeof self !== "undefined" && self) ||
|
||
window;
|
||
var apply = Function.prototype.apply;
|
||
|
||
// DOM APIs, for completeness
|
||
|
||
exports.setTimeout = function() {
|
||
return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);
|
||
};
|
||
exports.setInterval = function() {
|
||
return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);
|
||
};
|
||
exports.clearTimeout =
|
||
exports.clearInterval = function(timeout) {
|
||
if (timeout) {
|
||
timeout.close();
|
||
}
|
||
};
|
||
|
||
function Timeout(id, clearFn) {
|
||
this._id = id;
|
||
this._clearFn = clearFn;
|
||
}
|
||
Timeout.prototype.unref = Timeout.prototype.ref = function() {};
|
||
Timeout.prototype.close = function() {
|
||
this._clearFn.call(scope, this._id);
|
||
};
|
||
|
||
// Does not start the time, just sets up the members needed.
|
||
exports.enroll = function(item, msecs) {
|
||
clearTimeout(item._idleTimeoutId);
|
||
item._idleTimeout = msecs;
|
||
};
|
||
|
||
exports.unenroll = function(item) {
|
||
clearTimeout(item._idleTimeoutId);
|
||
item._idleTimeout = -1;
|
||
};
|
||
|
||
exports._unrefActive = exports.active = function(item) {
|
||
clearTimeout(item._idleTimeoutId);
|
||
|
||
var msecs = item._idleTimeout;
|
||
if (msecs >= 0) {
|
||
item._idleTimeoutId = setTimeout(function onTimeout() {
|
||
if (item._onTimeout)
|
||
item._onTimeout();
|
||
}, msecs);
|
||
}
|
||
};
|
||
|
||
// setimmediate attaches itself to the global object
|
||
__webpack_require__(109);
|
||
// On some exotic environments, it's not clear which object `setimmediate` was
|
||
// able to install onto. Search each possibility in the same order as the
|
||
// `setimmediate` library.
|
||
exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) ||
|
||
(typeof global !== "undefined" && global.setImmediate) ||
|
||
(this && this.setImmediate);
|
||
exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) ||
|
||
(typeof global !== "undefined" && global.clearImmediate) ||
|
||
(this && this.clearImmediate);
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(6)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 109:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {
|
||
"use strict";
|
||
|
||
if (global.setImmediate) {
|
||
return;
|
||
}
|
||
|
||
var nextHandle = 1; // Spec says greater than zero
|
||
var tasksByHandle = {};
|
||
var currentlyRunningATask = false;
|
||
var doc = global.document;
|
||
var registerImmediate;
|
||
|
||
function setImmediate(callback) {
|
||
// Callback can either be a function or a string
|
||
if (typeof callback !== "function") {
|
||
callback = new Function("" + callback);
|
||
}
|
||
// Copy function arguments
|
||
var args = new Array(arguments.length - 1);
|
||
for (var i = 0; i < args.length; i++) {
|
||
args[i] = arguments[i + 1];
|
||
}
|
||
// Store and register the task
|
||
var task = { callback: callback, args: args };
|
||
tasksByHandle[nextHandle] = task;
|
||
registerImmediate(nextHandle);
|
||
return nextHandle++;
|
||
}
|
||
|
||
function clearImmediate(handle) {
|
||
delete tasksByHandle[handle];
|
||
}
|
||
|
||
function run(task) {
|
||
var callback = task.callback;
|
||
var args = task.args;
|
||
switch (args.length) {
|
||
case 0:
|
||
callback();
|
||
break;
|
||
case 1:
|
||
callback(args[0]);
|
||
break;
|
||
case 2:
|
||
callback(args[0], args[1]);
|
||
break;
|
||
case 3:
|
||
callback(args[0], args[1], args[2]);
|
||
break;
|
||
default:
|
||
callback.apply(undefined, args);
|
||
break;
|
||
}
|
||
}
|
||
|
||
function runIfPresent(handle) {
|
||
// From the spec: "Wait until any invocations of this algorithm started before this one have completed."
|
||
// So if we're currently running a task, we'll need to delay this invocation.
|
||
if (currentlyRunningATask) {
|
||
// Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
|
||
// "too much recursion" error.
|
||
setTimeout(runIfPresent, 0, handle);
|
||
} else {
|
||
var task = tasksByHandle[handle];
|
||
if (task) {
|
||
currentlyRunningATask = true;
|
||
try {
|
||
run(task);
|
||
} finally {
|
||
clearImmediate(handle);
|
||
currentlyRunningATask = false;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
function installNextTickImplementation() {
|
||
registerImmediate = function(handle) {
|
||
process.nextTick(function () { runIfPresent(handle); });
|
||
};
|
||
}
|
||
|
||
function canUsePostMessage() {
|
||
// The test against `importScripts` prevents this implementation from being installed inside a web worker,
|
||
// where `global.postMessage` means something completely different and can't be used for this purpose.
|
||
if (global.postMessage && !global.importScripts) {
|
||
var postMessageIsAsynchronous = true;
|
||
var oldOnMessage = global.onmessage;
|
||
global.onmessage = function() {
|
||
postMessageIsAsynchronous = false;
|
||
};
|
||
global.postMessage("", "*");
|
||
global.onmessage = oldOnMessage;
|
||
return postMessageIsAsynchronous;
|
||
}
|
||
}
|
||
|
||
function installPostMessageImplementation() {
|
||
// Installs an event handler on `global` for the `message` event: see
|
||
// * https://developer.mozilla.org/en/DOM/window.postMessage
|
||
// * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
|
||
|
||
var messagePrefix = "setImmediate$" + Math.random() + "$";
|
||
var onGlobalMessage = function(event) {
|
||
if (event.source === global &&
|
||
typeof event.data === "string" &&
|
||
event.data.indexOf(messagePrefix) === 0) {
|
||
runIfPresent(+event.data.slice(messagePrefix.length));
|
||
}
|
||
};
|
||
|
||
if (global.addEventListener) {
|
||
global.addEventListener("message", onGlobalMessage, false);
|
||
} else {
|
||
global.attachEvent("onmessage", onGlobalMessage);
|
||
}
|
||
|
||
registerImmediate = function(handle) {
|
||
global.postMessage(messagePrefix + handle, "*");
|
||
};
|
||
}
|
||
|
||
function installMessageChannelImplementation() {
|
||
var channel = new MessageChannel();
|
||
channel.port1.onmessage = function(event) {
|
||
var handle = event.data;
|
||
runIfPresent(handle);
|
||
};
|
||
|
||
registerImmediate = function(handle) {
|
||
channel.port2.postMessage(handle);
|
||
};
|
||
}
|
||
|
||
function installReadyStateChangeImplementation() {
|
||
var html = doc.documentElement;
|
||
registerImmediate = function(handle) {
|
||
// Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
|
||
// into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
|
||
var script = doc.createElement("script");
|
||
script.onreadystatechange = function () {
|
||
runIfPresent(handle);
|
||
script.onreadystatechange = null;
|
||
html.removeChild(script);
|
||
script = null;
|
||
};
|
||
html.appendChild(script);
|
||
};
|
||
}
|
||
|
||
function installSetTimeoutImplementation() {
|
||
registerImmediate = function(handle) {
|
||
setTimeout(runIfPresent, 0, handle);
|
||
};
|
||
}
|
||
|
||
// If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
|
||
var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
|
||
attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
|
||
|
||
// Don't get fooled by e.g. browserify environments.
|
||
if ({}.toString.call(global.process) === "[object process]") {
|
||
// For Node.js before 0.9
|
||
installNextTickImplementation();
|
||
|
||
} else if (canUsePostMessage()) {
|
||
// For non-IE10 modern browsers
|
||
installPostMessageImplementation();
|
||
|
||
} else if (global.MessageChannel) {
|
||
// For web workers, where supported
|
||
installMessageChannelImplementation();
|
||
|
||
} else if (doc && "onreadystatechange" in doc.createElement("script")) {
|
||
// For IE 6–8
|
||
installReadyStateChangeImplementation();
|
||
|
||
} else {
|
||
// For older browsers
|
||
installSetTimeoutImplementation();
|
||
}
|
||
|
||
attachTo.setImmediate = setImmediate;
|
||
attachTo.clearImmediate = clearImmediate;
|
||
}(typeof self === "undefined" ? typeof global === "undefined" ? this : global : self));
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(6), __webpack_require__(8)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 11:
|
||
/***/ (function(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
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 12:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(global) {
|
||
|
||
var objectAssign = __webpack_require__(13);
|
||
|
||
// 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;
|
||
|
||
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
|
||
if (a[i] !== b[i]) {
|
||
x = a[i];
|
||
y = b[i];
|
||
break;
|
||
}
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
// 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.
|
||
|
||
// 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.
|
||
|
||
var util = __webpack_require__(7);
|
||
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.
|
||
|
||
var assert = module.exports = ok;
|
||
|
||
// 2. The AssertionError is defined in assert.
|
||
// new assert.AssertionError({ message: message,
|
||
// actual: actual,
|
||
// expected: expected })
|
||
|
||
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);
|
||
}
|
||
|
||
this.stack = out;
|
||
}
|
||
}
|
||
};
|
||
|
||
// assert.AssertionError instanceof Error
|
||
util.inherits(assert.AssertionError, Error);
|
||
|
||
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.
|
||
|
||
// 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.
|
||
|
||
function fail(actual, expected, message, operator, stackStartFunction) {
|
||
throw new assert.AssertionError({
|
||
message: message,
|
||
actual: actual,
|
||
expected: expected,
|
||
operator: operator,
|
||
stackStartFunction: stackStartFunction
|
||
});
|
||
}
|
||
|
||
// EXTENSION! allows for well behaved errors defined elsewhere.
|
||
assert.fail = fail;
|
||
|
||
// 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);.
|
||
|
||
function ok(value, message) {
|
||
if (!value) fail(value, true, message, '==', assert.ok);
|
||
}
|
||
assert.ok = ok;
|
||
|
||
// 5. The equality assertion tests shallow, coercive equality with
|
||
// ==.
|
||
// assert.equal(actual, expected, message_opt);
|
||
|
||
assert.equal = function equal(actual, expected, message) {
|
||
if (actual != expected) fail(actual, expected, message, '==', assert.equal);
|
||
};
|
||
|
||
// 6. The non-equality assertion tests for whether two objects are not equal
|
||
// with != assert.notEqual(actual, expected, message_opt);
|
||
|
||
assert.notEqual = function notEqual(actual, expected, message) {
|
||
if (actual == expected) {
|
||
fail(actual, expected, message, '!=', assert.notEqual);
|
||
}
|
||
};
|
||
|
||
// 7. The equivalence assertion tests a deep equality relation.
|
||
// assert.deepEqual(actual, expected, message_opt);
|
||
|
||
assert.deepEqual = function deepEqual(actual, expected, message) {
|
||
if (!_deepEqual(actual, expected, false)) {
|
||
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
|
||
}
|
||
};
|
||
|
||
assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
|
||
if (!_deepEqual(actual, expected, true)) {
|
||
fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);
|
||
}
|
||
};
|
||
|
||
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;
|
||
|
||
// 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();
|
||
|
||
// 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;
|
||
|
||
// 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;
|
||
|
||
// 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: []};
|
||
|
||
var actualIndex = memos.actual.indexOf(actual);
|
||
if (actualIndex !== -1) {
|
||
if (actualIndex === memos.expected.indexOf(expected)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
memos.actual.push(actual);
|
||
memos.expected.push(expected);
|
||
|
||
return objEquiv(actual, expected, strict, memos);
|
||
}
|
||
}
|
||
|
||
function isArguments(object) {
|
||
return Object.prototype.toString.call(object) == '[object Arguments]';
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
// 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);
|
||
}
|
||
};
|
||
|
||
assert.notDeepStrictEqual = notDeepStrictEqual;
|
||
function notDeepStrictEqual(actual, expected, message) {
|
||
if (_deepEqual(actual, expected, true)) {
|
||
fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);
|
||
}
|
||
}
|
||
|
||
|
||
// 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);
|
||
}
|
||
};
|
||
|
||
// 10. The strict non-equality assertion tests for strict inequality, as
|
||
// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
|
||
|
||
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
|
||
if (actual === expected) {
|
||
fail(actual, expected, message, '!==', assert.notStrictEqual);
|
||
}
|
||
};
|
||
|
||
function expectedException(actual, expected) {
|
||
if (!actual || !expected) {
|
||
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.
|
||
}
|
||
|
||
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 _throws(shouldThrow, block, expected, message) {
|
||
var actual;
|
||
|
||
if (typeof block !== 'function') {
|
||
throw new TypeError('"block" argument must be a function');
|
||
}
|
||
|
||
if (typeof expected === 'string') {
|
||
message = expected;
|
||
expected = null;
|
||
}
|
||
|
||
actual = _tryBlock(block);
|
||
|
||
message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
|
||
(message ? ' ' + message : '.');
|
||
|
||
if (shouldThrow && !actual) {
|
||
fail(actual, expected, 'Missing expected exception' + message);
|
||
}
|
||
|
||
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;
|
||
};
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(6)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 13:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/*
|
||
object-assign
|
||
(c) Sindre Sorhus
|
||
@license MIT
|
||
*/
|
||
|
||
|
||
/* 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);
|
||
}
|
||
|
||
function shouldUseNative() {
|
||
try {
|
||
if (!Object.assign) {
|
||
return false;
|
||
}
|
||
|
||
// Detect buggy property enumeration order in older V8 versions.
|
||
|
||
// 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;
|
||
}
|
||
|
||
// 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;
|
||
}
|
||
|
||
// 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;
|
||
}
|
||
}
|
||
|
||
module.exports = shouldUseNative() ? Object.assign : function (target, source) {
|
||
var from;
|
||
var to = toObject(target);
|
||
var symbols;
|
||
|
||
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];
|
||
}
|
||
}
|
||
|
||
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]];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return to;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 418:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/**
|
||
* ---------------------------------------------------------------------
|
||
* GLPI - Gestionnaire Libre de Parc Informatique
|
||
* Copyright (C) 2015-2020 Teclib' and contributors.
|
||
*
|
||
* http://glpi-project.org
|
||
*
|
||
* based on GLPI - Gestionnaire Libre de Parc Informatique
|
||
* Copyright (C) 2003-2014 by the INDEPNET Development Team.
|
||
*
|
||
* ---------------------------------------------------------------------
|
||
*
|
||
* LICENSE
|
||
*
|
||
* This file is part of GLPI.
|
||
*
|
||
* GLPI is free software; you can redistribute it and/or modify
|
||
* it under the terms of the GNU General Public License as published by
|
||
* the Free Software Foundation; either version 2 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* GLPI is distributed in the hope that it will be useful,
|
||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
* GNU General Public License for more details.
|
||
*
|
||
* You should have received a copy of the GNU General Public License
|
||
* along with GLPI. If not, see <http://www.gnu.org/licenses/>.
|
||
* ---------------------------------------------------------------------
|
||
*/
|
||
|
||
window.fileType = __webpack_require__(419);
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 419:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
const {ReadableWebToNodeStream} = __webpack_require__(420);
|
||
const toBuffer = __webpack_require__(447);
|
||
const core = __webpack_require__(449);
|
||
|
||
async function fromStream(stream) {
|
||
const readableWebToNodeStream = new ReadableWebToNodeStream(stream);
|
||
const fileType = await core.fromStream(readableWebToNodeStream);
|
||
await readableWebToNodeStream.close();
|
||
return fileType;
|
||
}
|
||
|
||
async function fromBlob(blob) {
|
||
const buffer = await convertBlobToBuffer(blob);
|
||
return core.fromBuffer(buffer);
|
||
}
|
||
|
||
/**
|
||
Convert Web API File to Node Buffer.
|
||
@param {Blob} blob - Web API Blob.
|
||
@returns {Promise<Buffer>}
|
||
*/
|
||
function convertBlobToBuffer(blob) {
|
||
return new Promise((resolve, reject) => {
|
||
const fileReader = new FileReader();
|
||
fileReader.addEventListener('loadend', event => {
|
||
let data = event.target.result;
|
||
if (data instanceof ArrayBuffer) {
|
||
data = toBuffer(new Uint8Array(event.target.result));
|
||
}
|
||
|
||
resolve(data);
|
||
});
|
||
|
||
fileReader.addEventListener('error', event => {
|
||
reject(new Error(event.message));
|
||
});
|
||
|
||
fileReader.addEventListener('abort', event => {
|
||
reject(new Error(event.type));
|
||
});
|
||
|
||
fileReader.readAsArrayBuffer(blob);
|
||
});
|
||
}
|
||
|
||
Object.assign(module.exports, core, {
|
||
fromStream,
|
||
fromBlob
|
||
});
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 420:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const stream_1 = __webpack_require__(421);
|
||
/**
|
||
* Converts a Web-API stream into Node stream.Readable class
|
||
* Node stream readable: https://nodejs.org/api/stream.html#stream_readable_streams
|
||
* Web API readable-stream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
|
||
* Node readable stream: https://nodejs.org/api/stream.html#stream_readable_streams
|
||
*/
|
||
class ReadableWebToNodeStream extends stream_1.Readable {
|
||
/**
|
||
*
|
||
* @param stream ReadableStream: https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream
|
||
*/
|
||
constructor(stream) {
|
||
super();
|
||
this.bytesRead = 0;
|
||
this.released = false;
|
||
this.reader = stream.getReader();
|
||
}
|
||
/**
|
||
* Implementation of readable._read(size).
|
||
* When readable._read() is called, if data is available from the resource,
|
||
* the implementation should begin pushing that data into the read queue
|
||
* https://nodejs.org/api/stream.html#stream_readable_read_size_1
|
||
*/
|
||
async _read() {
|
||
// Should start pushing data into the queue
|
||
// Read data from the underlying Web-API-readable-stream
|
||
if (this.released) {
|
||
this.push(null); // Signal EOF
|
||
return;
|
||
}
|
||
this.pendingRead = this.reader.read();
|
||
const data = await this.pendingRead;
|
||
// clear the promise before pushing pushing new data to the queue and allow sequential calls to _read()
|
||
delete this.pendingRead;
|
||
if (data.done || this.released) {
|
||
this.push(null); // Signal EOF
|
||
}
|
||
else {
|
||
this.bytesRead += data.value.length;
|
||
this.push(data.value); // Push new data to the queue
|
||
}
|
||
}
|
||
/**
|
||
* If there is no unresolved read call to Web-API ReadableStream immediately returns;
|
||
* otherwise will wait until the read is resolved.
|
||
*/
|
||
async waitForReadToComplete() {
|
||
if (this.pendingRead) {
|
||
await this.pendingRead;
|
||
}
|
||
}
|
||
/**
|
||
* Close wrapper
|
||
*/
|
||
async close() {
|
||
await this.syncAndRelease();
|
||
}
|
||
async syncAndRelease() {
|
||
this.released = true;
|
||
await this.waitForReadToComplete();
|
||
await this.reader.releaseLock();
|
||
}
|
||
}
|
||
exports.ReadableWebToNodeStream = ReadableWebToNodeStream;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 421:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
// 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.
|
||
|
||
module.exports = Stream;
|
||
|
||
var EE = __webpack_require__(422).EventEmitter;
|
||
var inherits = __webpack_require__(10);
|
||
|
||
inherits(Stream, EE);
|
||
Stream.Readable = __webpack_require__(423);
|
||
Stream.Writable = __webpack_require__(443);
|
||
Stream.Duplex = __webpack_require__(444);
|
||
Stream.Transform = __webpack_require__(445);
|
||
Stream.PassThrough = __webpack_require__(446);
|
||
|
||
// Backwards-compat with node 0.4.x
|
||
Stream.Stream = Stream;
|
||
|
||
|
||
|
||
// old-style streams. Note that the pipe method (the only relevant
|
||
// part of this class) is overridden in the Readable class.
|
||
|
||
function Stream() {
|
||
EE.call(this);
|
||
}
|
||
|
||
Stream.prototype.pipe = function(dest, options) {
|
||
var source = this;
|
||
|
||
function ondata(chunk) {
|
||
if (dest.writable) {
|
||
if (false === dest.write(chunk) && source.pause) {
|
||
source.pause();
|
||
}
|
||
}
|
||
}
|
||
|
||
source.on('data', ondata);
|
||
|
||
function ondrain() {
|
||
if (source.readable && source.resume) {
|
||
source.resume();
|
||
}
|
||
}
|
||
|
||
dest.on('drain', ondrain);
|
||
|
||
// If the 'end' option is not supplied, dest.end() will be called when
|
||
// source gets the 'end' or 'close' events. Only dest.end() once.
|
||
if (!dest._isStdio && (!options || options.end !== false)) {
|
||
source.on('end', onend);
|
||
source.on('close', onclose);
|
||
}
|
||
|
||
var didOnEnd = false;
|
||
function onend() {
|
||
if (didOnEnd) return;
|
||
didOnEnd = true;
|
||
|
||
dest.end();
|
||
}
|
||
|
||
|
||
function onclose() {
|
||
if (didOnEnd) return;
|
||
didOnEnd = true;
|
||
|
||
if (typeof dest.destroy === 'function') dest.destroy();
|
||
}
|
||
|
||
// don't leave dangling pipes when there are errors.
|
||
function onerror(er) {
|
||
cleanup();
|
||
if (EE.listenerCount(this, 'error') === 0) {
|
||
throw er; // Unhandled stream error in pipe.
|
||
}
|
||
}
|
||
|
||
source.on('error', onerror);
|
||
dest.on('error', onerror);
|
||
|
||
// remove all the event listeners that were added.
|
||
function cleanup() {
|
||
source.removeListener('data', ondata);
|
||
dest.removeListener('drain', ondrain);
|
||
|
||
source.removeListener('end', onend);
|
||
source.removeListener('close', onclose);
|
||
|
||
source.removeListener('error', onerror);
|
||
dest.removeListener('error', onerror);
|
||
|
||
source.removeListener('end', cleanup);
|
||
source.removeListener('close', cleanup);
|
||
|
||
dest.removeListener('close', cleanup);
|
||
}
|
||
|
||
source.on('end', cleanup);
|
||
source.on('close', cleanup);
|
||
|
||
dest.on('close', cleanup);
|
||
|
||
dest.emit('pipe', source);
|
||
|
||
// Allow for unix-like usage: A.pipe(B).pipe(C)
|
||
return dest;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 422:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(console) {// 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 R = typeof Reflect === 'object' ? Reflect : null
|
||
var ReflectApply = R && typeof R.apply === 'function'
|
||
? R.apply
|
||
: function ReflectApply(target, receiver, args) {
|
||
return Function.prototype.apply.call(target, receiver, args);
|
||
}
|
||
|
||
var ReflectOwnKeys
|
||
if (R && typeof R.ownKeys === 'function') {
|
||
ReflectOwnKeys = R.ownKeys
|
||
} else if (Object.getOwnPropertySymbols) {
|
||
ReflectOwnKeys = function ReflectOwnKeys(target) {
|
||
return Object.getOwnPropertyNames(target)
|
||
.concat(Object.getOwnPropertySymbols(target));
|
||
};
|
||
} else {
|
||
ReflectOwnKeys = function ReflectOwnKeys(target) {
|
||
return Object.getOwnPropertyNames(target);
|
||
};
|
||
}
|
||
|
||
function ProcessEmitWarning(warning) {
|
||
if (console && console.warn) console.warn(warning);
|
||
}
|
||
|
||
var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
|
||
return value !== value;
|
||
}
|
||
|
||
function EventEmitter() {
|
||
EventEmitter.init.call(this);
|
||
}
|
||
module.exports = EventEmitter;
|
||
|
||
// Backwards-compat with node 0.10.x
|
||
EventEmitter.EventEmitter = EventEmitter;
|
||
|
||
EventEmitter.prototype._events = undefined;
|
||
EventEmitter.prototype._eventsCount = 0;
|
||
EventEmitter.prototype._maxListeners = undefined;
|
||
|
||
// 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;
|
||
|
||
function checkListener(listener) {
|
||
if (typeof listener !== 'function') {
|
||
throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
|
||
}
|
||
}
|
||
|
||
Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
|
||
enumerable: true,
|
||
get: function() {
|
||
return defaultMaxListeners;
|
||
},
|
||
set: function(arg) {
|
||
if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
|
||
throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
|
||
}
|
||
defaultMaxListeners = arg;
|
||
}
|
||
});
|
||
|
||
EventEmitter.init = function() {
|
||
|
||
if (this._events === undefined ||
|
||
this._events === Object.getPrototypeOf(this)._events) {
|
||
this._events = Object.create(null);
|
||
this._eventsCount = 0;
|
||
}
|
||
|
||
this._maxListeners = this._maxListeners || undefined;
|
||
};
|
||
|
||
// 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 || NumberIsNaN(n)) {
|
||
throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
|
||
}
|
||
this._maxListeners = n;
|
||
return this;
|
||
};
|
||
|
||
function _getMaxListeners(that) {
|
||
if (that._maxListeners === undefined)
|
||
return EventEmitter.defaultMaxListeners;
|
||
return that._maxListeners;
|
||
}
|
||
|
||
EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
|
||
return _getMaxListeners(this);
|
||
};
|
||
|
||
EventEmitter.prototype.emit = function emit(type) {
|
||
var args = [];
|
||
for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
|
||
var doError = (type === 'error');
|
||
|
||
var events = this._events;
|
||
if (events !== undefined)
|
||
doError = (doError && events.error === undefined);
|
||
else if (!doError)
|
||
return false;
|
||
|
||
// If there is no 'error' event listener then throw.
|
||
if (doError) {
|
||
var er;
|
||
if (args.length > 0)
|
||
er = args[0];
|
||
if (er instanceof Error) {
|
||
// Note: The comments on the `throw` lines are intentional, they show
|
||
// up in Node's output if this results in an unhandled exception.
|
||
throw er; // Unhandled 'error' event
|
||
}
|
||
// At least give some kind of context to the user
|
||
var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
|
||
err.context = er;
|
||
throw err; // Unhandled 'error' event
|
||
}
|
||
|
||
var handler = events[type];
|
||
|
||
if (handler === undefined)
|
||
return false;
|
||
|
||
if (typeof handler === 'function') {
|
||
ReflectApply(handler, this, args);
|
||
} else {
|
||
var len = handler.length;
|
||
var listeners = arrayClone(handler, len);
|
||
for (var i = 0; i < len; ++i)
|
||
ReflectApply(listeners[i], this, args);
|
||
}
|
||
|
||
return true;
|
||
};
|
||
|
||
function _addListener(target, type, listener, prepend) {
|
||
var m;
|
||
var events;
|
||
var existing;
|
||
|
||
checkListener(listener);
|
||
|
||
events = target._events;
|
||
if (events === undefined) {
|
||
events = target._events = Object.create(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 !== undefined) {
|
||
target.emit('newListener', type,
|
||
listener.listener ? listener.listener : listener);
|
||
|
||
// Re-assign `events` because a newListener handler could have caused the
|
||
// this._events to be assigned to a new object
|
||
events = target._events;
|
||
}
|
||
existing = events[type];
|
||
}
|
||
|
||
if (existing === undefined) {
|
||
// 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];
|
||
// If we've already got an array, just append.
|
||
} else if (prepend) {
|
||
existing.unshift(listener);
|
||
} else {
|
||
existing.push(listener);
|
||
}
|
||
|
||
// Check for listener leak
|
||
m = _getMaxListeners(target);
|
||
if (m > 0 && existing.length > m && !existing.warned) {
|
||
existing.warned = true;
|
||
// No error code for this since it is a Warning
|
||
// eslint-disable-next-line no-restricted-syntax
|
||
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;
|
||
ProcessEmitWarning(w);
|
||
}
|
||
}
|
||
|
||
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);
|
||
};
|
||
|
||
function onceWrapper() {
|
||
if (!this.fired) {
|
||
this.target.removeListener(this.type, this.wrapFn);
|
||
this.fired = true;
|
||
if (arguments.length === 0)
|
||
return this.listener.call(this.target);
|
||
return this.listener.apply(this.target, arguments);
|
||
}
|
||
}
|
||
|
||
function _onceWrap(target, type, listener) {
|
||
var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
|
||
var wrapped = onceWrapper.bind(state);
|
||
wrapped.listener = listener;
|
||
state.wrapFn = wrapped;
|
||
return wrapped;
|
||
}
|
||
|
||
EventEmitter.prototype.once = function once(type, listener) {
|
||
checkListener(listener);
|
||
this.on(type, _onceWrap(this, type, listener));
|
||
return this;
|
||
};
|
||
|
||
EventEmitter.prototype.prependOnceListener =
|
||
function prependOnceListener(type, listener) {
|
||
checkListener(listener);
|
||
this.prependListener(type, _onceWrap(this, type, listener));
|
||
return this;
|
||
};
|
||
|
||
// 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;
|
||
|
||
checkListener(listener);
|
||
|
||
events = this._events;
|
||
if (events === undefined)
|
||
return this;
|
||
|
||
list = events[type];
|
||
if (list === undefined)
|
||
return this;
|
||
|
||
if (list === listener || list.listener === listener) {
|
||
if (--this._eventsCount === 0)
|
||
this._events = Object.create(null);
|
||
else {
|
||
delete events[type];
|
||
if (events.removeListener)
|
||
this.emit('removeListener', type, list.listener || listener);
|
||
}
|
||
} else if (typeof list !== 'function') {
|
||
position = -1;
|
||
|
||
for (i = list.length - 1; i >= 0; i--) {
|
||
if (list[i] === listener || list[i].listener === listener) {
|
||
originalListener = list[i].listener;
|
||
position = i;
|
||
break;
|
||
}
|
||
}
|
||
|
||
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 !== undefined)
|
||
this.emit('removeListener', type, originalListener || listener);
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
|
||
|
||
EventEmitter.prototype.removeAllListeners =
|
||
function removeAllListeners(type) {
|
||
var listeners, events, i;
|
||
|
||
events = this._events;
|
||
if (events === undefined)
|
||
return this;
|
||
|
||
// not listening for removeListener, no need to emit
|
||
if (events.removeListener === undefined) {
|
||
if (arguments.length === 0) {
|
||
this._events = Object.create(null);
|
||
this._eventsCount = 0;
|
||
} else if (events[type] !== undefined) {
|
||
if (--this._eventsCount === 0)
|
||
this._events = Object.create(null);
|
||
else
|
||
delete events[type];
|
||
}
|
||
return this;
|
||
}
|
||
|
||
// emit removeListener for all listeners on all events
|
||
if (arguments.length === 0) {
|
||
var keys = Object.keys(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 = Object.create(null);
|
||
this._eventsCount = 0;
|
||
return this;
|
||
}
|
||
|
||
listeners = events[type];
|
||
|
||
if (typeof listeners === 'function') {
|
||
this.removeListener(type, listeners);
|
||
} else if (listeners !== undefined) {
|
||
// LIFO order
|
||
for (i = listeners.length - 1; i >= 0; i--) {
|
||
this.removeListener(type, listeners[i]);
|
||
}
|
||
}
|
||
|
||
return this;
|
||
};
|
||
|
||
function _listeners(target, type, unwrap) {
|
||
var events = target._events;
|
||
|
||
if (events === undefined)
|
||
return [];
|
||
|
||
var evlistener = events[type];
|
||
if (evlistener === undefined)
|
||
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 !== undefined) {
|
||
var evlistener = events[type];
|
||
|
||
if (typeof evlistener === 'function') {
|
||
return 1;
|
||
} else if (evlistener !== undefined) {
|
||
return evlistener.length;
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
EventEmitter.prototype.eventNames = function eventNames() {
|
||
return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
|
||
};
|
||
|
||
function arrayClone(arr, n) {
|
||
var copy = new Array(n);
|
||
for (var i = 0; i < n; ++i)
|
||
copy[i] = arr[i];
|
||
return copy;
|
||
}
|
||
|
||
function spliceOne(list, index) {
|
||
for (; index + 1 < list.length; index++)
|
||
list[index] = list[index + 1];
|
||
list.pop();
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(5)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 423:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
exports = module.exports = __webpack_require__(424);
|
||
exports.Stream = exports;
|
||
exports.Readable = exports;
|
||
exports.Writable = __webpack_require__(438);
|
||
exports.Duplex = __webpack_require__(437);
|
||
exports.Transform = __webpack_require__(441);
|
||
exports.PassThrough = __webpack_require__(442);
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 424:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(global, process) {// 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.
|
||
|
||
|
||
|
||
/*<replacement>*/
|
||
|
||
var pna = __webpack_require__(425);
|
||
/*</replacement>*/
|
||
|
||
module.exports = Readable;
|
||
|
||
/*<replacement>*/
|
||
var isArray = __webpack_require__(426);
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
var Duplex;
|
||
/*</replacement>*/
|
||
|
||
Readable.ReadableState = ReadableState;
|
||
|
||
/*<replacement>*/
|
||
var EE = __webpack_require__(422).EventEmitter;
|
||
|
||
var EElistenerCount = function (emitter, type) {
|
||
return emitter.listeners(type).length;
|
||
};
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
var Stream = __webpack_require__(427);
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
|
||
var Buffer = __webpack_require__(428).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 = __webpack_require__(432);
|
||
util.inherits = __webpack_require__(10);
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
var debugUtil = __webpack_require__(433);
|
||
var debug = void 0;
|
||
if (debugUtil && debugUtil.debuglog) {
|
||
debug = debugUtil.debuglog('stream');
|
||
} else {
|
||
debug = function () {};
|
||
}
|
||
/*</replacement>*/
|
||
|
||
var BufferList = __webpack_require__(434);
|
||
var destroyImpl = __webpack_require__(436);
|
||
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 || __webpack_require__(437);
|
||
|
||
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 = __webpack_require__(440).StringDecoder;
|
||
this.decoder = new StringDecoder(options.encoding);
|
||
this.encoding = options.encoding;
|
||
}
|
||
}
|
||
|
||
function Readable(options) {
|
||
Duplex = Duplex || __webpack_require__(437);
|
||
|
||
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 = __webpack_require__(440).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;
|
||
}
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(6), __webpack_require__(8)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 425:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(process) {
|
||
|
||
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);
|
||
});
|
||
}
|
||
}
|
||
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(8)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 426:
|
||
/***/ (function(module, exports) {
|
||
|
||
var toString = {}.toString;
|
||
|
||
module.exports = Array.isArray || function (arr) {
|
||
return toString.call(arr) == '[object Array]';
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 427:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
module.exports = __webpack_require__(422).EventEmitter;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 428:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* eslint-disable node/no-deprecated-api */
|
||
var buffer = __webpack_require__(429)
|
||
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
|
||
}
|
||
|
||
function SafeBuffer (arg, encodingOrOffset, length) {
|
||
return Buffer(arg, encodingOrOffset, length)
|
||
}
|
||
|
||
// 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)
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
SafeBuffer.allocUnsafe = function (size) {
|
||
if (typeof size !== 'number') {
|
||
throw new TypeError('Argument must be a number')
|
||
}
|
||
return Buffer(size)
|
||
}
|
||
|
||
SafeBuffer.allocUnsafeSlow = function (size) {
|
||
if (typeof size !== 'number') {
|
||
throw new TypeError('Argument must be a number')
|
||
}
|
||
return buffer.SlowBuffer(size)
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 429:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(global) {/*!
|
||
* The buffer module from node.js, for the browser.
|
||
*
|
||
* @author Feross Aboukhadijeh <http://feross.org>
|
||
* @license MIT
|
||
*/
|
||
/* eslint-disable no-proto */
|
||
|
||
|
||
|
||
var base64 = __webpack_require__(430)
|
||
var ieee754 = __webpack_require__(431)
|
||
var isArray = __webpack_require__(426)
|
||
|
||
exports.Buffer = Buffer
|
||
exports.SlowBuffer = SlowBuffer
|
||
exports.INSPECT_MAX_BYTES = 50
|
||
|
||
/**
|
||
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
||
* === true Use Uint8Array implementation (fastest)
|
||
* === false Use 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+.
|
||
*
|
||
* Due to various browser bugs, sometimes the Object implementation will be used even
|
||
* when the browser supports typed arrays.
|
||
*
|
||
* Note:
|
||
*
|
||
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
|
||
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
|
||
*
|
||
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
|
||
*
|
||
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
|
||
* incorrect length in some situations.
|
||
|
||
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
|
||
* get the Object implementation, which is slower but behaves correctly.
|
||
*/
|
||
Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
|
||
? global.TYPED_ARRAY_SUPPORT
|
||
: typedArraySupport()
|
||
|
||
/*
|
||
* Export kMaxLength after typed array support is determined.
|
||
*/
|
||
exports.kMaxLength = kMaxLength()
|
||
|
||
function typedArraySupport () {
|
||
try {
|
||
var arr = new Uint8Array(1)
|
||
arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
|
||
return arr.foo() === 42 && // typed array instances can be augmented
|
||
typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
|
||
arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
|
||
} catch (e) {
|
||
return false
|
||
}
|
||
}
|
||
|
||
function kMaxLength () {
|
||
return Buffer.TYPED_ARRAY_SUPPORT
|
||
? 0x7fffffff
|
||
: 0x3fffffff
|
||
}
|
||
|
||
function createBuffer (that, length) {
|
||
if (kMaxLength() < length) {
|
||
throw new RangeError('Invalid typed array length')
|
||
}
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
// Return an augmented `Uint8Array` instance, for best performance
|
||
that = new Uint8Array(length)
|
||
that.__proto__ = Buffer.prototype
|
||
} else {
|
||
// Fallback: Return an object instance of the Buffer class
|
||
if (that === null) {
|
||
that = new Buffer(length)
|
||
}
|
||
that.length = length
|
||
}
|
||
|
||
return that
|
||
}
|
||
|
||
/**
|
||
* 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.
|
||
*/
|
||
|
||
function Buffer (arg, encodingOrOffset, length) {
|
||
if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
|
||
return new Buffer(arg, encodingOrOffset, length)
|
||
}
|
||
|
||
// Common case.
|
||
if (typeof arg === 'number') {
|
||
if (typeof encodingOrOffset === 'string') {
|
||
throw new Error(
|
||
'If encoding is specified then the first argument must be a string'
|
||
)
|
||
}
|
||
return allocUnsafe(this, arg)
|
||
}
|
||
return from(this, arg, encodingOrOffset, length)
|
||
}
|
||
|
||
Buffer.poolSize = 8192 // not used by this implementation
|
||
|
||
// TODO: Legacy, not needed anymore. Remove in next major version.
|
||
Buffer._augment = function (arr) {
|
||
arr.__proto__ = Buffer.prototype
|
||
return arr
|
||
}
|
||
|
||
function from (that, value, encodingOrOffset, length) {
|
||
if (typeof value === 'number') {
|
||
throw new TypeError('"value" argument must not be a number')
|
||
}
|
||
|
||
if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
|
||
return fromArrayBuffer(that, value, encodingOrOffset, length)
|
||
}
|
||
|
||
if (typeof value === 'string') {
|
||
return fromString(that, value, encodingOrOffset)
|
||
}
|
||
|
||
return fromObject(that, 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(null, value, encodingOrOffset, length)
|
||
}
|
||
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
Buffer.prototype.__proto__ = Uint8Array.prototype
|
||
Buffer.__proto__ = Uint8Array
|
||
if (typeof Symbol !== 'undefined' && Symbol.species &&
|
||
Buffer[Symbol.species] === Buffer) {
|
||
// Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
|
||
Object.defineProperty(Buffer, Symbol.species, {
|
||
value: null,
|
||
configurable: true
|
||
})
|
||
}
|
||
}
|
||
|
||
function assertSize (size) {
|
||
if (typeof size !== 'number') {
|
||
throw new TypeError('"size" argument must be a number')
|
||
} else if (size < 0) {
|
||
throw new RangeError('"size" argument must not be negative')
|
||
}
|
||
}
|
||
|
||
function alloc (that, size, fill, encoding) {
|
||
assertSize(size)
|
||
if (size <= 0) {
|
||
return createBuffer(that, 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(that, size).fill(fill, encoding)
|
||
: createBuffer(that, size).fill(fill)
|
||
}
|
||
return createBuffer(that, size)
|
||
}
|
||
|
||
/**
|
||
* Creates a new filled Buffer instance.
|
||
* alloc(size[, fill[, encoding]])
|
||
**/
|
||
Buffer.alloc = function (size, fill, encoding) {
|
||
return alloc(null, size, fill, encoding)
|
||
}
|
||
|
||
function allocUnsafe (that, size) {
|
||
assertSize(size)
|
||
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
|
||
if (!Buffer.TYPED_ARRAY_SUPPORT) {
|
||
for (var i = 0; i < size; ++i) {
|
||
that[i] = 0
|
||
}
|
||
}
|
||
return that
|
||
}
|
||
|
||
/**
|
||
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
|
||
* */
|
||
Buffer.allocUnsafe = function (size) {
|
||
return allocUnsafe(null, size)
|
||
}
|
||
/**
|
||
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
|
||
*/
|
||
Buffer.allocUnsafeSlow = function (size) {
|
||
return allocUnsafe(null, size)
|
||
}
|
||
|
||
function fromString (that, string, encoding) {
|
||
if (typeof encoding !== 'string' || encoding === '') {
|
||
encoding = 'utf8'
|
||
}
|
||
|
||
if (!Buffer.isEncoding(encoding)) {
|
||
throw new TypeError('"encoding" must be a valid string encoding')
|
||
}
|
||
|
||
var length = byteLength(string, encoding) | 0
|
||
that = createBuffer(that, length)
|
||
|
||
var actual = that.write(string, encoding)
|
||
|
||
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')
|
||
that = that.slice(0, actual)
|
||
}
|
||
|
||
return that
|
||
}
|
||
|
||
function fromArrayLike (that, array) {
|
||
var length = array.length < 0 ? 0 : checked(array.length) | 0
|
||
that = createBuffer(that, length)
|
||
for (var i = 0; i < length; i += 1) {
|
||
that[i] = array[i] & 255
|
||
}
|
||
return that
|
||
}
|
||
|
||
function fromArrayBuffer (that, array, byteOffset, length) {
|
||
array.byteLength // this throws if `array` is not a valid ArrayBuffer
|
||
|
||
if (byteOffset < 0 || array.byteLength < byteOffset) {
|
||
throw new RangeError('\'offset\' is out of bounds')
|
||
}
|
||
|
||
if (array.byteLength < byteOffset + (length || 0)) {
|
||
throw new RangeError('\'length\' is out of bounds')
|
||
}
|
||
|
||
if (byteOffset === undefined && length === undefined) {
|
||
array = new Uint8Array(array)
|
||
} else if (length === undefined) {
|
||
array = new Uint8Array(array, byteOffset)
|
||
} else {
|
||
array = new Uint8Array(array, byteOffset, length)
|
||
}
|
||
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
// Return an augmented `Uint8Array` instance, for best performance
|
||
that = array
|
||
that.__proto__ = Buffer.prototype
|
||
} else {
|
||
// Fallback: Return an object instance of the Buffer class
|
||
that = fromArrayLike(that, array)
|
||
}
|
||
return that
|
||
}
|
||
|
||
function fromObject (that, obj) {
|
||
if (Buffer.isBuffer(obj)) {
|
||
var len = checked(obj.length) | 0
|
||
that = createBuffer(that, len)
|
||
|
||
if (that.length === 0) {
|
||
return that
|
||
}
|
||
|
||
obj.copy(that, 0, 0, len)
|
||
return that
|
||
}
|
||
|
||
if (obj) {
|
||
if ((typeof ArrayBuffer !== 'undefined' &&
|
||
obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
|
||
if (typeof obj.length !== 'number' || isnan(obj.length)) {
|
||
return createBuffer(that, 0)
|
||
}
|
||
return fromArrayLike(that, obj)
|
||
}
|
||
|
||
if (obj.type === 'Buffer' && isArray(obj.data)) {
|
||
return fromArrayLike(that, obj.data)
|
||
}
|
||
}
|
||
|
||
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
|
||
}
|
||
|
||
function checked (length) {
|
||
// Note: cannot use `length < kMaxLength()` here because that fails when
|
||
// length is NaN (which is otherwise coerced to zero.)
|
||
if (length >= kMaxLength()) {
|
||
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
|
||
'size: 0x' + kMaxLength().toString(16) + ' bytes')
|
||
}
|
||
return length | 0
|
||
}
|
||
|
||
function SlowBuffer (length) {
|
||
if (+length != length) { // eslint-disable-line eqeqeq
|
||
length = 0
|
||
}
|
||
return Buffer.alloc(+length)
|
||
}
|
||
|
||
Buffer.isBuffer = function isBuffer (b) {
|
||
return !!(b != null && b._isBuffer)
|
||
}
|
||
|
||
Buffer.compare = function compare (a, b) {
|
||
if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
|
||
throw new TypeError('Arguments must be Buffers')
|
||
}
|
||
|
||
if (a === b) return 0
|
||
|
||
var x = a.length
|
||
var y = b.length
|
||
|
||
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
|
||
if (a[i] !== b[i]) {
|
||
x = a[i]
|
||
y = b[i]
|
||
break
|
||
}
|
||
}
|
||
|
||
if (x < y) return -1
|
||
if (y < x) return 1
|
||
return 0
|
||
}
|
||
|
||
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
|
||
}
|
||
}
|
||
|
||
Buffer.concat = function concat (list, length) {
|
||
if (!isArray(list)) {
|
||
throw new TypeError('"list" argument must be an Array of Buffers')
|
||
}
|
||
|
||
if (list.length === 0) {
|
||
return Buffer.alloc(0)
|
||
}
|
||
|
||
var i
|
||
if (length === undefined) {
|
||
length = 0
|
||
for (i = 0; i < list.length; ++i) {
|
||
length += list[i].length
|
||
}
|
||
}
|
||
|
||
var buffer = Buffer.allocUnsafe(length)
|
||
var pos = 0
|
||
for (i = 0; i < list.length; ++i) {
|
||
var buf = list[i]
|
||
if (!Buffer.isBuffer(buf)) {
|
||
throw new TypeError('"list" argument must be an Array of Buffers')
|
||
}
|
||
buf.copy(buffer, pos)
|
||
pos += buf.length
|
||
}
|
||
return buffer
|
||
}
|
||
|
||
function byteLength (string, encoding) {
|
||
if (Buffer.isBuffer(string)) {
|
||
return string.length
|
||
}
|
||
if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
|
||
(ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
|
||
return string.byteLength
|
||
}
|
||
if (typeof string !== 'string') {
|
||
string = '' + string
|
||
}
|
||
|
||
var len = string.length
|
||
if (len === 0) return 0
|
||
|
||
// 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':
|
||
case undefined:
|
||
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 utf8ToBytes(string).length // assume utf8
|
||
encoding = ('' + encoding).toLowerCase()
|
||
loweredCase = true
|
||
}
|
||
}
|
||
}
|
||
Buffer.byteLength = byteLength
|
||
|
||
function slowToString (encoding, start, end) {
|
||
var loweredCase = false
|
||
|
||
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
|
||
// property of a typed array.
|
||
|
||
// 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 ''
|
||
}
|
||
|
||
if (end === undefined || end > this.length) {
|
||
end = this.length
|
||
}
|
||
|
||
if (end <= 0) {
|
||
return ''
|
||
}
|
||
|
||
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
|
||
end >>>= 0
|
||
start >>>= 0
|
||
|
||
if (end <= start) {
|
||
return ''
|
||
}
|
||
|
||
if (!encoding) encoding = 'utf8'
|
||
|
||
while (true) {
|
||
switch (encoding) {
|
||
case 'hex':
|
||
return hexSlice(this, start, end)
|
||
|
||
case 'utf8':
|
||
case 'utf-8':
|
||
return utf8Slice(this, start, end)
|
||
|
||
case 'ascii':
|
||
return asciiSlice(this, start, end)
|
||
|
||
case 'latin1':
|
||
case 'binary':
|
||
return latin1Slice(this, start, end)
|
||
|
||
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
|
||
}
|
||
}
|
||
}
|
||
|
||
// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
|
||
// Buffer instances.
|
||
Buffer.prototype._isBuffer = true
|
||
|
||
function swap (b, n, m) {
|
||
var i = b[n]
|
||
b[n] = b[m]
|
||
b[m] = i
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
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)
|
||
}
|
||
return 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
|
||
}
|
||
|
||
Buffer.prototype.toString = function toString () {
|
||
var length = this.length | 0
|
||
if (length === 0) return ''
|
||
if (arguments.length === 0) return utf8Slice(this, 0, length)
|
||
return slowToString.apply(this, arguments)
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
Buffer.prototype.inspect = function inspect () {
|
||
var str = ''
|
||
var max = exports.INSPECT_MAX_BYTES
|
||
if (this.length > 0) {
|
||
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
|
||
if (this.length > max) str += ' ... '
|
||
}
|
||
return '<Buffer ' + str + '>'
|
||
}
|
||
|
||
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
|
||
if (!Buffer.isBuffer(target)) {
|
||
throw new TypeError('Argument must be a Buffer')
|
||
}
|
||
|
||
if (start === undefined) {
|
||
start = 0
|
||
}
|
||
if (end === undefined) {
|
||
end = target ? target.length : 0
|
||
}
|
||
if (thisStart === undefined) {
|
||
thisStart = 0
|
||
}
|
||
if (thisEnd === undefined) {
|
||
thisEnd = this.length
|
||
}
|
||
|
||
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
|
||
throw new RangeError('out of range index')
|
||
}
|
||
|
||
if (thisStart >= thisEnd && start >= end) {
|
||
return 0
|
||
}
|
||
if (thisStart >= thisEnd) {
|
||
return -1
|
||
}
|
||
if (start >= end) {
|
||
return 1
|
||
}
|
||
|
||
start >>>= 0
|
||
end >>>= 0
|
||
thisStart >>>= 0
|
||
thisEnd >>>= 0
|
||
|
||
if (this === target) return 0
|
||
|
||
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
|
||
}
|
||
}
|
||
|
||
if (x < y) return -1
|
||
if (y < x) return 1
|
||
return 0
|
||
}
|
||
|
||
// 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
|
||
|
||
// 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 (isNaN(byteOffset)) {
|
||
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
|
||
byteOffset = dir ? 0 : (buffer.length - 1)
|
||
}
|
||
|
||
// 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
|
||
}
|
||
|
||
// Normalize val
|
||
if (typeof val === 'string') {
|
||
val = Buffer.from(val, encoding)
|
||
}
|
||
|
||
// 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 (Buffer.TYPED_ARRAY_SUPPORT &&
|
||
typeof Uint8Array.prototype.indexOf === 'function') {
|
||
if (dir) {
|
||
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
|
||
} else {
|
||
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
|
||
}
|
||
}
|
||
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
|
||
|
||
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 {
|
||
if (foundIndex !== -1) i -= i - foundIndex
|
||
foundIndex = -1
|
||
}
|
||
}
|
||
} 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
|
||
}
|
||
}
|
||
|
||
return -1
|
||
}
|
||
|
||
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
|
||
return this.indexOf(val, byteOffset, encoding) !== -1
|
||
}
|
||
|
||
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
|
||
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
|
||
}
|
||
|
||
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
|
||
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
|
||
}
|
||
|
||
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
|
||
}
|
||
}
|
||
|
||
// must be an even number of digits
|
||
var strLen = string.length
|
||
if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
|
||
|
||
if (length > strLen / 2) {
|
||
length = strLen / 2
|
||
}
|
||
for (var i = 0; i < length; ++i) {
|
||
var parsed = parseInt(string.substr(i * 2, 2), 16)
|
||
if (isNaN(parsed)) return i
|
||
buf[offset + i] = parsed
|
||
}
|
||
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)
|
||
}
|
||
|
||
function latin1Write (buf, string, offset, length) {
|
||
return asciiWrite(buf, string, offset, length)
|
||
}
|
||
|
||
function base64Write (buf, string, offset, length) {
|
||
return blitBuffer(base64ToBytes(string), buf, offset, length)
|
||
}
|
||
|
||
function ucs2Write (buf, string, offset, length) {
|
||
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
|
||
}
|
||
|
||
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
|
||
}
|
||
// legacy write(string, encoding, offset, length) - remove in v0.13
|
||
} else {
|
||
throw new Error(
|
||
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
|
||
)
|
||
}
|
||
|
||
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')
|
||
}
|
||
|
||
if (!encoding) encoding = 'utf8'
|
||
|
||
var loweredCase = false
|
||
for (;;) {
|
||
switch (encoding) {
|
||
case 'hex':
|
||
return hexWrite(this, string, offset, length)
|
||
|
||
case 'utf8':
|
||
case 'utf-8':
|
||
return utf8Write(this, string, offset, length)
|
||
|
||
case 'ascii':
|
||
return asciiWrite(this, string, offset, length)
|
||
|
||
case 'latin1':
|
||
case 'binary':
|
||
return latin1Write(this, string, offset, length)
|
||
|
||
case 'base64':
|
||
// Warning: maxLength not taken into account in base64Write
|
||
return base64Write(this, string, offset, length)
|
||
|
||
case 'ucs2':
|
||
case 'ucs-2':
|
||
case 'utf16le':
|
||
case 'utf-16le':
|
||
return ucs2Write(this, string, offset, length)
|
||
|
||
default:
|
||
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
||
encoding = ('' + encoding).toLowerCase()
|
||
loweredCase = true
|
||
}
|
||
}
|
||
}
|
||
|
||
Buffer.prototype.toJSON = function toJSON () {
|
||
return {
|
||
type: 'Buffer',
|
||
data: Array.prototype.slice.call(this._arr || this, 0)
|
||
}
|
||
}
|
||
|
||
function base64Slice (buf, start, end) {
|
||
if (start === 0 && end === buf.length) {
|
||
return base64.fromByteArray(buf)
|
||
} else {
|
||
return base64.fromByteArray(buf.slice(start, end))
|
||
}
|
||
}
|
||
|
||
function utf8Slice (buf, start, end) {
|
||
end = Math.min(buf.length, end)
|
||
var res = []
|
||
|
||
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
|
||
|
||
if (i + bytesPerSequence <= end) {
|
||
var secondByte, thirdByte, fourthByte, tempCodePoint
|
||
|
||
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 (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
|
||
}
|
||
|
||
res.push(codePoint)
|
||
i += bytesPerSequence
|
||
}
|
||
|
||
return decodeCodePointsArray(res)
|
||
}
|
||
|
||
// 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
|
||
|
||
function decodeCodePointsArray (codePoints) {
|
||
var len = codePoints.length
|
||
if (len <= MAX_ARGUMENTS_LENGTH) {
|
||
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
|
||
}
|
||
|
||
// 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
|
||
}
|
||
|
||
function asciiSlice (buf, start, end) {
|
||
var ret = ''
|
||
end = Math.min(buf.length, end)
|
||
|
||
for (var i = start; i < end; ++i) {
|
||
ret += String.fromCharCode(buf[i] & 0x7F)
|
||
}
|
||
return ret
|
||
}
|
||
|
||
function latin1Slice (buf, start, end) {
|
||
var ret = ''
|
||
end = Math.min(buf.length, end)
|
||
|
||
for (var i = start; i < end; ++i) {
|
||
ret += String.fromCharCode(buf[i])
|
||
}
|
||
return ret
|
||
}
|
||
|
||
function hexSlice (buf, start, end) {
|
||
var len = buf.length
|
||
|
||
if (!start || start < 0) start = 0
|
||
if (!end || end < 0 || end > len) end = len
|
||
|
||
var out = ''
|
||
for (var i = start; i < end; ++i) {
|
||
out += toHex(buf[i])
|
||
}
|
||
return out
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
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 (end < 0) {
|
||
end += len
|
||
if (end < 0) end = 0
|
||
} else if (end > len) {
|
||
end = len
|
||
}
|
||
|
||
if (end < start) end = start
|
||
|
||
var newBuf
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
newBuf = this.subarray(start, end)
|
||
newBuf.__proto__ = Buffer.prototype
|
||
} else {
|
||
var sliceLen = end - start
|
||
newBuf = new Buffer(sliceLen, undefined)
|
||
for (var i = 0; i < sliceLen; ++i) {
|
||
newBuf[i] = this[i + start]
|
||
}
|
||
}
|
||
|
||
return newBuf
|
||
}
|
||
|
||
/*
|
||
* 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')
|
||
}
|
||
|
||
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
|
||
offset = offset | 0
|
||
byteLength = byteLength | 0
|
||
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
||
|
||
var val = this[offset]
|
||
var mul = 1
|
||
var i = 0
|
||
while (++i < byteLength && (mul *= 0x100)) {
|
||
val += this[offset + i] * mul
|
||
}
|
||
|
||
return val
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 1, this.length)
|
||
return this[offset]
|
||
}
|
||
|
||
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 2, this.length)
|
||
return this[offset] | (this[offset + 1] << 8)
|
||
}
|
||
|
||
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 2, this.length)
|
||
return (this[offset] << 8) | this[offset + 1]
|
||
}
|
||
|
||
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
||
return ((this[offset]) |
|
||
(this[offset + 1] << 8) |
|
||
(this[offset + 2] << 16)) +
|
||
(this[offset + 3] * 0x1000000)
|
||
}
|
||
|
||
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
||
return (this[offset] * 0x1000000) +
|
||
((this[offset + 1] << 16) |
|
||
(this[offset + 2] << 8) |
|
||
this[offset + 3])
|
||
}
|
||
|
||
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
|
||
offset = offset | 0
|
||
byteLength = byteLength | 0
|
||
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
||
|
||
var val = this[offset]
|
||
var mul = 1
|
||
var i = 0
|
||
while (++i < byteLength && (mul *= 0x100)) {
|
||
val += this[offset + i] * mul
|
||
}
|
||
mul *= 0x80
|
||
|
||
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
||
|
||
return val
|
||
}
|
||
|
||
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
|
||
offset = offset | 0
|
||
byteLength = byteLength | 0
|
||
if (!noAssert) checkOffset(offset, byteLength, this.length)
|
||
|
||
var i = byteLength
|
||
var mul = 1
|
||
var val = this[offset + --i]
|
||
while (i > 0 && (mul *= 0x100)) {
|
||
val += this[offset + --i] * mul
|
||
}
|
||
mul *= 0x80
|
||
|
||
if (val >= mul) val -= Math.pow(2, 8 * byteLength)
|
||
|
||
return val
|
||
}
|
||
|
||
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
|
||
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) {
|
||
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) {
|
||
if (!noAssert) checkOffset(offset, 2, this.length)
|
||
var val = this[offset + 1] | (this[offset] << 8)
|
||
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
||
}
|
||
|
||
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
||
return (this[offset]) |
|
||
(this[offset + 1] << 8) |
|
||
(this[offset + 2] << 16) |
|
||
(this[offset + 3] << 24)
|
||
}
|
||
|
||
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
|
||
return (this[offset] << 24) |
|
||
(this[offset + 1] << 16) |
|
||
(this[offset + 2] << 8) |
|
||
(this[offset + 3])
|
||
}
|
||
|
||
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
return ieee754.read(this, offset, true, 23, 4)
|
||
}
|
||
|
||
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 4, this.length)
|
||
return ieee754.read(this, offset, false, 23, 4)
|
||
}
|
||
|
||
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 8, this.length)
|
||
return ieee754.read(this, offset, true, 52, 8)
|
||
}
|
||
|
||
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
|
||
if (!noAssert) checkOffset(offset, 8, this.length)
|
||
return ieee754.read(this, offset, false, 52, 8)
|
||
}
|
||
|
||
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')
|
||
}
|
||
|
||
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)
|
||
}
|
||
|
||
var mul = 1
|
||
var i = 0
|
||
this[offset] = value & 0xFF
|
||
while (++i < byteLength && (mul *= 0x100)) {
|
||
this[offset + i] = (value / mul) & 0xFF
|
||
}
|
||
|
||
return offset + byteLength
|
||
}
|
||
|
||
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)
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
|
||
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
|
||
this[offset] = (value & 0xff)
|
||
return offset + 1
|
||
}
|
||
|
||
function objectWriteUInt16 (buf, value, offset, littleEndian) {
|
||
if (value < 0) value = 0xffff + value + 1
|
||
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
|
||
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
|
||
(littleEndian ? i : 1 - i) * 8
|
||
}
|
||
}
|
||
|
||
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
this[offset] = (value & 0xff)
|
||
this[offset + 1] = (value >>> 8)
|
||
} else {
|
||
objectWriteUInt16(this, value, offset, true)
|
||
}
|
||
return offset + 2
|
||
}
|
||
|
||
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
this[offset] = (value >>> 8)
|
||
this[offset + 1] = (value & 0xff)
|
||
} else {
|
||
objectWriteUInt16(this, value, offset, false)
|
||
}
|
||
return offset + 2
|
||
}
|
||
|
||
function objectWriteUInt32 (buf, value, offset, littleEndian) {
|
||
if (value < 0) value = 0xffffffff + value + 1
|
||
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
|
||
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
|
||
}
|
||
}
|
||
|
||
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
this[offset + 3] = (value >>> 24)
|
||
this[offset + 2] = (value >>> 16)
|
||
this[offset + 1] = (value >>> 8)
|
||
this[offset] = (value & 0xff)
|
||
} else {
|
||
objectWriteUInt32(this, value, offset, true)
|
||
}
|
||
return offset + 4
|
||
}
|
||
|
||
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
this[offset] = (value >>> 24)
|
||
this[offset + 1] = (value >>> 16)
|
||
this[offset + 2] = (value >>> 8)
|
||
this[offset + 3] = (value & 0xff)
|
||
} else {
|
||
objectWriteUInt32(this, value, offset, false)
|
||
}
|
||
return offset + 4
|
||
}
|
||
|
||
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) {
|
||
var limit = Math.pow(2, 8 * byteLength - 1)
|
||
|
||
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
return offset + byteLength
|
||
}
|
||
|
||
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) {
|
||
var limit = Math.pow(2, 8 * byteLength - 1)
|
||
|
||
checkInt(this, value, offset, byteLength, limit - 1, -limit)
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
return offset + byteLength
|
||
}
|
||
|
||
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
|
||
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
|
||
if (value < 0) value = 0xff + value + 1
|
||
this[offset] = (value & 0xff)
|
||
return offset + 1
|
||
}
|
||
|
||
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
this[offset] = (value & 0xff)
|
||
this[offset + 1] = (value >>> 8)
|
||
} else {
|
||
objectWriteUInt16(this, value, offset, true)
|
||
}
|
||
return offset + 2
|
||
}
|
||
|
||
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
this[offset] = (value >>> 8)
|
||
this[offset + 1] = (value & 0xff)
|
||
} else {
|
||
objectWriteUInt16(this, value, offset, false)
|
||
}
|
||
return offset + 2
|
||
}
|
||
|
||
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
|
||
value = +value
|
||
offset = offset | 0
|
||
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
this[offset] = (value & 0xff)
|
||
this[offset + 1] = (value >>> 8)
|
||
this[offset + 2] = (value >>> 16)
|
||
this[offset + 3] = (value >>> 24)
|
||
} else {
|
||
objectWriteUInt32(this, value, offset, true)
|
||
}
|
||
return offset + 4
|
||
}
|
||
|
||
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
|
||
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
||
this[offset] = (value >>> 24)
|
||
this[offset + 1] = (value >>> 16)
|
||
this[offset + 2] = (value >>> 8)
|
||
this[offset + 3] = (value & 0xff)
|
||
} else {
|
||
objectWriteUInt32(this, value, offset, false)
|
||
}
|
||
return offset + 4
|
||
}
|
||
|
||
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) {
|
||
if (!noAssert) {
|
||
checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
|
||
}
|
||
ieee754.write(buf, value, offset, littleEndian, 23, 4)
|
||
return offset + 4
|
||
}
|
||
|
||
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
|
||
return writeFloat(this, value, offset, true, noAssert)
|
||
}
|
||
|
||
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
|
||
return writeFloat(this, value, offset, false, noAssert)
|
||
}
|
||
|
||
function writeDouble (buf, value, offset, littleEndian, noAssert) {
|
||
if (!noAssert) {
|
||
checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
|
||
}
|
||
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)
|
||
}
|
||
|
||
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
|
||
return writeDouble(this, value, offset, false, noAssert)
|
||
}
|
||
|
||
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
||
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
|
||
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
|
||
|
||
// Copy 0 bytes; we're done
|
||
if (end === start) return 0
|
||
if (target.length === 0 || this.length === 0) return 0
|
||
|
||
// Fatal error conditions
|
||
if (targetStart < 0) {
|
||
throw new RangeError('targetStart out of bounds')
|
||
}
|
||
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
|
||
if (end < 0) throw new RangeError('sourceEnd out of bounds')
|
||
|
||
// Are we oob?
|
||
if (end > this.length) end = this.length
|
||
if (target.length - targetStart < end - start) {
|
||
end = target.length - targetStart + start
|
||
}
|
||
|
||
var len = end - start
|
||
var i
|
||
|
||
if (this === target && start < targetStart && targetStart < end) {
|
||
// descending copy from end
|
||
for (i = len - 1; i >= 0; --i) {
|
||
target[i + targetStart] = this[i + start]
|
||
}
|
||
} else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
|
||
// ascending copy from start
|
||
for (i = 0; i < len; ++i) {
|
||
target[i + targetStart] = this[i + start]
|
||
}
|
||
} else {
|
||
Uint8Array.prototype.set.call(
|
||
target,
|
||
this.subarray(start, start + len),
|
||
targetStart
|
||
)
|
||
}
|
||
|
||
return len
|
||
}
|
||
|
||
// 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 (val.length === 1) {
|
||
var code = val.charCodeAt(0)
|
||
if (code < 256) {
|
||
val = code
|
||
}
|
||
}
|
||
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)
|
||
}
|
||
} else if (typeof val === 'number') {
|
||
val = val & 255
|
||
}
|
||
|
||
// 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')
|
||
}
|
||
|
||
if (end <= start) {
|
||
return this
|
||
}
|
||
|
||
start = start >>> 0
|
||
end = end === undefined ? this.length : end >>> 0
|
||
|
||
if (!val) val = 0
|
||
|
||
var i
|
||
if (typeof val === 'number') {
|
||
for (i = start; i < end; ++i) {
|
||
this[i] = val
|
||
}
|
||
} else {
|
||
var bytes = Buffer.isBuffer(val)
|
||
? val
|
||
: utf8ToBytes(new Buffer(val, encoding).toString())
|
||
var len = bytes.length
|
||
for (i = 0; i < end - start; ++i) {
|
||
this[i + start] = bytes[i % len]
|
||
}
|
||
}
|
||
|
||
return this
|
||
}
|
||
|
||
// HELPER FUNCTIONS
|
||
// ================
|
||
|
||
var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g
|
||
|
||
function base64clean (str) {
|
||
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
||
str = stringtrim(str).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 stringtrim (str) {
|
||
if (str.trim) return str.trim()
|
||
return str.replace(/^\s+|\s+$/g, '')
|
||
}
|
||
|
||
function toHex (n) {
|
||
if (n < 16) return '0' + n.toString(16)
|
||
return n.toString(16)
|
||
}
|
||
|
||
function utf8ToBytes (string, units) {
|
||
units = units || Infinity
|
||
var codePoint
|
||
var length = string.length
|
||
var leadSurrogate = null
|
||
var bytes = []
|
||
|
||
for (var i = 0; i < length; ++i) {
|
||
codePoint = string.charCodeAt(i)
|
||
|
||
// 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
|
||
}
|
||
|
||
// valid lead
|
||
leadSurrogate = codePoint
|
||
|
||
continue
|
||
}
|
||
|
||
// 2 leads in a row
|
||
if (codePoint < 0xDC00) {
|
||
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
|
||
leadSurrogate = codePoint
|
||
continue
|
||
}
|
||
|
||
// 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)
|
||
}
|
||
|
||
leadSurrogate = 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 {
|
||
throw new Error('Invalid code point')
|
||
}
|
||
}
|
||
|
||
return bytes
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
function utf16leToBytes (str, units) {
|
||
var c, hi, lo
|
||
var byteArray = []
|
||
for (var i = 0; i < str.length; ++i) {
|
||
if ((units -= 2) < 0) break
|
||
|
||
c = str.charCodeAt(i)
|
||
hi = c >> 8
|
||
lo = c % 256
|
||
byteArray.push(lo)
|
||
byteArray.push(hi)
|
||
}
|
||
|
||
return byteArray
|
||
}
|
||
|
||
function base64ToBytes (str) {
|
||
return base64.toByteArray(base64clean(str))
|
||
}
|
||
|
||
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 isnan (val) {
|
||
return val !== val // eslint-disable-line no-self-compare
|
||
}
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(6)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 430:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"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
|
||
}
|
||
|
||
// 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
|
||
|
||
if (len % 4 > 0) {
|
||
throw new Error('Invalid string. Length must be a multiple of 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
|
||
|
||
var placeHoldersLen = validLen === len
|
||
? 0
|
||
: 4 - (validLen % 4)
|
||
|
||
return [validLen, placeHoldersLen]
|
||
}
|
||
|
||
// 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 _byteLength (b64, validLen, placeHoldersLen) {
|
||
return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
|
||
}
|
||
|
||
function toByteArray (b64) {
|
||
var tmp
|
||
var lens = getLens(b64)
|
||
var validLen = lens[0]
|
||
var placeHoldersLen = lens[1]
|
||
|
||
var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
|
||
|
||
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
|
||
}
|
||
|
||
if (placeHoldersLen === 2) {
|
||
tmp =
|
||
(revLookup[b64.charCodeAt(i)] << 2) |
|
||
(revLookup[b64.charCodeAt(i + 1)] >> 4)
|
||
arr[curByte++] = tmp & 0xFF
|
||
}
|
||
|
||
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 arr
|
||
}
|
||
|
||
function tripletToBase64 (num) {
|
||
return lookup[num >> 18 & 0x3F] +
|
||
lookup[num >> 12 & 0x3F] +
|
||
lookup[num >> 6 & 0x3F] +
|
||
lookup[num & 0x3F]
|
||
}
|
||
|
||
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 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
|
||
|
||
// 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)
|
||
))
|
||
}
|
||
|
||
// 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] +
|
||
'='
|
||
)
|
||
}
|
||
|
||
return parts.join('')
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 431:
|
||
/***/ (function(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.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
|
||
}
|
||
if (e + eBias >= 1) {
|
||
value += rt / c
|
||
} else {
|
||
value += rt * Math.pow(2, 1 - eBias)
|
||
}
|
||
if (value * c >= 2) {
|
||
e++
|
||
c /= 2
|
||
}
|
||
|
||
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
|
||
}
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 432:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(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);
|
||
}
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(429).Buffer))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 433:
|
||
/***/ (function(module, exports) {
|
||
|
||
/* (ignored) */
|
||
|
||
/***/ }),
|
||
|
||
/***/ 434:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
||
|
||
var Buffer = __webpack_require__(428).Buffer;
|
||
var util = __webpack_require__(435);
|
||
|
||
function copyBuffer(src, target, offset) {
|
||
src.copy(target, offset);
|
||
}
|
||
|
||
module.exports = function () {
|
||
function BufferList() {
|
||
_classCallCheck(this, BufferList);
|
||
|
||
this.head = null;
|
||
this.tail = null;
|
||
this.length = 0;
|
||
}
|
||
|
||
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;
|
||
};
|
||
|
||
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;
|
||
};
|
||
|
||
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;
|
||
};
|
||
|
||
BufferList.prototype.clear = function clear() {
|
||
this.head = this.tail = null;
|
||
this.length = 0;
|
||
};
|
||
|
||
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;
|
||
};
|
||
|
||
return BufferList;
|
||
}();
|
||
|
||
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;
|
||
};
|
||
}
|
||
|
||
/***/ }),
|
||
|
||
/***/ 435:
|
||
/***/ (function(module, exports) {
|
||
|
||
/* (ignored) */
|
||
|
||
/***/ }),
|
||
|
||
/***/ 436:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
/*<replacement>*/
|
||
|
||
var pna = __webpack_require__(425);
|
||
/*</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;
|
||
}
|
||
|
||
// we set destroyed to true before firing error callbacks in order
|
||
// to make it re-entrance safe in case destroy() is called within callbacks
|
||
|
||
if (this._readableState) {
|
||
this._readableState.destroyed = true;
|
||
}
|
||
|
||
// if this is a duplex stream mark the writable part as destroyed as well
|
||
if (this._writableState) {
|
||
this._writableState.destroyed = true;
|
||
}
|
||
|
||
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);
|
||
}
|
||
});
|
||
|
||
return this;
|
||
}
|
||
|
||
function undestroy() {
|
||
if (this._readableState) {
|
||
this._readableState.destroyed = false;
|
||
this._readableState.reading = false;
|
||
this._readableState.ended = false;
|
||
this._readableState.endEmitted = false;
|
||
}
|
||
|
||
if (this._writableState) {
|
||
this._writableState.destroyed = false;
|
||
this._writableState.ended = false;
|
||
this._writableState.ending = false;
|
||
this._writableState.finished = false;
|
||
this._writableState.errorEmitted = false;
|
||
}
|
||
}
|
||
|
||
function emitErrorNT(self, err) {
|
||
self.emit('error', err);
|
||
}
|
||
|
||
module.exports = {
|
||
destroy: destroy,
|
||
undestroy: undestroy
|
||
};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 437:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
// 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.
|
||
|
||
|
||
|
||
/*<replacement>*/
|
||
|
||
var pna = __webpack_require__(425);
|
||
/*</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 = __webpack_require__(432);
|
||
util.inherits = __webpack_require__(10);
|
||
/*</replacement>*/
|
||
|
||
var Readable = __webpack_require__(424);
|
||
var Writable = __webpack_require__(438);
|
||
|
||
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);
|
||
};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 438:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(process, setImmediate, 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 bit simpler than readable streams.
|
||
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
|
||
// the drain event emission and buffering.
|
||
|
||
|
||
|
||
/*<replacement>*/
|
||
|
||
var pna = __webpack_require__(425);
|
||
/*</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;
|
||
|
||
/*<replacement>*/
|
||
var util = __webpack_require__(432);
|
||
util.inherits = __webpack_require__(10);
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
var internalUtil = {
|
||
deprecate: __webpack_require__(439)
|
||
};
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
var Stream = __webpack_require__(427);
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
|
||
var Buffer = __webpack_require__(428).Buffer;
|
||
var OurUint8Array = global.Uint8Array || function () {};
|
||
function _uint8ArrayToBuffer(chunk) {
|
||
return Buffer.from(chunk);
|
||
}
|
||
function _isUint8Array(obj) {
|
||
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
|
||
}
|
||
|
||
/*</replacement>*/
|
||
|
||
var destroyImpl = __webpack_require__(436);
|
||
|
||
util.inherits(Writable, Stream);
|
||
|
||
function nop() {}
|
||
|
||
function WritableState(options, stream) {
|
||
Duplex = Duplex || __webpack_require__(437);
|
||
|
||
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 to indicate whether or not this stream
|
||
// contains buffers or objects.
|
||
this.objectMode = !!options.objectMode;
|
||
|
||
if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;
|
||
|
||
// 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 (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;
|
||
|
||
// cast to ints.
|
||
this.highWaterMark = Math.floor(this.highWaterMark);
|
||
|
||
// if _final has been called
|
||
this.finalCalled = false;
|
||
|
||
// 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;
|
||
|
||
// has it been destroyed
|
||
this.destroyed = false;
|
||
|
||
// 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;
|
||
|
||
// 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';
|
||
|
||
// 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;
|
||
|
||
// a flag to see when we're in the middle of a write.
|
||
this.writing = false;
|
||
|
||
// when true all writes will be buffered until .uncork() call
|
||
this.corked = 0;
|
||
|
||
// 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;
|
||
|
||
// 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;
|
||
|
||
// the callback that's passed to _write(chunk,cb)
|
||
this.onwrite = function (er) {
|
||
onwrite(stream, er);
|
||
};
|
||
|
||
// the callback that the user supplies to write(chunk,encoding,cb)
|
||
this.writecb = null;
|
||
|
||
// the amount that is being written when _write is called.
|
||
this.writelen = 0;
|
||
|
||
this.bufferedRequest = null;
|
||
this.lastBufferedRequest = null;
|
||
|
||
// number of pending user-supplied write callbacks
|
||
// this must be 0 before 'finish' can be emitted
|
||
this.pendingcb = 0;
|
||
|
||
// emit prefinish if the only thing we're waiting for is _write cbs
|
||
// This is relevant for synchronous Transform streams
|
||
this.prefinished = false;
|
||
|
||
// True if the error was already emitted and should not be thrown again
|
||
this.errorEmitted = false;
|
||
|
||
// 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);
|
||
}
|
||
|
||
WritableState.prototype.getBuffer = function getBuffer() {
|
||
var current = this.bufferedRequest;
|
||
var out = [];
|
||
while (current) {
|
||
out.push(current);
|
||
current = current.next;
|
||
}
|
||
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;
|
||
};
|
||
}
|
||
|
||
function Writable(options) {
|
||
Duplex = Duplex || __webpack_require__(437);
|
||
|
||
// 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);
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
Stream.call(this);
|
||
}
|
||
|
||
// 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);
|
||
}
|
||
|
||
// 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;
|
||
|
||
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;
|
||
}
|
||
|
||
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 (typeof encoding === 'function') {
|
||
cb = encoding;
|
||
encoding = null;
|
||
}
|
||
|
||
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 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);
|
||
}
|
||
};
|
||
|
||
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;
|
||
}
|
||
|
||
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 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;
|
||
|
||
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;
|
||
|
||
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);
|
||
}
|
||
|
||
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 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);
|
||
|
||
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);
|
||
}
|
||
|
||
if (sync) {
|
||
/*<replacement>*/
|
||
asyncWrite(afterWrite, stream, state, finished, cb);
|
||
/*</replacement>*/
|
||
} else {
|
||
afterWrite(stream, state, finished, cb);
|
||
}
|
||
}
|
||
}
|
||
|
||
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;
|
||
|
||
var count = 0;
|
||
var allBuffers = true;
|
||
while (entry) {
|
||
buffer[count] = entry;
|
||
if (!entry.isBuf) allBuffers = false;
|
||
entry = entry.next;
|
||
count += 1;
|
||
}
|
||
buffer.allBuffers = allBuffers;
|
||
|
||
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 {
|
||
// 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 (entry === null) state.lastBufferedRequest = null;
|
||
}
|
||
|
||
state.bufferedRequest = entry;
|
||
state.bufferProcessing = false;
|
||
}
|
||
|
||
Writable.prototype._write = function (chunk, encoding, cb) {
|
||
cb(new Error('_write() is not implemented'));
|
||
};
|
||
|
||
Writable.prototype._writev = null;
|
||
|
||
Writable.prototype.end = function (chunk, encoding, cb) {
|
||
var state = this._writableState;
|
||
|
||
if (typeof chunk === 'function') {
|
||
cb = chunk;
|
||
chunk = null;
|
||
encoding = null;
|
||
} else if (typeof encoding === 'function') {
|
||
cb = encoding;
|
||
encoding = null;
|
||
}
|
||
|
||
if (chunk !== null && chunk !== undefined) this.write(chunk, encoding);
|
||
|
||
// .end() fully uncorks
|
||
if (state.corked) {
|
||
state.corked = 1;
|
||
this.uncork();
|
||
}
|
||
|
||
// ignore unnecessary end() calls.
|
||
if (!state.ending && !state.finished) endWritable(this, state, cb);
|
||
};
|
||
|
||
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');
|
||
}
|
||
}
|
||
}
|
||
|
||
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 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 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;
|
||
}
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
// backward compatibility, the user is explicitly
|
||
// managing destroyed
|
||
this._writableState.destroyed = value;
|
||
}
|
||
});
|
||
|
||
Writable.prototype.destroy = destroyImpl.destroy;
|
||
Writable.prototype._undestroy = destroyImpl.undestroy;
|
||
Writable.prototype._destroy = function (err, cb) {
|
||
this.end();
|
||
cb(err);
|
||
};
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(8), __webpack_require__(108).setImmediate, __webpack_require__(6)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 439:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
|
||
/**
|
||
* For Node.js, simply re-export the core `util.deprecate` function.
|
||
*/
|
||
|
||
module.exports = __webpack_require__(7).deprecate;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 440:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
// 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.
|
||
|
||
|
||
|
||
/*<replacement>*/
|
||
|
||
var Buffer = __webpack_require__(428).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;
|
||
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);
|
||
}
|
||
|
||
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 || '';
|
||
};
|
||
|
||
StringDecoder.prototype.end = utf8End;
|
||
|
||
// Returns only complete characters in a Buffer
|
||
StringDecoder.prototype.text = utf8Text;
|
||
|
||
// 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;
|
||
};
|
||
|
||
// 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;
|
||
}
|
||
|
||
// 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;
|
||
}
|
||
return nb;
|
||
}
|
||
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 (self.lastNeed > 2 && buf.length > 2) {
|
||
if ((buf[2] & 0xC0) !== 0x80) {
|
||
self.lastNeed = 2;
|
||
return '\ufffd';
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 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);
|
||
}
|
||
}
|
||
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 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);
|
||
}
|
||
|
||
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;
|
||
}
|
||
|
||
// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
|
||
function simpleWrite(buf) {
|
||
return buf.toString(this.encoding);
|
||
}
|
||
|
||
function simpleEnd(buf) {
|
||
return buf && buf.length ? this.write(buf) : '';
|
||
}
|
||
|
||
/***/ }),
|
||
|
||
/***/ 441:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
// 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.
|
||
|
||
|
||
|
||
module.exports = Transform;
|
||
|
||
var Duplex = __webpack_require__(437);
|
||
|
||
/*<replacement>*/
|
||
var util = __webpack_require__(432);
|
||
util.inherits = __webpack_require__(10);
|
||
/*</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);
|
||
}
|
||
|
||
/***/ }),
|
||
|
||
/***/ 442:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
// 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.
|
||
|
||
|
||
|
||
module.exports = PassThrough;
|
||
|
||
var Transform = __webpack_require__(441);
|
||
|
||
/*<replacement>*/
|
||
var util = __webpack_require__(432);
|
||
util.inherits = __webpack_require__(10);
|
||
/*</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);
|
||
};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 443:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
module.exports = __webpack_require__(438);
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 444:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
module.exports = __webpack_require__(437);
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 445:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
module.exports = __webpack_require__(423).Transform
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 446:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
module.exports = __webpack_require__(423).PassThrough
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 447:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(Buffer) {/**
|
||
* Convert a typed array to a Buffer without a copy
|
||
*
|
||
* Author: Feross Aboukhadijeh <https://feross.org>
|
||
* License: MIT
|
||
*
|
||
* `npm install typedarray-to-buffer`
|
||
*/
|
||
|
||
var isTypedArray = __webpack_require__(448).strict
|
||
|
||
module.exports = function typedarrayToBuffer (arr) {
|
||
if (isTypedArray(arr)) {
|
||
// To avoid a copy, use the typed array's underlying ArrayBuffer to back new Buffer
|
||
var buf = Buffer.from(arr.buffer)
|
||
if (arr.byteLength !== arr.buffer.byteLength) {
|
||
// Respect the "view", i.e. byteOffset and byteLength, without doing a copy
|
||
buf = buf.slice(arr.byteOffset, arr.byteOffset + arr.byteLength)
|
||
}
|
||
return buf
|
||
} else {
|
||
// Pass through all other types to `Buffer.from`
|
||
return Buffer.from(arr)
|
||
}
|
||
}
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(429).Buffer))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 448:
|
||
/***/ (function(module, exports) {
|
||
|
||
module.exports = isTypedArray
|
||
isTypedArray.strict = isStrictTypedArray
|
||
isTypedArray.loose = isLooseTypedArray
|
||
|
||
var toString = Object.prototype.toString
|
||
var names = {
|
||
'[object Int8Array]': true
|
||
, '[object Int16Array]': true
|
||
, '[object Int32Array]': true
|
||
, '[object Uint8Array]': true
|
||
, '[object Uint8ClampedArray]': true
|
||
, '[object Uint16Array]': true
|
||
, '[object Uint32Array]': true
|
||
, '[object Float32Array]': true
|
||
, '[object Float64Array]': true
|
||
}
|
||
|
||
function isTypedArray(arr) {
|
||
return (
|
||
isStrictTypedArray(arr)
|
||
|| isLooseTypedArray(arr)
|
||
)
|
||
}
|
||
|
||
function isStrictTypedArray(arr) {
|
||
return (
|
||
arr instanceof Int8Array
|
||
|| arr instanceof Int16Array
|
||
|| arr instanceof Int32Array
|
||
|| arr instanceof Uint8Array
|
||
|| arr instanceof Uint8ClampedArray
|
||
|| arr instanceof Uint16Array
|
||
|| arr instanceof Uint32Array
|
||
|| arr instanceof Float32Array
|
||
|| arr instanceof Float64Array
|
||
)
|
||
}
|
||
|
||
function isLooseTypedArray(arr) {
|
||
return names[toString.call(arr)]
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 449:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(Buffer) {
|
||
const Token = __webpack_require__(450);
|
||
const strtok3 = __webpack_require__(451);
|
||
const {
|
||
stringToBytes,
|
||
tarHeaderChecksumMatches,
|
||
uint32SyncSafeToken,
|
||
uint8ArrayUtf8ByteString
|
||
} = __webpack_require__(466);
|
||
const supported = __webpack_require__(467);
|
||
|
||
const minimumBytes = 4100; // A fair amount of file-types are detectable within this range
|
||
|
||
async function fromStream(stream) {
|
||
const tokenizer = await strtok3.fromStream(stream);
|
||
try {
|
||
return await fromTokenizer(tokenizer);
|
||
} finally {
|
||
await tokenizer.close();
|
||
}
|
||
}
|
||
|
||
async function fromBuffer(input) {
|
||
if (!(input instanceof Uint8Array || input instanceof ArrayBuffer || Buffer.isBuffer(input))) {
|
||
throw new TypeError(`Expected the \`input\` argument to be of type \`Uint8Array\` or \`Buffer\` or \`ArrayBuffer\`, got \`${typeof input}\``);
|
||
}
|
||
|
||
const buffer = input instanceof Buffer ? input : Buffer.from(input);
|
||
|
||
if (!(buffer && buffer.length > 1)) {
|
||
return;
|
||
}
|
||
|
||
const tokenizer = strtok3.fromBuffer(buffer);
|
||
return fromTokenizer(tokenizer);
|
||
}
|
||
|
||
function _check(buffer, headers, options) {
|
||
options = {
|
||
offset: 0,
|
||
...options
|
||
};
|
||
|
||
for (const [index, header] of headers.entries()) {
|
||
// If a bitmask is set
|
||
if (options.mask) {
|
||
// If header doesn't equal `buf` with bits masked off
|
||
if (header !== (options.mask[index] & buffer[index + options.offset])) {
|
||
return false;
|
||
}
|
||
} else if (header !== buffer[index + options.offset]) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
async function _checkSequence(sequence, tokenizer, ignoreBytes) {
|
||
const buffer = Buffer.alloc(minimumBytes);
|
||
await tokenizer.ignore(ignoreBytes);
|
||
|
||
await tokenizer.peekBuffer(buffer, {mayBeLess: true});
|
||
|
||
return buffer.includes(Buffer.from(sequence));
|
||
}
|
||
|
||
async function fromTokenizer(tokenizer) {
|
||
try {
|
||
return _fromTokenizer(tokenizer);
|
||
} catch (error) {
|
||
if (!(error instanceof strtok3.EndOfStreamError)) {
|
||
throw error;
|
||
}
|
||
}
|
||
}
|
||
|
||
async function _fromTokenizer(tokenizer) {
|
||
let buffer = Buffer.alloc(minimumBytes);
|
||
const bytesRead = 12;
|
||
const check = (header, options) => _check(buffer, header, options);
|
||
const checkString = (header, options) => check(stringToBytes(header), options);
|
||
const checkSequence = (sequence, ignoreBytes) => _checkSequence(sequence, tokenizer, ignoreBytes);
|
||
|
||
// Keep reading until EOF if the file size is unknown.
|
||
if (!tokenizer.fileInfo.size) {
|
||
tokenizer.fileInfo.size = Number.MAX_SAFE_INTEGER;
|
||
}
|
||
|
||
await tokenizer.peekBuffer(buffer, {length: bytesRead, mayBeLess: true});
|
||
|
||
// -- 2-byte signatures --
|
||
|
||
if (check([0x42, 0x4D])) {
|
||
return {
|
||
ext: 'bmp',
|
||
mime: 'image/bmp'
|
||
};
|
||
}
|
||
|
||
if (check([0x0B, 0x77])) {
|
||
return {
|
||
ext: 'ac3',
|
||
mime: 'audio/vnd.dolby.dd-raw'
|
||
};
|
||
}
|
||
|
||
if (check([0x78, 0x01])) {
|
||
return {
|
||
ext: 'dmg',
|
||
mime: 'application/x-apple-diskimage'
|
||
};
|
||
}
|
||
|
||
if (check([0x4D, 0x5A])) {
|
||
return {
|
||
ext: 'exe',
|
||
mime: 'application/x-msdownload'
|
||
};
|
||
}
|
||
|
||
if (check([0x25, 0x21])) {
|
||
await tokenizer.peekBuffer(buffer, {length: 24, mayBeLess: true});
|
||
|
||
if (checkString('PS-Adobe-', {offset: 2}) &&
|
||
checkString(' EPSF-', {offset: 14})) {
|
||
return {
|
||
ext: 'eps',
|
||
mime: 'application/eps'
|
||
};
|
||
}
|
||
|
||
return {
|
||
ext: 'ps',
|
||
mime: 'application/postscript'
|
||
};
|
||
}
|
||
|
||
if (
|
||
check([0x1F, 0xA0]) ||
|
||
check([0x1F, 0x9D])
|
||
) {
|
||
return {
|
||
ext: 'Z',
|
||
mime: 'application/x-compress'
|
||
};
|
||
}
|
||
|
||
// -- 3-byte signatures --
|
||
|
||
if (check([0xFF, 0xD8, 0xFF])) {
|
||
return {
|
||
ext: 'jpg',
|
||
mime: 'image/jpeg'
|
||
};
|
||
}
|
||
|
||
if (check([0x49, 0x49, 0xBC])) {
|
||
return {
|
||
ext: 'jxr',
|
||
mime: 'image/vnd.ms-photo'
|
||
};
|
||
}
|
||
|
||
if (check([0x1F, 0x8B, 0x8])) {
|
||
return {
|
||
ext: 'gz',
|
||
mime: 'application/gzip'
|
||
};
|
||
}
|
||
|
||
if (check([0x42, 0x5A, 0x68])) {
|
||
return {
|
||
ext: 'bz2',
|
||
mime: 'application/x-bzip2'
|
||
};
|
||
}
|
||
|
||
if (checkString('ID3')) {
|
||
await tokenizer.ignore(6); // Skip ID3 header until the header size
|
||
const id3HeaderLen = await tokenizer.readToken(uint32SyncSafeToken);
|
||
if (tokenizer.position + id3HeaderLen > tokenizer.fileInfo.size) {
|
||
// Guess file type based on ID3 header for backward compatibility
|
||
return {
|
||
ext: 'mp3',
|
||
mime: 'audio/mpeg'
|
||
};
|
||
}
|
||
|
||
await tokenizer.ignore(id3HeaderLen);
|
||
return fromTokenizer(tokenizer); // Skip ID3 header, recursion
|
||
}
|
||
|
||
// Musepack, SV7
|
||
if (checkString('MP+')) {
|
||
return {
|
||
ext: 'mpc',
|
||
mime: 'audio/x-musepack'
|
||
};
|
||
}
|
||
|
||
if (
|
||
(buffer[0] === 0x43 || buffer[0] === 0x46) &&
|
||
check([0x57, 0x53], {offset: 1})
|
||
) {
|
||
return {
|
||
ext: 'swf',
|
||
mime: 'application/x-shockwave-flash'
|
||
};
|
||
}
|
||
|
||
// -- 4-byte signatures --
|
||
|
||
if (check([0x47, 0x49, 0x46])) {
|
||
return {
|
||
ext: 'gif',
|
||
mime: 'image/gif'
|
||
};
|
||
}
|
||
|
||
if (checkString('FLIF')) {
|
||
return {
|
||
ext: 'flif',
|
||
mime: 'image/flif'
|
||
};
|
||
}
|
||
|
||
if (checkString('8BPS')) {
|
||
return {
|
||
ext: 'psd',
|
||
mime: 'image/vnd.adobe.photoshop'
|
||
};
|
||
}
|
||
|
||
if (checkString('WEBP', {offset: 8})) {
|
||
return {
|
||
ext: 'webp',
|
||
mime: 'image/webp'
|
||
};
|
||
}
|
||
|
||
// Musepack, SV8
|
||
if (checkString('MPCK')) {
|
||
return {
|
||
ext: 'mpc',
|
||
mime: 'audio/x-musepack'
|
||
};
|
||
}
|
||
|
||
if (checkString('FORM')) {
|
||
return {
|
||
ext: 'aif',
|
||
mime: 'audio/aiff'
|
||
};
|
||
}
|
||
|
||
if (checkString('icns', {offset: 0})) {
|
||
return {
|
||
ext: 'icns',
|
||
mime: 'image/icns'
|
||
};
|
||
}
|
||
|
||
// Zip-based file formats
|
||
// Need to be before the `zip` check
|
||
if (check([0x50, 0x4B, 0x3, 0x4])) { // Local file header signature
|
||
try {
|
||
while (tokenizer.position + 30 < tokenizer.fileInfo.size) {
|
||
await tokenizer.readBuffer(buffer, {length: 30});
|
||
|
||
// https://en.wikipedia.org/wiki/Zip_(file_format)#File_headers
|
||
const zipHeader = {
|
||
compressedSize: buffer.readUInt32LE(18),
|
||
uncompressedSize: buffer.readUInt32LE(22),
|
||
filenameLength: buffer.readUInt16LE(26),
|
||
extraFieldLength: buffer.readUInt16LE(28)
|
||
};
|
||
|
||
zipHeader.filename = await tokenizer.readToken(new Token.StringType(zipHeader.filenameLength, 'utf-8'));
|
||
await tokenizer.ignore(zipHeader.extraFieldLength);
|
||
|
||
// Assumes signed `.xpi` from addons.mozilla.org
|
||
if (zipHeader.filename === 'META-INF/mozilla.rsa') {
|
||
return {
|
||
ext: 'xpi',
|
||
mime: 'application/x-xpinstall'
|
||
};
|
||
}
|
||
|
||
if (zipHeader.filename.endsWith('.rels') || zipHeader.filename.endsWith('.xml')) {
|
||
const type = zipHeader.filename.split('/')[0];
|
||
switch (type) {
|
||
case '_rels':
|
||
break;
|
||
case 'word':
|
||
return {
|
||
ext: 'docx',
|
||
mime: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
|
||
};
|
||
case 'ppt':
|
||
return {
|
||
ext: 'pptx',
|
||
mime: 'application/vnd.openxmlformats-officedocument.presentationml.presentation'
|
||
};
|
||
case 'xl':
|
||
return {
|
||
ext: 'xlsx',
|
||
mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
|
||
};
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (zipHeader.filename.startsWith('xl/')) {
|
||
return {
|
||
ext: 'xlsx',
|
||
mime: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
|
||
};
|
||
}
|
||
|
||
// The docx, xlsx and pptx file types extend the Office Open XML file format:
|
||
// https://en.wikipedia.org/wiki/Office_Open_XML_file_formats
|
||
// We look for:
|
||
// - one entry named '[Content_Types].xml' or '_rels/.rels',
|
||
// - one entry indicating specific type of file.
|
||
// MS Office, OpenOffice and LibreOffice may put the parts in different order, so the check should not rely on it.
|
||
if (zipHeader.filename === 'mimetype' && zipHeader.compressedSize === zipHeader.uncompressedSize) {
|
||
const mimeType = await tokenizer.readToken(new Token.StringType(zipHeader.compressedSize, 'utf-8'));
|
||
|
||
switch (mimeType) {
|
||
case 'application/epub+zip':
|
||
return {
|
||
ext: 'epub',
|
||
mime: 'application/epub+zip'
|
||
};
|
||
case 'application/vnd.oasis.opendocument.text':
|
||
return {
|
||
ext: 'odt',
|
||
mime: 'application/vnd.oasis.opendocument.text'
|
||
};
|
||
case 'application/vnd.oasis.opendocument.spreadsheet':
|
||
return {
|
||
ext: 'ods',
|
||
mime: 'application/vnd.oasis.opendocument.spreadsheet'
|
||
};
|
||
case 'application/vnd.oasis.opendocument.presentation':
|
||
return {
|
||
ext: 'odp',
|
||
mime: 'application/vnd.oasis.opendocument.presentation'
|
||
};
|
||
default:
|
||
}
|
||
}
|
||
|
||
await tokenizer.ignore(zipHeader.compressedSize);
|
||
}
|
||
} catch (error) {
|
||
if (!(error instanceof strtok3.EndOfStreamError)) {
|
||
throw error;
|
||
}
|
||
}
|
||
|
||
return {
|
||
ext: 'zip',
|
||
mime: 'application/zip'
|
||
};
|
||
}
|
||
|
||
if (checkString('OggS')) {
|
||
// This is an OGG container
|
||
await tokenizer.ignore(28);
|
||
const type = Buffer.alloc(8);
|
||
await tokenizer.readBuffer(type);
|
||
|
||
// Needs to be before `ogg` check
|
||
if (_check(type, [0x4F, 0x70, 0x75, 0x73, 0x48, 0x65, 0x61, 0x64])) {
|
||
return {
|
||
ext: 'opus',
|
||
mime: 'audio/opus'
|
||
};
|
||
}
|
||
|
||
// If ' theora' in header.
|
||
if (_check(type, [0x80, 0x74, 0x68, 0x65, 0x6F, 0x72, 0x61])) {
|
||
return {
|
||
ext: 'ogv',
|
||
mime: 'video/ogg'
|
||
};
|
||
}
|
||
|
||
// If '\x01video' in header.
|
||
if (_check(type, [0x01, 0x76, 0x69, 0x64, 0x65, 0x6F, 0x00])) {
|
||
return {
|
||
ext: 'ogm',
|
||
mime: 'video/ogg'
|
||
};
|
||
}
|
||
|
||
// If ' FLAC' in header https://xiph.org/flac/faq.html
|
||
if (_check(type, [0x7F, 0x46, 0x4C, 0x41, 0x43])) {
|
||
return {
|
||
ext: 'oga',
|
||
mime: 'audio/ogg'
|
||
};
|
||
}
|
||
|
||
// 'Speex ' in header https://en.wikipedia.org/wiki/Speex
|
||
if (_check(type, [0x53, 0x70, 0x65, 0x65, 0x78, 0x20, 0x20])) {
|
||
return {
|
||
ext: 'spx',
|
||
mime: 'audio/ogg'
|
||
};
|
||
}
|
||
|
||
// If '\x01vorbis' in header
|
||
if (_check(type, [0x01, 0x76, 0x6F, 0x72, 0x62, 0x69, 0x73])) {
|
||
return {
|
||
ext: 'ogg',
|
||
mime: 'audio/ogg'
|
||
};
|
||
}
|
||
|
||
// Default OGG container https://www.iana.org/assignments/media-types/application/ogg
|
||
return {
|
||
ext: 'ogx',
|
||
mime: 'application/ogg'
|
||
};
|
||
}
|
||
|
||
if (
|
||
check([0x50, 0x4B]) &&
|
||
(buffer[2] === 0x3 || buffer[2] === 0x5 || buffer[2] === 0x7) &&
|
||
(buffer[3] === 0x4 || buffer[3] === 0x6 || buffer[3] === 0x8)
|
||
) {
|
||
return {
|
||
ext: 'zip',
|
||
mime: 'application/zip'
|
||
};
|
||
}
|
||
|
||
//
|
||
|
||
// File Type Box (https://en.wikipedia.org/wiki/ISO_base_media_file_format)
|
||
// It's not required to be first, but it's recommended to be. Almost all ISO base media files start with `ftyp` box.
|
||
// `ftyp` box must contain a brand major identifier, which must consist of ISO 8859-1 printable characters.
|
||
// Here we check for 8859-1 printable characters (for simplicity, it's a mask which also catches one non-printable character).
|
||
if (
|
||
checkString('ftyp', {offset: 4}) &&
|
||
(buffer[8] & 0x60) !== 0x00 // Brand major, first character ASCII?
|
||
) {
|
||
// They all can have MIME `video/mp4` except `application/mp4` special-case which is hard to detect.
|
||
// For some cases, we're specific, everything else falls to `video/mp4` with `mp4` extension.
|
||
const brandMajor = uint8ArrayUtf8ByteString(buffer, 8, 12).replace('\0', ' ').trim();
|
||
switch (brandMajor) {
|
||
case 'avif':
|
||
return {ext: 'avif', mime: 'image/avif'};
|
||
case 'mif1':
|
||
return {ext: 'heic', mime: 'image/heif'};
|
||
case 'msf1':
|
||
return {ext: 'heic', mime: 'image/heif-sequence'};
|
||
case 'heic':
|
||
case 'heix':
|
||
return {ext: 'heic', mime: 'image/heic'};
|
||
case 'hevc':
|
||
case 'hevx':
|
||
return {ext: 'heic', mime: 'image/heic-sequence'};
|
||
case 'qt':
|
||
return {ext: 'mov', mime: 'video/quicktime'};
|
||
case 'M4V':
|
||
case 'M4VH':
|
||
case 'M4VP':
|
||
return {ext: 'm4v', mime: 'video/x-m4v'};
|
||
case 'M4P':
|
||
return {ext: 'm4p', mime: 'video/mp4'};
|
||
case 'M4B':
|
||
return {ext: 'm4b', mime: 'audio/mp4'};
|
||
case 'M4A':
|
||
return {ext: 'm4a', mime: 'audio/x-m4a'};
|
||
case 'F4V':
|
||
return {ext: 'f4v', mime: 'video/mp4'};
|
||
case 'F4P':
|
||
return {ext: 'f4p', mime: 'video/mp4'};
|
||
case 'F4A':
|
||
return {ext: 'f4a', mime: 'audio/mp4'};
|
||
case 'F4B':
|
||
return {ext: 'f4b', mime: 'audio/mp4'};
|
||
case 'crx':
|
||
return {ext: 'cr3', mime: 'image/x-canon-cr3'};
|
||
default:
|
||
if (brandMajor.startsWith('3g')) {
|
||
if (brandMajor.startsWith('3g2')) {
|
||
return {ext: '3g2', mime: 'video/3gpp2'};
|
||
}
|
||
|
||
return {ext: '3gp', mime: 'video/3gpp'};
|
||
}
|
||
|
||
return {ext: 'mp4', mime: 'video/mp4'};
|
||
}
|
||
}
|
||
|
||
if (checkString('MThd')) {
|
||
return {
|
||
ext: 'mid',
|
||
mime: 'audio/midi'
|
||
};
|
||
}
|
||
|
||
if (
|
||
checkString('wOFF') &&
|
||
(
|
||
check([0x00, 0x01, 0x00, 0x00], {offset: 4}) ||
|
||
checkString('OTTO', {offset: 4})
|
||
)
|
||
) {
|
||
return {
|
||
ext: 'woff',
|
||
mime: 'font/woff'
|
||
};
|
||
}
|
||
|
||
if (
|
||
checkString('wOF2') &&
|
||
(
|
||
check([0x00, 0x01, 0x00, 0x00], {offset: 4}) ||
|
||
checkString('OTTO', {offset: 4})
|
||
)
|
||
) {
|
||
return {
|
||
ext: 'woff2',
|
||
mime: 'font/woff2'
|
||
};
|
||
}
|
||
|
||
if (check([0xD4, 0xC3, 0xB2, 0xA1]) || check([0xA1, 0xB2, 0xC3, 0xD4])) {
|
||
return {
|
||
ext: 'pcap',
|
||
mime: 'application/vnd.tcpdump.pcap'
|
||
};
|
||
}
|
||
|
||
// Sony DSD Stream File (DSF)
|
||
if (checkString('DSD ')) {
|
||
return {
|
||
ext: 'dsf',
|
||
mime: 'audio/x-dsf' // Non-standard
|
||
};
|
||
}
|
||
|
||
if (checkString('LZIP')) {
|
||
return {
|
||
ext: 'lz',
|
||
mime: 'application/x-lzip'
|
||
};
|
||
}
|
||
|
||
if (checkString('fLaC')) {
|
||
return {
|
||
ext: 'flac',
|
||
mime: 'audio/x-flac'
|
||
};
|
||
}
|
||
|
||
if (check([0x42, 0x50, 0x47, 0xFB])) {
|
||
return {
|
||
ext: 'bpg',
|
||
mime: 'image/bpg'
|
||
};
|
||
}
|
||
|
||
if (checkString('wvpk')) {
|
||
return {
|
||
ext: 'wv',
|
||
mime: 'audio/wavpack'
|
||
};
|
||
}
|
||
|
||
if (checkString('%PDF')) {
|
||
// Check if this is an Adobe Illustrator file
|
||
const isAiFile = await checkSequence('Adobe Illustrator', 1350);
|
||
if (isAiFile) {
|
||
return {
|
||
ext: 'ai',
|
||
mime: 'application/postscript'
|
||
};
|
||
}
|
||
|
||
// Assume this is just a normal PDF
|
||
return {
|
||
ext: 'pdf',
|
||
mime: 'application/pdf'
|
||
};
|
||
}
|
||
|
||
if (check([0x00, 0x61, 0x73, 0x6D])) {
|
||
return {
|
||
ext: 'wasm',
|
||
mime: 'application/wasm'
|
||
};
|
||
}
|
||
|
||
// TIFF, little-endian type
|
||
if (check([0x49, 0x49, 0x2A, 0x0])) {
|
||
if (checkString('CR', {offset: 8})) {
|
||
return {
|
||
ext: 'cr2',
|
||
mime: 'image/x-canon-cr2'
|
||
};
|
||
}
|
||
|
||
if (check([0x1C, 0x00, 0xFE, 0x00], {offset: 8}) || check([0x1F, 0x00, 0x0B, 0x00], {offset: 8})) {
|
||
return {
|
||
ext: 'nef',
|
||
mime: 'image/x-nikon-nef'
|
||
};
|
||
}
|
||
|
||
if (
|
||
check([0x08, 0x00, 0x00, 0x00], {offset: 4}) &&
|
||
(check([0x2D, 0x00, 0xFE, 0x00], {offset: 8}) ||
|
||
check([0x27, 0x00, 0xFE, 0x00], {offset: 8}))
|
||
) {
|
||
return {
|
||
ext: 'dng',
|
||
mime: 'image/x-adobe-dng'
|
||
};
|
||
}
|
||
|
||
buffer = Buffer.alloc(24);
|
||
await tokenizer.peekBuffer(buffer);
|
||
if (
|
||
(check([0x10, 0xFB, 0x86, 0x01], {offset: 4}) || check([0x08, 0x00, 0x00, 0x00], {offset: 4})) &&
|
||
// This pattern differentiates ARW from other TIFF-ish file types:
|
||
check([0x00, 0xFE, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x01], {offset: 9})
|
||
) {
|
||
return {
|
||
ext: 'arw',
|
||
mime: 'image/x-sony-arw'
|
||
};
|
||
}
|
||
|
||
return {
|
||
ext: 'tif',
|
||
mime: 'image/tiff'
|
||
};
|
||
}
|
||
|
||
// TIFF, big-endian type
|
||
if (check([0x4D, 0x4D, 0x0, 0x2A])) {
|
||
return {
|
||
ext: 'tif',
|
||
mime: 'image/tiff'
|
||
};
|
||
}
|
||
|
||
if (checkString('MAC ')) {
|
||
return {
|
||
ext: 'ape',
|
||
mime: 'audio/ape'
|
||
};
|
||
}
|
||
|
||
// https://github.com/threatstack/libmagic/blob/master/magic/Magdir/matroska
|
||
if (check([0x1A, 0x45, 0xDF, 0xA3])) { // Root element: EBML
|
||
async function readField() {
|
||
const msb = await tokenizer.peekNumber(Token.UINT8);
|
||
let mask = 0x80;
|
||
let ic = 0; // 0 = A, 1 = B, 2 = C, 3 = D
|
||
|
||
while ((msb & mask) === 0) {
|
||
++ic;
|
||
mask >>= 1;
|
||
}
|
||
|
||
const id = Buffer.alloc(ic + 1);
|
||
await tokenizer.readBuffer(id);
|
||
return id;
|
||
}
|
||
|
||
async function readElement() {
|
||
const id = await readField();
|
||
const lenField = await readField();
|
||
lenField[0] ^= 0x80 >> (lenField.length - 1);
|
||
const nrLen = Math.min(6, lenField.length); // JavaScript can max read 6 bytes integer
|
||
return {
|
||
id: id.readUIntBE(0, id.length),
|
||
len: lenField.readUIntBE(lenField.length - nrLen, nrLen)
|
||
};
|
||
}
|
||
|
||
async function readChildren(level, children) {
|
||
while (children > 0) {
|
||
const e = await readElement();
|
||
if (e.id === 0x4282) {
|
||
return tokenizer.readToken(new Token.StringType(e.len, 'utf-8')); // Return DocType
|
||
}
|
||
|
||
await tokenizer.ignore(e.len); // ignore payload
|
||
--children;
|
||
}
|
||
}
|
||
|
||
const re = await readElement();
|
||
const docType = await readChildren(1, re.len);
|
||
|
||
switch (docType) {
|
||
case 'webm':
|
||
return {
|
||
ext: 'webm',
|
||
mime: 'video/webm'
|
||
};
|
||
|
||
case 'matroska':
|
||
return {
|
||
ext: 'mkv',
|
||
mime: 'video/x-matroska'
|
||
};
|
||
|
||
default:
|
||
return;
|
||
}
|
||
}
|
||
|
||
// RIFF file format which might be AVI, WAV, QCP, etc
|
||
if (check([0x52, 0x49, 0x46, 0x46])) {
|
||
if (check([0x41, 0x56, 0x49], {offset: 8})) {
|
||
return {
|
||
ext: 'avi',
|
||
mime: 'video/vnd.avi'
|
||
};
|
||
}
|
||
|
||
if (check([0x57, 0x41, 0x56, 0x45], {offset: 8})) {
|
||
return {
|
||
ext: 'wav',
|
||
mime: 'audio/vnd.wave'
|
||
};
|
||
}
|
||
|
||
// QLCM, QCP file
|
||
if (check([0x51, 0x4C, 0x43, 0x4D], {offset: 8})) {
|
||
return {
|
||
ext: 'qcp',
|
||
mime: 'audio/qcelp'
|
||
};
|
||
}
|
||
}
|
||
|
||
if (checkString('SQLi')) {
|
||
return {
|
||
ext: 'sqlite',
|
||
mime: 'application/x-sqlite3'
|
||
};
|
||
}
|
||
|
||
if (check([0x4E, 0x45, 0x53, 0x1A])) {
|
||
return {
|
||
ext: 'nes',
|
||
mime: 'application/x-nintendo-nes-rom'
|
||
};
|
||
}
|
||
|
||
if (checkString('Cr24')) {
|
||
return {
|
||
ext: 'crx',
|
||
mime: 'application/x-google-chrome-extension'
|
||
};
|
||
}
|
||
|
||
if (
|
||
checkString('MSCF') ||
|
||
checkString('ISc(')
|
||
) {
|
||
return {
|
||
ext: 'cab',
|
||
mime: 'application/vnd.ms-cab-compressed'
|
||
};
|
||
}
|
||
|
||
if (check([0xED, 0xAB, 0xEE, 0xDB])) {
|
||
return {
|
||
ext: 'rpm',
|
||
mime: 'application/x-rpm'
|
||
};
|
||
}
|
||
|
||
if (check([0xC5, 0xD0, 0xD3, 0xC6])) {
|
||
return {
|
||
ext: 'eps',
|
||
mime: 'application/eps'
|
||
};
|
||
}
|
||
|
||
// -- 5-byte signatures --
|
||
|
||
if (check([0x4F, 0x54, 0x54, 0x4F, 0x00])) {
|
||
return {
|
||
ext: 'otf',
|
||
mime: 'font/otf'
|
||
};
|
||
}
|
||
|
||
if (checkString('#!AMR')) {
|
||
return {
|
||
ext: 'amr',
|
||
mime: 'audio/amr'
|
||
};
|
||
}
|
||
|
||
if (checkString('{\\rtf')) {
|
||
return {
|
||
ext: 'rtf',
|
||
mime: 'application/rtf'
|
||
};
|
||
}
|
||
|
||
if (check([0x46, 0x4C, 0x56, 0x01])) {
|
||
return {
|
||
ext: 'flv',
|
||
mime: 'video/x-flv'
|
||
};
|
||
}
|
||
|
||
if (checkString('IMPM')) {
|
||
return {
|
||
ext: 'it',
|
||
mime: 'audio/x-it'
|
||
};
|
||
}
|
||
|
||
if (
|
||
checkString('-lh0-', {offset: 2}) ||
|
||
checkString('-lh1-', {offset: 2}) ||
|
||
checkString('-lh2-', {offset: 2}) ||
|
||
checkString('-lh3-', {offset: 2}) ||
|
||
checkString('-lh4-', {offset: 2}) ||
|
||
checkString('-lh5-', {offset: 2}) ||
|
||
checkString('-lh6-', {offset: 2}) ||
|
||
checkString('-lh7-', {offset: 2}) ||
|
||
checkString('-lzs-', {offset: 2}) ||
|
||
checkString('-lz4-', {offset: 2}) ||
|
||
checkString('-lz5-', {offset: 2}) ||
|
||
checkString('-lhd-', {offset: 2})
|
||
) {
|
||
return {
|
||
ext: 'lzh',
|
||
mime: 'application/x-lzh-compressed'
|
||
};
|
||
}
|
||
|
||
// MPEG program stream (PS or MPEG-PS)
|
||
if (check([0x00, 0x00, 0x01, 0xBA])) {
|
||
// MPEG-PS, MPEG-1 Part 1
|
||
if (check([0x21], {offset: 4, mask: [0xF1]})) {
|
||
return {
|
||
ext: 'mpg', // May also be .ps, .mpeg
|
||
mime: 'video/MP1S'
|
||
};
|
||
}
|
||
|
||
// MPEG-PS, MPEG-2 Part 1
|
||
if (check([0x44], {offset: 4, mask: [0xC4]})) {
|
||
return {
|
||
ext: 'mpg', // May also be .mpg, .m2p, .vob or .sub
|
||
mime: 'video/MP2P'
|
||
};
|
||
}
|
||
}
|
||
|
||
// -- 6-byte signatures --
|
||
|
||
if (check([0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00])) {
|
||
return {
|
||
ext: 'xz',
|
||
mime: 'application/x-xz'
|
||
};
|
||
}
|
||
|
||
if (checkString('<?xml ')) {
|
||
return {
|
||
ext: 'xml',
|
||
mime: 'application/xml'
|
||
};
|
||
}
|
||
|
||
if (checkString('BEGIN:')) {
|
||
return {
|
||
ext: 'ics',
|
||
mime: 'text/calendar'
|
||
};
|
||
}
|
||
|
||
if (check([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C])) {
|
||
return {
|
||
ext: '7z',
|
||
mime: 'application/x-7z-compressed'
|
||
};
|
||
}
|
||
|
||
if (
|
||
check([0x52, 0x61, 0x72, 0x21, 0x1A, 0x7]) &&
|
||
(buffer[6] === 0x0 || buffer[6] === 0x1)
|
||
) {
|
||
return {
|
||
ext: 'rar',
|
||
mime: 'application/x-rar-compressed'
|
||
};
|
||
}
|
||
|
||
// -- 7-byte signatures --
|
||
|
||
if (checkString('BLENDER')) {
|
||
return {
|
||
ext: 'blend',
|
||
mime: 'application/x-blender'
|
||
};
|
||
}
|
||
|
||
if (checkString('!<arch>')) {
|
||
await tokenizer.ignore(8);
|
||
const str = await tokenizer.readToken(new Token.StringType(13, 'ascii'));
|
||
if (str === 'debian-binary') {
|
||
return {
|
||
ext: 'deb',
|
||
mime: 'application/x-deb'
|
||
};
|
||
}
|
||
|
||
return {
|
||
ext: 'ar',
|
||
mime: 'application/x-unix-archive'
|
||
};
|
||
}
|
||
|
||
// -- 8-byte signatures --
|
||
|
||
if (check([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])) {
|
||
// APNG format (https://wiki.mozilla.org/APNG_Specification)
|
||
// 1. Find the first IDAT (image data) chunk (49 44 41 54)
|
||
// 2. Check if there is an "acTL" chunk before the IDAT one (61 63 54 4C)
|
||
|
||
// Offset calculated as follows:
|
||
// - 8 bytes: PNG signature
|
||
// - 4 (length) + 4 (chunk type) + 13 (chunk data) + 4 (CRC): IHDR chunk
|
||
|
||
await tokenizer.ignore(8); // ignore PNG signature
|
||
|
||
async function readChunkHeader() {
|
||
return {
|
||
length: await tokenizer.readToken(Token.INT32_BE),
|
||
type: await tokenizer.readToken(new Token.StringType(4, 'binary'))
|
||
};
|
||
}
|
||
|
||
do {
|
||
const chunk = await readChunkHeader();
|
||
switch (chunk.type) {
|
||
case 'IDAT':
|
||
return {
|
||
ext: 'png',
|
||
mime: 'image/png'
|
||
};
|
||
case 'acTL':
|
||
return {
|
||
ext: 'apng',
|
||
mime: 'image/apng'
|
||
};
|
||
default:
|
||
await tokenizer.ignore(chunk.length + 4); // Ignore chunk-data + CRC
|
||
}
|
||
} while (tokenizer.position < tokenizer.fileInfo.size);
|
||
|
||
return {
|
||
ext: 'png',
|
||
mime: 'image/png'
|
||
};
|
||
}
|
||
|
||
if (check([0x41, 0x52, 0x52, 0x4F, 0x57, 0x31, 0x00, 0x00])) {
|
||
return {
|
||
ext: 'arrow',
|
||
mime: 'application/x-apache-arrow'
|
||
};
|
||
}
|
||
|
||
if (check([0x67, 0x6C, 0x54, 0x46, 0x02, 0x00, 0x00, 0x00])) {
|
||
return {
|
||
ext: 'glb',
|
||
mime: 'model/gltf-binary'
|
||
};
|
||
}
|
||
|
||
// `mov` format variants
|
||
if (
|
||
check([0x66, 0x72, 0x65, 0x65], {offset: 4}) || // `free`
|
||
check([0x6D, 0x64, 0x61, 0x74], {offset: 4}) || // `mdat` MJPEG
|
||
check([0x6D, 0x6F, 0x6F, 0x76], {offset: 4}) || // `moov`
|
||
check([0x77, 0x69, 0x64, 0x65], {offset: 4}) // `wide`
|
||
) {
|
||
return {
|
||
ext: 'mov',
|
||
mime: 'video/quicktime'
|
||
};
|
||
}
|
||
|
||
// -- 9-byte signatures --
|
||
|
||
if (check([0x49, 0x49, 0x52, 0x4F, 0x08, 0x00, 0x00, 0x00, 0x18])) {
|
||
return {
|
||
ext: 'orf',
|
||
mime: 'image/x-olympus-orf'
|
||
};
|
||
}
|
||
|
||
// -- 12-byte signatures --
|
||
|
||
if (check([0x49, 0x49, 0x55, 0x00, 0x18, 0x00, 0x00, 0x00, 0x88, 0xE7, 0x74, 0xD8])) {
|
||
return {
|
||
ext: 'rw2',
|
||
mime: 'image/x-panasonic-rw2'
|
||
};
|
||
}
|
||
|
||
// ASF_Header_Object first 80 bytes
|
||
if (check([0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9])) {
|
||
async function readHeader() {
|
||
const guid = Buffer.alloc(16);
|
||
await tokenizer.readBuffer(guid);
|
||
return {
|
||
id: guid,
|
||
size: await tokenizer.readToken(Token.UINT64_LE)
|
||
};
|
||
}
|
||
|
||
await tokenizer.ignore(30);
|
||
// Search for header should be in first 1KB of file.
|
||
while (tokenizer.position + 24 < tokenizer.fileInfo.size) {
|
||
const header = await readHeader();
|
||
let payload = header.size - 24;
|
||
if (_check(header.id, [0x91, 0x07, 0xDC, 0xB7, 0xB7, 0xA9, 0xCF, 0x11, 0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65])) {
|
||
// Sync on Stream-Properties-Object (B7DC0791-A9B7-11CF-8EE6-00C00C205365)
|
||
const typeId = Buffer.alloc(16);
|
||
payload -= await tokenizer.readBuffer(typeId);
|
||
|
||
if (_check(typeId, [0x40, 0x9E, 0x69, 0xF8, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
|
||
// Found audio:
|
||
return {
|
||
ext: 'wma',
|
||
mime: 'audio/x-ms-wma'
|
||
};
|
||
}
|
||
|
||
if (_check(typeId, [0xC0, 0xEF, 0x19, 0xBC, 0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B])) {
|
||
// Found video:
|
||
return {
|
||
ext: 'wmv',
|
||
mime: 'video/x-ms-asf'
|
||
};
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
await tokenizer.ignore(payload);
|
||
}
|
||
|
||
// Default to ASF generic extension
|
||
return {
|
||
ext: 'asf',
|
||
mime: 'application/vnd.ms-asf'
|
||
};
|
||
}
|
||
|
||
if (check([0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A])) {
|
||
return {
|
||
ext: 'ktx',
|
||
mime: 'image/ktx'
|
||
};
|
||
}
|
||
|
||
if ((check([0x7E, 0x10, 0x04]) || check([0x7E, 0x18, 0x04])) && check([0x30, 0x4D, 0x49, 0x45], {offset: 4})) {
|
||
return {
|
||
ext: 'mie',
|
||
mime: 'application/x-mie'
|
||
};
|
||
}
|
||
|
||
if (check([0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], {offset: 2})) {
|
||
return {
|
||
ext: 'shp',
|
||
mime: 'application/x-esri-shape'
|
||
};
|
||
}
|
||
|
||
if (check([0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20, 0x0D, 0x0A, 0x87, 0x0A])) {
|
||
// JPEG-2000 family
|
||
|
||
await tokenizer.ignore(20);
|
||
const type = await tokenizer.readToken(new Token.StringType(4, 'ascii'));
|
||
switch (type) {
|
||
case 'jp2 ':
|
||
return {
|
||
ext: 'jp2',
|
||
mime: 'image/jp2'
|
||
};
|
||
case 'jpx ':
|
||
return {
|
||
ext: 'jpx',
|
||
mime: 'image/jpx'
|
||
};
|
||
case 'jpm ':
|
||
return {
|
||
ext: 'jpm',
|
||
mime: 'image/jpm'
|
||
};
|
||
case 'mjp2':
|
||
return {
|
||
ext: 'mj2',
|
||
mime: 'image/mj2'
|
||
};
|
||
default:
|
||
return;
|
||
}
|
||
}
|
||
|
||
// -- Unsafe signatures --
|
||
|
||
if (
|
||
check([0x0, 0x0, 0x1, 0xBA]) ||
|
||
check([0x0, 0x0, 0x1, 0xB3])
|
||
) {
|
||
return {
|
||
ext: 'mpg',
|
||
mime: 'video/mpeg'
|
||
};
|
||
}
|
||
|
||
if (check([0x00, 0x01, 0x00, 0x00, 0x00])) {
|
||
return {
|
||
ext: 'ttf',
|
||
mime: 'font/ttf'
|
||
};
|
||
}
|
||
|
||
if (check([0x00, 0x00, 0x01, 0x00])) {
|
||
return {
|
||
ext: 'ico',
|
||
mime: 'image/x-icon'
|
||
};
|
||
}
|
||
|
||
if (check([0x00, 0x00, 0x02, 0x00])) {
|
||
return {
|
||
ext: 'cur',
|
||
mime: 'image/x-icon'
|
||
};
|
||
}
|
||
|
||
// Increase sample size from 12 to 256.
|
||
await tokenizer.peekBuffer(buffer, {length: Math.min(256, tokenizer.fileInfo.size), mayBeLess: true});
|
||
|
||
// `raf` is here just to keep all the raw image detectors together.
|
||
if (checkString('FUJIFILMCCD-RAW')) {
|
||
return {
|
||
ext: 'raf',
|
||
mime: 'image/x-fujifilm-raf'
|
||
};
|
||
}
|
||
|
||
if (checkString('Extended Module:')) {
|
||
return {
|
||
ext: 'xm',
|
||
mime: 'audio/x-xm'
|
||
};
|
||
}
|
||
|
||
if (checkString('Creative Voice File')) {
|
||
return {
|
||
ext: 'voc',
|
||
mime: 'audio/x-voc'
|
||
};
|
||
}
|
||
|
||
if (
|
||
check([0x30, 0x30, 0x30, 0x30, 0x30, 0x30], {offset: 148, mask: [0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8]}) && // Valid tar checksum
|
||
tarHeaderChecksumMatches(buffer)
|
||
) {
|
||
return {
|
||
ext: 'tar',
|
||
mime: 'application/x-tar'
|
||
};
|
||
}
|
||
|
||
if (check([0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3E])) {
|
||
return {
|
||
ext: 'msi',
|
||
mime: 'application/x-msi'
|
||
};
|
||
}
|
||
|
||
if (check([0x06, 0x0E, 0x2B, 0x34, 0x02, 0x05, 0x01, 0x01, 0x0D, 0x01, 0x02, 0x01, 0x01, 0x02])) {
|
||
return {
|
||
ext: 'mxf',
|
||
mime: 'application/mxf'
|
||
};
|
||
}
|
||
|
||
if (checkString('SCRM', {offset: 44})) {
|
||
return {
|
||
ext: 's3m',
|
||
mime: 'audio/x-s3m'
|
||
};
|
||
}
|
||
|
||
if (check([0x47], {offset: 4}) && (check([0x47], {offset: 192}) || check([0x47], {offset: 196}))) {
|
||
return {
|
||
ext: 'mts',
|
||
mime: 'video/mp2t'
|
||
};
|
||
}
|
||
|
||
if (check([0x42, 0x4F, 0x4F, 0x4B, 0x4D, 0x4F, 0x42, 0x49], {offset: 60})) {
|
||
return {
|
||
ext: 'mobi',
|
||
mime: 'application/x-mobipocket-ebook'
|
||
};
|
||
}
|
||
|
||
if (check([0x44, 0x49, 0x43, 0x4D], {offset: 128})) {
|
||
return {
|
||
ext: 'dcm',
|
||
mime: 'application/dicom'
|
||
};
|
||
}
|
||
|
||
if (check([0x4C, 0x00, 0x00, 0x00, 0x01, 0x14, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46])) {
|
||
return {
|
||
ext: 'lnk',
|
||
mime: 'application/x.ms.shortcut' // Invented by us
|
||
};
|
||
}
|
||
|
||
if (check([0x62, 0x6F, 0x6F, 0x6B, 0x00, 0x00, 0x00, 0x00, 0x6D, 0x61, 0x72, 0x6B, 0x00, 0x00, 0x00, 0x00])) {
|
||
return {
|
||
ext: 'alias',
|
||
mime: 'application/x.apple.alias' // Invented by us
|
||
};
|
||
}
|
||
|
||
if (
|
||
check([0x4C, 0x50], {offset: 34}) &&
|
||
(
|
||
check([0x00, 0x00, 0x01], {offset: 8}) ||
|
||
check([0x01, 0x00, 0x02], {offset: 8}) ||
|
||
check([0x02, 0x00, 0x02], {offset: 8})
|
||
)
|
||
) {
|
||
return {
|
||
ext: 'eot',
|
||
mime: 'application/vnd.ms-fontobject'
|
||
};
|
||
}
|
||
|
||
// Increase sample size from 256 to 512
|
||
await tokenizer.peekBuffer(buffer, {length: Math.min(512, tokenizer.fileInfo.size), mayBeLess: true});
|
||
|
||
if (
|
||
check([0x30, 0x30, 0x30, 0x30, 0x30, 0x30], {offset: 148, mask: [0xF8, 0xF8, 0xF8, 0xF8, 0xF8, 0xF8]}) && // Valid tar checksum
|
||
tarHeaderChecksumMatches(buffer)
|
||
) {
|
||
return {
|
||
ext: 'tar',
|
||
mime: 'application/x-tar'
|
||
};
|
||
}
|
||
|
||
if (check([0xFF, 0xFE, 0xFF, 0x0E, 0x53, 0x00, 0x6B, 0x00, 0x65, 0x00, 0x74, 0x00, 0x63, 0x00, 0x68, 0x00, 0x55, 0x00, 0x70, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x6F, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00])) {
|
||
return {
|
||
ext: 'skp',
|
||
mime: 'application/vnd.sketchup.skp'
|
||
};
|
||
}
|
||
|
||
// Check for MPEG header at different starting offsets
|
||
for (let start = 0; start < 2 && start < (buffer.length - 16); start++) {
|
||
// Check MPEG 1 or 2 Layer 3 header, or 'layer 0' for ADTS (MPEG sync-word 0xFFE)
|
||
if (buffer.length >= start + 2 && check([0xFF, 0xE0], {offset: start, mask: [0xFF, 0xE0]})) {
|
||
if (check([0x10], {offset: start + 1, mask: [0x16]})) {
|
||
// Check for (ADTS) MPEG-2
|
||
if (check([0x08], {offset: start + 1, mask: [0x08]})) {
|
||
return {
|
||
ext: 'aac',
|
||
mime: 'audio/aac'
|
||
};
|
||
}
|
||
|
||
// Must be (ADTS) MPEG-4
|
||
return {
|
||
ext: 'aac',
|
||
mime: 'audio/aac'
|
||
};
|
||
}
|
||
|
||
// MPEG 1 or 2 Layer 3 header
|
||
// Check for MPEG layer 3
|
||
if (check([0x02], {offset: start + 1, mask: [0x06]})) {
|
||
return {
|
||
ext: 'mp3',
|
||
mime: 'audio/mpeg'
|
||
};
|
||
}
|
||
|
||
// Check for MPEG layer 2
|
||
if (check([0x04], {offset: start + 1, mask: [0x06]})) {
|
||
return {
|
||
ext: 'mp2',
|
||
mime: 'audio/mpeg'
|
||
};
|
||
}
|
||
|
||
// Check for MPEG layer 1
|
||
if (check([0x06], {offset: start + 1, mask: [0x06]})) {
|
||
return {
|
||
ext: 'mp1',
|
||
mime: 'audio/mpeg'
|
||
};
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
const stream = readableStream => new Promise((resolve, reject) => {
|
||
// Using `eval` to work around issues when bundling with Webpack
|
||
const stream = eval('require')('stream'); // eslint-disable-line no-eval
|
||
|
||
readableStream.on('error', reject);
|
||
readableStream.once('readable', async () => {
|
||
// Set up output stream
|
||
const pass = new stream.PassThrough();
|
||
let outputStream;
|
||
if (stream.pipeline) {
|
||
outputStream = stream.pipeline(readableStream, pass, () => {});
|
||
} else {
|
||
outputStream = readableStream.pipe(pass);
|
||
}
|
||
|
||
// Read the input stream and detect the filetype
|
||
const chunk = readableStream.read(minimumBytes) || readableStream.read() || Buffer.alloc(0);
|
||
try {
|
||
const fileType = await fromBuffer(chunk);
|
||
pass.fileType = fileType;
|
||
} catch (error) {
|
||
reject(error);
|
||
}
|
||
|
||
resolve(outputStream);
|
||
});
|
||
});
|
||
|
||
const fileType = {
|
||
fromStream,
|
||
fromTokenizer,
|
||
fromBuffer,
|
||
stream
|
||
};
|
||
|
||
Object.defineProperty(fileType, 'extensions', {
|
||
get() {
|
||
return new Set(supported.extensions);
|
||
}
|
||
});
|
||
|
||
Object.defineProperty(fileType, 'mimeTypes', {
|
||
get() {
|
||
return new Set(supported.mimeTypes);
|
||
}
|
||
});
|
||
|
||
module.exports = fileType;
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(429).Buffer))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 450:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const assert = __webpack_require__(12);
|
||
const ieee754 = __webpack_require__(431);
|
||
// Primitive types
|
||
/**
|
||
* 8-bit unsigned integer
|
||
*/
|
||
exports.UINT8 = {
|
||
len: 1,
|
||
get(buf, off) {
|
||
return buf.readUInt8(off);
|
||
},
|
||
put(buf, off, v) {
|
||
assert.equal(typeof off, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= 0 && v <= 0xff);
|
||
assert.ok(off >= 0);
|
||
assert.ok(this.len <= buf.length);
|
||
return buf.writeUInt8(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* 16-bit unsigned integer, Little Endian byte order
|
||
*/
|
||
exports.UINT16_LE = {
|
||
len: 2,
|
||
get(buf, off) {
|
||
return buf.readUInt16LE(off);
|
||
},
|
||
put(buf, off, v) {
|
||
assert.equal(typeof off, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= 0 && v <= 0xffff);
|
||
assert.ok(off >= 0);
|
||
assert.ok(this.len <= buf.length);
|
||
return buf.writeUInt16LE(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* 16-bit unsigned integer, Big Endian byte order
|
||
*/
|
||
exports.UINT16_BE = {
|
||
len: 2,
|
||
get(buf, off) {
|
||
return buf.readUInt16BE(off);
|
||
},
|
||
put(buf, off, v) {
|
||
assert.equal(typeof off, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= 0 && v <= 0xffff);
|
||
assert.ok(off >= 0);
|
||
assert.ok(this.len <= buf.length);
|
||
return buf.writeUInt16BE(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* 24-bit unsigned integer, Little Endian byte order
|
||
*/
|
||
exports.UINT24_LE = {
|
||
len: 3,
|
||
get(buf, off) {
|
||
return buf.readUIntLE(off, 3);
|
||
},
|
||
put(buf, off, v) {
|
||
assert.equal(typeof off, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= 0 && v <= 0xffffff);
|
||
assert.ok(off >= 0);
|
||
assert.ok(this.len <= buf.length);
|
||
return buf.writeUIntLE(v, off, 3);
|
||
}
|
||
};
|
||
/**
|
||
* 24-bit unsigned integer, Big Endian byte order
|
||
*/
|
||
exports.UINT24_BE = {
|
||
len: 3,
|
||
get(buf, off) {
|
||
return buf.readUIntBE(off, 3);
|
||
},
|
||
put(buf, off, v) {
|
||
assert.equal(typeof off, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= 0 && v <= 0xffffff);
|
||
assert.ok(off >= 0);
|
||
assert.ok(this.len <= buf.length);
|
||
return buf.writeUIntBE(v, off, 3);
|
||
}
|
||
};
|
||
/**
|
||
* 32-bit unsigned integer, Little Endian byte order
|
||
*/
|
||
exports.UINT32_LE = {
|
||
len: 4,
|
||
get(buf, off) {
|
||
return buf.readUInt32LE(off);
|
||
},
|
||
put(b, o, v) {
|
||
assert.equal(typeof o, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= 0 && v <= 0xffffffff);
|
||
assert.ok(o >= 0);
|
||
assert.ok(this.len <= b.length);
|
||
return b.writeUInt32LE(v, o);
|
||
}
|
||
};
|
||
/**
|
||
* 32-bit unsigned integer, Big Endian byte order
|
||
*/
|
||
exports.UINT32_BE = {
|
||
len: 4,
|
||
get(buf, off) {
|
||
return buf.readUInt32BE(off);
|
||
},
|
||
put(buf, off, v) {
|
||
assert.equal(typeof off, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= 0 && v <= 0xffffffff);
|
||
assert.ok(off >= 0);
|
||
assert.ok(this.len <= buf.length);
|
||
return buf.writeUInt32BE(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* 8-bit signed integer
|
||
*/
|
||
exports.INT8 = {
|
||
len: 1,
|
||
get(buf, off) {
|
||
return buf.readInt8(off);
|
||
},
|
||
put(buf, off, v) {
|
||
assert.equal(typeof off, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= -128 && v <= 127);
|
||
assert.ok(off >= 0);
|
||
assert.ok(this.len <= buf.length);
|
||
return buf.writeInt8(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* 16-bit signed integer, Big Endian byte order
|
||
*/
|
||
exports.INT16_BE = {
|
||
len: 2,
|
||
get(buf, off) {
|
||
return buf.readInt16BE(off);
|
||
},
|
||
put(b, o, v) {
|
||
assert.equal(typeof o, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= -32768 && v <= 32767);
|
||
assert.ok(o >= 0);
|
||
assert.ok(this.len <= b.length);
|
||
return b.writeInt16BE(v, o);
|
||
}
|
||
};
|
||
/**
|
||
* 16-bit signed integer, Little Endian byte order
|
||
*/
|
||
exports.INT16_LE = {
|
||
len: 2,
|
||
get(buf, off) {
|
||
return buf.readInt16LE(off);
|
||
},
|
||
put(b, o, v) {
|
||
assert.equal(typeof o, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= -32768 && v <= 32767);
|
||
assert.ok(o >= 0);
|
||
assert.ok(this.len <= b.length);
|
||
return b.writeInt16LE(v, o);
|
||
}
|
||
};
|
||
/**
|
||
* 24-bit signed integer, Little Endian byte order
|
||
*/
|
||
exports.INT24_LE = {
|
||
len: 3,
|
||
get(buf, off) {
|
||
return buf.readIntLE(off, 3);
|
||
},
|
||
put(b, o, v) {
|
||
assert.equal(typeof o, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= -0x800000 && v <= 0x7fffff);
|
||
assert.ok(o >= 0);
|
||
assert.ok(this.len <= b.length);
|
||
return b.writeIntLE(v, o, 3);
|
||
}
|
||
};
|
||
/**
|
||
* 24-bit signed integer, Big Endian byte order
|
||
*/
|
||
exports.INT24_BE = {
|
||
len: 3,
|
||
get(buf, off) {
|
||
return buf.readIntBE(off, 3);
|
||
},
|
||
put(b, o, v) {
|
||
assert.equal(typeof o, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= -0x800000 && v <= 0x7fffff);
|
||
assert.ok(o >= 0);
|
||
assert.ok(this.len <= b.length);
|
||
return b.writeIntBE(v, o, 3);
|
||
}
|
||
};
|
||
/**
|
||
* 32-bit signed integer, Big Endian byte order
|
||
*/
|
||
exports.INT32_BE = {
|
||
len: 4,
|
||
get(buf, off) {
|
||
return buf.readInt32BE(off);
|
||
},
|
||
put(b, o, v) {
|
||
assert.equal(typeof o, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= -2147483648 && v <= 2147483647);
|
||
assert.ok(o >= 0);
|
||
assert.ok(this.len <= b.length);
|
||
return b.writeInt32BE(v, o);
|
||
}
|
||
};
|
||
/**
|
||
* 32-bit signed integer, Big Endian byte order
|
||
*/
|
||
exports.INT32_LE = {
|
||
len: 4,
|
||
get(buf, off) {
|
||
return buf.readInt32LE(off);
|
||
},
|
||
put(b, o, v) {
|
||
assert.equal(typeof o, 'number');
|
||
assert.equal(typeof v, 'number');
|
||
assert.ok(v >= -2147483648 && v <= 2147483647);
|
||
assert.ok(o >= 0);
|
||
assert.ok(this.len <= b.length);
|
||
return b.writeInt32LE(v, o);
|
||
}
|
||
};
|
||
/**
|
||
* 64-bit unsigned integer, Little Endian byte order
|
||
*/
|
||
exports.UINT64_LE = {
|
||
len: 8,
|
||
get(buf, off) {
|
||
return readUIntLE(buf, off, this.len);
|
||
},
|
||
put(b, o, v) {
|
||
return writeUIntLE(b, v, o, this.len);
|
||
}
|
||
};
|
||
/**
|
||
* 64-bit signed integer, Little Endian byte order
|
||
*/
|
||
exports.INT64_LE = {
|
||
len: 8,
|
||
get(buf, off) {
|
||
return readIntLE(buf, off, this.len);
|
||
},
|
||
put(b, off, v) {
|
||
return writeIntLE(b, v, off, this.len);
|
||
}
|
||
};
|
||
/**
|
||
* 64-bit unsigned integer, Big Endian byte order
|
||
*/
|
||
exports.UINT64_BE = {
|
||
len: 8,
|
||
get(b, off) {
|
||
return readUIntBE(b, off, this.len);
|
||
},
|
||
put(b, o, v) {
|
||
return writeUIntBE(b, v, o, this.len);
|
||
}
|
||
};
|
||
/**
|
||
* 64-bit signed integer, Big Endian byte order
|
||
*/
|
||
exports.INT64_BE = {
|
||
len: 8,
|
||
get(b, off) {
|
||
return readIntBE(b, off, this.len);
|
||
},
|
||
put(b, off, v) {
|
||
return writeIntBE(b, v, off, this.len);
|
||
}
|
||
};
|
||
/**
|
||
* IEEE 754 16-bit (half precision) float, big endian
|
||
*/
|
||
exports.Float16_BE = {
|
||
len: 2,
|
||
get(b, off) {
|
||
return ieee754.read(b, off, false, 10, this.len);
|
||
},
|
||
put(b, off, v) {
|
||
return ieee754.write(b, v, off, false, 10, this.len);
|
||
}
|
||
};
|
||
/**
|
||
* IEEE 754 16-bit (half precision) float, little endian
|
||
*/
|
||
exports.Float16_LE = {
|
||
len: 2,
|
||
get(b, off) {
|
||
return ieee754.read(b, off, true, 10, this.len);
|
||
},
|
||
put(b, off, v) {
|
||
return ieee754.write(b, v, off, true, 10, this.len);
|
||
}
|
||
};
|
||
/**
|
||
* IEEE 754 32-bit (single precision) float, big endian
|
||
*/
|
||
exports.Float32_BE = {
|
||
len: 4,
|
||
get(b, off) {
|
||
return b.readFloatBE(off);
|
||
},
|
||
put(b, off, v) {
|
||
return b.writeFloatBE(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* IEEE 754 32-bit (single precision) float, little endian
|
||
*/
|
||
exports.Float32_LE = {
|
||
len: 4,
|
||
get(b, off) {
|
||
return b.readFloatLE(off);
|
||
},
|
||
put(b, off, v) {
|
||
return b.writeFloatLE(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* IEEE 754 64-bit (double precision) float, big endian
|
||
*/
|
||
exports.Float64_BE = {
|
||
len: 8,
|
||
get(b, off) {
|
||
return b.readDoubleBE(off);
|
||
},
|
||
put(b, off, v) {
|
||
return b.writeDoubleBE(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* IEEE 754 64-bit (double precision) float, little endian
|
||
*/
|
||
exports.Float64_LE = {
|
||
len: 8,
|
||
get(b, off) {
|
||
return b.readDoubleLE(off);
|
||
},
|
||
put(b, off, v) {
|
||
return b.writeDoubleLE(v, off);
|
||
}
|
||
};
|
||
/**
|
||
* IEEE 754 80-bit (extended precision) float, big endian
|
||
*/
|
||
exports.Float80_BE = {
|
||
len: 10,
|
||
get(b, off) {
|
||
return ieee754.read(b, off, false, 63, this.len);
|
||
},
|
||
put(b, off, v) {
|
||
return ieee754.write(b, v, off, false, 63, this.len);
|
||
}
|
||
};
|
||
/**
|
||
* IEEE 754 80-bit (extended precision) float, little endian
|
||
*/
|
||
exports.Float80_LE = {
|
||
len: 10,
|
||
get(b, off) {
|
||
return ieee754.read(b, off, true, 63, this.len);
|
||
},
|
||
put(b, off, v) {
|
||
return ieee754.write(b, v, off, true, 63, this.len);
|
||
}
|
||
};
|
||
/**
|
||
* Ignore a given number of bytes
|
||
*/
|
||
class IgnoreType {
|
||
/**
|
||
* @param len number of bytes to ignore
|
||
*/
|
||
constructor(len) {
|
||
this.len = len;
|
||
}
|
||
// ToDo: don't read, but skip data
|
||
get(buf, off) {
|
||
}
|
||
}
|
||
exports.IgnoreType = IgnoreType;
|
||
class BufferType {
|
||
constructor(len) {
|
||
this.len = len;
|
||
}
|
||
get(buf, off) {
|
||
return buf.slice(off, off + this.len);
|
||
}
|
||
}
|
||
exports.BufferType = BufferType;
|
||
/**
|
||
* Consume a fixed number of bytes from the stream and return a string with a specified encoding.
|
||
*/
|
||
class StringType {
|
||
constructor(len, encoding) {
|
||
this.len = len;
|
||
this.encoding = encoding;
|
||
}
|
||
get(buf, off) {
|
||
return buf.toString(this.encoding, off, off + this.len);
|
||
}
|
||
}
|
||
exports.StringType = StringType;
|
||
/**
|
||
* ANSI Latin 1 String
|
||
* Using windows-1252 / ISO 8859-1 decoding
|
||
*/
|
||
class AnsiStringType {
|
||
constructor(len) {
|
||
this.len = len;
|
||
}
|
||
static decode(buffer, off, until) {
|
||
let str = '';
|
||
for (let i = off; i < until; ++i) {
|
||
str += AnsiStringType.codePointToString(AnsiStringType.singleByteDecoder(buffer[i]));
|
||
}
|
||
return str;
|
||
}
|
||
static inRange(a, min, max) {
|
||
return min <= a && a <= max;
|
||
}
|
||
static codePointToString(cp) {
|
||
if (cp <= 0xFFFF) {
|
||
return String.fromCharCode(cp);
|
||
}
|
||
else {
|
||
cp -= 0x10000;
|
||
return String.fromCharCode((cp >> 10) + 0xD800, (cp & 0x3FF) + 0xDC00);
|
||
}
|
||
}
|
||
static singleByteDecoder(bite) {
|
||
if (AnsiStringType.inRange(bite, 0x00, 0x7F)) {
|
||
return bite;
|
||
}
|
||
const codePoint = AnsiStringType.windows1252[bite - 0x80];
|
||
if (codePoint === null) {
|
||
throw Error('invaliding encoding');
|
||
}
|
||
return codePoint;
|
||
}
|
||
get(buf, off = 0) {
|
||
return AnsiStringType.decode(buf, off, off + this.len);
|
||
}
|
||
}
|
||
exports.AnsiStringType = AnsiStringType;
|
||
AnsiStringType.windows1252 = [8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352,
|
||
8249, 338, 141, 381, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732,
|
||
8482, 353, 8250, 339, 157, 382, 376, 160, 161, 162, 163, 164, 165, 166, 167, 168,
|
||
169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
|
||
185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200,
|
||
201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216,
|
||
217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232,
|
||
233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247,
|
||
248, 249, 250, 251, 252, 253, 254, 255];
|
||
/**
|
||
* Best effort approach to read up to 64 bit unsigned integer, little endian.
|
||
* Note that JavasScript is limited to 2^53 - 1 bit.
|
||
*/
|
||
function readUIntLE(buf, offset, byteLength) {
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
let val = buf[offset];
|
||
let mul = 1;
|
||
let i = 0;
|
||
while (++i < byteLength && (mul *= 0x100)) {
|
||
val += buf[offset + i] * mul;
|
||
}
|
||
return val;
|
||
}
|
||
/**
|
||
* Best effort approach to write up to 64 bit unsigned integer, little endian.
|
||
* Note that JavasScript is limited to 2^53 - 1 bit.
|
||
*/
|
||
function writeUIntLE(buf, value, offset, byteLength) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
let mul = 1;
|
||
let i = 0;
|
||
buf[offset] = value & 0xFF;
|
||
while (++i < byteLength && (mul *= 0x100)) {
|
||
buf[offset + i] = (value / mul) & 0xFF;
|
||
}
|
||
return offset + byteLength;
|
||
}
|
||
/**
|
||
* Best effort approach to read 64 but signed integer, little endian.
|
||
* Note that JavasScript is limited to 2^53 - 1 bit.
|
||
*/
|
||
function readIntLE(buf, offset, byteLength) {
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
let val = buf[offset];
|
||
let mul = 1;
|
||
let i = 0;
|
||
while (++i < byteLength && (mul *= 0x100)) {
|
||
val += buf[offset + i] * mul;
|
||
}
|
||
mul *= 0x80;
|
||
if (val >= mul)
|
||
val -= Math.pow(2, 8 * byteLength);
|
||
return val;
|
||
}
|
||
/**
|
||
* Best effort approach to write 64 but signed integer, little endian.
|
||
* Note that JavasScript is limited to 2^53 - 1 bit.
|
||
*/
|
||
function writeIntLE(buf, value, offset, byteLength) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
let i = 0;
|
||
let mul = 1;
|
||
let sub = 0;
|
||
buf[offset] = value & 0xFF;
|
||
while (++i < byteLength && (mul *= 0x100)) {
|
||
if (value < 0 && sub === 0 && buf[offset + i - 1] !== 0) {
|
||
sub = 1;
|
||
}
|
||
buf[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
|
||
}
|
||
return offset + byteLength;
|
||
}
|
||
exports.writeIntLE = writeIntLE;
|
||
/**
|
||
* Best effort approach to read up to 64 bit unsigned integer, big endian.
|
||
* Note that JavasScript is limited to 2^53 - 1 bit.
|
||
*/
|
||
function readUIntBE(buf, offset, byteLength) {
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
let val = buf[offset + --byteLength];
|
||
let mul = 1;
|
||
while (byteLength > 0 && (mul *= 0x100)) {
|
||
val += buf[offset + --byteLength] * mul;
|
||
}
|
||
return val;
|
||
}
|
||
exports.readUIntBE = readUIntBE;
|
||
/**
|
||
* Best effort approach to write up to 64 bit unsigned integer, big endian.
|
||
* Note that JavasScript is limited to 2^53 - 1 bit.
|
||
*/
|
||
function writeUIntBE(buf, value, offset, byteLength) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
let i = byteLength - 1;
|
||
let mul = 1;
|
||
buf[offset + i] = value & 0xFF;
|
||
while (--i >= 0 && (mul *= 0x100)) {
|
||
buf[offset + i] = (value / mul) & 0xFF;
|
||
}
|
||
return offset + byteLength;
|
||
}
|
||
exports.writeUIntBE = writeUIntBE;
|
||
/**
|
||
* Best effort approach to read 64 but signed integer, big endian.
|
||
* Note that JavasScript is limited to 2^53 - 1 bit.
|
||
*/
|
||
function readIntBE(buf, offset, byteLength) {
|
||
offset = offset >>> 0;
|
||
byteLength = byteLength >>> 0;
|
||
let i = byteLength;
|
||
let mul = 1;
|
||
let val = buf[offset + --i];
|
||
while (i > 0 && (mul *= 0x100)) {
|
||
val += buf[offset + --i] * mul;
|
||
}
|
||
mul *= 0x80;
|
||
if (val >= mul)
|
||
val -= Math.pow(2, 8 * byteLength);
|
||
return val;
|
||
}
|
||
exports.readIntBE = readIntBE;
|
||
/**
|
||
* Best effort approach to write 64 but signed integer, big endian.
|
||
* Note that JavasScript is limited to 2^53 - 1 bit.
|
||
*/
|
||
function writeIntBE(buf, value, offset, byteLength) {
|
||
value = +value;
|
||
offset = offset >>> 0;
|
||
let i = byteLength - 1;
|
||
let mul = 1;
|
||
let sub = 0;
|
||
buf[offset + i] = value & 0xFF;
|
||
while (--i >= 0 && (mul *= 0x100)) {
|
||
if (value < 0 && sub === 0 && buf[offset + i + 1] !== 0) {
|
||
sub = 1;
|
||
}
|
||
buf[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
|
||
}
|
||
return offset + byteLength;
|
||
}
|
||
exports.writeIntBE = writeIntBE;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 451:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const ReadStreamTokenizer_1 = __webpack_require__(452);
|
||
const BufferTokenizer_1 = __webpack_require__(465);
|
||
var peek_readable_1 = __webpack_require__(454);
|
||
exports.EndOfStreamError = peek_readable_1.EndOfStreamError;
|
||
/**
|
||
* Construct ReadStreamTokenizer from given Stream.
|
||
* Will set fileSize, if provided given Stream has set the .path property/
|
||
* @param stream - Read from Node.js Stream.Readable
|
||
* @param fileInfo - Pass the file information, like size and MIME-type of the correspnding stream.
|
||
* @returns ReadStreamTokenizer
|
||
*/
|
||
function fromStream(stream, fileInfo) {
|
||
fileInfo = fileInfo ? fileInfo : {};
|
||
return new ReadStreamTokenizer_1.ReadStreamTokenizer(stream, fileInfo);
|
||
}
|
||
exports.fromStream = fromStream;
|
||
/**
|
||
* Construct ReadStreamTokenizer from given Buffer.
|
||
* @param buffer - Buffer to tokenize
|
||
* @param fileInfo - Pass additional file information to the tokenizer
|
||
* @returns BufferTokenizer
|
||
*/
|
||
function fromBuffer(buffer, fileInfo) {
|
||
return new BufferTokenizer_1.BufferTokenizer(buffer, fileInfo);
|
||
}
|
||
exports.fromBuffer = fromBuffer;
|
||
//# sourceMappingURL=core.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 452:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(Buffer) {
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const AbstractTokenizer_1 = __webpack_require__(453);
|
||
const peek_readable_1 = __webpack_require__(454);
|
||
const _debug = __webpack_require__(456);
|
||
const debug = _debug('strtok3:ReadStreamTokenizer');
|
||
const maxBufferSize = 1 * 1000 * 1000;
|
||
class ReadStreamTokenizer extends AbstractTokenizer_1.AbstractTokenizer {
|
||
constructor(stream, fileInfo) {
|
||
super(fileInfo);
|
||
this.streamReader = new peek_readable_1.StreamReader(stream);
|
||
}
|
||
/**
|
||
* Get file information, an HTTP-client may implement this doing a HEAD request
|
||
* @return Promise with file information
|
||
*/
|
||
async getFileInfo() {
|
||
return this.fileInfo;
|
||
}
|
||
/**
|
||
* Read buffer from tokenizer
|
||
* @param buffer - Target buffer to fill with data read from the tokenizer-stream
|
||
* @param options - Read behaviour options
|
||
* @returns Promise with number of bytes read
|
||
*/
|
||
async readBuffer(buffer, options) {
|
||
// const _offset = position ? position : this.position;
|
||
// debug(`readBuffer ${_offset}...${_offset + length - 1}`);
|
||
let offset = 0;
|
||
let length = buffer.length;
|
||
if (options) {
|
||
if (Number.isInteger(options.length)) {
|
||
length = options.length;
|
||
}
|
||
else {
|
||
length -= options.offset || 0;
|
||
}
|
||
if (options.position) {
|
||
const skipBytes = options.position - this.position;
|
||
if (skipBytes > 0) {
|
||
await this.ignore(skipBytes);
|
||
return this.readBuffer(buffer, options);
|
||
}
|
||
else if (skipBytes < 0) {
|
||
throw new Error('`options.position` can be less than `tokenizer.position`');
|
||
}
|
||
}
|
||
if (options.offset) {
|
||
offset = options.offset;
|
||
}
|
||
}
|
||
if (length === 0) {
|
||
return 0;
|
||
}
|
||
const bytesRead = await this.streamReader.read(buffer, offset, length);
|
||
this.position += bytesRead;
|
||
if ((!options || !options.mayBeLess) && bytesRead < length) {
|
||
throw new peek_readable_1.EndOfStreamError();
|
||
}
|
||
return bytesRead;
|
||
}
|
||
/**
|
||
* Peek (read ahead) buffer from tokenizer
|
||
* @param buffer - Target buffer to write the data read to
|
||
* @param options - Read behaviour options
|
||
* @returns Promise with number of bytes peeked
|
||
*/
|
||
async peekBuffer(buffer, options) {
|
||
// const _offset = position ? position : this.position;
|
||
// debug(`peek ${_offset}...${_offset + length - 1}`);
|
||
let offset = 0;
|
||
let bytesRead;
|
||
let length = buffer.length;
|
||
if (options) {
|
||
if (options.offset) {
|
||
offset = options.offset;
|
||
}
|
||
if (Number.isInteger(options.length)) {
|
||
length = options.length;
|
||
}
|
||
else {
|
||
length -= options.offset || 0;
|
||
}
|
||
if (options.position) {
|
||
const skipBytes = options.position - this.position;
|
||
if (skipBytes > 0) {
|
||
const skipBuffer = Buffer.alloc(length + skipBytes);
|
||
bytesRead = await this.peekBuffer(skipBuffer, { mayBeLess: options.mayBeLess });
|
||
skipBuffer.copy(buffer, offset, skipBytes);
|
||
return bytesRead - skipBytes;
|
||
}
|
||
else if (skipBytes < 0) {
|
||
throw new Error('Cannot peek from a negative offset in a stream');
|
||
}
|
||
}
|
||
}
|
||
bytesRead = await this.streamReader.peek(buffer, offset, length);
|
||
if ((!options || !options.mayBeLess) && bytesRead < length) {
|
||
throw new peek_readable_1.EndOfStreamError();
|
||
}
|
||
return bytesRead;
|
||
}
|
||
async ignore(length) {
|
||
debug(`ignore ${this.position}...${this.position + length - 1}`);
|
||
const bufSize = Math.min(maxBufferSize, length);
|
||
const buf = Buffer.alloc(bufSize);
|
||
let totBytesRead = 0;
|
||
while (totBytesRead < length) {
|
||
const remaining = length - totBytesRead;
|
||
const bytesRead = await this.readBuffer(buf, { length: Math.min(bufSize, remaining) });
|
||
if (bytesRead < 0) {
|
||
return bytesRead;
|
||
}
|
||
totBytesRead += bytesRead;
|
||
}
|
||
return totBytesRead;
|
||
}
|
||
}
|
||
exports.ReadStreamTokenizer = ReadStreamTokenizer;
|
||
//# sourceMappingURL=ReadStreamTokenizer.js.map
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(429).Buffer))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 453:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(Buffer) {
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const peek_readable_1 = __webpack_require__(454);
|
||
/**
|
||
* Core tokenizer
|
||
*/
|
||
class AbstractTokenizer {
|
||
constructor(fileInfo) {
|
||
/**
|
||
* Tokenizer-stream position
|
||
*/
|
||
this.position = 0;
|
||
this.numBuffer = Buffer.alloc(10);
|
||
this.fileInfo = fileInfo ? fileInfo : {};
|
||
}
|
||
/**
|
||
* Read a token from the tokenizer-stream
|
||
* @param token - The token to read
|
||
* @param position - If provided, the desired position in the tokenizer-stream
|
||
* @returns Promise with token data
|
||
*/
|
||
async readToken(token, position) {
|
||
const buffer = Buffer.alloc(token.len);
|
||
const len = await this.readBuffer(buffer, { position });
|
||
if (len < token.len)
|
||
throw new peek_readable_1.EndOfStreamError();
|
||
return token.get(buffer, 0);
|
||
}
|
||
/**
|
||
* Peek a token from the tokenizer-stream.
|
||
* @param token - Token to peek from the tokenizer-stream.
|
||
* @param position - Offset where to begin reading within the file. If position is null, data will be read from the current file position.
|
||
* @returns Promise with token data
|
||
*/
|
||
async peekToken(token, position = this.position) {
|
||
const buffer = Buffer.alloc(token.len);
|
||
const len = await this.peekBuffer(buffer, { position });
|
||
if (len < token.len)
|
||
throw new peek_readable_1.EndOfStreamError();
|
||
return token.get(buffer, 0);
|
||
}
|
||
/**
|
||
* Read a numeric token from the stream
|
||
* @param token - Numeric token
|
||
* @returns Promise with number
|
||
*/
|
||
async readNumber(token) {
|
||
const len = await this.readBuffer(this.numBuffer, { length: token.len });
|
||
if (len < token.len)
|
||
throw new peek_readable_1.EndOfStreamError();
|
||
return token.get(this.numBuffer, 0);
|
||
}
|
||
/**
|
||
* Read a numeric token from the stream
|
||
* @param token - Numeric token
|
||
* @returns Promise with number
|
||
*/
|
||
async peekNumber(token) {
|
||
const len = await this.peekBuffer(this.numBuffer, { length: token.len });
|
||
if (len < token.len)
|
||
throw new peek_readable_1.EndOfStreamError();
|
||
return token.get(this.numBuffer, 0);
|
||
}
|
||
async close() {
|
||
// empty
|
||
}
|
||
}
|
||
exports.AbstractTokenizer = AbstractTokenizer;
|
||
//# sourceMappingURL=AbstractTokenizer.js.map
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(429).Buffer))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 454:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const assert = __webpack_require__(12);
|
||
const EndOfFileStream_1 = __webpack_require__(455);
|
||
var EndOfFileStream_2 = __webpack_require__(455);
|
||
exports.EndOfStreamError = EndOfFileStream_2.EndOfStreamError;
|
||
class Deferred {
|
||
constructor() {
|
||
this.promise = new Promise((resolve, reject) => {
|
||
this.reject = reject;
|
||
this.resolve = resolve;
|
||
});
|
||
}
|
||
}
|
||
const maxStreamReadSize = 1 * 1024 * 1024; // Maximum request length on read-stream operation
|
||
class StreamReader {
|
||
constructor(s) {
|
||
this.s = s;
|
||
this.endOfStream = false;
|
||
/**
|
||
* Store peeked data
|
||
* @type {Array}
|
||
*/
|
||
this.peekQueue = [];
|
||
if (!s.read || !s.once) {
|
||
throw new Error('Expected an instance of stream.Readable');
|
||
}
|
||
this.s.once('end', () => this.reject(new EndOfFileStream_1.EndOfStreamError()));
|
||
this.s.once('error', err => this.reject(err));
|
||
this.s.once('close', () => this.reject(new Error('Stream closed')));
|
||
}
|
||
/**
|
||
* Read ahead (peek) from stream. Subsequent read or peeks will return the same data
|
||
* @param buffer - Buffer to store data read from stream in
|
||
* @param offset - Offset buffer
|
||
* @param length - Number of bytes to read
|
||
* @returns Number of bytes peeked
|
||
*/
|
||
async peek(buffer, offset, length) {
|
||
const bytesRead = await this.read(buffer, offset, length);
|
||
this.peekQueue.push(buffer.slice(offset, offset + bytesRead)); // Put read data back to peek buffer
|
||
return bytesRead;
|
||
}
|
||
/**
|
||
* Read chunk from stream
|
||
* @param buffer - Target buffer to store data read from stream in
|
||
* @param offset - Offset of target buffer
|
||
* @param length - Number of bytes to read
|
||
* @returns Number of bytes read
|
||
*/
|
||
async read(buffer, offset, length) {
|
||
if (length === 0) {
|
||
return 0;
|
||
}
|
||
if (this.peekQueue.length === 0 && this.endOfStream) {
|
||
throw new EndOfFileStream_1.EndOfStreamError();
|
||
}
|
||
let remaining = length;
|
||
let bytesRead = 0;
|
||
// consume peeked data first
|
||
while (this.peekQueue.length > 0 && remaining > 0) {
|
||
const peekData = this.peekQueue.pop(); // Front of queue
|
||
const lenCopy = Math.min(peekData.length, remaining);
|
||
peekData.copy(buffer, offset + bytesRead, 0, lenCopy);
|
||
bytesRead += lenCopy;
|
||
remaining -= lenCopy;
|
||
if (lenCopy < peekData.length) {
|
||
// remainder back to queue
|
||
this.peekQueue.push(peekData.slice(lenCopy));
|
||
}
|
||
}
|
||
// continue reading from stream if required
|
||
while (remaining > 0 && !this.endOfStream) {
|
||
const reqLen = Math.min(remaining, maxStreamReadSize);
|
||
const chunkLen = await this._read(buffer, offset + bytesRead, reqLen);
|
||
bytesRead += chunkLen;
|
||
if (chunkLen < reqLen)
|
||
break;
|
||
remaining -= chunkLen;
|
||
}
|
||
return bytesRead;
|
||
}
|
||
/**
|
||
* Read chunk from stream
|
||
* @param buffer Buffer to store data read from stream in
|
||
* @param offset Offset buffer
|
||
* @param length Number of bytes to read
|
||
* @returns {any}
|
||
*/
|
||
async _read(buffer, offset, length) {
|
||
assert.ok(!this.request, 'Concurrent read operation?');
|
||
const readBuffer = this.s.read(length);
|
||
if (readBuffer) {
|
||
readBuffer.copy(buffer, offset);
|
||
return readBuffer.length;
|
||
}
|
||
else {
|
||
this.request = {
|
||
buffer,
|
||
offset,
|
||
length,
|
||
deferred: new Deferred()
|
||
};
|
||
this.s.once('readable', () => {
|
||
this.tryRead();
|
||
});
|
||
return this.request.deferred.promise.then(n => {
|
||
this.request = null;
|
||
return n;
|
||
}, err => {
|
||
this.request = null;
|
||
throw err;
|
||
});
|
||
}
|
||
}
|
||
tryRead() {
|
||
const readBuffer = this.s.read(this.request.length);
|
||
if (readBuffer) {
|
||
readBuffer.copy(this.request.buffer, this.request.offset);
|
||
this.request.deferred.resolve(readBuffer.length);
|
||
}
|
||
else {
|
||
this.s.once('readable', () => {
|
||
this.tryRead();
|
||
});
|
||
}
|
||
}
|
||
reject(err) {
|
||
this.endOfStream = true;
|
||
if (this.request) {
|
||
this.request.deferred.reject(err);
|
||
this.request = null;
|
||
}
|
||
}
|
||
}
|
||
exports.StreamReader = StreamReader;
|
||
//# sourceMappingURL=index.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 455:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.defaultMessages = 'End-Of-Stream';
|
||
/**
|
||
* Thrown on read operation of the end of file or stream has been reached
|
||
*/
|
||
class EndOfStreamError extends Error {
|
||
constructor() {
|
||
super(exports.defaultMessages);
|
||
}
|
||
}
|
||
exports.EndOfStreamError = EndOfStreamError;
|
||
//# sourceMappingURL=EndOfFileStream.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 456:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(process) {/**
|
||
* Detect Electron renderer / nwjs process, which is node, but we should
|
||
* treat as a browser.
|
||
*/
|
||
|
||
if (typeof process === 'undefined' || process.type === 'renderer' || process.browser === true || process.__nwjs) {
|
||
module.exports = __webpack_require__(457);
|
||
} else {
|
||
module.exports = __webpack_require__(460);
|
||
}
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(8)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 457:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(console, process) {/* eslint-env browser */
|
||
|
||
/**
|
||
* This is the web browser implementation of `debug()`.
|
||
*/
|
||
|
||
exports.log = log;
|
||
exports.formatArgs = formatArgs;
|
||
exports.save = save;
|
||
exports.load = load;
|
||
exports.useColors = useColors;
|
||
exports.storage = localstorage();
|
||
|
||
/**
|
||
* Colors.
|
||
*/
|
||
|
||
exports.colors = [
|
||
'#0000CC',
|
||
'#0000FF',
|
||
'#0033CC',
|
||
'#0033FF',
|
||
'#0066CC',
|
||
'#0066FF',
|
||
'#0099CC',
|
||
'#0099FF',
|
||
'#00CC00',
|
||
'#00CC33',
|
||
'#00CC66',
|
||
'#00CC99',
|
||
'#00CCCC',
|
||
'#00CCFF',
|
||
'#3300CC',
|
||
'#3300FF',
|
||
'#3333CC',
|
||
'#3333FF',
|
||
'#3366CC',
|
||
'#3366FF',
|
||
'#3399CC',
|
||
'#3399FF',
|
||
'#33CC00',
|
||
'#33CC33',
|
||
'#33CC66',
|
||
'#33CC99',
|
||
'#33CCCC',
|
||
'#33CCFF',
|
||
'#6600CC',
|
||
'#6600FF',
|
||
'#6633CC',
|
||
'#6633FF',
|
||
'#66CC00',
|
||
'#66CC33',
|
||
'#9900CC',
|
||
'#9900FF',
|
||
'#9933CC',
|
||
'#9933FF',
|
||
'#99CC00',
|
||
'#99CC33',
|
||
'#CC0000',
|
||
'#CC0033',
|
||
'#CC0066',
|
||
'#CC0099',
|
||
'#CC00CC',
|
||
'#CC00FF',
|
||
'#CC3300',
|
||
'#CC3333',
|
||
'#CC3366',
|
||
'#CC3399',
|
||
'#CC33CC',
|
||
'#CC33FF',
|
||
'#CC6600',
|
||
'#CC6633',
|
||
'#CC9900',
|
||
'#CC9933',
|
||
'#CCCC00',
|
||
'#CCCC33',
|
||
'#FF0000',
|
||
'#FF0033',
|
||
'#FF0066',
|
||
'#FF0099',
|
||
'#FF00CC',
|
||
'#FF00FF',
|
||
'#FF3300',
|
||
'#FF3333',
|
||
'#FF3366',
|
||
'#FF3399',
|
||
'#FF33CC',
|
||
'#FF33FF',
|
||
'#FF6600',
|
||
'#FF6633',
|
||
'#FF9900',
|
||
'#FF9933',
|
||
'#FFCC00',
|
||
'#FFCC33'
|
||
];
|
||
|
||
/**
|
||
* Currently only WebKit-based Web Inspectors, Firefox >= v31,
|
||
* and the Firebug extension (any Firefox version) are known
|
||
* to support "%c" CSS customizations.
|
||
*
|
||
* TODO: add a `localStorage` variable to explicitly enable/disable colors
|
||
*/
|
||
|
||
// eslint-disable-next-line complexity
|
||
function useColors() {
|
||
// NB: In an Electron preload script, document will be defined but not fully
|
||
// initialized. Since we know we're in Chrome, we'll just detect this case
|
||
// explicitly
|
||
if (typeof window !== 'undefined' && window.process && (window.process.type === 'renderer' || window.process.__nwjs)) {
|
||
return true;
|
||
}
|
||
|
||
// Internet Explorer and Edge do not support colors.
|
||
if (typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
|
||
return false;
|
||
}
|
||
|
||
// Is webkit? http://stackoverflow.com/a/16459606/376773
|
||
// document is undefined in react-native: https://github.com/facebook/react-native/pull/1632
|
||
return (typeof document !== 'undefined' && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance) ||
|
||
// Is firebug? http://stackoverflow.com/a/398120/376773
|
||
(typeof window !== 'undefined' && window.console && (window.console.firebug || (window.console.exception && window.console.table))) ||
|
||
// Is firefox >= v31?
|
||
// https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
|
||
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31) ||
|
||
// Double check webkit in userAgent just in case we are in a worker
|
||
(typeof navigator !== 'undefined' && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/));
|
||
}
|
||
|
||
/**
|
||
* Colorize log arguments if enabled.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function formatArgs(args) {
|
||
args[0] = (this.useColors ? '%c' : '') +
|
||
this.namespace +
|
||
(this.useColors ? ' %c' : ' ') +
|
||
args[0] +
|
||
(this.useColors ? '%c ' : ' ') +
|
||
'+' + module.exports.humanize(this.diff);
|
||
|
||
if (!this.useColors) {
|
||
return;
|
||
}
|
||
|
||
const c = 'color: ' + this.color;
|
||
args.splice(1, 0, c, 'color: inherit');
|
||
|
||
// The final "%c" is somewhat tricky, because there could be other
|
||
// arguments passed either before or after the %c, so we need to
|
||
// figure out the correct index to insert the CSS into
|
||
let index = 0;
|
||
let lastC = 0;
|
||
args[0].replace(/%[a-zA-Z%]/g, match => {
|
||
if (match === '%%') {
|
||
return;
|
||
}
|
||
index++;
|
||
if (match === '%c') {
|
||
// We only are interested in the *last* %c
|
||
// (the user may have provided their own)
|
||
lastC = index;
|
||
}
|
||
});
|
||
|
||
args.splice(lastC, 0, c);
|
||
}
|
||
|
||
/**
|
||
* Invokes `console.log()` when available.
|
||
* No-op when `console.log` is not a "function".
|
||
*
|
||
* @api public
|
||
*/
|
||
function log(...args) {
|
||
// This hackery is required for IE8/9, where
|
||
// the `console.log` function doesn't have 'apply'
|
||
return typeof console === 'object' &&
|
||
console.log &&
|
||
console.log(...args);
|
||
}
|
||
|
||
/**
|
||
* Save `namespaces`.
|
||
*
|
||
* @param {String} namespaces
|
||
* @api private
|
||
*/
|
||
function save(namespaces) {
|
||
try {
|
||
if (namespaces) {
|
||
exports.storage.setItem('debug', namespaces);
|
||
} else {
|
||
exports.storage.removeItem('debug');
|
||
}
|
||
} catch (error) {
|
||
// Swallow
|
||
// XXX (@Qix-) should we be logging these?
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Load `namespaces`.
|
||
*
|
||
* @return {String} returns the previously persisted debug modes
|
||
* @api private
|
||
*/
|
||
function load() {
|
||
let r;
|
||
try {
|
||
r = exports.storage.getItem('debug');
|
||
} catch (error) {
|
||
// Swallow
|
||
// XXX (@Qix-) should we be logging these?
|
||
}
|
||
|
||
// If debug isn't set in LS, and we're in Electron, try to load $DEBUG
|
||
if (!r && typeof process !== 'undefined' && 'env' in process) {
|
||
r = process.env.DEBUG;
|
||
}
|
||
|
||
return r;
|
||
}
|
||
|
||
/**
|
||
* Localstorage attempts to return the localstorage.
|
||
*
|
||
* This is necessary because safari throws
|
||
* when a user disables cookies/localstorage
|
||
* and you attempt to access it.
|
||
*
|
||
* @return {LocalStorage}
|
||
* @api private
|
||
*/
|
||
|
||
function localstorage() {
|
||
try {
|
||
// TVMLKit (Apple TV JS Runtime) does not have a window object, just localStorage in the global context
|
||
// The Browser also has localStorage in the global context.
|
||
return localStorage;
|
||
} catch (error) {
|
||
// Swallow
|
||
// XXX (@Qix-) should we be logging these?
|
||
}
|
||
}
|
||
|
||
module.exports = __webpack_require__(458)(exports);
|
||
|
||
const {formatters} = module.exports;
|
||
|
||
/**
|
||
* Map %j to `JSON.stringify()`, since no Web Inspectors do that by default.
|
||
*/
|
||
|
||
formatters.j = function (v) {
|
||
try {
|
||
return JSON.stringify(v);
|
||
} catch (error) {
|
||
return '[UnexpectedJSONParseError]: ' + error.message;
|
||
}
|
||
};
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(5), __webpack_require__(8)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 458:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
|
||
/**
|
||
* This is the common logic for both the Node.js and web browser
|
||
* implementations of `debug()`.
|
||
*/
|
||
|
||
function setup(env) {
|
||
createDebug.debug = createDebug;
|
||
createDebug.default = createDebug;
|
||
createDebug.coerce = coerce;
|
||
createDebug.disable = disable;
|
||
createDebug.enable = enable;
|
||
createDebug.enabled = enabled;
|
||
createDebug.humanize = __webpack_require__(459);
|
||
|
||
Object.keys(env).forEach(key => {
|
||
createDebug[key] = env[key];
|
||
});
|
||
|
||
/**
|
||
* Active `debug` instances.
|
||
*/
|
||
createDebug.instances = [];
|
||
|
||
/**
|
||
* The currently active debug mode names, and names to skip.
|
||
*/
|
||
|
||
createDebug.names = [];
|
||
createDebug.skips = [];
|
||
|
||
/**
|
||
* Map of special "%n" handling functions, for the debug "format" argument.
|
||
*
|
||
* Valid key names are a single, lower or upper-case letter, i.e. "n" and "N".
|
||
*/
|
||
createDebug.formatters = {};
|
||
|
||
/**
|
||
* Selects a color for a debug namespace
|
||
* @param {String} namespace The namespace string for the for the debug instance to be colored
|
||
* @return {Number|String} An ANSI color code for the given namespace
|
||
* @api private
|
||
*/
|
||
function selectColor(namespace) {
|
||
let hash = 0;
|
||
|
||
for (let i = 0; i < namespace.length; i++) {
|
||
hash = ((hash << 5) - hash) + namespace.charCodeAt(i);
|
||
hash |= 0; // Convert to 32bit integer
|
||
}
|
||
|
||
return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
|
||
}
|
||
createDebug.selectColor = selectColor;
|
||
|
||
/**
|
||
* Create a debugger with the given `namespace`.
|
||
*
|
||
* @param {String} namespace
|
||
* @return {Function}
|
||
* @api public
|
||
*/
|
||
function createDebug(namespace) {
|
||
let prevTime;
|
||
|
||
function debug(...args) {
|
||
// Disabled?
|
||
if (!debug.enabled) {
|
||
return;
|
||
}
|
||
|
||
const self = debug;
|
||
|
||
// Set `diff` timestamp
|
||
const curr = Number(new Date());
|
||
const ms = curr - (prevTime || curr);
|
||
self.diff = ms;
|
||
self.prev = prevTime;
|
||
self.curr = curr;
|
||
prevTime = curr;
|
||
|
||
args[0] = createDebug.coerce(args[0]);
|
||
|
||
if (typeof args[0] !== 'string') {
|
||
// Anything else let's inspect with %O
|
||
args.unshift('%O');
|
||
}
|
||
|
||
// Apply any `formatters` transformations
|
||
let index = 0;
|
||
args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
|
||
// If we encounter an escaped % then don't increase the array index
|
||
if (match === '%%') {
|
||
return match;
|
||
}
|
||
index++;
|
||
const formatter = createDebug.formatters[format];
|
||
if (typeof formatter === 'function') {
|
||
const val = args[index];
|
||
match = formatter.call(self, val);
|
||
|
||
// Now we need to remove `args[index]` since it's inlined in the `format`
|
||
args.splice(index, 1);
|
||
index--;
|
||
}
|
||
return match;
|
||
});
|
||
|
||
// Apply env-specific formatting (colors, etc.)
|
||
createDebug.formatArgs.call(self, args);
|
||
|
||
const logFn = self.log || createDebug.log;
|
||
logFn.apply(self, args);
|
||
}
|
||
|
||
debug.namespace = namespace;
|
||
debug.enabled = createDebug.enabled(namespace);
|
||
debug.useColors = createDebug.useColors();
|
||
debug.color = selectColor(namespace);
|
||
debug.destroy = destroy;
|
||
debug.extend = extend;
|
||
// Debug.formatArgs = formatArgs;
|
||
// debug.rawLog = rawLog;
|
||
|
||
// env-specific initialization logic for debug instances
|
||
if (typeof createDebug.init === 'function') {
|
||
createDebug.init(debug);
|
||
}
|
||
|
||
createDebug.instances.push(debug);
|
||
|
||
return debug;
|
||
}
|
||
|
||
function destroy() {
|
||
const index = createDebug.instances.indexOf(this);
|
||
if (index !== -1) {
|
||
createDebug.instances.splice(index, 1);
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
function extend(namespace, delimiter) {
|
||
const newDebug = createDebug(this.namespace + (typeof delimiter === 'undefined' ? ':' : delimiter) + namespace);
|
||
newDebug.log = this.log;
|
||
return newDebug;
|
||
}
|
||
|
||
/**
|
||
* Enables a debug mode by namespaces. This can include modes
|
||
* separated by a colon and wildcards.
|
||
*
|
||
* @param {String} namespaces
|
||
* @api public
|
||
*/
|
||
function enable(namespaces) {
|
||
createDebug.save(namespaces);
|
||
|
||
createDebug.names = [];
|
||
createDebug.skips = [];
|
||
|
||
let i;
|
||
const split = (typeof namespaces === 'string' ? namespaces : '').split(/[\s,]+/);
|
||
const len = split.length;
|
||
|
||
for (i = 0; i < len; i++) {
|
||
if (!split[i]) {
|
||
// ignore empty strings
|
||
continue;
|
||
}
|
||
|
||
namespaces = split[i].replace(/\*/g, '.*?');
|
||
|
||
if (namespaces[0] === '-') {
|
||
createDebug.skips.push(new RegExp('^' + namespaces.substr(1) + '$'));
|
||
} else {
|
||
createDebug.names.push(new RegExp('^' + namespaces + '$'));
|
||
}
|
||
}
|
||
|
||
for (i = 0; i < createDebug.instances.length; i++) {
|
||
const instance = createDebug.instances[i];
|
||
instance.enabled = createDebug.enabled(instance.namespace);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Disable debug output.
|
||
*
|
||
* @return {String} namespaces
|
||
* @api public
|
||
*/
|
||
function disable() {
|
||
const namespaces = [
|
||
...createDebug.names.map(toNamespace),
|
||
...createDebug.skips.map(toNamespace).map(namespace => '-' + namespace)
|
||
].join(',');
|
||
createDebug.enable('');
|
||
return namespaces;
|
||
}
|
||
|
||
/**
|
||
* Returns true if the given mode name is enabled, false otherwise.
|
||
*
|
||
* @param {String} name
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
function enabled(name) {
|
||
if (name[name.length - 1] === '*') {
|
||
return true;
|
||
}
|
||
|
||
let i;
|
||
let len;
|
||
|
||
for (i = 0, len = createDebug.skips.length; i < len; i++) {
|
||
if (createDebug.skips[i].test(name)) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
for (i = 0, len = createDebug.names.length; i < len; i++) {
|
||
if (createDebug.names[i].test(name)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* Convert regexp to namespace
|
||
*
|
||
* @param {RegExp} regxep
|
||
* @return {String} namespace
|
||
* @api private
|
||
*/
|
||
function toNamespace(regexp) {
|
||
return regexp.toString()
|
||
.substring(2, regexp.toString().length - 2)
|
||
.replace(/\.\*\?$/, '*');
|
||
}
|
||
|
||
/**
|
||
* Coerce `val`.
|
||
*
|
||
* @param {Mixed} val
|
||
* @return {Mixed}
|
||
* @api private
|
||
*/
|
||
function coerce(val) {
|
||
if (val instanceof Error) {
|
||
return val.stack || val.message;
|
||
}
|
||
return val;
|
||
}
|
||
|
||
createDebug.enable(createDebug.load());
|
||
|
||
return createDebug;
|
||
}
|
||
|
||
module.exports = setup;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 459:
|
||
/***/ (function(module, exports) {
|
||
|
||
/**
|
||
* Helpers.
|
||
*/
|
||
|
||
var s = 1000;
|
||
var m = s * 60;
|
||
var h = m * 60;
|
||
var d = h * 24;
|
||
var w = d * 7;
|
||
var y = d * 365.25;
|
||
|
||
/**
|
||
* Parse or format the given `val`.
|
||
*
|
||
* Options:
|
||
*
|
||
* - `long` verbose formatting [false]
|
||
*
|
||
* @param {String|Number} val
|
||
* @param {Object} [options]
|
||
* @throws {Error} throw an error if val is not a non-empty string or a number
|
||
* @return {String|Number}
|
||
* @api public
|
||
*/
|
||
|
||
module.exports = function(val, options) {
|
||
options = options || {};
|
||
var type = typeof val;
|
||
if (type === 'string' && val.length > 0) {
|
||
return parse(val);
|
||
} else if (type === 'number' && isFinite(val)) {
|
||
return options.long ? fmtLong(val) : fmtShort(val);
|
||
}
|
||
throw new Error(
|
||
'val is not a non-empty string or a valid number. val=' +
|
||
JSON.stringify(val)
|
||
);
|
||
};
|
||
|
||
/**
|
||
* Parse the given `str` and return milliseconds.
|
||
*
|
||
* @param {String} str
|
||
* @return {Number}
|
||
* @api private
|
||
*/
|
||
|
||
function parse(str) {
|
||
str = String(str);
|
||
if (str.length > 100) {
|
||
return;
|
||
}
|
||
var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
|
||
str
|
||
);
|
||
if (!match) {
|
||
return;
|
||
}
|
||
var n = parseFloat(match[1]);
|
||
var type = (match[2] || 'ms').toLowerCase();
|
||
switch (type) {
|
||
case 'years':
|
||
case 'year':
|
||
case 'yrs':
|
||
case 'yr':
|
||
case 'y':
|
||
return n * y;
|
||
case 'weeks':
|
||
case 'week':
|
||
case 'w':
|
||
return n * w;
|
||
case 'days':
|
||
case 'day':
|
||
case 'd':
|
||
return n * d;
|
||
case 'hours':
|
||
case 'hour':
|
||
case 'hrs':
|
||
case 'hr':
|
||
case 'h':
|
||
return n * h;
|
||
case 'minutes':
|
||
case 'minute':
|
||
case 'mins':
|
||
case 'min':
|
||
case 'm':
|
||
return n * m;
|
||
case 'seconds':
|
||
case 'second':
|
||
case 'secs':
|
||
case 'sec':
|
||
case 's':
|
||
return n * s;
|
||
case 'milliseconds':
|
||
case 'millisecond':
|
||
case 'msecs':
|
||
case 'msec':
|
||
case 'ms':
|
||
return n;
|
||
default:
|
||
return undefined;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Short format for `ms`.
|
||
*
|
||
* @param {Number} ms
|
||
* @return {String}
|
||
* @api private
|
||
*/
|
||
|
||
function fmtShort(ms) {
|
||
var msAbs = Math.abs(ms);
|
||
if (msAbs >= d) {
|
||
return Math.round(ms / d) + 'd';
|
||
}
|
||
if (msAbs >= h) {
|
||
return Math.round(ms / h) + 'h';
|
||
}
|
||
if (msAbs >= m) {
|
||
return Math.round(ms / m) + 'm';
|
||
}
|
||
if (msAbs >= s) {
|
||
return Math.round(ms / s) + 's';
|
||
}
|
||
return ms + 'ms';
|
||
}
|
||
|
||
/**
|
||
* Long format for `ms`.
|
||
*
|
||
* @param {Number} ms
|
||
* @return {String}
|
||
* @api private
|
||
*/
|
||
|
||
function fmtLong(ms) {
|
||
var msAbs = Math.abs(ms);
|
||
if (msAbs >= d) {
|
||
return plural(ms, msAbs, d, 'day');
|
||
}
|
||
if (msAbs >= h) {
|
||
return plural(ms, msAbs, h, 'hour');
|
||
}
|
||
if (msAbs >= m) {
|
||
return plural(ms, msAbs, m, 'minute');
|
||
}
|
||
if (msAbs >= s) {
|
||
return plural(ms, msAbs, s, 'second');
|
||
}
|
||
return ms + ' ms';
|
||
}
|
||
|
||
/**
|
||
* Pluralization helper.
|
||
*/
|
||
|
||
function plural(ms, msAbs, n, name) {
|
||
var isPlural = msAbs >= n * 1.5;
|
||
return Math.round(ms / n) + ' ' + name + (isPlural ? 's' : '');
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 460:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(process) {/**
|
||
* Module dependencies.
|
||
*/
|
||
|
||
const tty = __webpack_require__(461);
|
||
const util = __webpack_require__(7);
|
||
|
||
/**
|
||
* This is the Node.js implementation of `debug()`.
|
||
*/
|
||
|
||
exports.init = init;
|
||
exports.log = log;
|
||
exports.formatArgs = formatArgs;
|
||
exports.save = save;
|
||
exports.load = load;
|
||
exports.useColors = useColors;
|
||
|
||
/**
|
||
* Colors.
|
||
*/
|
||
|
||
exports.colors = [6, 2, 3, 4, 5, 1];
|
||
|
||
try {
|
||
// Optional dependency (as in, doesn't need to be installed, NOT like optionalDependencies in package.json)
|
||
// eslint-disable-next-line import/no-extraneous-dependencies
|
||
const supportsColor = __webpack_require__(462);
|
||
|
||
if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
|
||
exports.colors = [
|
||
20,
|
||
21,
|
||
26,
|
||
27,
|
||
32,
|
||
33,
|
||
38,
|
||
39,
|
||
40,
|
||
41,
|
||
42,
|
||
43,
|
||
44,
|
||
45,
|
||
56,
|
||
57,
|
||
62,
|
||
63,
|
||
68,
|
||
69,
|
||
74,
|
||
75,
|
||
76,
|
||
77,
|
||
78,
|
||
79,
|
||
80,
|
||
81,
|
||
92,
|
||
93,
|
||
98,
|
||
99,
|
||
112,
|
||
113,
|
||
128,
|
||
129,
|
||
134,
|
||
135,
|
||
148,
|
||
149,
|
||
160,
|
||
161,
|
||
162,
|
||
163,
|
||
164,
|
||
165,
|
||
166,
|
||
167,
|
||
168,
|
||
169,
|
||
170,
|
||
171,
|
||
172,
|
||
173,
|
||
178,
|
||
179,
|
||
184,
|
||
185,
|
||
196,
|
||
197,
|
||
198,
|
||
199,
|
||
200,
|
||
201,
|
||
202,
|
||
203,
|
||
204,
|
||
205,
|
||
206,
|
||
207,
|
||
208,
|
||
209,
|
||
214,
|
||
215,
|
||
220,
|
||
221
|
||
];
|
||
}
|
||
} catch (error) {
|
||
// Swallow - we only care if `supports-color` is available; it doesn't have to be.
|
||
}
|
||
|
||
/**
|
||
* Build up the default `inspectOpts` object from the environment variables.
|
||
*
|
||
* $ DEBUG_COLORS=no DEBUG_DEPTH=10 DEBUG_SHOW_HIDDEN=enabled node script.js
|
||
*/
|
||
|
||
exports.inspectOpts = Object.keys(process.env).filter(key => {
|
||
return /^debug_/i.test(key);
|
||
}).reduce((obj, key) => {
|
||
// Camel-case
|
||
const prop = key
|
||
.substring(6)
|
||
.toLowerCase()
|
||
.replace(/_([a-z])/g, (_, k) => {
|
||
return k.toUpperCase();
|
||
});
|
||
|
||
// Coerce string value into JS value
|
||
let val = process.env[key];
|
||
if (/^(yes|on|true|enabled)$/i.test(val)) {
|
||
val = true;
|
||
} else if (/^(no|off|false|disabled)$/i.test(val)) {
|
||
val = false;
|
||
} else if (val === 'null') {
|
||
val = null;
|
||
} else {
|
||
val = Number(val);
|
||
}
|
||
|
||
obj[prop] = val;
|
||
return obj;
|
||
}, {});
|
||
|
||
/**
|
||
* Is stdout a TTY? Colored output is enabled when `true`.
|
||
*/
|
||
|
||
function useColors() {
|
||
return 'colors' in exports.inspectOpts ?
|
||
Boolean(exports.inspectOpts.colors) :
|
||
tty.isatty(process.stderr.fd);
|
||
}
|
||
|
||
/**
|
||
* Adds ANSI color escape codes if enabled.
|
||
*
|
||
* @api public
|
||
*/
|
||
|
||
function formatArgs(args) {
|
||
const {namespace: name, useColors} = this;
|
||
|
||
if (useColors) {
|
||
const c = this.color;
|
||
const colorCode = '\u001B[3' + (c < 8 ? c : '8;5;' + c);
|
||
const prefix = ` ${colorCode};1m${name} \u001B[0m`;
|
||
|
||
args[0] = prefix + args[0].split('\n').join('\n' + prefix);
|
||
args.push(colorCode + 'm+' + module.exports.humanize(this.diff) + '\u001B[0m');
|
||
} else {
|
||
args[0] = getDate() + name + ' ' + args[0];
|
||
}
|
||
}
|
||
|
||
function getDate() {
|
||
if (exports.inspectOpts.hideDate) {
|
||
return '';
|
||
}
|
||
return new Date().toISOString() + ' ';
|
||
}
|
||
|
||
/**
|
||
* Invokes `util.format()` with the specified arguments and writes to stderr.
|
||
*/
|
||
|
||
function log(...args) {
|
||
return process.stderr.write(util.format(...args) + '\n');
|
||
}
|
||
|
||
/**
|
||
* Save `namespaces`.
|
||
*
|
||
* @param {String} namespaces
|
||
* @api private
|
||
*/
|
||
function save(namespaces) {
|
||
if (namespaces) {
|
||
process.env.DEBUG = namespaces;
|
||
} else {
|
||
// If you set a process.env field to null or undefined, it gets cast to the
|
||
// string 'null' or 'undefined'. Just delete instead.
|
||
delete process.env.DEBUG;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Load `namespaces`.
|
||
*
|
||
* @return {String} returns the previously persisted debug modes
|
||
* @api private
|
||
*/
|
||
|
||
function load() {
|
||
return process.env.DEBUG;
|
||
}
|
||
|
||
/**
|
||
* Init logic for `debug` instances.
|
||
*
|
||
* Create a new `inspectOpts` object in case `useColors` is set
|
||
* differently for a particular `debug` instance.
|
||
*/
|
||
|
||
function init(debug) {
|
||
debug.inspectOpts = {};
|
||
|
||
const keys = Object.keys(exports.inspectOpts);
|
||
for (let i = 0; i < keys.length; i++) {
|
||
debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
|
||
}
|
||
}
|
||
|
||
module.exports = __webpack_require__(458)(exports);
|
||
|
||
const {formatters} = module.exports;
|
||
|
||
/**
|
||
* Map %o to `util.inspect()`, all on a single line.
|
||
*/
|
||
|
||
formatters.o = function (v) {
|
||
this.inspectOpts.colors = this.useColors;
|
||
return util.inspect(v, this.inspectOpts)
|
||
.replace(/\s*\n\s*/g, ' ');
|
||
};
|
||
|
||
/**
|
||
* Map %O to `util.inspect()`, allowing multiple lines if needed.
|
||
*/
|
||
|
||
formatters.O = function (v) {
|
||
this.inspectOpts.colors = this.useColors;
|
||
return util.inspect(v, this.inspectOpts);
|
||
};
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(8)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 461:
|
||
/***/ (function(module, exports) {
|
||
|
||
exports.isatty = function () { return false; };
|
||
|
||
function ReadStream() {
|
||
throw new Error('tty.ReadStream is not implemented');
|
||
}
|
||
exports.ReadStream = ReadStream;
|
||
|
||
function WriteStream() {
|
||
throw new Error('tty.ReadStream is not implemented');
|
||
}
|
||
exports.WriteStream = WriteStream;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 462:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(process) {
|
||
const os = __webpack_require__(463);
|
||
const hasFlag = __webpack_require__(464);
|
||
|
||
const env = process.env;
|
||
|
||
let forceColor;
|
||
if (hasFlag('no-color') ||
|
||
hasFlag('no-colors') ||
|
||
hasFlag('color=false')) {
|
||
forceColor = false;
|
||
} else if (hasFlag('color') ||
|
||
hasFlag('colors') ||
|
||
hasFlag('color=true') ||
|
||
hasFlag('color=always')) {
|
||
forceColor = true;
|
||
}
|
||
if ('FORCE_COLOR' in env) {
|
||
forceColor = env.FORCE_COLOR.length === 0 || parseInt(env.FORCE_COLOR, 10) !== 0;
|
||
}
|
||
|
||
function translateLevel(level) {
|
||
if (level === 0) {
|
||
return false;
|
||
}
|
||
|
||
return {
|
||
level,
|
||
hasBasic: true,
|
||
has256: level >= 2,
|
||
has16m: level >= 3
|
||
};
|
||
}
|
||
|
||
function supportsColor(stream) {
|
||
if (forceColor === false) {
|
||
return 0;
|
||
}
|
||
|
||
if (hasFlag('color=16m') ||
|
||
hasFlag('color=full') ||
|
||
hasFlag('color=truecolor')) {
|
||
return 3;
|
||
}
|
||
|
||
if (hasFlag('color=256')) {
|
||
return 2;
|
||
}
|
||
|
||
if (stream && !stream.isTTY && forceColor !== true) {
|
||
return 0;
|
||
}
|
||
|
||
const min = forceColor ? 1 : 0;
|
||
|
||
if (process.platform === 'win32') {
|
||
// Node.js 7.5.0 is the first version of Node.js to include a patch to
|
||
// libuv that enables 256 color output on Windows. Anything earlier and it
|
||
// won't work. However, here we target Node.js 8 at minimum as it is an LTS
|
||
// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
|
||
// release that supports 256 colors. Windows 10 build 14931 is the first release
|
||
// that supports 16m/TrueColor.
|
||
const osRelease = os.release().split('.');
|
||
if (
|
||
Number(process.versions.node.split('.')[0]) >= 8 &&
|
||
Number(osRelease[0]) >= 10 &&
|
||
Number(osRelease[2]) >= 10586
|
||
) {
|
||
return Number(osRelease[2]) >= 14931 ? 3 : 2;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
if ('CI' in env) {
|
||
if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
|
||
return 1;
|
||
}
|
||
|
||
return min;
|
||
}
|
||
|
||
if ('TEAMCITY_VERSION' in env) {
|
||
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
|
||
}
|
||
|
||
if (env.COLORTERM === 'truecolor') {
|
||
return 3;
|
||
}
|
||
|
||
if ('TERM_PROGRAM' in env) {
|
||
const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
|
||
|
||
switch (env.TERM_PROGRAM) {
|
||
case 'iTerm.app':
|
||
return version >= 3 ? 3 : 2;
|
||
case 'Apple_Terminal':
|
||
return 2;
|
||
// No default
|
||
}
|
||
}
|
||
|
||
if (/-256(color)?$/i.test(env.TERM)) {
|
||
return 2;
|
||
}
|
||
|
||
if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
|
||
return 1;
|
||
}
|
||
|
||
if ('COLORTERM' in env) {
|
||
return 1;
|
||
}
|
||
|
||
if (env.TERM === 'dumb') {
|
||
return min;
|
||
}
|
||
|
||
return min;
|
||
}
|
||
|
||
function getSupportLevel(stream) {
|
||
const level = supportsColor(stream);
|
||
return translateLevel(level);
|
||
}
|
||
|
||
module.exports = {
|
||
supportsColor: getSupportLevel,
|
||
stdout: getSupportLevel(process.stdout),
|
||
stderr: getSupportLevel(process.stderr)
|
||
};
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(8)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 463:
|
||
/***/ (function(module, exports) {
|
||
|
||
exports.endianness = function () { return 'LE' };
|
||
|
||
exports.hostname = function () {
|
||
if (typeof location !== 'undefined') {
|
||
return location.hostname
|
||
}
|
||
else return '';
|
||
};
|
||
|
||
exports.loadavg = function () { return [] };
|
||
|
||
exports.uptime = function () { return 0 };
|
||
|
||
exports.freemem = function () {
|
||
return Number.MAX_VALUE;
|
||
};
|
||
|
||
exports.totalmem = function () {
|
||
return Number.MAX_VALUE;
|
||
};
|
||
|
||
exports.cpus = function () { return [] };
|
||
|
||
exports.type = function () { return 'Browser' };
|
||
|
||
exports.release = function () {
|
||
if (typeof navigator !== 'undefined') {
|
||
return navigator.appVersion;
|
||
}
|
||
return '';
|
||
};
|
||
|
||
exports.networkInterfaces
|
||
= exports.getNetworkInterfaces
|
||
= function () { return {} };
|
||
|
||
exports.arch = function () { return 'javascript' };
|
||
|
||
exports.platform = function () { return 'browser' };
|
||
|
||
exports.tmpdir = exports.tmpDir = function () {
|
||
return '/tmp';
|
||
};
|
||
|
||
exports.EOL = '\n';
|
||
|
||
exports.homedir = function () {
|
||
return '/'
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 464:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/* WEBPACK VAR INJECTION */(function(process) {
|
||
module.exports = (flag, argv) => {
|
||
argv = argv || process.argv;
|
||
const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
|
||
const pos = argv.indexOf(prefix + flag);
|
||
const terminatorPos = argv.indexOf('--');
|
||
return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
|
||
};
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(8)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 465:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const peek_readable_1 = __webpack_require__(454);
|
||
class BufferTokenizer {
|
||
/**
|
||
* Construct BufferTokenizer
|
||
* @param buffer - Buffer to tokenize
|
||
* @param fileInfo - Pass additional file information to the tokenizer
|
||
*/
|
||
constructor(buffer, fileInfo) {
|
||
this.buffer = buffer;
|
||
this.position = 0;
|
||
this.fileInfo = fileInfo ? fileInfo : {};
|
||
this.fileInfo.size = this.fileInfo.size ? this.fileInfo.size : buffer.length;
|
||
}
|
||
/**
|
||
* Read buffer from tokenizer
|
||
* @param buffer
|
||
* @param options - Read behaviour options
|
||
* @returns {Promise<number>}
|
||
*/
|
||
async readBuffer(buffer, options) {
|
||
if (options && options.position) {
|
||
if (options.position < this.position) {
|
||
throw new Error('`options.position` can be less than `tokenizer.position`');
|
||
}
|
||
this.position = options.position;
|
||
}
|
||
return this.peekBuffer(buffer, options).then(bytesRead => {
|
||
this.position += bytesRead;
|
||
return bytesRead;
|
||
});
|
||
}
|
||
/**
|
||
* Peek (read ahead) buffer from tokenizer
|
||
* @param buffer
|
||
* @param options - Read behaviour options
|
||
* @returns {Promise<number>}
|
||
*/
|
||
async peekBuffer(buffer, options) {
|
||
let offset = 0;
|
||
let length = buffer.length;
|
||
let position = this.position;
|
||
if (options) {
|
||
if (options.position) {
|
||
if (options.position < this.position) {
|
||
throw new Error('`options.position` can be less than `tokenizer.position`');
|
||
}
|
||
position = options.position;
|
||
}
|
||
if (Number.isInteger(options.length)) {
|
||
length = options.length;
|
||
}
|
||
else {
|
||
length -= options.offset || 0;
|
||
}
|
||
if (options.offset) {
|
||
offset = options.offset;
|
||
}
|
||
}
|
||
if (length === 0) {
|
||
return Promise.resolve(0);
|
||
}
|
||
position = position || this.position;
|
||
if (!length) {
|
||
length = buffer.length;
|
||
}
|
||
const bytes2read = Math.min(this.buffer.length - position, length);
|
||
if ((!options || !options.mayBeLess) && bytes2read < length) {
|
||
throw new peek_readable_1.EndOfStreamError();
|
||
}
|
||
else {
|
||
this.buffer.copy(buffer, offset, position, position + bytes2read);
|
||
return bytes2read;
|
||
}
|
||
}
|
||
async readToken(token, position) {
|
||
this.position = position || this.position;
|
||
try {
|
||
const tv = this.peekToken(token, this.position);
|
||
this.position += token.len;
|
||
return tv;
|
||
}
|
||
catch (err) {
|
||
this.position += this.buffer.length - position;
|
||
throw err;
|
||
}
|
||
}
|
||
async peekToken(token, position = this.position) {
|
||
if (this.buffer.length - position < token.len) {
|
||
throw new peek_readable_1.EndOfStreamError();
|
||
}
|
||
return token.get(this.buffer, position);
|
||
}
|
||
async readNumber(token) {
|
||
return this.readToken(token);
|
||
}
|
||
async peekNumber(token) {
|
||
return this.peekToken(token);
|
||
}
|
||
/**
|
||
* @return actual number of bytes ignored
|
||
*/
|
||
async ignore(length) {
|
||
const bytesIgnored = Math.min(this.buffer.length - this.position, length);
|
||
this.position += bytesIgnored;
|
||
return bytesIgnored;
|
||
}
|
||
async close() {
|
||
// empty
|
||
}
|
||
}
|
||
exports.BufferTokenizer = BufferTokenizer;
|
||
//# sourceMappingURL=BufferTokenizer.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 466:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
exports.stringToBytes = string => [...string].map(character => character.charCodeAt(0));
|
||
|
||
const uint8ArrayUtf8ByteString = (array, start, end) => {
|
||
return String.fromCharCode(...array.slice(start, end));
|
||
};
|
||
|
||
exports.tarHeaderChecksumMatches = buffer => { // Does not check if checksum field characters are valid
|
||
if (buffer.length < 512) { // `tar` header size, cannot compute checksum without it
|
||
return false;
|
||
}
|
||
|
||
const MASK_8TH_BIT = 0x80;
|
||
|
||
let sum = 256; // Intitalize sum, with 256 as sum of 8 spaces in checksum field
|
||
let signedBitSum = 0; // Initialize signed bit sum
|
||
|
||
for (let i = 0; i < 148; i++) {
|
||
const byte = buffer[i];
|
||
sum += byte;
|
||
signedBitSum += byte & MASK_8TH_BIT; // Add signed bit to signed bit sum
|
||
}
|
||
|
||
// Skip checksum field
|
||
|
||
for (let i = 156; i < 512; i++) {
|
||
const byte = buffer[i];
|
||
sum += byte;
|
||
signedBitSum += byte & MASK_8TH_BIT; // Add signed bit to signed bit sum
|
||
}
|
||
|
||
const readSum = parseInt(uint8ArrayUtf8ByteString(buffer, 148, 154), 8); // Read sum in header
|
||
|
||
// Some implementations compute checksum incorrectly using signed bytes
|
||
return (
|
||
// Checksum in header equals the sum we calculated
|
||
readSum === sum ||
|
||
|
||
// Checksum in header equals sum we calculated plus signed-to-unsigned delta
|
||
readSum === (sum - (signedBitSum << 1))
|
||
);
|
||
};
|
||
|
||
exports.uint8ArrayUtf8ByteString = uint8ArrayUtf8ByteString;
|
||
|
||
/**
|
||
ID3 UINT32 sync-safe tokenizer token.
|
||
28 bits (representing up to 256MB) integer, the msb is 0 to avoid "false syncsignals".
|
||
*/
|
||
exports.uint32SyncSafeToken = {
|
||
get: (buffer, offset) => {
|
||
return (buffer[offset + 3] & 0x7F) | ((buffer[offset + 2]) << 7) | ((buffer[offset + 1]) << 14) | ((buffer[offset]) << 21);
|
||
},
|
||
len: 4
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 467:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
module.exports = {
|
||
extensions: [
|
||
'jpg',
|
||
'png',
|
||
'apng',
|
||
'gif',
|
||
'webp',
|
||
'flif',
|
||
'cr2',
|
||
'cr3',
|
||
'orf',
|
||
'arw',
|
||
'dng',
|
||
'nef',
|
||
'rw2',
|
||
'raf',
|
||
'tif',
|
||
'bmp',
|
||
'icns',
|
||
'jxr',
|
||
'psd',
|
||
'zip',
|
||
'tar',
|
||
'rar',
|
||
'gz',
|
||
'bz2',
|
||
'7z',
|
||
'dmg',
|
||
'mp4',
|
||
'mid',
|
||
'mkv',
|
||
'webm',
|
||
'mov',
|
||
'avi',
|
||
'mpg',
|
||
'mp2',
|
||
'mp3',
|
||
'm4a',
|
||
'oga',
|
||
'ogg',
|
||
'ogv',
|
||
'opus',
|
||
'flac',
|
||
'wav',
|
||
'spx',
|
||
'amr',
|
||
'pdf',
|
||
'epub',
|
||
'exe',
|
||
'swf',
|
||
'rtf',
|
||
'wasm',
|
||
'woff',
|
||
'woff2',
|
||
'eot',
|
||
'ttf',
|
||
'otf',
|
||
'ico',
|
||
'flv',
|
||
'ps',
|
||
'xz',
|
||
'sqlite',
|
||
'nes',
|
||
'crx',
|
||
'xpi',
|
||
'cab',
|
||
'deb',
|
||
'ar',
|
||
'rpm',
|
||
'Z',
|
||
'lz',
|
||
'msi',
|
||
'mxf',
|
||
'mts',
|
||
'blend',
|
||
'bpg',
|
||
'docx',
|
||
'pptx',
|
||
'xlsx',
|
||
'3gp',
|
||
'3g2',
|
||
'jp2',
|
||
'jpm',
|
||
'jpx',
|
||
'mj2',
|
||
'aif',
|
||
'qcp',
|
||
'odt',
|
||
'ods',
|
||
'odp',
|
||
'xml',
|
||
'mobi',
|
||
'heic',
|
||
'cur',
|
||
'ktx',
|
||
'ape',
|
||
'wv',
|
||
'wmv',
|
||
'wma',
|
||
'dcm',
|
||
'ics',
|
||
'glb',
|
||
'pcap',
|
||
'dsf',
|
||
'lnk',
|
||
'alias',
|
||
'voc',
|
||
'ac3',
|
||
'm4v',
|
||
'm4p',
|
||
'm4b',
|
||
'f4v',
|
||
'f4p',
|
||
'f4b',
|
||
'f4a',
|
||
'mie',
|
||
'asf',
|
||
'ogm',
|
||
'ogx',
|
||
'mpc',
|
||
'arrow',
|
||
'shp',
|
||
'aac',
|
||
'mp1',
|
||
'it',
|
||
's3m',
|
||
'xm',
|
||
'ai',
|
||
'skp',
|
||
'avif',
|
||
'eps',
|
||
'lzh'
|
||
],
|
||
mimeTypes: [
|
||
'image/jpeg',
|
||
'image/png',
|
||
'image/gif',
|
||
'image/webp',
|
||
'image/flif',
|
||
'image/x-canon-cr2',
|
||
'image/x-canon-cr3',
|
||
'image/tiff',
|
||
'image/bmp',
|
||
'image/vnd.ms-photo',
|
||
'image/vnd.adobe.photoshop',
|
||
'application/epub+zip',
|
||
'application/x-xpinstall',
|
||
'application/vnd.oasis.opendocument.text',
|
||
'application/vnd.oasis.opendocument.spreadsheet',
|
||
'application/vnd.oasis.opendocument.presentation',
|
||
'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
||
'application/vnd.openxmlformats-officedocument.presentationml.presentation',
|
||
'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
'application/zip',
|
||
'application/x-tar',
|
||
'application/x-rar-compressed',
|
||
'application/gzip',
|
||
'application/x-bzip2',
|
||
'application/x-7z-compressed',
|
||
'application/x-apple-diskimage',
|
||
'application/x-apache-arrow',
|
||
'video/mp4',
|
||
'audio/midi',
|
||
'video/x-matroska',
|
||
'video/webm',
|
||
'video/quicktime',
|
||
'video/vnd.avi',
|
||
'audio/vnd.wave',
|
||
'audio/qcelp',
|
||
'audio/x-ms-wma',
|
||
'video/x-ms-asf',
|
||
'application/vnd.ms-asf',
|
||
'video/mpeg',
|
||
'video/3gpp',
|
||
'audio/mpeg',
|
||
'audio/mp4', // RFC 4337
|
||
'audio/opus',
|
||
'video/ogg',
|
||
'audio/ogg',
|
||
'application/ogg',
|
||
'audio/x-flac',
|
||
'audio/ape',
|
||
'audio/wavpack',
|
||
'audio/amr',
|
||
'application/pdf',
|
||
'application/x-msdownload',
|
||
'application/x-shockwave-flash',
|
||
'application/rtf',
|
||
'application/wasm',
|
||
'font/woff',
|
||
'font/woff2',
|
||
'application/vnd.ms-fontobject',
|
||
'font/ttf',
|
||
'font/otf',
|
||
'image/x-icon',
|
||
'video/x-flv',
|
||
'application/postscript',
|
||
'application/eps',
|
||
'application/x-xz',
|
||
'application/x-sqlite3',
|
||
'application/x-nintendo-nes-rom',
|
||
'application/x-google-chrome-extension',
|
||
'application/vnd.ms-cab-compressed',
|
||
'application/x-deb',
|
||
'application/x-unix-archive',
|
||
'application/x-rpm',
|
||
'application/x-compress',
|
||
'application/x-lzip',
|
||
'application/x-msi',
|
||
'application/x-mie',
|
||
'application/mxf',
|
||
'video/mp2t',
|
||
'application/x-blender',
|
||
'image/bpg',
|
||
'image/jp2',
|
||
'image/jpx',
|
||
'image/jpm',
|
||
'image/mj2',
|
||
'audio/aiff',
|
||
'application/xml',
|
||
'application/x-mobipocket-ebook',
|
||
'image/heif',
|
||
'image/heif-sequence',
|
||
'image/heic',
|
||
'image/heic-sequence',
|
||
'image/icns',
|
||
'image/ktx',
|
||
'application/dicom',
|
||
'audio/x-musepack',
|
||
'text/calendar',
|
||
'model/gltf-binary',
|
||
'application/vnd.tcpdump.pcap',
|
||
'audio/x-dsf', // Non-standard
|
||
'application/x.ms.shortcut', // Invented by us
|
||
'application/x.apple.alias', // Invented by us
|
||
'audio/x-voc',
|
||
'audio/vnd.dolby.dd-raw',
|
||
'audio/x-m4a',
|
||
'image/apng',
|
||
'image/x-olympus-orf',
|
||
'image/x-sony-arw',
|
||
'image/x-adobe-dng',
|
||
'image/x-nikon-nef',
|
||
'image/x-panasonic-rw2',
|
||
'image/x-fujifilm-raf',
|
||
'video/x-m4v',
|
||
'video/3gpp2',
|
||
'application/x-esri-shape',
|
||
'audio/aac',
|
||
'audio/x-it',
|
||
'audio/x-s3m',
|
||
'audio/x-xm',
|
||
'video/MP1S',
|
||
'video/MP2P',
|
||
'application/vnd.sketchup.skp',
|
||
'image/avif',
|
||
'application/x-lzh-compressed'
|
||
]
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 5:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(global) {/*global window, global*/
|
||
var util = __webpack_require__(7)
|
||
var assert = __webpack_require__(12)
|
||
function now() { return new Date().getTime() }
|
||
|
||
var slice = Array.prototype.slice
|
||
var console
|
||
var times = {}
|
||
|
||
if (typeof global !== "undefined" && global.console) {
|
||
console = global.console
|
||
} else if (typeof window !== "undefined" && window.console) {
|
||
console = window.console
|
||
} else {
|
||
console = {}
|
||
}
|
||
|
||
var functions = [
|
||
[log, "log"],
|
||
[info, "info"],
|
||
[warn, "warn"],
|
||
[error, "error"],
|
||
[time, "time"],
|
||
[timeEnd, "timeEnd"],
|
||
[trace, "trace"],
|
||
[dir, "dir"],
|
||
[consoleAssert, "assert"]
|
||
]
|
||
|
||
for (var i = 0; i < functions.length; i++) {
|
||
var tuple = functions[i]
|
||
var f = tuple[0]
|
||
var name = tuple[1]
|
||
|
||
if (!console[name]) {
|
||
console[name] = f
|
||
}
|
||
}
|
||
|
||
module.exports = console
|
||
|
||
function log() {}
|
||
|
||
function info() {
|
||
console.log.apply(console, arguments)
|
||
}
|
||
|
||
function warn() {
|
||
console.log.apply(console, arguments)
|
||
}
|
||
|
||
function error() {
|
||
console.warn.apply(console, arguments)
|
||
}
|
||
|
||
function time(label) {
|
||
times[label] = now()
|
||
}
|
||
|
||
function timeEnd(label) {
|
||
var time = times[label]
|
||
if (!time) {
|
||
throw new Error("No such label: " + label)
|
||
}
|
||
|
||
delete times[label]
|
||
var duration = now() - time
|
||
console.log(label + ": " + duration + "ms")
|
||
}
|
||
|
||
function trace() {
|
||
var err = new Error()
|
||
err.name = "Trace"
|
||
err.message = util.format.apply(null, arguments)
|
||
console.error(err.stack)
|
||
}
|
||
|
||
function dir(object) {
|
||
console.log(util.inspect(object) + "\n")
|
||
}
|
||
|
||
function consoleAssert(expression) {
|
||
if (!expression) {
|
||
var arr = slice.call(arguments, 1)
|
||
assert.ok(false, util.format.apply(null, arr))
|
||
}
|
||
}
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(6)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 6:
|
||
/***/ (function(module, exports) {
|
||
|
||
var g;
|
||
|
||
// This works in non-strict mode
|
||
g = (function() {
|
||
return this;
|
||
})();
|
||
|
||
try {
|
||
// This works if eval is allowed (see CSP)
|
||
g = g || new Function("return this")();
|
||
} catch (e) {
|
||
// This works if the window reference is available
|
||
if (typeof window === "object") g = window;
|
||
}
|
||
|
||
// g can still be undefined, but nothing to do about it...
|
||
// We return undefined, instead of nothing here, so it's
|
||
// easier to handle this case. if(!global) { ...}
|
||
|
||
module.exports = g;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 7:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/* WEBPACK VAR INJECTION */(function(process, console) {// 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 getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||
|
||
function getOwnPropertyDescriptors(obj) {
|
||
var keys = Object.keys(obj);
|
||
var descriptors = {};
|
||
for (var i = 0; i < keys.length; i++) {
|
||
descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);
|
||
}
|
||
return descriptors;
|
||
};
|
||
|
||
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(' ');
|
||
}
|
||
|
||
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;
|
||
};
|
||
|
||
|
||
// 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) {
|
||
if (typeof process !== 'undefined' && process.noDeprecation === true) {
|
||
return fn;
|
||
}
|
||
|
||
// Allow for deprecating things in the process of starting up.
|
||
if (typeof process === 'undefined') {
|
||
return function() {
|
||
return exports.deprecate(fn, msg).apply(this, arguments);
|
||
};
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
return deprecated;
|
||
};
|
||
|
||
|
||
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];
|
||
};
|
||
|
||
|
||
/**
|
||
* 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.inspect = inspect;
|
||
|
||
|
||
// 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]
|
||
};
|
||
|
||
// 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'
|
||
};
|
||
|
||
|
||
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';
|
||
} else {
|
||
return str;
|
||
}
|
||
}
|
||
|
||
|
||
function stylizeNoColor(str, styleType) {
|
||
return str;
|
||
}
|
||
|
||
|
||
function arrayToHash(array) {
|
||
var hash = {};
|
||
|
||
array.forEach(function(val, idx) {
|
||
hash[val] = true;
|
||
});
|
||
|
||
return hash;
|
||
}
|
||
|
||
|
||
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;
|
||
}
|
||
|
||
// Primitive types cannot have properties
|
||
var primitive = formatPrimitive(ctx, value);
|
||
if (primitive) {
|
||
return primitive;
|
||
}
|
||
|
||
// Look up the keys of the object.
|
||
var keys = Object.keys(value);
|
||
var visibleKeys = arrayToHash(keys);
|
||
|
||
if (ctx.showHidden) {
|
||
keys = Object.getOwnPropertyNames(value);
|
||
}
|
||
|
||
// 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);
|
||
}
|
||
|
||
// 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);
|
||
}
|
||
}
|
||
|
||
var base = '', array = false, braces = ['{', '}'];
|
||
|
||
// Make Array say that they are Array
|
||
if (isArray(value)) {
|
||
array = true;
|
||
braces = ['[', ']'];
|
||
}
|
||
|
||
// Make functions say that they are functions
|
||
if (isFunction(value)) {
|
||
var n = value.name ? ': ' + value.name : '';
|
||
base = ' [Function' + n + ']';
|
||
}
|
||
|
||
// Make RegExps say that they are RegExps
|
||
if (isRegExp(value)) {
|
||
base = ' ' + RegExp.prototype.toString.call(value);
|
||
}
|
||
|
||
// Make dates with properties first say the date
|
||
if (isDate(value)) {
|
||
base = ' ' + Date.prototype.toUTCString.call(value);
|
||
}
|
||
|
||
// Make error with message first say the error
|
||
if (isError(value)) {
|
||
base = ' ' + formatError(value);
|
||
}
|
||
|
||
if (keys.length === 0 && (!array || value.length == 0)) {
|
||
return braces[0] + base + braces[1];
|
||
}
|
||
|
||
if (recurseTimes < 0) {
|
||
if (isRegExp(value)) {
|
||
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
|
||
} else {
|
||
return ctx.stylize('[Object]', 'special');
|
||
}
|
||
}
|
||
|
||
ctx.seen.push(value);
|
||
|
||
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);
|
||
});
|
||
}
|
||
|
||
ctx.seen.pop();
|
||
|
||
return reduceToSingleString(output, base, braces);
|
||
}
|
||
|
||
|
||
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');
|
||
}
|
||
|
||
|
||
function formatError(value) {
|
||
return '[' + Error.prototype.toString.call(value) + ']';
|
||
}
|
||
|
||
|
||
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('');
|
||
}
|
||
}
|
||
keys.forEach(function(key) {
|
||
if (!key.match(/^\d+$/)) {
|
||
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
|
||
key, true));
|
||
}
|
||
});
|
||
return output;
|
||
}
|
||
|
||
|
||
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');
|
||
}
|
||
}
|
||
|
||
return name + ': ' + str;
|
||
}
|
||
|
||
|
||
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);
|
||
|
||
if (length > 60) {
|
||
return braces[0] +
|
||
(base === '' ? '' : base + '\n ') +
|
||
' ' +
|
||
output.join(',\n ') +
|
||
' ' +
|
||
braces[1];
|
||
}
|
||
|
||
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
|
||
}
|
||
|
||
|
||
// 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;
|
||
|
||
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 isObject(re) && objectToString(re) === '[object RegExp]';
|
||
}
|
||
exports.isRegExp = isRegExp;
|
||
|
||
function isObject(arg) {
|
||
return typeof arg === 'object' && arg !== null;
|
||
}
|
||
exports.isObject = isObject;
|
||
|
||
function isDate(d) {
|
||
return isObject(d) && objectToString(d) === '[object Date]';
|
||
}
|
||
exports.isDate = isDate;
|
||
|
||
function isError(e) {
|
||
return isObject(e) &&
|
||
(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 = __webpack_require__(9);
|
||
|
||
function objectToString(o) {
|
||
return Object.prototype.toString.call(o);
|
||
}
|
||
|
||
|
||
function pad(n) {
|
||
return n < 10 ? '0' + n.toString(10) : n.toString(10);
|
||
}
|
||
|
||
|
||
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
|
||
'Oct', 'Nov', 'Dec'];
|
||
|
||
// 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(' ');
|
||
}
|
||
|
||
|
||
// 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));
|
||
};
|
||
|
||
|
||
/**
|
||
* 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 = __webpack_require__(10);
|
||
|
||
exports._extend = function(origin, add) {
|
||
// Don't do anything if add isn't an object
|
||
if (!add || !isObject(add)) return origin;
|
||
|
||
var keys = Object.keys(add);
|
||
var i = keys.length;
|
||
while (i--) {
|
||
origin[keys[i]] = add[keys[i]];
|
||
}
|
||
return origin;
|
||
};
|
||
|
||
function hasOwnProperty(obj, prop) {
|
||
return Object.prototype.hasOwnProperty.call(obj, prop);
|
||
}
|
||
|
||
var kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;
|
||
|
||
exports.promisify = function promisify(original) {
|
||
if (typeof original !== 'function')
|
||
throw new TypeError('The "original" argument must be of type Function');
|
||
|
||
if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
|
||
var fn = original[kCustomPromisifiedSymbol];
|
||
if (typeof fn !== 'function') {
|
||
throw new TypeError('The "util.promisify.custom" argument must be of type Function');
|
||
}
|
||
Object.defineProperty(fn, kCustomPromisifiedSymbol, {
|
||
value: fn, enumerable: false, writable: false, configurable: true
|
||
});
|
||
return fn;
|
||
}
|
||
|
||
function fn() {
|
||
var promiseResolve, promiseReject;
|
||
var promise = new Promise(function (resolve, reject) {
|
||
promiseResolve = resolve;
|
||
promiseReject = reject;
|
||
});
|
||
|
||
var args = [];
|
||
for (var i = 0; i < arguments.length; i++) {
|
||
args.push(arguments[i]);
|
||
}
|
||
args.push(function (err, value) {
|
||
if (err) {
|
||
promiseReject(err);
|
||
} else {
|
||
promiseResolve(value);
|
||
}
|
||
});
|
||
|
||
try {
|
||
original.apply(this, args);
|
||
} catch (err) {
|
||
promiseReject(err);
|
||
}
|
||
|
||
return promise;
|
||
}
|
||
|
||
Object.setPrototypeOf(fn, Object.getPrototypeOf(original));
|
||
|
||
if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {
|
||
value: fn, enumerable: false, writable: false, configurable: true
|
||
});
|
||
return Object.defineProperties(
|
||
fn,
|
||
getOwnPropertyDescriptors(original)
|
||
);
|
||
}
|
||
|
||
exports.promisify.custom = kCustomPromisifiedSymbol
|
||
|
||
function callbackifyOnRejected(reason, cb) {
|
||
// `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).
|
||
// Because `null` is a special error value in callbacks which means "no error
|
||
// occurred", we error-wrap so the callback consumer can distinguish between
|
||
// "the promise rejected with null" or "the promise fulfilled with undefined".
|
||
if (!reason) {
|
||
var newReason = new Error('Promise was rejected with a falsy value');
|
||
newReason.reason = reason;
|
||
reason = newReason;
|
||
}
|
||
return cb(reason);
|
||
}
|
||
|
||
function callbackify(original) {
|
||
if (typeof original !== 'function') {
|
||
throw new TypeError('The "original" argument must be of type Function');
|
||
}
|
||
|
||
// We DO NOT return the promise as it gives the user a false sense that
|
||
// the promise is actually somehow related to the callback's execution
|
||
// and that the callback throwing will reject the promise.
|
||
function callbackified() {
|
||
var args = [];
|
||
for (var i = 0; i < arguments.length; i++) {
|
||
args.push(arguments[i]);
|
||
}
|
||
|
||
var maybeCb = args.pop();
|
||
if (typeof maybeCb !== 'function') {
|
||
throw new TypeError('The last argument must be of type Function');
|
||
}
|
||
var self = this;
|
||
var cb = function() {
|
||
return maybeCb.apply(self, arguments);
|
||
};
|
||
// In true node style we process the callback on `nextTick` with all the
|
||
// implications (stack, `uncaughtException`, `async_hooks`)
|
||
original.apply(this, args)
|
||
.then(function(ret) { process.nextTick(cb, null, ret) },
|
||
function(rej) { process.nextTick(callbackifyOnRejected, rej, cb) });
|
||
}
|
||
|
||
Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));
|
||
Object.defineProperties(callbackified,
|
||
getOwnPropertyDescriptors(original));
|
||
return callbackified;
|
||
}
|
||
exports.callbackify = callbackify;
|
||
|
||
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(8), __webpack_require__(5)))
|
||
|
||
/***/ }),
|
||
|
||
/***/ 8:
|
||
/***/ (function(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);
|
||
}
|
||
}
|
||
|
||
|
||
}
|
||
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);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
}
|
||
var queue = [];
|
||
var draining = false;
|
||
var currentQueue;
|
||
var queueIndex = -1;
|
||
|
||
function cleanUpNextTick() {
|
||
if (!draining || !currentQueue) {
|
||
return;
|
||
}
|
||
draining = false;
|
||
if (currentQueue.length) {
|
||
queue = currentQueue.concat(queue);
|
||
} else {
|
||
queueIndex = -1;
|
||
}
|
||
if (queue.length) {
|
||
drainQueue();
|
||
}
|
||
}
|
||
|
||
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);
|
||
}
|
||
|
||
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;
|
||
}
|
||
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() {}
|
||
|
||
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;
|
||
|
||
process.listeners = function (name) { return [] }
|
||
|
||
process.binding = function (name) {
|
||
throw new Error('process.binding is not supported');
|
||
};
|
||
|
||
process.cwd = function () { return '/' };
|
||
process.chdir = function (dir) {
|
||
throw new Error('process.chdir is not supported');
|
||
};
|
||
process.umask = function() { return 0; };
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 9:
|
||
/***/ (function(module, exports) {
|
||
|
||
module.exports = function isBuffer(arg) {
|
||
return arg && typeof arg === 'object'
|
||
&& typeof arg.copy === 'function'
|
||
&& typeof arg.fill === 'function'
|
||
&& typeof arg.readUInt8 === 'function';
|
||
}
|
||
|
||
/***/ })
|
||
|
||
/******/ });
|
||
//# sourceMappingURL=file-type.js.map
|