mirror of
https://github.com/bcomnes/deploy-to-neocities.git
synced 2026-01-16 22:56:28 +00:00
11038 lines
434 KiB
JavaScript
11038 lines
434 KiB
JavaScript
require('./sourcemap-register.js');module.exports =
|
||
/******/ (function(modules, runtime) { // webpackBootstrap
|
||
/******/ "use strict";
|
||
/******/ // 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
|
||
/******/ var threw = true;
|
||
/******/ try {
|
||
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
||
/******/ threw = false;
|
||
/******/ } finally {
|
||
/******/ if(threw) delete installedModules[moduleId];
|
||
/******/ }
|
||
/******/
|
||
/******/ // Flag the module as loaded
|
||
/******/ module.l = true;
|
||
/******/
|
||
/******/ // Return the exports of the module
|
||
/******/ return module.exports;
|
||
/******/ }
|
||
/******/
|
||
/******/
|
||
/******/ __webpack_require__.ab = __dirname + "/";
|
||
/******/
|
||
/******/ // the startup function
|
||
/******/ function startup() {
|
||
/******/ // Load entry module and return exports
|
||
/******/ return __webpack_require__(104);
|
||
/******/ };
|
||
/******/
|
||
/******/ // run startup
|
||
/******/ return startup();
|
||
/******/ })
|
||
/************************************************************************/
|
||
/******/ ({
|
||
|
||
/***/ 9:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var once = __webpack_require__(49);
|
||
|
||
var noop = function() {};
|
||
|
||
var isRequest = function(stream) {
|
||
return stream.setHeader && typeof stream.abort === 'function';
|
||
};
|
||
|
||
var isChildProcess = function(stream) {
|
||
return stream.stdio && Array.isArray(stream.stdio) && stream.stdio.length === 3
|
||
};
|
||
|
||
var eos = function(stream, opts, callback) {
|
||
if (typeof opts === 'function') return eos(stream, null, opts);
|
||
if (!opts) opts = {};
|
||
|
||
callback = once(callback || noop);
|
||
|
||
var ws = stream._writableState;
|
||
var rs = stream._readableState;
|
||
var readable = opts.readable || (opts.readable !== false && stream.readable);
|
||
var writable = opts.writable || (opts.writable !== false && stream.writable);
|
||
var cancelled = false;
|
||
|
||
var onlegacyfinish = function() {
|
||
if (!stream.writable) onfinish();
|
||
};
|
||
|
||
var onfinish = function() {
|
||
writable = false;
|
||
if (!readable) callback.call(stream);
|
||
};
|
||
|
||
var onend = function() {
|
||
readable = false;
|
||
if (!writable) callback.call(stream);
|
||
};
|
||
|
||
var onexit = function(exitCode) {
|
||
callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
|
||
};
|
||
|
||
var onerror = function(err) {
|
||
callback.call(stream, err);
|
||
};
|
||
|
||
var onclose = function() {
|
||
process.nextTick(onclosenexttick);
|
||
};
|
||
|
||
var onclosenexttick = function() {
|
||
if (cancelled) return;
|
||
if (readable && !(rs && (rs.ended && !rs.destroyed))) return callback.call(stream, new Error('premature close'));
|
||
if (writable && !(ws && (ws.ended && !ws.destroyed))) return callback.call(stream, new Error('premature close'));
|
||
};
|
||
|
||
var onrequest = function() {
|
||
stream.req.on('finish', onfinish);
|
||
};
|
||
|
||
if (isRequest(stream)) {
|
||
stream.on('complete', onfinish);
|
||
stream.on('abort', onclose);
|
||
if (stream.req) onrequest();
|
||
else stream.on('request', onrequest);
|
||
} else if (writable && !ws) { // legacy streams
|
||
stream.on('end', onlegacyfinish);
|
||
stream.on('close', onlegacyfinish);
|
||
}
|
||
|
||
if (isChildProcess(stream)) stream.on('exit', onexit);
|
||
|
||
stream.on('end', onend);
|
||
stream.on('finish', onfinish);
|
||
if (opts.error !== false) stream.on('error', onerror);
|
||
stream.on('close', onclose);
|
||
|
||
return function() {
|
||
cancelled = true;
|
||
stream.removeListener('complete', onfinish);
|
||
stream.removeListener('abort', onclose);
|
||
stream.removeListener('request', onrequest);
|
||
if (stream.req) stream.req.removeListener('finish', onfinish);
|
||
stream.removeListener('end', onlegacyfinish);
|
||
stream.removeListener('close', onlegacyfinish);
|
||
stream.removeListener('finish', onfinish);
|
||
stream.removeListener('exit', onexit);
|
||
stream.removeListener('end', onend);
|
||
stream.removeListener('error', onerror);
|
||
stream.removeListener('close', onclose);
|
||
};
|
||
};
|
||
|
||
module.exports = eos;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 11:
|
||
/***/ (function(module) {
|
||
|
||
// Returns a wrapper function that returns a wrapped callback
|
||
// The wrapper function should do some stuff, and return a
|
||
// presumably different callback function.
|
||
// This makes sure that own properties are retained, so that
|
||
// decorations and such are not lost along the way.
|
||
module.exports = wrappy
|
||
function wrappy (fn, cb) {
|
||
if (fn && cb) return wrappy(fn)(cb)
|
||
|
||
if (typeof fn !== 'function')
|
||
throw new TypeError('need wrapper function')
|
||
|
||
Object.keys(fn).forEach(function (k) {
|
||
wrapper[k] = fn[k]
|
||
})
|
||
|
||
return wrapper
|
||
|
||
function wrapper() {
|
||
var args = new Array(arguments.length)
|
||
for (var i = 0; i < args.length; i++) {
|
||
args[i] = arguments[i]
|
||
}
|
||
var ret = fn.apply(this, args)
|
||
var cb = args[args.length-1]
|
||
if (typeof ret === 'function' && ret !== cb) {
|
||
Object.keys(cb).forEach(function (k) {
|
||
ret[k] = cb[k]
|
||
})
|
||
}
|
||
return ret
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 13:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var replace = String.prototype.replace;
|
||
var percentTwenties = /%20/g;
|
||
|
||
var util = __webpack_require__(581);
|
||
|
||
var Format = {
|
||
RFC1738: 'RFC1738',
|
||
RFC3986: 'RFC3986'
|
||
};
|
||
|
||
module.exports = util.assign(
|
||
{
|
||
'default': Format.RFC3986,
|
||
formatters: {
|
||
RFC1738: function (value) {
|
||
return replace.call(value, percentTwenties, '+');
|
||
},
|
||
RFC3986: function (value) {
|
||
return String(value);
|
||
}
|
||
}
|
||
},
|
||
Format
|
||
);
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 18:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = eval("require")("encoding");
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 46:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var _Object$setPrototypeO;
|
||
|
||
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
||
|
||
var finished = __webpack_require__(287);
|
||
|
||
var kLastResolve = Symbol('lastResolve');
|
||
var kLastReject = Symbol('lastReject');
|
||
var kError = Symbol('error');
|
||
var kEnded = Symbol('ended');
|
||
var kLastPromise = Symbol('lastPromise');
|
||
var kHandlePromise = Symbol('handlePromise');
|
||
var kStream = Symbol('stream');
|
||
|
||
function createIterResult(value, done) {
|
||
return {
|
||
value: value,
|
||
done: done
|
||
};
|
||
}
|
||
|
||
function readAndResolve(iter) {
|
||
var resolve = iter[kLastResolve];
|
||
|
||
if (resolve !== null) {
|
||
var data = iter[kStream].read(); // we defer if data is null
|
||
// we can be expecting either 'end' or
|
||
// 'error'
|
||
|
||
if (data !== null) {
|
||
iter[kLastPromise] = null;
|
||
iter[kLastResolve] = null;
|
||
iter[kLastReject] = null;
|
||
resolve(createIterResult(data, false));
|
||
}
|
||
}
|
||
}
|
||
|
||
function onReadable(iter) {
|
||
// we wait for the next tick, because it might
|
||
// emit an error with process.nextTick
|
||
process.nextTick(readAndResolve, iter);
|
||
}
|
||
|
||
function wrapForNext(lastPromise, iter) {
|
||
return function (resolve, reject) {
|
||
lastPromise.then(function () {
|
||
if (iter[kEnded]) {
|
||
resolve(createIterResult(undefined, true));
|
||
return;
|
||
}
|
||
|
||
iter[kHandlePromise](resolve, reject);
|
||
}, reject);
|
||
};
|
||
}
|
||
|
||
var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
|
||
var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
|
||
get stream() {
|
||
return this[kStream];
|
||
},
|
||
|
||
next: function next() {
|
||
var _this = this;
|
||
|
||
// if we have detected an error in the meanwhile
|
||
// reject straight away
|
||
var error = this[kError];
|
||
|
||
if (error !== null) {
|
||
return Promise.reject(error);
|
||
}
|
||
|
||
if (this[kEnded]) {
|
||
return Promise.resolve(createIterResult(undefined, true));
|
||
}
|
||
|
||
if (this[kStream].destroyed) {
|
||
// We need to defer via nextTick because if .destroy(err) is
|
||
// called, the error will be emitted via nextTick, and
|
||
// we cannot guarantee that there is no error lingering around
|
||
// waiting to be emitted.
|
||
return new Promise(function (resolve, reject) {
|
||
process.nextTick(function () {
|
||
if (_this[kError]) {
|
||
reject(_this[kError]);
|
||
} else {
|
||
resolve(createIterResult(undefined, true));
|
||
}
|
||
});
|
||
});
|
||
} // if we have multiple next() calls
|
||
// we will wait for the previous Promise to finish
|
||
// this logic is optimized to support for await loops,
|
||
// where next() is only called once at a time
|
||
|
||
|
||
var lastPromise = this[kLastPromise];
|
||
var promise;
|
||
|
||
if (lastPromise) {
|
||
promise = new Promise(wrapForNext(lastPromise, this));
|
||
} else {
|
||
// fast path needed to support multiple this.push()
|
||
// without triggering the next() queue
|
||
var data = this[kStream].read();
|
||
|
||
if (data !== null) {
|
||
return Promise.resolve(createIterResult(data, false));
|
||
}
|
||
|
||
promise = new Promise(this[kHandlePromise]);
|
||
}
|
||
|
||
this[kLastPromise] = promise;
|
||
return promise;
|
||
}
|
||
}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
|
||
return this;
|
||
}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
|
||
var _this2 = this;
|
||
|
||
// destroy(err, cb) is a private API
|
||
// we can guarantee we have that here, because we control the
|
||
// Readable class this is attached to
|
||
return new Promise(function (resolve, reject) {
|
||
_this2[kStream].destroy(null, function (err) {
|
||
if (err) {
|
||
reject(err);
|
||
return;
|
||
}
|
||
|
||
resolve(createIterResult(undefined, true));
|
||
});
|
||
});
|
||
}), _Object$setPrototypeO), AsyncIteratorPrototype);
|
||
|
||
var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
|
||
var _Object$create;
|
||
|
||
var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
|
||
value: stream,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kLastResolve, {
|
||
value: null,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kLastReject, {
|
||
value: null,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kError, {
|
||
value: null,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kEnded, {
|
||
value: stream._readableState.endEmitted,
|
||
writable: true
|
||
}), _defineProperty(_Object$create, kHandlePromise, {
|
||
value: function value(resolve, reject) {
|
||
var data = iterator[kStream].read();
|
||
|
||
if (data) {
|
||
iterator[kLastPromise] = null;
|
||
iterator[kLastResolve] = null;
|
||
iterator[kLastReject] = null;
|
||
resolve(createIterResult(data, false));
|
||
} else {
|
||
iterator[kLastResolve] = resolve;
|
||
iterator[kLastReject] = reject;
|
||
}
|
||
},
|
||
writable: true
|
||
}), _Object$create));
|
||
iterator[kLastPromise] = null;
|
||
finished(stream, function (err) {
|
||
if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
|
||
var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
|
||
// returned by next() and store the error
|
||
|
||
if (reject !== null) {
|
||
iterator[kLastPromise] = null;
|
||
iterator[kLastResolve] = null;
|
||
iterator[kLastReject] = null;
|
||
reject(err);
|
||
}
|
||
|
||
iterator[kError] = err;
|
||
return;
|
||
}
|
||
|
||
var resolve = iterator[kLastResolve];
|
||
|
||
if (resolve !== null) {
|
||
iterator[kLastPromise] = null;
|
||
iterator[kLastResolve] = null;
|
||
iterator[kLastReject] = null;
|
||
resolve(createIterResult(undefined, true));
|
||
}
|
||
|
||
iterator[kEnded] = true;
|
||
});
|
||
stream.on('readable', onReadable.bind(null, iterator));
|
||
return iterator;
|
||
};
|
||
|
||
module.exports = createReadableStreamAsyncIterator;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 49:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var wrappy = __webpack_require__(11)
|
||
module.exports = wrappy(once)
|
||
module.exports.strict = wrappy(onceStrict)
|
||
|
||
once.proto = once(function () {
|
||
Object.defineProperty(Function.prototype, 'once', {
|
||
value: function () {
|
||
return once(this)
|
||
},
|
||
configurable: true
|
||
})
|
||
|
||
Object.defineProperty(Function.prototype, 'onceStrict', {
|
||
value: function () {
|
||
return onceStrict(this)
|
||
},
|
||
configurable: true
|
||
})
|
||
})
|
||
|
||
function once (fn) {
|
||
var f = function () {
|
||
if (f.called) return f.value
|
||
f.called = true
|
||
return f.value = fn.apply(this, arguments)
|
||
}
|
||
f.called = false
|
||
return f
|
||
}
|
||
|
||
function onceStrict (fn) {
|
||
var f = function () {
|
||
if (f.called)
|
||
throw new Error(f.onceError)
|
||
f.called = true
|
||
return f.value = fn.apply(this, arguments)
|
||
}
|
||
var name = fn.name || 'Function wrapped with `once`'
|
||
f.onceError = name + " shouldn't be called more than once"
|
||
f.called = false
|
||
return f
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 69:
|
||
/***/ (function(module) {
|
||
|
||
// populates missing values
|
||
module.exports = function(dst, src) {
|
||
|
||
Object.keys(src).forEach(function(prop)
|
||
{
|
||
dst[prop] = dst[prop] || src[prop];
|
||
});
|
||
|
||
return dst;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 87:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("os");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 91:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var serialOrdered = __webpack_require__(892);
|
||
|
||
// Public API
|
||
module.exports = serial;
|
||
|
||
/**
|
||
* Runs iterator over provided array elements in series
|
||
*
|
||
* @param {array|object} list - array or object (named list) to iterate over
|
||
* @param {function} iterator - iterator to run
|
||
* @param {function} callback - invoked when all elements processed
|
||
* @returns {function} - jobs terminator
|
||
*/
|
||
function serial(list, iterator, callback)
|
||
{
|
||
return serialOrdered(list, iterator, null, callback);
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 98:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
const crypto = __webpack_require__(417)
|
||
const util = __webpack_require__(669)
|
||
const fs = __webpack_require__(747)
|
||
|
||
const ppump = util.promisify(__webpack_require__(453))
|
||
|
||
/**
|
||
* neocitiesLocalDiff returns an array of files to delete and update and some useful stats.
|
||
* @param {Array} neocitiesFiles Array of files returned from the neocities list api.
|
||
* @param {Array} localListing Array of files returned by a full data async-folder-walker run.
|
||
* @return {Promise<Object>} Object of filesToUpload, filesToDelete and filesSkipped.
|
||
*/
|
||
async function neocitiesLocalDiff (neocitiesFiles, localListing) {
|
||
const localIndex = {}
|
||
const ncIndex = {}
|
||
|
||
const neoCitiesFiltered = neocitiesFiles.filter(f => !f.is_directory)
|
||
neoCitiesFiltered.forEach(f => { ncIndex[f.path] = f }) // index
|
||
const ncFiles = new Set(neoCitiesFiltered.map(f => f.path)) // shape
|
||
|
||
const localListingFiltered = localListing.filter(f => !f.stat.isDirectory()) // files only
|
||
localListingFiltered.forEach(f => { localIndex[forceUnixRelname(f.relname)] = f }) // index
|
||
const localFiles = new Set(localListingFiltered.map(f => forceUnixRelname(f.relname))) // shape
|
||
|
||
const filesToAdd = difference(localFiles, ncFiles)
|
||
const filesToDelete = difference(ncFiles, localFiles)
|
||
|
||
const maybeUpdate = intersection(localFiles, ncFiles)
|
||
const skipped = new Set()
|
||
|
||
for (const p of maybeUpdate) {
|
||
const local = localIndex[p]
|
||
const remote = ncIndex[p]
|
||
|
||
if (local.stat.size !== remote.size) { filesToAdd.add(p); continue }
|
||
|
||
const localSha1 = await sha1FromPath(local.filepath)
|
||
if (localSha1 !== remote.sha1_hash) { filesToAdd.add(p); continue }
|
||
|
||
skipped.add(p)
|
||
}
|
||
|
||
return {
|
||
filesToUpload: Array.from(filesToAdd).map(p => ({
|
||
name: forceUnixRelname(localIndex[p].relname),
|
||
path: localIndex[p].filepath
|
||
})),
|
||
filesToDelete: Array.from(filesToDelete).map(p => ncIndex[p].path),
|
||
filesSkipped: Array.from(skipped).map(p => localIndex[p])
|
||
}
|
||
}
|
||
|
||
module.exports = {
|
||
neocitiesLocalDiff
|
||
}
|
||
|
||
/**
|
||
* sha1FromPath returns a sha1 hex from a path
|
||
* @param {String} p string of the path of the file to hash
|
||
* @return {Promise<String>} the hex representation of the sha1
|
||
*/
|
||
async function sha1FromPath (p) {
|
||
const rs = fs.createReadStream(p)
|
||
const hash = crypto.createHash('sha1')
|
||
|
||
await ppump(rs, hash)
|
||
|
||
return hash.digest('hex')
|
||
}
|
||
|
||
// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set#Implementing_basic_set_operations
|
||
|
||
/**
|
||
* difference returnss the difference betwen setA and setB.
|
||
* @param {Set} setA LHS set
|
||
* @param {Set} setB RHS set
|
||
* @return {Set} The difference Set
|
||
*/
|
||
function difference (setA, setB) {
|
||
const _difference = new Set(setA)
|
||
for (const elem of setB) {
|
||
_difference.delete(elem)
|
||
}
|
||
return _difference
|
||
}
|
||
|
||
/**
|
||
* intersection returns the interesction between setA and setB.
|
||
* @param {Set} setA setA LHS set
|
||
* @param {Set} setB setB RHS set
|
||
* @return {Set} The intersection set between setA and setB.
|
||
*/
|
||
function intersection (setA, setB) {
|
||
const _intersection = new Set()
|
||
for (const elem of setB) {
|
||
if (setA.has(elem)) {
|
||
_intersection.add(elem)
|
||
}
|
||
}
|
||
return _intersection
|
||
}
|
||
|
||
/**
|
||
* forceUnixRelname forces a OS dependent path to a unix style path.
|
||
* @param {String} relname String path to convert to unix style.
|
||
* @return {String} The unix variant of the path
|
||
*/
|
||
function forceUnixRelname (relname) {
|
||
return relname.split(relname.sep).join('/')
|
||
}
|
||
|
||
/**
|
||
* Example of neocitiesFiles
|
||
*/
|
||
// [
|
||
// {
|
||
// path: 'img',
|
||
// is_directory: true,
|
||
// updated_at: 'Thu, 21 Nov 2019 04:06:17 -0000'
|
||
// },
|
||
// {
|
||
// path: 'index.html',
|
||
// is_directory: false,
|
||
// size: 1094,
|
||
// updated_at: 'Mon, 11 Nov 2019 22:23:16 -0000',
|
||
// sha1_hash: '7f15617e87d83218223662340f4052d9bb9d096d'
|
||
// },
|
||
// {
|
||
// path: 'neocities.png',
|
||
// is_directory: false,
|
||
// size: 13232,
|
||
// updated_at: 'Mon, 11 Nov 2019 22:23:16 -0000',
|
||
// sha1_hash: 'fd2ee41b1922a39a716cacb88c323d613b0955e4'
|
||
// },
|
||
// {
|
||
// path: 'not_found.html',
|
||
// is_directory: false,
|
||
// size: 347,
|
||
// updated_at: 'Mon, 11 Nov 2019 22:23:16 -0000',
|
||
// sha1_hash: 'd7f004e9d3b2eaaa8827f741356f1122dc9eb030'
|
||
// },
|
||
// {
|
||
// path: 'style.css',
|
||
// is_directory: false,
|
||
// size: 298,
|
||
// updated_at: 'Mon, 11 Nov 2019 22:23:16 -0000',
|
||
// sha1_hash: 'e516457acdb0d00710ab62cc257109ef67209ce8'
|
||
// }
|
||
// ]
|
||
|
||
/**
|
||
* Example of localListing
|
||
*/
|
||
// [{
|
||
// root: '/Users/bret/repos/async-folder-walker/fixtures',
|
||
// filepath: '/Users/bret/repos/async-folder-walker/fixtures/sub-folder/sub-sub-folder',
|
||
// stat: Stats {
|
||
// dev: 16777220,
|
||
// mode: 16877,
|
||
// nlink: 3,
|
||
// uid: 501,
|
||
// gid: 20,
|
||
// rdev: 0,
|
||
// blksize: 4096,
|
||
// ino: 30244023,
|
||
// size: 96,
|
||
// blocks: 0,
|
||
// atimeMs: 1574381262779.8396,
|
||
// mtimeMs: 1574380914743.5474,
|
||
// ctimeMs: 1574380914743.5474,
|
||
// birthtimeMs: 1574380905232.5996,
|
||
// atime: 2019-11-22T00:07:42.780Z,
|
||
// mtime: 2019-11-22T00:01:54.744Z,
|
||
// ctime: 2019-11-22T00:01:54.744Z,
|
||
// birthtime: 2019-11-22T00:01:45.233Z
|
||
// },
|
||
// relname: 'sub-folder/sub-sub-folder',
|
||
// basename: 'sub-sub-folder'
|
||
// }]
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 104:
|
||
/***/ (function(__unusedmodule, __unusedexports, __webpack_require__) {
|
||
|
||
const core = __webpack_require__(470)
|
||
// const github = require('@actions/github')
|
||
const Neocities = __webpack_require__(248)
|
||
const path = __webpack_require__(622)
|
||
const ms = __webpack_require__(317)
|
||
const assert = __webpack_require__(920).default
|
||
const fsp = __webpack_require__(747).promises
|
||
|
||
async function doDeploy () {
|
||
const token = core.getInput('api_token')
|
||
const distDir = path.join(process.cwd(), core.getInput('dist_dir'))
|
||
const cleanup = JSON.parse(core.getInput('cleanup'))
|
||
|
||
assert(typeof cleanup === 'boolean', 'Cleanup input must be a boolean "true" or "false"')
|
||
const stat = await fsp.stat(distDir)
|
||
assert(stat.isDirectory(), 'dist_dir must be a directory that exists')
|
||
|
||
const client = new Neocities(token)
|
||
|
||
const stats = await client.deploy(distDir, {
|
||
cleanup,
|
||
statsCb: Neocities.statsHandler()
|
||
})
|
||
|
||
console.log(`Deployed to Neocities in ${ms(stats.time)}:`)
|
||
console.log(` Uploaded ${stats.filesToUpload.length} files`)
|
||
console.log(` ${cleanup ? 'Deleted' : 'Orphaned'} ${stats.filesToDelete.length} files`)
|
||
console.log(` Skipped ${stats.filesSkipped.length} files`)
|
||
}
|
||
|
||
doDeploy().catch(err => {
|
||
console.error(err)
|
||
core.setFailed(err.message)
|
||
})
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 108:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
const { Writable, Transform } = __webpack_require__(745)
|
||
const pump = __webpack_require__(453)
|
||
const pumpify = __webpack_require__(746)
|
||
|
||
function getStreamLength (readable) {
|
||
let length = 0
|
||
|
||
const dummyLoad = new Writable({
|
||
write (data, cb) {
|
||
length += data.length
|
||
cb(null)
|
||
}
|
||
})
|
||
|
||
return new Promise((resolve, reject) => {
|
||
pump(readable, dummyLoad, (err) => {
|
||
if (err) return reject(err)
|
||
resolve(length)
|
||
})
|
||
})
|
||
}
|
||
|
||
function meterStream (readable, statsCb) {
|
||
let bytesRead = 0
|
||
const meter = new Transform({
|
||
transform (data, cb) {
|
||
bytesRead += data.length
|
||
statsCb(bytesRead)
|
||
cb(null, data)
|
||
}
|
||
})
|
||
return pumpify(readable, meter)
|
||
}
|
||
|
||
module.exports = {
|
||
getStreamLength,
|
||
meterStream
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 134:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
const FixedFIFO = __webpack_require__(740)
|
||
|
||
module.exports = class FastFIFO {
|
||
constructor (hwm) {
|
||
this.hwm = hwm || 16
|
||
this.head = new FixedFIFO(this.hwm)
|
||
this.tail = this.head
|
||
}
|
||
|
||
push (val) {
|
||
if (!this.head.push(val)) {
|
||
const prev = this.head
|
||
this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length)
|
||
this.head.push(val)
|
||
}
|
||
}
|
||
|
||
shift () {
|
||
const val = this.tail.shift()
|
||
if (val === undefined && this.tail.next) {
|
||
const next = this.tail.next
|
||
this.tail.next = null
|
||
this.tail = next
|
||
return this.tail.shift()
|
||
}
|
||
return val
|
||
}
|
||
|
||
isEmpty () {
|
||
return this.head.isEmpty()
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 147:
|
||
/***/ (function(module) {
|
||
|
||
// API
|
||
module.exports = state;
|
||
|
||
/**
|
||
* Creates initial state object
|
||
* for iteration over list
|
||
*
|
||
* @param {array|object} list - list to iterate over
|
||
* @param {function|null} sortMethod - function to use for keys sort,
|
||
* or `null` to keep them as is
|
||
* @returns {object} - initial state object
|
||
*/
|
||
function state(list, sortMethod)
|
||
{
|
||
var isNamedList = !Array.isArray(list)
|
||
, initState =
|
||
{
|
||
index : 0,
|
||
keyedList: isNamedList || sortMethod ? Object.keys(list) : null,
|
||
jobs : {},
|
||
results : isNamedList ? {} : [],
|
||
size : isNamedList ? Object.keys(list).length : list.length
|
||
}
|
||
;
|
||
|
||
if (sortMethod)
|
||
{
|
||
// sort array keys based on it's values
|
||
// sort object's keys just on own merit
|
||
initState.keyedList.sort(isNamedList ? sortMethod : function(a, b)
|
||
{
|
||
return sortMethod(list[a], list[b]);
|
||
});
|
||
}
|
||
|
||
return initState;
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 149:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
|
||
/* eslint-disable node/no-deprecated-api */
|
||
var buffer = __webpack_require__(293)
|
||
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)
|
||
}
|
||
|
||
SafeBuffer.prototype = Object.create(Buffer.prototype)
|
||
|
||
// 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)
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 152:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var Stream = __webpack_require__(413).Stream;
|
||
var util = __webpack_require__(669);
|
||
|
||
module.exports = DelayedStream;
|
||
function DelayedStream() {
|
||
this.source = null;
|
||
this.dataSize = 0;
|
||
this.maxDataSize = 1024 * 1024;
|
||
this.pauseStream = true;
|
||
|
||
this._maxDataSizeExceeded = false;
|
||
this._released = false;
|
||
this._bufferedEvents = [];
|
||
}
|
||
util.inherits(DelayedStream, Stream);
|
||
|
||
DelayedStream.create = function(source, options) {
|
||
var delayedStream = new this();
|
||
|
||
options = options || {};
|
||
for (var option in options) {
|
||
delayedStream[option] = options[option];
|
||
}
|
||
|
||
delayedStream.source = source;
|
||
|
||
var realEmit = source.emit;
|
||
source.emit = function() {
|
||
delayedStream._handleEmit(arguments);
|
||
return realEmit.apply(source, arguments);
|
||
};
|
||
|
||
source.on('error', function() {});
|
||
if (delayedStream.pauseStream) {
|
||
source.pause();
|
||
}
|
||
|
||
return delayedStream;
|
||
};
|
||
|
||
Object.defineProperty(DelayedStream.prototype, 'readable', {
|
||
configurable: true,
|
||
enumerable: true,
|
||
get: function() {
|
||
return this.source.readable;
|
||
}
|
||
});
|
||
|
||
DelayedStream.prototype.setEncoding = function() {
|
||
return this.source.setEncoding.apply(this.source, arguments);
|
||
};
|
||
|
||
DelayedStream.prototype.resume = function() {
|
||
if (!this._released) {
|
||
this.release();
|
||
}
|
||
|
||
this.source.resume();
|
||
};
|
||
|
||
DelayedStream.prototype.pause = function() {
|
||
this.source.pause();
|
||
};
|
||
|
||
DelayedStream.prototype.release = function() {
|
||
this._released = true;
|
||
|
||
this._bufferedEvents.forEach(function(args) {
|
||
this.emit.apply(this, args);
|
||
}.bind(this));
|
||
this._bufferedEvents = [];
|
||
};
|
||
|
||
DelayedStream.prototype.pipe = function() {
|
||
var r = Stream.prototype.pipe.apply(this, arguments);
|
||
this.resume();
|
||
return r;
|
||
};
|
||
|
||
DelayedStream.prototype._handleEmit = function(args) {
|
||
if (this._released) {
|
||
this.emit.apply(this, args);
|
||
return;
|
||
}
|
||
|
||
if (args[0] === 'data') {
|
||
this.dataSize += args[1].length;
|
||
this._checkIfMaxDataSizeExceeded();
|
||
}
|
||
|
||
this._bufferedEvents.push(args);
|
||
};
|
||
|
||
DelayedStream.prototype._checkIfMaxDataSizeExceeded = function() {
|
||
if (this._maxDataSizeExceeded) {
|
||
return;
|
||
}
|
||
|
||
if (this.dataSize <= this.maxDataSize) {
|
||
return;
|
||
}
|
||
|
||
this._maxDataSizeExceeded = true;
|
||
var message =
|
||
'DelayedStream#maxDataSize of ' + this.maxDataSize + ' bytes exceeded.'
|
||
this.emit('error', new Error(message));
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 157:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var async = __webpack_require__(751)
|
||
, abort = __webpack_require__(566)
|
||
;
|
||
|
||
// API
|
||
module.exports = iterate;
|
||
|
||
/**
|
||
* Iterates over each job object
|
||
*
|
||
* @param {array|object} list - array or object (named list) to iterate over
|
||
* @param {function} iterator - iterator to run
|
||
* @param {object} state - current job status
|
||
* @param {function} callback - invoked when all elements processed
|
||
*/
|
||
function iterate(list, iterator, state, callback)
|
||
{
|
||
// store current index
|
||
var key = state['keyedList'] ? state['keyedList'][state.index] : state.index;
|
||
|
||
state.jobs[key] = runJob(iterator, key, list[key], function(error, output)
|
||
{
|
||
// don't repeat yourself
|
||
// skip secondary callbacks
|
||
if (!(key in state.jobs))
|
||
{
|
||
return;
|
||
}
|
||
|
||
// clean up jobs
|
||
delete state.jobs[key];
|
||
|
||
if (error)
|
||
{
|
||
// don't process rest of the results
|
||
// stop still active jobs
|
||
// and reset the list
|
||
abort(state);
|
||
}
|
||
else
|
||
{
|
||
state.results[key] = output;
|
||
}
|
||
|
||
// return salvaged results
|
||
callback(error, state.results);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Runs iterator over provided job element
|
||
*
|
||
* @param {function} iterator - iterator to invoke
|
||
* @param {string|number} key - key/index of the element in the list of jobs
|
||
* @param {mixed} item - job description
|
||
* @param {function} callback - invoked after iterator is done with the job
|
||
* @returns {function|mixed} - job abort function or something else
|
||
*/
|
||
function runJob(iterator, key, item, callback)
|
||
{
|
||
var aborter;
|
||
|
||
// allow shortcut if iterator expects only two arguments
|
||
if (iterator.length == 2)
|
||
{
|
||
aborter = iterator(item, async(callback));
|
||
}
|
||
// otherwise go with full three arguments
|
||
else
|
||
{
|
||
aborter = iterator(item, key, async(callback));
|
||
}
|
||
|
||
return aborter;
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 176:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
|
||
|
||
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
|
||
|
||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
||
|
||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
||
|
||
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
||
|
||
var ERR_INVALID_ARG_TYPE = __webpack_require__(563).codes.ERR_INVALID_ARG_TYPE;
|
||
|
||
function from(Readable, iterable, opts) {
|
||
var iterator;
|
||
|
||
if (iterable && typeof iterable.next === 'function') {
|
||
iterator = iterable;
|
||
} else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
|
||
|
||
var readable = new Readable(_objectSpread({
|
||
objectMode: true
|
||
}, opts)); // Reading boolean to protect against _read
|
||
// being called before last iteration completion.
|
||
|
||
var reading = false;
|
||
|
||
readable._read = function () {
|
||
if (!reading) {
|
||
reading = true;
|
||
next();
|
||
}
|
||
};
|
||
|
||
function next() {
|
||
return _next2.apply(this, arguments);
|
||
}
|
||
|
||
function _next2() {
|
||
_next2 = _asyncToGenerator(function* () {
|
||
try {
|
||
var _ref = yield iterator.next(),
|
||
value = _ref.value,
|
||
done = _ref.done;
|
||
|
||
if (done) {
|
||
readable.push(null);
|
||
} else if (readable.push((yield value))) {
|
||
next();
|
||
} else {
|
||
reading = false;
|
||
}
|
||
} catch (err) {
|
||
readable.destroy(err);
|
||
}
|
||
});
|
||
return _next2.apply(this, arguments);
|
||
}
|
||
|
||
return readable;
|
||
}
|
||
|
||
module.exports = from;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 211:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("https");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 216:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var ERR_INVALID_OPT_VALUE = __webpack_require__(563).codes.ERR_INVALID_OPT_VALUE;
|
||
|
||
function highWaterMarkFrom(options, isDuplex, duplexKey) {
|
||
return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
|
||
}
|
||
|
||
function getHighWaterMark(state, options, duplexKey, isDuplex) {
|
||
var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
|
||
|
||
if (hwm != null) {
|
||
if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
|
||
var name = isDuplex ? duplexKey : 'highWaterMark';
|
||
throw new ERR_INVALID_OPT_VALUE(name, hwm);
|
||
}
|
||
|
||
return Math.floor(hwm);
|
||
} // Default value
|
||
|
||
|
||
return state.objectMode ? 16 : 16 * 1024;
|
||
}
|
||
|
||
module.exports = {
|
||
getHighWaterMark: getHighWaterMark
|
||
};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 226:
|
||
/***/ (function(module, __unusedexports, __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.
|
||
|
||
|
||
module.exports = Readable;
|
||
/*<replacement>*/
|
||
|
||
var Duplex;
|
||
/*</replacement>*/
|
||
|
||
Readable.ReadableState = ReadableState;
|
||
/*<replacement>*/
|
||
|
||
var EE = __webpack_require__(614).EventEmitter;
|
||
|
||
var EElistenerCount = function EElistenerCount(emitter, type) {
|
||
return emitter.listeners(type).length;
|
||
};
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
|
||
|
||
var Stream = __webpack_require__(427);
|
||
/*</replacement>*/
|
||
|
||
|
||
var Buffer = __webpack_require__(293).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 debugUtil = __webpack_require__(669);
|
||
|
||
var debug;
|
||
|
||
if (debugUtil && debugUtil.debuglog) {
|
||
debug = debugUtil.debuglog('stream');
|
||
} else {
|
||
debug = function debug() {};
|
||
}
|
||
/*</replacement>*/
|
||
|
||
|
||
var BufferList = __webpack_require__(896);
|
||
|
||
var destroyImpl = __webpack_require__(232);
|
||
|
||
var _require = __webpack_require__(216),
|
||
getHighWaterMark = _require.getHighWaterMark;
|
||
|
||
var _require$codes = __webpack_require__(563).codes,
|
||
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
|
||
ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
|
||
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
||
ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.
|
||
|
||
|
||
var StringDecoder;
|
||
var createReadableStreamAsyncIterator;
|
||
var from;
|
||
|
||
__webpack_require__(689)(Readable, Stream);
|
||
|
||
var errorOrDestroy = destroyImpl.errorOrDestroy;
|
||
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 (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
|
||
}
|
||
|
||
function ReadableState(options, stream, isDuplex) {
|
||
Duplex = Duplex || __webpack_require__(831);
|
||
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.
|
||
|
||
if (typeof isDuplex !== 'boolean') 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"
|
||
|
||
this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // 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;
|
||
this.paused = true; // Should close be emitted on destroy. Defaults to true.
|
||
|
||
this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')
|
||
|
||
this.autoDestroy = !!options.autoDestroy; // 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__(674).StringDecoder;
|
||
this.decoder = new StringDecoder(options.encoding);
|
||
this.encoding = options.encoding;
|
||
}
|
||
}
|
||
|
||
function Readable(options) {
|
||
Duplex = Duplex || __webpack_require__(831);
|
||
if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside
|
||
// the ReadableState constructor, at least with V8 6.5
|
||
|
||
var isDuplex = this instanceof Duplex;
|
||
this._readableState = new ReadableState(options, this, isDuplex); // 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', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
if (this._readableState === undefined) {
|
||
return false;
|
||
}
|
||
|
||
return this._readableState.destroyed;
|
||
},
|
||
set: function set(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) {
|
||
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) {
|
||
debug('readableAddChunk', chunk);
|
||
var state = stream._readableState;
|
||
|
||
if (chunk === null) {
|
||
state.reading = false;
|
||
onEofChunk(stream, state);
|
||
} else {
|
||
var er;
|
||
if (!skipChunkCheck) er = chunkInvalid(state, chunk);
|
||
|
||
if (er) {
|
||
errorOrDestroy(stream, 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) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
|
||
} else if (state.ended) {
|
||
errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
|
||
} else if (state.destroyed) {
|
||
return false;
|
||
} 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;
|
||
maybeReadMore(stream, state);
|
||
}
|
||
} // We can push more data if we are below the highWaterMark.
|
||
// 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.
|
||
|
||
|
||
return !state.ended && (state.length < state.highWaterMark || state.length === 0);
|
||
}
|
||
|
||
function addChunk(stream, state, chunk, addToFront) {
|
||
if (state.flowing && state.length === 0 && !state.sync) {
|
||
state.awaitDrain = 0;
|
||
stream.emit('data', chunk);
|
||
} 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 ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
|
||
}
|
||
|
||
return er;
|
||
}
|
||
|
||
Readable.prototype.isPaused = function () {
|
||
return this._readableState.flowing === false;
|
||
}; // backwards compatibility.
|
||
|
||
|
||
Readable.prototype.setEncoding = function (enc) {
|
||
if (!StringDecoder) StringDecoder = __webpack_require__(674).StringDecoder;
|
||
var decoder = new StringDecoder(enc);
|
||
this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8
|
||
|
||
this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:
|
||
|
||
var p = this._readableState.buffer.head;
|
||
var content = '';
|
||
|
||
while (p !== null) {
|
||
content += decoder.write(p.data);
|
||
p = p.next;
|
||
}
|
||
|
||
this._readableState.buffer.clear();
|
||
|
||
if (content !== '') this._readableState.buffer.push(content);
|
||
this._readableState.length = content.length;
|
||
return this;
|
||
}; // Don't raise the hwm > 1GB
|
||
|
||
|
||
var MAX_HWM = 0x40000000;
|
||
|
||
function computeNewHighWaterMark(n) {
|
||
if (n >= MAX_HWM) {
|
||
// TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
|
||
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.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || 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 = state.length <= state.highWaterMark;
|
||
n = 0;
|
||
} else {
|
||
state.length -= n;
|
||
state.awaitDrain = 0;
|
||
}
|
||
|
||
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) {
|
||
debug('onEofChunk');
|
||
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;
|
||
|
||
if (state.sync) {
|
||
// if we are sync, wait until next tick to emit the data.
|
||
// Otherwise we risk emitting data in the flow()
|
||
// the readable code triggers during a read() call
|
||
emitReadable(stream);
|
||
} else {
|
||
// emit 'readable' now to make sure it gets picked up.
|
||
state.needReadable = false;
|
||
|
||
if (!state.emittedReadable) {
|
||
state.emittedReadable = true;
|
||
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;
|
||
debug('emitReadable', state.needReadable, state.emittedReadable);
|
||
state.needReadable = false;
|
||
|
||
if (!state.emittedReadable) {
|
||
debug('emitReadable', state.flowing);
|
||
state.emittedReadable = true;
|
||
process.nextTick(emitReadable_, stream);
|
||
}
|
||
}
|
||
|
||
function emitReadable_(stream) {
|
||
var state = stream._readableState;
|
||
debug('emitReadable_', state.destroyed, state.length, state.ended);
|
||
|
||
if (!state.destroyed && (state.length || state.ended)) {
|
||
stream.emit('readable');
|
||
state.emittedReadable = false;
|
||
} // The stream needs another readable event if
|
||
// 1. It is not flowing, as the flow mechanism will take
|
||
// care of it.
|
||
// 2. It is not ended.
|
||
// 3. It is below the highWaterMark, so we can schedule
|
||
// another readable later.
|
||
|
||
|
||
state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
|
||
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;
|
||
process.nextTick(maybeReadMore_, stream, state);
|
||
}
|
||
}
|
||
|
||
function maybeReadMore_(stream, state) {
|
||
// Attempt to read more data if we should.
|
||
//
|
||
// The conditions for reading more data are (one of):
|
||
// - Not enough data buffered (state.length < state.highWaterMark). The loop
|
||
// is responsible for filling the buffer with enough data if such data
|
||
// is available. If highWaterMark is 0 and we are not in the flowing mode
|
||
// we should _not_ attempt to buffer any extra data. We'll get more data
|
||
// when the stream consumer calls read() instead.
|
||
// - No data in the buffer, and the stream is in flowing mode. In this mode
|
||
// the loop below is responsible for ensuring read() is called. Failing to
|
||
// call read here would abort the flow and there's no other mechanism for
|
||
// continuing the flow if the stream consumer has just subscribed to the
|
||
// 'data' event.
|
||
//
|
||
// In addition to the above conditions to keep reading data, the following
|
||
// conditions prevent the data from being read:
|
||
// - The stream has ended (state.ended).
|
||
// - There is already a pending 'read' operation (state.reading). This is a
|
||
// case where the the stream has called the implementation defined _read()
|
||
// method, but they are processing the call asynchronously and have _not_
|
||
// called push() with new data. In this case we skip performing more
|
||
// read()s. The execution ends in this method again after the _read() ends
|
||
// up calling push() with more data.
|
||
while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
|
||
var len = state.length;
|
||
debug('maybeReadMore read 0');
|
||
stream.read(0);
|
||
if (len === state.length) // didn't get any data, stop spinning.
|
||
break;
|
||
}
|
||
|
||
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) {
|
||
errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
|
||
};
|
||
|
||
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) process.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();
|
||
}
|
||
|
||
src.on('data', ondata);
|
||
|
||
function ondata(chunk) {
|
||
debug('ondata');
|
||
var ret = dest.write(chunk);
|
||
debug('dest.write', ret);
|
||
|
||
if (ret === false) {
|
||
// 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', state.awaitDrain);
|
||
state.awaitDrain++;
|
||
}
|
||
|
||
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) errorOrDestroy(dest, 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 pipeOnDrainFunctionResult() {
|
||
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, {
|
||
hasUnpiped: false
|
||
});
|
||
}
|
||
|
||
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);
|
||
var state = this._readableState;
|
||
|
||
if (ev === 'data') {
|
||
// update readableListening so that resume() may be a no-op
|
||
// a few lines down. This is needed to support once('readable').
|
||
state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused
|
||
|
||
if (state.flowing !== false) this.resume();
|
||
} else if (ev === 'readable') {
|
||
if (!state.endEmitted && !state.readableListening) {
|
||
state.readableListening = state.needReadable = true;
|
||
state.flowing = false;
|
||
state.emittedReadable = false;
|
||
debug('on readable', state.length, state.reading);
|
||
|
||
if (state.length) {
|
||
emitReadable(this);
|
||
} else if (!state.reading) {
|
||
process.nextTick(nReadingNextTick, this);
|
||
}
|
||
}
|
||
}
|
||
|
||
return res;
|
||
};
|
||
|
||
Readable.prototype.addListener = Readable.prototype.on;
|
||
|
||
Readable.prototype.removeListener = function (ev, fn) {
|
||
var res = Stream.prototype.removeListener.call(this, ev, fn);
|
||
|
||
if (ev === 'readable') {
|
||
// We need to check if there is someone still listening to
|
||
// readable and reset the state. However this needs to happen
|
||
// after readable has been emitted but before I/O (nextTick) to
|
||
// support once('readable', fn) cycles. This means that calling
|
||
// resume within the same tick will have no
|
||
// effect.
|
||
process.nextTick(updateReadableListening, this);
|
||
}
|
||
|
||
return res;
|
||
};
|
||
|
||
Readable.prototype.removeAllListeners = function (ev) {
|
||
var res = Stream.prototype.removeAllListeners.apply(this, arguments);
|
||
|
||
if (ev === 'readable' || ev === undefined) {
|
||
// We need to check if there is someone still listening to
|
||
// readable and reset the state. However this needs to happen
|
||
// after readable has been emitted but before I/O (nextTick) to
|
||
// support once('readable', fn) cycles. This means that calling
|
||
// resume within the same tick will have no
|
||
// effect.
|
||
process.nextTick(updateReadableListening, this);
|
||
}
|
||
|
||
return res;
|
||
};
|
||
|
||
function updateReadableListening(self) {
|
||
var state = self._readableState;
|
||
state.readableListening = self.listenerCount('readable') > 0;
|
||
|
||
if (state.resumeScheduled && !state.paused) {
|
||
// flowing needs to be set to true now, otherwise
|
||
// the upcoming resume will not flow.
|
||
state.flowing = true; // crude way to check if we should resume
|
||
} else if (self.listenerCount('data') > 0) {
|
||
self.resume();
|
||
}
|
||
}
|
||
|
||
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'); // we flow only if there is no one listening
|
||
// for readable, but we still have to call
|
||
// resume()
|
||
|
||
state.flowing = !state.readableListening;
|
||
resume(this, state);
|
||
}
|
||
|
||
state.paused = false;
|
||
return this;
|
||
};
|
||
|
||
function resume(stream, state) {
|
||
if (!state.resumeScheduled) {
|
||
state.resumeScheduled = true;
|
||
process.nextTick(resume_, stream, state);
|
||
}
|
||
}
|
||
|
||
function resume_(stream, state) {
|
||
debug('resume', state.reading);
|
||
|
||
if (!state.reading) {
|
||
stream.read(0);
|
||
}
|
||
|
||
state.resumeScheduled = false;
|
||
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 (this._readableState.flowing !== false) {
|
||
debug('pause');
|
||
this._readableState.flowing = false;
|
||
this.emit('pause');
|
||
}
|
||
|
||
this._readableState.paused = true;
|
||
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 methodWrap(method) {
|
||
return function methodWrapReturnFunction() {
|
||
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;
|
||
};
|
||
|
||
if (typeof Symbol === 'function') {
|
||
Readable.prototype[Symbol.asyncIterator] = function () {
|
||
if (createReadableStreamAsyncIterator === undefined) {
|
||
createReadableStreamAsyncIterator = __webpack_require__(46);
|
||
}
|
||
|
||
return createReadableStreamAsyncIterator(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 get() {
|
||
return this._readableState.highWaterMark;
|
||
}
|
||
});
|
||
Object.defineProperty(Readable.prototype, 'readableBuffer', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._readableState && this._readableState.buffer;
|
||
}
|
||
});
|
||
Object.defineProperty(Readable.prototype, 'readableFlowing', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._readableState.flowing;
|
||
},
|
||
set: function set(state) {
|
||
if (this._readableState) {
|
||
this._readableState.flowing = state;
|
||
}
|
||
}
|
||
}); // exposed for testing purposes only.
|
||
|
||
Readable._fromList = fromList;
|
||
Object.defineProperty(Readable.prototype, 'readableLength', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._readableState.length;
|
||
}
|
||
}); // 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.first();else ret = state.buffer.concat(state.length);
|
||
state.buffer.clear();
|
||
} else {
|
||
// read part of list
|
||
ret = state.buffer.consume(n, state.decoder);
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
function endReadable(stream) {
|
||
var state = stream._readableState;
|
||
debug('endReadable', state.endEmitted);
|
||
|
||
if (!state.endEmitted) {
|
||
state.ended = true;
|
||
process.nextTick(endReadableNT, state, stream);
|
||
}
|
||
}
|
||
|
||
function endReadableNT(state, stream) {
|
||
debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.
|
||
|
||
if (!state.endEmitted && state.length === 0) {
|
||
state.endEmitted = true;
|
||
stream.readable = false;
|
||
stream.emit('end');
|
||
|
||
if (state.autoDestroy) {
|
||
// In case of duplex streams we need a way to detect
|
||
// if the writable side is ready for autoDestroy as well
|
||
var wState = stream._writableState;
|
||
|
||
if (!wState || wState.autoDestroy && wState.finished) {
|
||
stream.destroy();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (typeof Symbol === 'function') {
|
||
Readable.from = function (iterable, opts) {
|
||
if (from === undefined) {
|
||
from = __webpack_require__(176);
|
||
}
|
||
|
||
return from(Readable, iterable, opts);
|
||
};
|
||
}
|
||
|
||
function indexOf(xs, x) {
|
||
for (var i = 0, l = xs.length; i < l; i++) {
|
||
if (xs[i] === x) return i;
|
||
}
|
||
|
||
return -1;
|
||
}
|
||
|
||
/***/ }),
|
||
|
||
/***/ 232:
|
||
/***/ (function(module) {
|
||
|
||
"use strict";
|
||
// 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) {
|
||
if (!this._writableState) {
|
||
process.nextTick(emitErrorNT, this, err);
|
||
} else if (!this._writableState.errorEmitted) {
|
||
this._writableState.errorEmitted = true;
|
||
process.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) {
|
||
if (!_this._writableState) {
|
||
process.nextTick(emitErrorAndCloseNT, _this, err);
|
||
} else if (!_this._writableState.errorEmitted) {
|
||
_this._writableState.errorEmitted = true;
|
||
process.nextTick(emitErrorAndCloseNT, _this, err);
|
||
} else {
|
||
process.nextTick(emitCloseNT, _this);
|
||
}
|
||
} else if (cb) {
|
||
process.nextTick(emitCloseNT, _this);
|
||
cb(err);
|
||
} else {
|
||
process.nextTick(emitCloseNT, _this);
|
||
}
|
||
});
|
||
|
||
return this;
|
||
}
|
||
|
||
function emitErrorAndCloseNT(self, err) {
|
||
emitErrorNT(self, err);
|
||
emitCloseNT(self);
|
||
}
|
||
|
||
function emitCloseNT(self) {
|
||
if (self._writableState && !self._writableState.emitClose) return;
|
||
if (self._readableState && !self._readableState.emitClose) return;
|
||
self.emit('close');
|
||
}
|
||
|
||
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.finalCalled = false;
|
||
this._writableState.prefinished = false;
|
||
this._writableState.finished = false;
|
||
this._writableState.errorEmitted = false;
|
||
}
|
||
}
|
||
|
||
function emitErrorNT(self, err) {
|
||
self.emit('error', err);
|
||
}
|
||
|
||
function errorOrDestroy(stream, err) {
|
||
// We have tests that rely on errors being emitted
|
||
// in the same tick, so changing this is semver major.
|
||
// For now when you opt-in to autoDestroy we allow
|
||
// the error to be emitted nextTick. In a future
|
||
// semver major update we should change the default to this.
|
||
var rState = stream._readableState;
|
||
var wState = stream._writableState;
|
||
if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
|
||
}
|
||
|
||
module.exports = {
|
||
destroy: destroy,
|
||
undestroy: undestroy,
|
||
errorOrDestroy: errorOrDestroy
|
||
};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 238:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
// Ported from https://github.com/mafintosh/pump with
|
||
// permission from the author, Mathias Buus (@mafintosh).
|
||
|
||
|
||
var eos;
|
||
|
||
function once(callback) {
|
||
var called = false;
|
||
return function () {
|
||
if (called) return;
|
||
called = true;
|
||
callback.apply(void 0, arguments);
|
||
};
|
||
}
|
||
|
||
var _require$codes = __webpack_require__(563).codes,
|
||
ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
|
||
ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
|
||
|
||
function noop(err) {
|
||
// Rethrow the error if it exists to avoid swallowing it
|
||
if (err) throw err;
|
||
}
|
||
|
||
function isRequest(stream) {
|
||
return stream.setHeader && typeof stream.abort === 'function';
|
||
}
|
||
|
||
function destroyer(stream, reading, writing, callback) {
|
||
callback = once(callback);
|
||
var closed = false;
|
||
stream.on('close', function () {
|
||
closed = true;
|
||
});
|
||
if (eos === undefined) eos = __webpack_require__(287);
|
||
eos(stream, {
|
||
readable: reading,
|
||
writable: writing
|
||
}, function (err) {
|
||
if (err) return callback(err);
|
||
closed = true;
|
||
callback();
|
||
});
|
||
var destroyed = false;
|
||
return function (err) {
|
||
if (closed) return;
|
||
if (destroyed) return;
|
||
destroyed = true; // request.destroy just do .end - .abort is what we want
|
||
|
||
if (isRequest(stream)) return stream.abort();
|
||
if (typeof stream.destroy === 'function') return stream.destroy();
|
||
callback(err || new ERR_STREAM_DESTROYED('pipe'));
|
||
};
|
||
}
|
||
|
||
function call(fn) {
|
||
fn();
|
||
}
|
||
|
||
function pipe(from, to) {
|
||
return from.pipe(to);
|
||
}
|
||
|
||
function popCallback(streams) {
|
||
if (!streams.length) return noop;
|
||
if (typeof streams[streams.length - 1] !== 'function') return noop;
|
||
return streams.pop();
|
||
}
|
||
|
||
function pipeline() {
|
||
for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
streams[_key] = arguments[_key];
|
||
}
|
||
|
||
var callback = popCallback(streams);
|
||
if (Array.isArray(streams[0])) streams = streams[0];
|
||
|
||
if (streams.length < 2) {
|
||
throw new ERR_MISSING_ARGS('streams');
|
||
}
|
||
|
||
var error;
|
||
var destroys = streams.map(function (stream, i) {
|
||
var reading = i < streams.length - 1;
|
||
var writing = i > 0;
|
||
return destroyer(stream, reading, writing, function (err) {
|
||
if (!error) error = err;
|
||
if (err) destroys.forEach(call);
|
||
if (reading) return;
|
||
destroys.forEach(call);
|
||
callback(error);
|
||
});
|
||
});
|
||
return streams.reduce(pipe);
|
||
}
|
||
|
||
module.exports = pipeline;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 241:
|
||
/***/ (function(module, __unusedexports, __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 bit simpler than readable streams.
|
||
// Implement an async ._write(chunk, encoding, cb), and it'll handle all
|
||
// the drain event emission and buffering.
|
||
|
||
|
||
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 Duplex;
|
||
/*</replacement>*/
|
||
|
||
Writable.WritableState = WritableState;
|
||
/*<replacement>*/
|
||
|
||
var internalUtil = {
|
||
deprecate: __webpack_require__(917)
|
||
};
|
||
/*</replacement>*/
|
||
|
||
/*<replacement>*/
|
||
|
||
var Stream = __webpack_require__(427);
|
||
/*</replacement>*/
|
||
|
||
|
||
var Buffer = __webpack_require__(293).Buffer;
|
||
|
||
var OurUint8Array = global.Uint8Array || function () {};
|
||
|
||
function _uint8ArrayToBuffer(chunk) {
|
||
return Buffer.from(chunk);
|
||
}
|
||
|
||
function _isUint8Array(obj) {
|
||
return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
|
||
}
|
||
|
||
var destroyImpl = __webpack_require__(232);
|
||
|
||
var _require = __webpack_require__(216),
|
||
getHighWaterMark = _require.getHighWaterMark;
|
||
|
||
var _require$codes = __webpack_require__(563).codes,
|
||
ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
|
||
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
||
ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
|
||
ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
|
||
ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
|
||
ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
|
||
ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
|
||
ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
|
||
|
||
var errorOrDestroy = destroyImpl.errorOrDestroy;
|
||
|
||
__webpack_require__(689)(Writable, Stream);
|
||
|
||
function nop() {}
|
||
|
||
function WritableState(options, stream, isDuplex) {
|
||
Duplex = Duplex || __webpack_require__(831);
|
||
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,
|
||
// e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
|
||
|
||
if (typeof isDuplex !== 'boolean') 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()
|
||
|
||
this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // 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; // Should close be emitted on destroy. Defaults to true.
|
||
|
||
this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')
|
||
|
||
this.autoDestroy = !!options.autoDestroy; // 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 writableStateBufferGetter() {
|
||
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 value(object) {
|
||
if (realHasInstance.call(this, object)) return true;
|
||
if (this !== Writable) return false;
|
||
return object && object._writableState instanceof WritableState;
|
||
}
|
||
});
|
||
} else {
|
||
realHasInstance = function realHasInstance(object) {
|
||
return object instanceof this;
|
||
};
|
||
}
|
||
|
||
function Writable(options) {
|
||
Duplex = Duplex || __webpack_require__(831); // 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.
|
||
// Checking for a Stream.Duplex instance is faster here instead of inside
|
||
// the WritableState constructor, at least with V8 6.5
|
||
|
||
var isDuplex = this instanceof Duplex;
|
||
if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
|
||
this._writableState = new WritableState(options, this, isDuplex); // 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 () {
|
||
errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
|
||
};
|
||
|
||
function writeAfterEnd(stream, cb) {
|
||
var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
|
||
|
||
errorOrDestroy(stream, er);
|
||
process.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 er;
|
||
|
||
if (chunk === null) {
|
||
er = new ERR_STREAM_NULL_VALUES();
|
||
} else if (typeof chunk !== 'string' && !state.objectMode) {
|
||
er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
|
||
}
|
||
|
||
if (er) {
|
||
errorOrDestroy(stream, er);
|
||
process.nextTick(cb, er);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
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.ending) 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 () {
|
||
this._writableState.corked++;
|
||
};
|
||
|
||
Writable.prototype.uncork = function () {
|
||
var state = this._writableState;
|
||
|
||
if (state.corked) {
|
||
state.corked--;
|
||
if (!state.writing && !state.corked && !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 ERR_UNKNOWN_ENCODING(encoding);
|
||
this._writableState.defaultEncoding = encoding;
|
||
return this;
|
||
};
|
||
|
||
Object.defineProperty(Writable.prototype, 'writableBuffer', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState && this._writableState.getBuffer();
|
||
}
|
||
});
|
||
|
||
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 get() {
|
||
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 (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else 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
|
||
process.nextTick(cb, er); // this can emit finish, and it will always happen
|
||
// after error
|
||
|
||
process.nextTick(finishMaybe, stream, state);
|
||
stream._writableState.errorEmitted = true;
|
||
errorOrDestroy(stream, er);
|
||
} else {
|
||
// the caller expect this to happen before if
|
||
// it is async
|
||
cb(er);
|
||
stream._writableState.errorEmitted = true;
|
||
errorOrDestroy(stream, 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;
|
||
if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
|
||
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) || stream.destroyed;
|
||
|
||
if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
|
||
clearBuffer(stream, state);
|
||
}
|
||
|
||
if (sync) {
|
||
process.nextTick(afterWrite, stream, state, finished, cb);
|
||
} 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 ERR_METHOD_NOT_IMPLEMENTED('_write()'));
|
||
};
|
||
|
||
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) endWritable(this, state, cb);
|
||
return this;
|
||
};
|
||
|
||
Object.defineProperty(Writable.prototype, 'writableLength', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState.length;
|
||
}
|
||
});
|
||
|
||
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) {
|
||
errorOrDestroy(stream, 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.destroyed) {
|
||
state.pendingcb++;
|
||
state.finalCalled = true;
|
||
process.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');
|
||
|
||
if (state.autoDestroy) {
|
||
// In case of duplex streams we need a way to detect
|
||
// if the readable side is ready for autoDestroy as well
|
||
var rState = stream._readableState;
|
||
|
||
if (!rState || rState.autoDestroy && rState.endEmitted) {
|
||
stream.destroy();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return need;
|
||
}
|
||
|
||
function endWritable(stream, state, cb) {
|
||
state.ending = true;
|
||
finishMaybe(stream, state);
|
||
|
||
if (cb) {
|
||
if (state.finished) process.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;
|
||
} // reuse the free corkReq.
|
||
|
||
|
||
state.corkedRequestsFree.next = corkReq;
|
||
}
|
||
|
||
Object.defineProperty(Writable.prototype, 'destroyed', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
if (this._writableState === undefined) {
|
||
return false;
|
||
}
|
||
|
||
return this._writableState.destroyed;
|
||
},
|
||
set: function set(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) {
|
||
cb(err);
|
||
};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 248:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
const { handleResponse } = __webpack_require__(823)
|
||
const { createReadStream } = __webpack_require__(747)
|
||
const afw = __webpack_require__(722)
|
||
const FormData = __webpack_require__(928)
|
||
const assert = __webpack_require__(487)
|
||
const fetch = __webpack_require__(454)
|
||
const { URL } = __webpack_require__(835)
|
||
const qs = __webpack_require__(386)
|
||
const os = __webpack_require__(87)
|
||
|
||
const { neocitiesLocalDiff } = __webpack_require__(98)
|
||
const pkg = __webpack_require__(442)
|
||
const SimpleTimer = __webpack_require__(979)
|
||
const { getStreamLength, meterStream } = __webpack_require__(108)
|
||
const statsHandler = __webpack_require__(423)
|
||
|
||
const defaultURL = 'https://neocities.org'
|
||
|
||
// Progress API constants
|
||
const START = 'start'
|
||
const PROGRESS = 'progress' // progress updates
|
||
const STOP = 'stop'
|
||
const SKIP = 'skip'
|
||
// Progress stages
|
||
const INSPECTING = 'inspecting'
|
||
const DIFFING = 'diffing'
|
||
const APPLYING = 'applying'
|
||
|
||
/**
|
||
* NeocitiesAPIClient class representing a neocities api client.
|
||
*/
|
||
class NeocitiesAPIClient {
|
||
/**
|
||
* getKey returns an apiKey from a sitename and password.
|
||
* @param {String} sitename username/sitename to log into.
|
||
* @param {String} password password to log in with.
|
||
* @param {Object} [opts] Options object.
|
||
* @param {Object} [opts.url=https://neocities.org] Base URL to request to.
|
||
* @return {Promise<String>} An api key for the sitename..
|
||
*/
|
||
static getKey (sitename, password, opts) {
|
||
assert(sitename, 'must pass sitename as first arg')
|
||
assert(typeof sitename === 'string', 'user arg must be a string')
|
||
assert(password, 'must pass a password as the second arg')
|
||
assert(typeof password, 'password arg must be a string')
|
||
|
||
opts = Object.assign({
|
||
url: defaultURL
|
||
}, opts)
|
||
|
||
const baseURL = opts.url
|
||
delete opts.url
|
||
|
||
const url = new URL('/api/key', baseURL)
|
||
url.username = sitename
|
||
url.password = password
|
||
return fetch(url, opts)
|
||
}
|
||
|
||
static statsHandler (...args) { return statsHandler(...args) }
|
||
|
||
/**
|
||
* Create an async-neocities api client.
|
||
* @param {string} apiKey An apiKey to make requests with.
|
||
* @param {Object} [opts] Options object.
|
||
* @param {Object} [opts.url=https://neocities.org] Base URL to make requests to.
|
||
* @return {Object} An api client instance.
|
||
*/
|
||
constructor (apiKey, opts) {
|
||
assert(apiKey, 'must pass apiKey as first argument')
|
||
assert(typeof apiKey === 'string', 'apiKey must be a string')
|
||
opts = Object.assign({
|
||
url: defaultURL
|
||
})
|
||
|
||
this.url = opts.url
|
||
this.apiKey = apiKey
|
||
}
|
||
|
||
get defaultHeaders () {
|
||
return {
|
||
Authorization: `Bearer ${this.apiKey}`,
|
||
Accept: 'application/json',
|
||
'User-Agent': `async-neocities/${pkg.version} (${os.type()})`
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Generic GET request to neocities.
|
||
* @param {String} endpoint An endpoint path to GET request.
|
||
* @param {Object} [quieries] An object that gets added to the request in the form of a query string.
|
||
* @param {Object} [opts] Options object.
|
||
* @param {String} [opts.method=GET] The http method to use.
|
||
* @param {Object} [opts.headers] Headers to include in the request.
|
||
* @return {Object} The parsed JSON from the request response.
|
||
*/
|
||
get (endpoint, quieries, opts) {
|
||
assert(endpoint, 'must pass endpoint as first argument')
|
||
opts = Object.assign({
|
||
method: 'GET'
|
||
}, opts)
|
||
opts.headers = Object.assign({}, this.defaultHeaders, opts.headers)
|
||
|
||
let path = `/api/${endpoint}`
|
||
if (quieries) path += `?${qs.stringify(quieries)}`
|
||
|
||
const url = new URL(path, this.url)
|
||
return fetch(url, opts)
|
||
}
|
||
|
||
/**
|
||
* Low level POST request to neocities with FormData.
|
||
* @param {String} endpoint The endpoint to make the request to.
|
||
* @param {Array.<{name: String, value: String}>} formEntries Array of form entries.
|
||
* @param {Object} [opts] Options object.
|
||
* @param {String} [opts.method=POST] HTTP Method.
|
||
* @param {Object} [opts.headers] Additional headers to send.
|
||
* @return {Object} The parsed JSON response object.
|
||
*/
|
||
async post (endpoint, formEntries, opts) {
|
||
assert(endpoint, 'must pass endpoint as first argument')
|
||
assert(formEntries, 'must pass formEntries as second argument')
|
||
|
||
function createForm () {
|
||
const form = new FormData()
|
||
for (const { name, value } of formEntries) {
|
||
form.append(name, value)
|
||
}
|
||
|
||
return form
|
||
}
|
||
|
||
opts = Object.assign({
|
||
method: 'POST',
|
||
statsCb: () => {}
|
||
}, opts)
|
||
const statsCb = opts.statsCb
|
||
delete opts.statsCb
|
||
|
||
const stats = {
|
||
totalBytes: await getStreamLength(createForm()),
|
||
bytesWritten: 0
|
||
}
|
||
statsCb(stats)
|
||
|
||
const form = createForm()
|
||
|
||
opts.body = meterStream(form, bytesRead => {
|
||
stats.bytesWritten = bytesRead
|
||
statsCb(stats)
|
||
})
|
||
|
||
opts.headers = Object.assign(
|
||
{},
|
||
this.defaultHeaders,
|
||
form.getHeaders(),
|
||
opts.headers)
|
||
|
||
const url = new URL(`/api/${endpoint}`, this.url)
|
||
return fetch(url, opts)
|
||
}
|
||
|
||
/**
|
||
* Upload files to neocities
|
||
*/
|
||
upload (files, opts = {}) {
|
||
opts = {
|
||
statsCb: () => {},
|
||
...opts
|
||
}
|
||
const formEntries = files.map(({ name, path }) => {
|
||
const streamCtor = (next) => next(createReadStream(path))
|
||
streamCtor.path = path
|
||
return {
|
||
name,
|
||
value: streamCtor
|
||
}
|
||
})
|
||
|
||
return this.post('upload', formEntries, { statsCb: opts.statsCb }).then(handleResponse)
|
||
}
|
||
|
||
/**
|
||
* delete files from your website
|
||
*/
|
||
delete (filenames, opts = {}) {
|
||
assert(filenames, 'filenames is a required first argument')
|
||
assert(Array.isArray(filenames), 'filenames argument must be an array of file paths in your website')
|
||
opts = {
|
||
statsCb: () => {},
|
||
...opts
|
||
}
|
||
|
||
const formEntries = filenames.map(file => ({
|
||
name: 'filenames[]',
|
||
value: file
|
||
}))
|
||
|
||
return this.post('delete', formEntries, { statsCb: opts.statsCb }).then(handleResponse)
|
||
}
|
||
|
||
list (queries) {
|
||
// args.path: Path to list
|
||
return this.get('list', queries).then(handleResponse)
|
||
}
|
||
|
||
/**
|
||
* info returns info on your site, or optionally on a sitename querystrign
|
||
* @param {Object} args Querystring arguments to include (e.g. sitename)
|
||
* @return {Promise} Fetch request promise
|
||
*/
|
||
info (queries) {
|
||
// args.sitename: sitename to get info on
|
||
return this.get('info', queries).then(handleResponse)
|
||
}
|
||
|
||
/**
|
||
* Deploy a directory to neocities, skipping already uploaded files and optionally cleaning orphaned files.
|
||
* @param {String} directory The path of the directory to deploy.
|
||
* @param {Object} opts Options object.
|
||
* @param {Boolean} opts.cleanup Boolean to delete orphaned files nor not. Defaults to false.
|
||
* @param {Boolean} opts.statsCb Get access to stat info before uploading is complete.
|
||
* @return {Promise} Promise containing stats about the deploy
|
||
*/
|
||
async deploy (directory, opts) {
|
||
opts = {
|
||
cleanup: false, // delete remote orphaned files
|
||
statsCb: () => {},
|
||
...opts
|
||
}
|
||
|
||
const statsCb = opts.statsCb
|
||
const totalTime = new SimpleTimer(Date.now())
|
||
|
||
// INSPECTION STAGE
|
||
statsCb({ stage: INSPECTING, status: START })
|
||
const [localFiles, remoteFiles] = await Promise.all([
|
||
afw.allFiles(directory, { shaper: f => f }),
|
||
this.list().then(res => res.files)
|
||
])
|
||
statsCb({ stage: INSPECTING, status: STOP })
|
||
|
||
// DIFFING STAGE
|
||
statsCb({ stage: DIFFING, status: START })
|
||
const { filesToUpload, filesToDelete, filesSkipped } = await neocitiesLocalDiff(remoteFiles, localFiles)
|
||
statsCb({ stage: DIFFING, status: STOP })
|
||
|
||
// APPLYING STAGE
|
||
if (filesToUpload.length === 0 && (!opts.cleanup || filesToDelete.length === 0)) {
|
||
statsCb({ stage: APPLYING, status: SKIP })
|
||
return stats()
|
||
}
|
||
|
||
statsCb({ stage: APPLYING, status: START })
|
||
const work = []
|
||
|
||
if (filesToUpload.length > 0) {
|
||
const uploadJob = this.upload(filesToUpload, {
|
||
statsCb ({ totalBytes, bytesWritten }) {
|
||
statsCb({
|
||
stage: APPLYING,
|
||
status: PROGRESS,
|
||
complete: false,
|
||
totalBytes,
|
||
bytesWritten,
|
||
get progress () {
|
||
return (this.bytesWritten / this.totalBytes) || 0
|
||
}
|
||
})
|
||
}
|
||
}).then((_) => {
|
||
statsCb({
|
||
stage: APPLYING,
|
||
status: PROGRESS,
|
||
complete: true,
|
||
progress: 1.0
|
||
})
|
||
})
|
||
work.push(uploadJob)
|
||
}
|
||
|
||
if (opts.cleanup && filesToDelete.length > 0) {
|
||
work.push(this.delete(filesToDelete))
|
||
}
|
||
|
||
await Promise.all(work)
|
||
statsCb({ stage: APPLYING, status: STOP })
|
||
|
||
return stats()
|
||
|
||
function stats () {
|
||
totalTime.stop()
|
||
return {
|
||
time: totalTime.elapsed,
|
||
filesToUpload,
|
||
filesToDelete,
|
||
filesSkipped
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
module.exports = NeocitiesAPIClient
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 287:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
// Ported from https://github.com/mafintosh/end-of-stream with
|
||
// permission from the author, Mathias Buus (@mafintosh).
|
||
|
||
|
||
var ERR_STREAM_PREMATURE_CLOSE = __webpack_require__(563).codes.ERR_STREAM_PREMATURE_CLOSE;
|
||
|
||
function once(callback) {
|
||
var called = false;
|
||
return function () {
|
||
if (called) return;
|
||
called = true;
|
||
|
||
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
||
args[_key] = arguments[_key];
|
||
}
|
||
|
||
callback.apply(this, args);
|
||
};
|
||
}
|
||
|
||
function noop() {}
|
||
|
||
function isRequest(stream) {
|
||
return stream.setHeader && typeof stream.abort === 'function';
|
||
}
|
||
|
||
function eos(stream, opts, callback) {
|
||
if (typeof opts === 'function') return eos(stream, null, opts);
|
||
if (!opts) opts = {};
|
||
callback = once(callback || noop);
|
||
var readable = opts.readable || opts.readable !== false && stream.readable;
|
||
var writable = opts.writable || opts.writable !== false && stream.writable;
|
||
|
||
var onlegacyfinish = function onlegacyfinish() {
|
||
if (!stream.writable) onfinish();
|
||
};
|
||
|
||
var writableEnded = stream._writableState && stream._writableState.finished;
|
||
|
||
var onfinish = function onfinish() {
|
||
writable = false;
|
||
writableEnded = true;
|
||
if (!readable) callback.call(stream);
|
||
};
|
||
|
||
var readableEnded = stream._readableState && stream._readableState.endEmitted;
|
||
|
||
var onend = function onend() {
|
||
readable = false;
|
||
readableEnded = true;
|
||
if (!writable) callback.call(stream);
|
||
};
|
||
|
||
var onerror = function onerror(err) {
|
||
callback.call(stream, err);
|
||
};
|
||
|
||
var onclose = function onclose() {
|
||
var err;
|
||
|
||
if (readable && !readableEnded) {
|
||
if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
|
||
return callback.call(stream, err);
|
||
}
|
||
|
||
if (writable && !writableEnded) {
|
||
if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
|
||
return callback.call(stream, err);
|
||
}
|
||
};
|
||
|
||
var onrequest = function onrequest() {
|
||
stream.req.on('finish', onfinish);
|
||
};
|
||
|
||
if (isRequest(stream)) {
|
||
stream.on('complete', onfinish);
|
||
stream.on('abort', onclose);
|
||
if (stream.req) onrequest();else stream.on('request', onrequest);
|
||
} else if (writable && !stream._writableState) {
|
||
// legacy streams
|
||
stream.on('end', onlegacyfinish);
|
||
stream.on('close', onlegacyfinish);
|
||
}
|
||
|
||
stream.on('end', onend);
|
||
stream.on('finish', onfinish);
|
||
if (opts.error !== false) stream.on('error', onerror);
|
||
stream.on('close', onclose);
|
||
return function () {
|
||
stream.removeListener('complete', onfinish);
|
||
stream.removeListener('abort', onclose);
|
||
stream.removeListener('request', onrequest);
|
||
if (stream.req) stream.req.removeListener('finish', onfinish);
|
||
stream.removeListener('end', onlegacyfinish);
|
||
stream.removeListener('close', onlegacyfinish);
|
||
stream.removeListener('finish', onfinish);
|
||
stream.removeListener('end', onend);
|
||
stream.removeListener('error', onerror);
|
||
stream.removeListener('close', onclose);
|
||
};
|
||
}
|
||
|
||
module.exports = eos;
|
||
|
||
/***/ }),
|
||
|
||
/***/ 293:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("buffer");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 315:
|
||
/***/ (function(module) {
|
||
|
||
if (typeof Object.create === 'function') {
|
||
// implementation from standard node.js 'util' module
|
||
module.exports = function inherits(ctor, superCtor) {
|
||
if (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) {
|
||
if (superCtor) {
|
||
ctor.super_ = superCtor
|
||
var TempCtor = function () {}
|
||
TempCtor.prototype = superCtor.prototype
|
||
ctor.prototype = new TempCtor()
|
||
ctor.prototype.constructor = ctor
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 317:
|
||
/***/ (function(module) {
|
||
|
||
/**
|
||
* 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' : '');
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 334:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
module.exports =
|
||
{
|
||
parallel : __webpack_require__(424),
|
||
serial : __webpack_require__(91),
|
||
serialOrdered : __webpack_require__(892)
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 386:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var stringify = __webpack_require__(897);
|
||
var parse = __webpack_require__(755);
|
||
var formats = __webpack_require__(13);
|
||
|
||
module.exports = {
|
||
formats: formats,
|
||
parse: parse,
|
||
stringify: stringify
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 394:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var stream = __webpack_require__(574)
|
||
var eos = __webpack_require__(9)
|
||
var inherits = __webpack_require__(689)
|
||
var shift = __webpack_require__(475)
|
||
|
||
var SIGNAL_FLUSH = (Buffer.from && Buffer.from !== Uint8Array.from)
|
||
? Buffer.from([0])
|
||
: new Buffer([0])
|
||
|
||
var onuncork = function(self, fn) {
|
||
if (self._corked) self.once('uncork', fn)
|
||
else fn()
|
||
}
|
||
|
||
var autoDestroy = function (self, err) {
|
||
if (self._autoDestroy) self.destroy(err)
|
||
}
|
||
|
||
var destroyer = function(self, end) {
|
||
return function(err) {
|
||
if (err) autoDestroy(self, err.message === 'premature close' ? null : err)
|
||
else if (end && !self._ended) self.end()
|
||
}
|
||
}
|
||
|
||
var end = function(ws, fn) {
|
||
if (!ws) return fn()
|
||
if (ws._writableState && ws._writableState.finished) return fn()
|
||
if (ws._writableState) return ws.end(fn)
|
||
ws.end()
|
||
fn()
|
||
}
|
||
|
||
var noop = function() {}
|
||
|
||
var toStreams2 = function(rs) {
|
||
return new (stream.Readable)({objectMode:true, highWaterMark:16}).wrap(rs)
|
||
}
|
||
|
||
var Duplexify = function(writable, readable, opts) {
|
||
if (!(this instanceof Duplexify)) return new Duplexify(writable, readable, opts)
|
||
stream.Duplex.call(this, opts)
|
||
|
||
this._writable = null
|
||
this._readable = null
|
||
this._readable2 = null
|
||
|
||
this._autoDestroy = !opts || opts.autoDestroy !== false
|
||
this._forwardDestroy = !opts || opts.destroy !== false
|
||
this._forwardEnd = !opts || opts.end !== false
|
||
this._corked = 1 // start corked
|
||
this._ondrain = null
|
||
this._drained = false
|
||
this._forwarding = false
|
||
this._unwrite = null
|
||
this._unread = null
|
||
this._ended = false
|
||
|
||
this.destroyed = false
|
||
|
||
if (writable) this.setWritable(writable)
|
||
if (readable) this.setReadable(readable)
|
||
}
|
||
|
||
inherits(Duplexify, stream.Duplex)
|
||
|
||
Duplexify.obj = function(writable, readable, opts) {
|
||
if (!opts) opts = {}
|
||
opts.objectMode = true
|
||
opts.highWaterMark = 16
|
||
return new Duplexify(writable, readable, opts)
|
||
}
|
||
|
||
Duplexify.prototype.cork = function() {
|
||
if (++this._corked === 1) this.emit('cork')
|
||
}
|
||
|
||
Duplexify.prototype.uncork = function() {
|
||
if (this._corked && --this._corked === 0) this.emit('uncork')
|
||
}
|
||
|
||
Duplexify.prototype.setWritable = function(writable) {
|
||
if (this._unwrite) this._unwrite()
|
||
|
||
if (this.destroyed) {
|
||
if (writable && writable.destroy) writable.destroy()
|
||
return
|
||
}
|
||
|
||
if (writable === null || writable === false) {
|
||
this.end()
|
||
return
|
||
}
|
||
|
||
var self = this
|
||
var unend = eos(writable, {writable:true, readable:false}, destroyer(this, this._forwardEnd))
|
||
|
||
var ondrain = function() {
|
||
var ondrain = self._ondrain
|
||
self._ondrain = null
|
||
if (ondrain) ondrain()
|
||
}
|
||
|
||
var clear = function() {
|
||
self._writable.removeListener('drain', ondrain)
|
||
unend()
|
||
}
|
||
|
||
if (this._unwrite) process.nextTick(ondrain) // force a drain on stream reset to avoid livelocks
|
||
|
||
this._writable = writable
|
||
this._writable.on('drain', ondrain)
|
||
this._unwrite = clear
|
||
|
||
this.uncork() // always uncork setWritable
|
||
}
|
||
|
||
Duplexify.prototype.setReadable = function(readable) {
|
||
if (this._unread) this._unread()
|
||
|
||
if (this.destroyed) {
|
||
if (readable && readable.destroy) readable.destroy()
|
||
return
|
||
}
|
||
|
||
if (readable === null || readable === false) {
|
||
this.push(null)
|
||
this.resume()
|
||
return
|
||
}
|
||
|
||
var self = this
|
||
var unend = eos(readable, {writable:false, readable:true}, destroyer(this))
|
||
|
||
var onreadable = function() {
|
||
self._forward()
|
||
}
|
||
|
||
var onend = function() {
|
||
self.push(null)
|
||
}
|
||
|
||
var clear = function() {
|
||
self._readable2.removeListener('readable', onreadable)
|
||
self._readable2.removeListener('end', onend)
|
||
unend()
|
||
}
|
||
|
||
this._drained = true
|
||
this._readable = readable
|
||
this._readable2 = readable._readableState ? readable : toStreams2(readable)
|
||
this._readable2.on('readable', onreadable)
|
||
this._readable2.on('end', onend)
|
||
this._unread = clear
|
||
|
||
this._forward()
|
||
}
|
||
|
||
Duplexify.prototype._read = function() {
|
||
this._drained = true
|
||
this._forward()
|
||
}
|
||
|
||
Duplexify.prototype._forward = function() {
|
||
if (this._forwarding || !this._readable2 || !this._drained) return
|
||
this._forwarding = true
|
||
|
||
var data
|
||
|
||
while (this._drained && (data = shift(this._readable2)) !== null) {
|
||
if (this.destroyed) continue
|
||
this._drained = this.push(data)
|
||
}
|
||
|
||
this._forwarding = false
|
||
}
|
||
|
||
Duplexify.prototype.destroy = function(err, cb) {
|
||
if (!cb) cb = noop
|
||
if (this.destroyed) return cb(null)
|
||
this.destroyed = true
|
||
|
||
var self = this
|
||
process.nextTick(function() {
|
||
self._destroy(err)
|
||
cb(null)
|
||
})
|
||
}
|
||
|
||
Duplexify.prototype._destroy = function(err) {
|
||
if (err) {
|
||
var ondrain = this._ondrain
|
||
this._ondrain = null
|
||
if (ondrain) ondrain(err)
|
||
else this.emit('error', err)
|
||
}
|
||
|
||
if (this._forwardDestroy) {
|
||
if (this._readable && this._readable.destroy) this._readable.destroy()
|
||
if (this._writable && this._writable.destroy) this._writable.destroy()
|
||
}
|
||
|
||
this.emit('close')
|
||
}
|
||
|
||
Duplexify.prototype._write = function(data, enc, cb) {
|
||
if (this.destroyed) return
|
||
if (this._corked) return onuncork(this, this._write.bind(this, data, enc, cb))
|
||
if (data === SIGNAL_FLUSH) return this._finish(cb)
|
||
if (!this._writable) return cb()
|
||
|
||
if (this._writable.write(data) === false) this._ondrain = cb
|
||
else if (!this.destroyed) cb()
|
||
}
|
||
|
||
Duplexify.prototype._finish = function(cb) {
|
||
var self = this
|
||
this.emit('preend')
|
||
onuncork(this, function() {
|
||
end(self._forwardEnd && self._writable, function() {
|
||
// haxx to not emit prefinish twice
|
||
if (self._writableState.prefinished === false) self._writableState.prefinished = true
|
||
self.emit('prefinish')
|
||
onuncork(self, cb)
|
||
})
|
||
})
|
||
}
|
||
|
||
Duplexify.prototype.end = function(data, enc, cb) {
|
||
if (typeof data === 'function') return this.end(null, null, data)
|
||
if (typeof enc === 'function') return this.end(data, null, enc)
|
||
this._ended = true
|
||
if (data) this.write(data)
|
||
if (!this._writableState.ending) this.write(SIGNAL_FLUSH)
|
||
return stream.Writable.prototype.end.call(this, cb)
|
||
}
|
||
|
||
module.exports = Duplexify
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 413:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("stream");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 417:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("crypto");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 423:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
const prettyBytes = __webpack_require__(589)
|
||
|
||
// Progress API constants
|
||
const START = 'start'
|
||
const PROGRESS = 'progress' // progress updates
|
||
const STOP = 'stop'
|
||
const SKIP = 'skip'
|
||
|
||
function statsHandler (opts = {}) {
|
||
let progressInterval
|
||
const lastStats = {}
|
||
|
||
return (stats) => {
|
||
switch (stats.status) {
|
||
case START: {
|
||
console.log(`Starting ${stats.stage} stage...`)
|
||
break
|
||
}
|
||
case STOP: {
|
||
console.log(`Finished ${stats.stage} stage.`)
|
||
break
|
||
}
|
||
case SKIP: {
|
||
console.log(`Skipping ${stats.stage} stage.`)
|
||
break
|
||
}
|
||
case PROGRESS: {
|
||
progressHandler(stats)
|
||
break
|
||
}
|
||
default: {
|
||
}
|
||
}
|
||
}
|
||
|
||
function progressHandler (stats) {
|
||
Object.assign(lastStats, stats)
|
||
if (!stats.complete && stats.progress < 1) {
|
||
if (!progressInterval) {
|
||
progressInterval = setInterval(logProgress, 500, lastStats)
|
||
logProgress(lastStats)
|
||
}
|
||
} else {
|
||
if (progressInterval) {
|
||
clearInterval(progressInterval)
|
||
logProgress(lastStats)
|
||
}
|
||
}
|
||
}
|
||
|
||
function logProgress (stats) {
|
||
let logLine = `Stage ${stats.stage}: ${(stats.progress * 100).toFixed(2)}%`
|
||
if (stats.bytesWritten != null && stats.totalBytes != null) {
|
||
logLine = logLine + ` (${prettyBytes(stats.bytesWritten)} / ${prettyBytes(stats.totalBytes)})`
|
||
}
|
||
console.log(logLine)
|
||
}
|
||
}
|
||
|
||
module.exports = statsHandler
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 424:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var iterate = __webpack_require__(157)
|
||
, initState = __webpack_require__(147)
|
||
, terminator = __webpack_require__(939)
|
||
;
|
||
|
||
// Public API
|
||
module.exports = parallel;
|
||
|
||
/**
|
||
* Runs iterator over provided array elements in parallel
|
||
*
|
||
* @param {array|object} list - array or object (named list) to iterate over
|
||
* @param {function} iterator - iterator to run
|
||
* @param {function} callback - invoked when all elements processed
|
||
* @returns {function} - jobs terminator
|
||
*/
|
||
function parallel(list, iterator, callback)
|
||
{
|
||
var state = initState(list);
|
||
|
||
while (state.index < (state['keyedList'] || list).length)
|
||
{
|
||
iterate(list, iterator, state, function(error, result)
|
||
{
|
||
if (error)
|
||
{
|
||
callback(error, result);
|
||
return;
|
||
}
|
||
|
||
// looks like it's the last one
|
||
if (Object.keys(state.jobs).length === 0)
|
||
{
|
||
callback(null, state.results);
|
||
return;
|
||
}
|
||
});
|
||
|
||
state.index++;
|
||
}
|
||
|
||
return terminator.bind(state, callback);
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 427:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
module.exports = __webpack_require__(413);
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 431:
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||
result["default"] = mod;
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const os = __importStar(__webpack_require__(87));
|
||
/**
|
||
* Commands
|
||
*
|
||
* Command Format:
|
||
* ::name key=value,key=value::message
|
||
*
|
||
* Examples:
|
||
* ::warning::This is the message
|
||
* ::set-env name=MY_VAR::some value
|
||
*/
|
||
function issueCommand(command, properties, message) {
|
||
const cmd = new Command(command, properties, message);
|
||
process.stdout.write(cmd.toString() + os.EOL);
|
||
}
|
||
exports.issueCommand = issueCommand;
|
||
function issue(name, message = '') {
|
||
issueCommand(name, {}, message);
|
||
}
|
||
exports.issue = issue;
|
||
const CMD_STRING = '::';
|
||
class Command {
|
||
constructor(command, properties, message) {
|
||
if (!command) {
|
||
command = 'missing.command';
|
||
}
|
||
this.command = command;
|
||
this.properties = properties;
|
||
this.message = message;
|
||
}
|
||
toString() {
|
||
let cmdStr = CMD_STRING + this.command;
|
||
if (this.properties && Object.keys(this.properties).length > 0) {
|
||
cmdStr += ' ';
|
||
let first = true;
|
||
for (const key in this.properties) {
|
||
if (this.properties.hasOwnProperty(key)) {
|
||
const val = this.properties[key];
|
||
if (val) {
|
||
if (first) {
|
||
first = false;
|
||
}
|
||
else {
|
||
cmdStr += ',';
|
||
}
|
||
cmdStr += `${key}=${escapeProperty(val)}`;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
cmdStr += `${CMD_STRING}${escapeData(this.message)}`;
|
||
return cmdStr;
|
||
}
|
||
}
|
||
/**
|
||
* Sanitizes an input into a string so it can be passed into issueCommand safely
|
||
* @param input input to sanitize into a string
|
||
*/
|
||
function toCommandValue(input) {
|
||
if (input === null || input === undefined) {
|
||
return '';
|
||
}
|
||
else if (typeof input === 'string' || input instanceof String) {
|
||
return input;
|
||
}
|
||
return JSON.stringify(input);
|
||
}
|
||
exports.toCommandValue = toCommandValue;
|
||
function escapeData(s) {
|
||
return toCommandValue(s)
|
||
.replace(/%/g, '%25')
|
||
.replace(/\r/g, '%0D')
|
||
.replace(/\n/g, '%0A');
|
||
}
|
||
function escapeProperty(s) {
|
||
return toCommandValue(s)
|
||
.replace(/%/g, '%25')
|
||
.replace(/\r/g, '%0D')
|
||
.replace(/\n/g, '%0A')
|
||
.replace(/:/g, '%3A')
|
||
.replace(/,/g, '%2C');
|
||
}
|
||
//# sourceMappingURL=command.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 442:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = {"_from":"async-neocities@1.1.6","_id":"async-neocities@1.1.6","_inBundle":false,"_integrity":"sha512-q5fTVttBaN9znGxqxxDAh/ks+bZngIJPu6zPS7nlbJLC9NnOhrcP5Mu0VntxgEBtAuaExyI6uH/C+CxKSW0LeQ==","_location":"/async-neocities","_phantomChildren":{},"_requested":{"type":"version","registry":true,"raw":"async-neocities@1.1.6","name":"async-neocities","escapedName":"async-neocities","rawSpec":"1.1.6","saveSpec":null,"fetchSpec":"1.1.6"},"_requiredBy":["/"],"_resolved":"https://registry.npmjs.org/async-neocities/-/async-neocities-1.1.6.tgz","_shasum":"405b45565ccbe9c4ea56e65552ae9c48c20a0309","_spec":"async-neocities@1.1.6","_where":"/home/runner/work/deploy-to-neocities/deploy-to-neocities","author":{"name":"Bret Comnes","email":"bcomnes@gmail.com","url":"https://bret.io"},"bugs":{"url":"https://github.com/bcomnes/async-neocities/issues"},"bundleDependencies":false,"dependencies":{"async-folder-walker":"^2.0.1","fetch-errors":"^2.0.1","form-data":"^3.0.0","nanoassert":"^2.0.0","node-fetch":"^2.6.0","pretty-bytes":"^5.3.0","pump":"^3.0.0","pumpify":"^2.0.1","qs":"^6.9.1","streamx":"^2.6.0"},"deprecated":false,"description":"WIP - nothing to see here","devDependencies":{"auto-changelog":"^1.16.2","dependency-check":"^4.1.0","gh-release":"^3.5.0","npm-run-all":"^4.1.5","standard":"^13.1.0","tap":"^14.10.2"},"homepage":"https://github.com/bcomnes/async-neocities","keywords":["neocities","async","api client","static hosting"],"license":"MIT","main":"index.js","name":"async-neocities","repository":{"type":"git","url":"git+https://github.com/bcomnes/async-neocities.git"},"scripts":{"prepublishOnly":"git push --follow-tags && gh-release","test":"run-s test:*","test:deps":"dependency-check . --no-dev --no-peer","test:standard":"standard","test:tape":"tap","version":"auto-changelog -p --template keepachangelog auto-changelog --breaking-pattern 'BREAKING:' && git add CHANGELOG.md"},"standard":{"ignore":["dist"]},"version":"1.1.6"};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 453:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var once = __webpack_require__(49)
|
||
var eos = __webpack_require__(9)
|
||
var fs = __webpack_require__(747) // we only need fs to get the ReadStream and WriteStream prototypes
|
||
|
||
var noop = function () {}
|
||
var ancient = /^v?\.0/.test(process.version)
|
||
|
||
var isFn = function (fn) {
|
||
return typeof fn === 'function'
|
||
}
|
||
|
||
var isFS = function (stream) {
|
||
if (!ancient) return false // newer node version do not need to care about fs is a special way
|
||
if (!fs) return false // browser
|
||
return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close)
|
||
}
|
||
|
||
var isRequest = function (stream) {
|
||
return stream.setHeader && isFn(stream.abort)
|
||
}
|
||
|
||
var destroyer = function (stream, reading, writing, callback) {
|
||
callback = once(callback)
|
||
|
||
var closed = false
|
||
stream.on('close', function () {
|
||
closed = true
|
||
})
|
||
|
||
eos(stream, {readable: reading, writable: writing}, function (err) {
|
||
if (err) return callback(err)
|
||
closed = true
|
||
callback()
|
||
})
|
||
|
||
var destroyed = false
|
||
return function (err) {
|
||
if (closed) return
|
||
if (destroyed) return
|
||
destroyed = true
|
||
|
||
if (isFS(stream)) return stream.close(noop) // use close for fs streams to avoid fd leaks
|
||
if (isRequest(stream)) return stream.abort() // request.destroy just do .end - .abort is what we want
|
||
|
||
if (isFn(stream.destroy)) return stream.destroy()
|
||
|
||
callback(err || new Error('stream was destroyed'))
|
||
}
|
||
}
|
||
|
||
var call = function (fn) {
|
||
fn()
|
||
}
|
||
|
||
var pipe = function (from, to) {
|
||
return from.pipe(to)
|
||
}
|
||
|
||
var pump = function () {
|
||
var streams = Array.prototype.slice.call(arguments)
|
||
var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop
|
||
|
||
if (Array.isArray(streams[0])) streams = streams[0]
|
||
if (streams.length < 2) throw new Error('pump requires two streams per minimum')
|
||
|
||
var error
|
||
var destroys = streams.map(function (stream, i) {
|
||
var reading = i < streams.length - 1
|
||
var writing = i > 0
|
||
return destroyer(stream, reading, writing, function (err) {
|
||
if (!error) error = err
|
||
if (err) destroys.forEach(call)
|
||
if (reading) return
|
||
destroys.forEach(call)
|
||
callback(error)
|
||
})
|
||
})
|
||
|
||
return streams.reduce(pipe)
|
||
}
|
||
|
||
module.exports = pump
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 454:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
||
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
||
|
||
var Stream = _interopDefault(__webpack_require__(413));
|
||
var http = _interopDefault(__webpack_require__(605));
|
||
var Url = _interopDefault(__webpack_require__(835));
|
||
var https = _interopDefault(__webpack_require__(211));
|
||
var zlib = _interopDefault(__webpack_require__(761));
|
||
|
||
// Based on https://github.com/tmpvar/jsdom/blob/aa85b2abf07766ff7bf5c1f6daafb3726f2f2db5/lib/jsdom/living/blob.js
|
||
|
||
// fix for "Readable" isn't a named export issue
|
||
const Readable = Stream.Readable;
|
||
|
||
const BUFFER = Symbol('buffer');
|
||
const TYPE = Symbol('type');
|
||
|
||
class Blob {
|
||
constructor() {
|
||
this[TYPE] = '';
|
||
|
||
const blobParts = arguments[0];
|
||
const options = arguments[1];
|
||
|
||
const buffers = [];
|
||
let size = 0;
|
||
|
||
if (blobParts) {
|
||
const a = blobParts;
|
||
const length = Number(a.length);
|
||
for (let i = 0; i < length; i++) {
|
||
const element = a[i];
|
||
let buffer;
|
||
if (element instanceof Buffer) {
|
||
buffer = element;
|
||
} else if (ArrayBuffer.isView(element)) {
|
||
buffer = Buffer.from(element.buffer, element.byteOffset, element.byteLength);
|
||
} else if (element instanceof ArrayBuffer) {
|
||
buffer = Buffer.from(element);
|
||
} else if (element instanceof Blob) {
|
||
buffer = element[BUFFER];
|
||
} else {
|
||
buffer = Buffer.from(typeof element === 'string' ? element : String(element));
|
||
}
|
||
size += buffer.length;
|
||
buffers.push(buffer);
|
||
}
|
||
}
|
||
|
||
this[BUFFER] = Buffer.concat(buffers);
|
||
|
||
let type = options && options.type !== undefined && String(options.type).toLowerCase();
|
||
if (type && !/[^\u0020-\u007E]/.test(type)) {
|
||
this[TYPE] = type;
|
||
}
|
||
}
|
||
get size() {
|
||
return this[BUFFER].length;
|
||
}
|
||
get type() {
|
||
return this[TYPE];
|
||
}
|
||
text() {
|
||
return Promise.resolve(this[BUFFER].toString());
|
||
}
|
||
arrayBuffer() {
|
||
const buf = this[BUFFER];
|
||
const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
|
||
return Promise.resolve(ab);
|
||
}
|
||
stream() {
|
||
const readable = new Readable();
|
||
readable._read = function () {};
|
||
readable.push(this[BUFFER]);
|
||
readable.push(null);
|
||
return readable;
|
||
}
|
||
toString() {
|
||
return '[object Blob]';
|
||
}
|
||
slice() {
|
||
const size = this.size;
|
||
|
||
const start = arguments[0];
|
||
const end = arguments[1];
|
||
let relativeStart, relativeEnd;
|
||
if (start === undefined) {
|
||
relativeStart = 0;
|
||
} else if (start < 0) {
|
||
relativeStart = Math.max(size + start, 0);
|
||
} else {
|
||
relativeStart = Math.min(start, size);
|
||
}
|
||
if (end === undefined) {
|
||
relativeEnd = size;
|
||
} else if (end < 0) {
|
||
relativeEnd = Math.max(size + end, 0);
|
||
} else {
|
||
relativeEnd = Math.min(end, size);
|
||
}
|
||
const span = Math.max(relativeEnd - relativeStart, 0);
|
||
|
||
const buffer = this[BUFFER];
|
||
const slicedBuffer = buffer.slice(relativeStart, relativeStart + span);
|
||
const blob = new Blob([], { type: arguments[2] });
|
||
blob[BUFFER] = slicedBuffer;
|
||
return blob;
|
||
}
|
||
}
|
||
|
||
Object.defineProperties(Blob.prototype, {
|
||
size: { enumerable: true },
|
||
type: { enumerable: true },
|
||
slice: { enumerable: true }
|
||
});
|
||
|
||
Object.defineProperty(Blob.prototype, Symbol.toStringTag, {
|
||
value: 'Blob',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
/**
|
||
* fetch-error.js
|
||
*
|
||
* FetchError interface for operational errors
|
||
*/
|
||
|
||
/**
|
||
* Create FetchError instance
|
||
*
|
||
* @param String message Error message for human
|
||
* @param String type Error type for machine
|
||
* @param String systemError For Node.js system error
|
||
* @return FetchError
|
||
*/
|
||
function FetchError(message, type, systemError) {
|
||
Error.call(this, message);
|
||
|
||
this.message = message;
|
||
this.type = type;
|
||
|
||
// when err.type is `system`, err.code contains system error code
|
||
if (systemError) {
|
||
this.code = this.errno = systemError.code;
|
||
}
|
||
|
||
// hide custom error implementation details from end-users
|
||
Error.captureStackTrace(this, this.constructor);
|
||
}
|
||
|
||
FetchError.prototype = Object.create(Error.prototype);
|
||
FetchError.prototype.constructor = FetchError;
|
||
FetchError.prototype.name = 'FetchError';
|
||
|
||
let convert;
|
||
try {
|
||
convert = __webpack_require__(18).convert;
|
||
} catch (e) {}
|
||
|
||
const INTERNALS = Symbol('Body internals');
|
||
|
||
// fix an issue where "PassThrough" isn't a named export for node <10
|
||
const PassThrough = Stream.PassThrough;
|
||
|
||
/**
|
||
* Body mixin
|
||
*
|
||
* Ref: https://fetch.spec.whatwg.org/#body
|
||
*
|
||
* @param Stream body Readable stream
|
||
* @param Object opts Response options
|
||
* @return Void
|
||
*/
|
||
function Body(body) {
|
||
var _this = this;
|
||
|
||
var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
|
||
_ref$size = _ref.size;
|
||
|
||
let size = _ref$size === undefined ? 0 : _ref$size;
|
||
var _ref$timeout = _ref.timeout;
|
||
let timeout = _ref$timeout === undefined ? 0 : _ref$timeout;
|
||
|
||
if (body == null) {
|
||
// body is undefined or null
|
||
body = null;
|
||
} else if (isURLSearchParams(body)) {
|
||
// body is a URLSearchParams
|
||
body = Buffer.from(body.toString());
|
||
} else if (isBlob(body)) ; else if (Buffer.isBuffer(body)) ; else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
|
||
// body is ArrayBuffer
|
||
body = Buffer.from(body);
|
||
} else if (ArrayBuffer.isView(body)) {
|
||
// body is ArrayBufferView
|
||
body = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
|
||
} else if (body instanceof Stream) ; else {
|
||
// none of the above
|
||
// coerce to string then buffer
|
||
body = Buffer.from(String(body));
|
||
}
|
||
this[INTERNALS] = {
|
||
body,
|
||
disturbed: false,
|
||
error: null
|
||
};
|
||
this.size = size;
|
||
this.timeout = timeout;
|
||
|
||
if (body instanceof Stream) {
|
||
body.on('error', function (err) {
|
||
const error = err.name === 'AbortError' ? err : new FetchError(`Invalid response body while trying to fetch ${_this.url}: ${err.message}`, 'system', err);
|
||
_this[INTERNALS].error = error;
|
||
});
|
||
}
|
||
}
|
||
|
||
Body.prototype = {
|
||
get body() {
|
||
return this[INTERNALS].body;
|
||
},
|
||
|
||
get bodyUsed() {
|
||
return this[INTERNALS].disturbed;
|
||
},
|
||
|
||
/**
|
||
* Decode response as ArrayBuffer
|
||
*
|
||
* @return Promise
|
||
*/
|
||
arrayBuffer() {
|
||
return consumeBody.call(this).then(function (buf) {
|
||
return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Return raw response as Blob
|
||
*
|
||
* @return Promise
|
||
*/
|
||
blob() {
|
||
let ct = this.headers && this.headers.get('content-type') || '';
|
||
return consumeBody.call(this).then(function (buf) {
|
||
return Object.assign(
|
||
// Prevent copying
|
||
new Blob([], {
|
||
type: ct.toLowerCase()
|
||
}), {
|
||
[BUFFER]: buf
|
||
});
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Decode response as json
|
||
*
|
||
* @return Promise
|
||
*/
|
||
json() {
|
||
var _this2 = this;
|
||
|
||
return consumeBody.call(this).then(function (buffer) {
|
||
try {
|
||
return JSON.parse(buffer.toString());
|
||
} catch (err) {
|
||
return Body.Promise.reject(new FetchError(`invalid json response body at ${_this2.url} reason: ${err.message}`, 'invalid-json'));
|
||
}
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Decode response as text
|
||
*
|
||
* @return Promise
|
||
*/
|
||
text() {
|
||
return consumeBody.call(this).then(function (buffer) {
|
||
return buffer.toString();
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Decode response as buffer (non-spec api)
|
||
*
|
||
* @return Promise
|
||
*/
|
||
buffer() {
|
||
return consumeBody.call(this);
|
||
},
|
||
|
||
/**
|
||
* Decode response as text, while automatically detecting the encoding and
|
||
* trying to decode to UTF-8 (non-spec api)
|
||
*
|
||
* @return Promise
|
||
*/
|
||
textConverted() {
|
||
var _this3 = this;
|
||
|
||
return consumeBody.call(this).then(function (buffer) {
|
||
return convertBody(buffer, _this3.headers);
|
||
});
|
||
}
|
||
};
|
||
|
||
// In browsers, all properties are enumerable.
|
||
Object.defineProperties(Body.prototype, {
|
||
body: { enumerable: true },
|
||
bodyUsed: { enumerable: true },
|
||
arrayBuffer: { enumerable: true },
|
||
blob: { enumerable: true },
|
||
json: { enumerable: true },
|
||
text: { enumerable: true }
|
||
});
|
||
|
||
Body.mixIn = function (proto) {
|
||
for (const name of Object.getOwnPropertyNames(Body.prototype)) {
|
||
// istanbul ignore else: future proof
|
||
if (!(name in proto)) {
|
||
const desc = Object.getOwnPropertyDescriptor(Body.prototype, name);
|
||
Object.defineProperty(proto, name, desc);
|
||
}
|
||
}
|
||
};
|
||
|
||
/**
|
||
* Consume and convert an entire Body to a Buffer.
|
||
*
|
||
* Ref: https://fetch.spec.whatwg.org/#concept-body-consume-body
|
||
*
|
||
* @return Promise
|
||
*/
|
||
function consumeBody() {
|
||
var _this4 = this;
|
||
|
||
if (this[INTERNALS].disturbed) {
|
||
return Body.Promise.reject(new TypeError(`body used already for: ${this.url}`));
|
||
}
|
||
|
||
this[INTERNALS].disturbed = true;
|
||
|
||
if (this[INTERNALS].error) {
|
||
return Body.Promise.reject(this[INTERNALS].error);
|
||
}
|
||
|
||
let body = this.body;
|
||
|
||
// body is null
|
||
if (body === null) {
|
||
return Body.Promise.resolve(Buffer.alloc(0));
|
||
}
|
||
|
||
// body is blob
|
||
if (isBlob(body)) {
|
||
body = body.stream();
|
||
}
|
||
|
||
// body is buffer
|
||
if (Buffer.isBuffer(body)) {
|
||
return Body.Promise.resolve(body);
|
||
}
|
||
|
||
// istanbul ignore if: should never happen
|
||
if (!(body instanceof Stream)) {
|
||
return Body.Promise.resolve(Buffer.alloc(0));
|
||
}
|
||
|
||
// body is stream
|
||
// get ready to actually consume the body
|
||
let accum = [];
|
||
let accumBytes = 0;
|
||
let abort = false;
|
||
|
||
return new Body.Promise(function (resolve, reject) {
|
||
let resTimeout;
|
||
|
||
// allow timeout on slow response body
|
||
if (_this4.timeout) {
|
||
resTimeout = setTimeout(function () {
|
||
abort = true;
|
||
reject(new FetchError(`Response timeout while trying to fetch ${_this4.url} (over ${_this4.timeout}ms)`, 'body-timeout'));
|
||
}, _this4.timeout);
|
||
}
|
||
|
||
// handle stream errors
|
||
body.on('error', function (err) {
|
||
if (err.name === 'AbortError') {
|
||
// if the request was aborted, reject with this Error
|
||
abort = true;
|
||
reject(err);
|
||
} else {
|
||
// other errors, such as incorrect content-encoding
|
||
reject(new FetchError(`Invalid response body while trying to fetch ${_this4.url}: ${err.message}`, 'system', err));
|
||
}
|
||
});
|
||
|
||
body.on('data', function (chunk) {
|
||
if (abort || chunk === null) {
|
||
return;
|
||
}
|
||
|
||
if (_this4.size && accumBytes + chunk.length > _this4.size) {
|
||
abort = true;
|
||
reject(new FetchError(`content size at ${_this4.url} over limit: ${_this4.size}`, 'max-size'));
|
||
return;
|
||
}
|
||
|
||
accumBytes += chunk.length;
|
||
accum.push(chunk);
|
||
});
|
||
|
||
body.on('end', function () {
|
||
if (abort) {
|
||
return;
|
||
}
|
||
|
||
clearTimeout(resTimeout);
|
||
|
||
try {
|
||
resolve(Buffer.concat(accum, accumBytes));
|
||
} catch (err) {
|
||
// handle streams that have accumulated too much data (issue #414)
|
||
reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, 'system', err));
|
||
}
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Detect buffer encoding and convert to target encoding
|
||
* ref: http://www.w3.org/TR/2011/WD-html5-20110113/parsing.html#determining-the-character-encoding
|
||
*
|
||
* @param Buffer buffer Incoming buffer
|
||
* @param String encoding Target encoding
|
||
* @return String
|
||
*/
|
||
function convertBody(buffer, headers) {
|
||
if (typeof convert !== 'function') {
|
||
throw new Error('The package `encoding` must be installed to use the textConverted() function');
|
||
}
|
||
|
||
const ct = headers.get('content-type');
|
||
let charset = 'utf-8';
|
||
let res, str;
|
||
|
||
// header
|
||
if (ct) {
|
||
res = /charset=([^;]*)/i.exec(ct);
|
||
}
|
||
|
||
// no charset in content type, peek at response body for at most 1024 bytes
|
||
str = buffer.slice(0, 1024).toString();
|
||
|
||
// html5
|
||
if (!res && str) {
|
||
res = /<meta.+?charset=(['"])(.+?)\1/i.exec(str);
|
||
}
|
||
|
||
// html4
|
||
if (!res && str) {
|
||
res = /<meta[\s]+?http-equiv=(['"])content-type\1[\s]+?content=(['"])(.+?)\2/i.exec(str);
|
||
if (!res) {
|
||
res = /<meta[\s]+?content=(['"])(.+?)\1[\s]+?http-equiv=(['"])content-type\3/i.exec(str);
|
||
if (res) {
|
||
res.pop(); // drop last quote
|
||
}
|
||
}
|
||
|
||
if (res) {
|
||
res = /charset=(.*)/i.exec(res.pop());
|
||
}
|
||
}
|
||
|
||
// xml
|
||
if (!res && str) {
|
||
res = /<\?xml.+?encoding=(['"])(.+?)\1/i.exec(str);
|
||
}
|
||
|
||
// found charset
|
||
if (res) {
|
||
charset = res.pop();
|
||
|
||
// prevent decode issues when sites use incorrect encoding
|
||
// ref: https://hsivonen.fi/encoding-menu/
|
||
if (charset === 'gb2312' || charset === 'gbk') {
|
||
charset = 'gb18030';
|
||
}
|
||
}
|
||
|
||
// turn raw buffers into a single utf-8 buffer
|
||
return convert(buffer, 'UTF-8', charset).toString();
|
||
}
|
||
|
||
/**
|
||
* Detect a URLSearchParams object
|
||
* ref: https://github.com/bitinn/node-fetch/issues/296#issuecomment-307598143
|
||
*
|
||
* @param Object obj Object to detect by type or brand
|
||
* @return String
|
||
*/
|
||
function isURLSearchParams(obj) {
|
||
// Duck-typing as a necessary condition.
|
||
if (typeof obj !== 'object' || typeof obj.append !== 'function' || typeof obj.delete !== 'function' || typeof obj.get !== 'function' || typeof obj.getAll !== 'function' || typeof obj.has !== 'function' || typeof obj.set !== 'function') {
|
||
return false;
|
||
}
|
||
|
||
// Brand-checking and more duck-typing as optional condition.
|
||
return obj.constructor.name === 'URLSearchParams' || Object.prototype.toString.call(obj) === '[object URLSearchParams]' || typeof obj.sort === 'function';
|
||
}
|
||
|
||
/**
|
||
* Check if `obj` is a W3C `Blob` object (which `File` inherits from)
|
||
* @param {*} obj
|
||
* @return {boolean}
|
||
*/
|
||
function isBlob(obj) {
|
||
return typeof obj === 'object' && typeof obj.arrayBuffer === 'function' && typeof obj.type === 'string' && typeof obj.stream === 'function' && typeof obj.constructor === 'function' && typeof obj.constructor.name === 'string' && /^(Blob|File)$/.test(obj.constructor.name) && /^(Blob|File)$/.test(obj[Symbol.toStringTag]);
|
||
}
|
||
|
||
/**
|
||
* Clone body given Res/Req instance
|
||
*
|
||
* @param Mixed instance Response or Request instance
|
||
* @return Mixed
|
||
*/
|
||
function clone(instance) {
|
||
let p1, p2;
|
||
let body = instance.body;
|
||
|
||
// don't allow cloning a used body
|
||
if (instance.bodyUsed) {
|
||
throw new Error('cannot clone body after it is used');
|
||
}
|
||
|
||
// check that body is a stream and not form-data object
|
||
// note: we can't clone the form-data object without having it as a dependency
|
||
if (body instanceof Stream && typeof body.getBoundary !== 'function') {
|
||
// tee instance body
|
||
p1 = new PassThrough();
|
||
p2 = new PassThrough();
|
||
body.pipe(p1);
|
||
body.pipe(p2);
|
||
// set instance body to teed body and return the other teed body
|
||
instance[INTERNALS].body = p1;
|
||
body = p2;
|
||
}
|
||
|
||
return body;
|
||
}
|
||
|
||
/**
|
||
* Performs the operation "extract a `Content-Type` value from |object|" as
|
||
* specified in the specification:
|
||
* https://fetch.spec.whatwg.org/#concept-bodyinit-extract
|
||
*
|
||
* This function assumes that instance.body is present.
|
||
*
|
||
* @param Mixed instance Any options.body input
|
||
*/
|
||
function extractContentType(body) {
|
||
if (body === null) {
|
||
// body is null
|
||
return null;
|
||
} else if (typeof body === 'string') {
|
||
// body is string
|
||
return 'text/plain;charset=UTF-8';
|
||
} else if (isURLSearchParams(body)) {
|
||
// body is a URLSearchParams
|
||
return 'application/x-www-form-urlencoded;charset=UTF-8';
|
||
} else if (isBlob(body)) {
|
||
// body is blob
|
||
return body.type || null;
|
||
} else if (Buffer.isBuffer(body)) {
|
||
// body is buffer
|
||
return null;
|
||
} else if (Object.prototype.toString.call(body) === '[object ArrayBuffer]') {
|
||
// body is ArrayBuffer
|
||
return null;
|
||
} else if (ArrayBuffer.isView(body)) {
|
||
// body is ArrayBufferView
|
||
return null;
|
||
} else if (typeof body.getBoundary === 'function') {
|
||
// detect form data input from form-data module
|
||
return `multipart/form-data;boundary=${body.getBoundary()}`;
|
||
} else if (body instanceof Stream) {
|
||
// body is stream
|
||
// can't really do much about this
|
||
return null;
|
||
} else {
|
||
// Body constructor defaults other things to string
|
||
return 'text/plain;charset=UTF-8';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* The Fetch Standard treats this as if "total bytes" is a property on the body.
|
||
* For us, we have to explicitly get it with a function.
|
||
*
|
||
* ref: https://fetch.spec.whatwg.org/#concept-body-total-bytes
|
||
*
|
||
* @param Body instance Instance of Body
|
||
* @return Number? Number of bytes, or null if not possible
|
||
*/
|
||
function getTotalBytes(instance) {
|
||
const body = instance.body;
|
||
|
||
|
||
if (body === null) {
|
||
// body is null
|
||
return 0;
|
||
} else if (isBlob(body)) {
|
||
return body.size;
|
||
} else if (Buffer.isBuffer(body)) {
|
||
// body is buffer
|
||
return body.length;
|
||
} else if (body && typeof body.getLengthSync === 'function') {
|
||
// detect form data input from form-data module
|
||
if (body._lengthRetrievers && body._lengthRetrievers.length == 0 || // 1.x
|
||
body.hasKnownLength && body.hasKnownLength()) {
|
||
// 2.x
|
||
return body.getLengthSync();
|
||
}
|
||
return null;
|
||
} else {
|
||
// body is stream
|
||
return null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Write a Body to a Node.js WritableStream (e.g. http.Request) object.
|
||
*
|
||
* @param Body instance Instance of Body
|
||
* @return Void
|
||
*/
|
||
function writeToStream(dest, instance) {
|
||
const body = instance.body;
|
||
|
||
|
||
if (body === null) {
|
||
// body is null
|
||
dest.end();
|
||
} else if (isBlob(body)) {
|
||
body.stream().pipe(dest);
|
||
} else if (Buffer.isBuffer(body)) {
|
||
// body is buffer
|
||
dest.write(body);
|
||
dest.end();
|
||
} else {
|
||
// body is stream
|
||
body.pipe(dest);
|
||
}
|
||
}
|
||
|
||
// expose Promise
|
||
Body.Promise = global.Promise;
|
||
|
||
/**
|
||
* headers.js
|
||
*
|
||
* Headers class offers convenient helpers
|
||
*/
|
||
|
||
const invalidTokenRegex = /[^\^_`a-zA-Z\-0-9!#$%&'*+.|~]/;
|
||
const invalidHeaderCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
|
||
|
||
function validateName(name) {
|
||
name = `${name}`;
|
||
if (invalidTokenRegex.test(name) || name === '') {
|
||
throw new TypeError(`${name} is not a legal HTTP header name`);
|
||
}
|
||
}
|
||
|
||
function validateValue(value) {
|
||
value = `${value}`;
|
||
if (invalidHeaderCharRegex.test(value)) {
|
||
throw new TypeError(`${value} is not a legal HTTP header value`);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Find the key in the map object given a header name.
|
||
*
|
||
* Returns undefined if not found.
|
||
*
|
||
* @param String name Header name
|
||
* @return String|Undefined
|
||
*/
|
||
function find(map, name) {
|
||
name = name.toLowerCase();
|
||
for (const key in map) {
|
||
if (key.toLowerCase() === name) {
|
||
return key;
|
||
}
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
const MAP = Symbol('map');
|
||
class Headers {
|
||
/**
|
||
* Headers class
|
||
*
|
||
* @param Object headers Response headers
|
||
* @return Void
|
||
*/
|
||
constructor() {
|
||
let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
|
||
|
||
this[MAP] = Object.create(null);
|
||
|
||
if (init instanceof Headers) {
|
||
const rawHeaders = init.raw();
|
||
const headerNames = Object.keys(rawHeaders);
|
||
|
||
for (const headerName of headerNames) {
|
||
for (const value of rawHeaders[headerName]) {
|
||
this.append(headerName, value);
|
||
}
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
// We don't worry about converting prop to ByteString here as append()
|
||
// will handle it.
|
||
if (init == null) ; else if (typeof init === 'object') {
|
||
const method = init[Symbol.iterator];
|
||
if (method != null) {
|
||
if (typeof method !== 'function') {
|
||
throw new TypeError('Header pairs must be iterable');
|
||
}
|
||
|
||
// sequence<sequence<ByteString>>
|
||
// Note: per spec we have to first exhaust the lists then process them
|
||
const pairs = [];
|
||
for (const pair of init) {
|
||
if (typeof pair !== 'object' || typeof pair[Symbol.iterator] !== 'function') {
|
||
throw new TypeError('Each header pair must be iterable');
|
||
}
|
||
pairs.push(Array.from(pair));
|
||
}
|
||
|
||
for (const pair of pairs) {
|
||
if (pair.length !== 2) {
|
||
throw new TypeError('Each header pair must be a name/value tuple');
|
||
}
|
||
this.append(pair[0], pair[1]);
|
||
}
|
||
} else {
|
||
// record<ByteString, ByteString>
|
||
for (const key of Object.keys(init)) {
|
||
const value = init[key];
|
||
this.append(key, value);
|
||
}
|
||
}
|
||
} else {
|
||
throw new TypeError('Provided initializer must be an object');
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Return combined header value given name
|
||
*
|
||
* @param String name Header name
|
||
* @return Mixed
|
||
*/
|
||
get(name) {
|
||
name = `${name}`;
|
||
validateName(name);
|
||
const key = find(this[MAP], name);
|
||
if (key === undefined) {
|
||
return null;
|
||
}
|
||
|
||
return this[MAP][key].join(', ');
|
||
}
|
||
|
||
/**
|
||
* Iterate over all headers
|
||
*
|
||
* @param Function callback Executed for each item with parameters (value, name, thisArg)
|
||
* @param Boolean thisArg `this` context for callback function
|
||
* @return Void
|
||
*/
|
||
forEach(callback) {
|
||
let thisArg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
|
||
|
||
let pairs = getHeaders(this);
|
||
let i = 0;
|
||
while (i < pairs.length) {
|
||
var _pairs$i = pairs[i];
|
||
const name = _pairs$i[0],
|
||
value = _pairs$i[1];
|
||
|
||
callback.call(thisArg, value, name, this);
|
||
pairs = getHeaders(this);
|
||
i++;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Overwrite header values given name
|
||
*
|
||
* @param String name Header name
|
||
* @param String value Header value
|
||
* @return Void
|
||
*/
|
||
set(name, value) {
|
||
name = `${name}`;
|
||
value = `${value}`;
|
||
validateName(name);
|
||
validateValue(value);
|
||
const key = find(this[MAP], name);
|
||
this[MAP][key !== undefined ? key : name] = [value];
|
||
}
|
||
|
||
/**
|
||
* Append a value onto existing header
|
||
*
|
||
* @param String name Header name
|
||
* @param String value Header value
|
||
* @return Void
|
||
*/
|
||
append(name, value) {
|
||
name = `${name}`;
|
||
value = `${value}`;
|
||
validateName(name);
|
||
validateValue(value);
|
||
const key = find(this[MAP], name);
|
||
if (key !== undefined) {
|
||
this[MAP][key].push(value);
|
||
} else {
|
||
this[MAP][name] = [value];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Check for header name existence
|
||
*
|
||
* @param String name Header name
|
||
* @return Boolean
|
||
*/
|
||
has(name) {
|
||
name = `${name}`;
|
||
validateName(name);
|
||
return find(this[MAP], name) !== undefined;
|
||
}
|
||
|
||
/**
|
||
* Delete all header values given name
|
||
*
|
||
* @param String name Header name
|
||
* @return Void
|
||
*/
|
||
delete(name) {
|
||
name = `${name}`;
|
||
validateName(name);
|
||
const key = find(this[MAP], name);
|
||
if (key !== undefined) {
|
||
delete this[MAP][key];
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Return raw headers (non-spec api)
|
||
*
|
||
* @return Object
|
||
*/
|
||
raw() {
|
||
return this[MAP];
|
||
}
|
||
|
||
/**
|
||
* Get an iterator on keys.
|
||
*
|
||
* @return Iterator
|
||
*/
|
||
keys() {
|
||
return createHeadersIterator(this, 'key');
|
||
}
|
||
|
||
/**
|
||
* Get an iterator on values.
|
||
*
|
||
* @return Iterator
|
||
*/
|
||
values() {
|
||
return createHeadersIterator(this, 'value');
|
||
}
|
||
|
||
/**
|
||
* Get an iterator on entries.
|
||
*
|
||
* This is the default iterator of the Headers object.
|
||
*
|
||
* @return Iterator
|
||
*/
|
||
[Symbol.iterator]() {
|
||
return createHeadersIterator(this, 'key+value');
|
||
}
|
||
}
|
||
Headers.prototype.entries = Headers.prototype[Symbol.iterator];
|
||
|
||
Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
|
||
value: 'Headers',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
Object.defineProperties(Headers.prototype, {
|
||
get: { enumerable: true },
|
||
forEach: { enumerable: true },
|
||
set: { enumerable: true },
|
||
append: { enumerable: true },
|
||
has: { enumerable: true },
|
||
delete: { enumerable: true },
|
||
keys: { enumerable: true },
|
||
values: { enumerable: true },
|
||
entries: { enumerable: true }
|
||
});
|
||
|
||
function getHeaders(headers) {
|
||
let kind = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'key+value';
|
||
|
||
const keys = Object.keys(headers[MAP]).sort();
|
||
return keys.map(kind === 'key' ? function (k) {
|
||
return k.toLowerCase();
|
||
} : kind === 'value' ? function (k) {
|
||
return headers[MAP][k].join(', ');
|
||
} : function (k) {
|
||
return [k.toLowerCase(), headers[MAP][k].join(', ')];
|
||
});
|
||
}
|
||
|
||
const INTERNAL = Symbol('internal');
|
||
|
||
function createHeadersIterator(target, kind) {
|
||
const iterator = Object.create(HeadersIteratorPrototype);
|
||
iterator[INTERNAL] = {
|
||
target,
|
||
kind,
|
||
index: 0
|
||
};
|
||
return iterator;
|
||
}
|
||
|
||
const HeadersIteratorPrototype = Object.setPrototypeOf({
|
||
next() {
|
||
// istanbul ignore if
|
||
if (!this || Object.getPrototypeOf(this) !== HeadersIteratorPrototype) {
|
||
throw new TypeError('Value of `this` is not a HeadersIterator');
|
||
}
|
||
|
||
var _INTERNAL = this[INTERNAL];
|
||
const target = _INTERNAL.target,
|
||
kind = _INTERNAL.kind,
|
||
index = _INTERNAL.index;
|
||
|
||
const values = getHeaders(target, kind);
|
||
const len = values.length;
|
||
if (index >= len) {
|
||
return {
|
||
value: undefined,
|
||
done: true
|
||
};
|
||
}
|
||
|
||
this[INTERNAL].index = index + 1;
|
||
|
||
return {
|
||
value: values[index],
|
||
done: false
|
||
};
|
||
}
|
||
}, Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]())));
|
||
|
||
Object.defineProperty(HeadersIteratorPrototype, Symbol.toStringTag, {
|
||
value: 'HeadersIterator',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
/**
|
||
* Export the Headers object in a form that Node.js can consume.
|
||
*
|
||
* @param Headers headers
|
||
* @return Object
|
||
*/
|
||
function exportNodeCompatibleHeaders(headers) {
|
||
const obj = Object.assign({ __proto__: null }, headers[MAP]);
|
||
|
||
// http.request() only supports string as Host header. This hack makes
|
||
// specifying custom Host header possible.
|
||
const hostHeaderKey = find(headers[MAP], 'Host');
|
||
if (hostHeaderKey !== undefined) {
|
||
obj[hostHeaderKey] = obj[hostHeaderKey][0];
|
||
}
|
||
|
||
return obj;
|
||
}
|
||
|
||
/**
|
||
* Create a Headers object from an object of headers, ignoring those that do
|
||
* not conform to HTTP grammar productions.
|
||
*
|
||
* @param Object obj Object of headers
|
||
* @return Headers
|
||
*/
|
||
function createHeadersLenient(obj) {
|
||
const headers = new Headers();
|
||
for (const name of Object.keys(obj)) {
|
||
if (invalidTokenRegex.test(name)) {
|
||
continue;
|
||
}
|
||
if (Array.isArray(obj[name])) {
|
||
for (const val of obj[name]) {
|
||
if (invalidHeaderCharRegex.test(val)) {
|
||
continue;
|
||
}
|
||
if (headers[MAP][name] === undefined) {
|
||
headers[MAP][name] = [val];
|
||
} else {
|
||
headers[MAP][name].push(val);
|
||
}
|
||
}
|
||
} else if (!invalidHeaderCharRegex.test(obj[name])) {
|
||
headers[MAP][name] = [obj[name]];
|
||
}
|
||
}
|
||
return headers;
|
||
}
|
||
|
||
const INTERNALS$1 = Symbol('Response internals');
|
||
|
||
// fix an issue where "STATUS_CODES" aren't a named export for node <10
|
||
const STATUS_CODES = http.STATUS_CODES;
|
||
|
||
/**
|
||
* Response class
|
||
*
|
||
* @param Stream body Readable stream
|
||
* @param Object opts Response options
|
||
* @return Void
|
||
*/
|
||
class Response {
|
||
constructor() {
|
||
let body = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
|
||
let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
|
||
Body.call(this, body, opts);
|
||
|
||
const status = opts.status || 200;
|
||
const headers = new Headers(opts.headers);
|
||
|
||
if (body != null && !headers.has('Content-Type')) {
|
||
const contentType = extractContentType(body);
|
||
if (contentType) {
|
||
headers.append('Content-Type', contentType);
|
||
}
|
||
}
|
||
|
||
this[INTERNALS$1] = {
|
||
url: opts.url,
|
||
status,
|
||
statusText: opts.statusText || STATUS_CODES[status],
|
||
headers,
|
||
counter: opts.counter
|
||
};
|
||
}
|
||
|
||
get url() {
|
||
return this[INTERNALS$1].url || '';
|
||
}
|
||
|
||
get status() {
|
||
return this[INTERNALS$1].status;
|
||
}
|
||
|
||
/**
|
||
* Convenience property representing if the request ended normally
|
||
*/
|
||
get ok() {
|
||
return this[INTERNALS$1].status >= 200 && this[INTERNALS$1].status < 300;
|
||
}
|
||
|
||
get redirected() {
|
||
return this[INTERNALS$1].counter > 0;
|
||
}
|
||
|
||
get statusText() {
|
||
return this[INTERNALS$1].statusText;
|
||
}
|
||
|
||
get headers() {
|
||
return this[INTERNALS$1].headers;
|
||
}
|
||
|
||
/**
|
||
* Clone this response
|
||
*
|
||
* @return Response
|
||
*/
|
||
clone() {
|
||
return new Response(clone(this), {
|
||
url: this.url,
|
||
status: this.status,
|
||
statusText: this.statusText,
|
||
headers: this.headers,
|
||
ok: this.ok,
|
||
redirected: this.redirected
|
||
});
|
||
}
|
||
}
|
||
|
||
Body.mixIn(Response.prototype);
|
||
|
||
Object.defineProperties(Response.prototype, {
|
||
url: { enumerable: true },
|
||
status: { enumerable: true },
|
||
ok: { enumerable: true },
|
||
redirected: { enumerable: true },
|
||
statusText: { enumerable: true },
|
||
headers: { enumerable: true },
|
||
clone: { enumerable: true }
|
||
});
|
||
|
||
Object.defineProperty(Response.prototype, Symbol.toStringTag, {
|
||
value: 'Response',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
const INTERNALS$2 = Symbol('Request internals');
|
||
|
||
// fix an issue where "format", "parse" aren't a named export for node <10
|
||
const parse_url = Url.parse;
|
||
const format_url = Url.format;
|
||
|
||
const streamDestructionSupported = 'destroy' in Stream.Readable.prototype;
|
||
|
||
/**
|
||
* Check if a value is an instance of Request.
|
||
*
|
||
* @param Mixed input
|
||
* @return Boolean
|
||
*/
|
||
function isRequest(input) {
|
||
return typeof input === 'object' && typeof input[INTERNALS$2] === 'object';
|
||
}
|
||
|
||
function isAbortSignal(signal) {
|
||
const proto = signal && typeof signal === 'object' && Object.getPrototypeOf(signal);
|
||
return !!(proto && proto.constructor.name === 'AbortSignal');
|
||
}
|
||
|
||
/**
|
||
* Request class
|
||
*
|
||
* @param Mixed input Url or Request instance
|
||
* @param Object init Custom options
|
||
* @return Void
|
||
*/
|
||
class Request {
|
||
constructor(input) {
|
||
let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
||
|
||
let parsedURL;
|
||
|
||
// normalize input
|
||
if (!isRequest(input)) {
|
||
if (input && input.href) {
|
||
// in order to support Node.js' Url objects; though WHATWG's URL objects
|
||
// will fall into this branch also (since their `toString()` will return
|
||
// `href` property anyway)
|
||
parsedURL = parse_url(input.href);
|
||
} else {
|
||
// coerce input to a string before attempting to parse
|
||
parsedURL = parse_url(`${input}`);
|
||
}
|
||
input = {};
|
||
} else {
|
||
parsedURL = parse_url(input.url);
|
||
}
|
||
|
||
let method = init.method || input.method || 'GET';
|
||
method = method.toUpperCase();
|
||
|
||
if ((init.body != null || isRequest(input) && input.body !== null) && (method === 'GET' || method === 'HEAD')) {
|
||
throw new TypeError('Request with GET/HEAD method cannot have body');
|
||
}
|
||
|
||
let inputBody = init.body != null ? init.body : isRequest(input) && input.body !== null ? clone(input) : null;
|
||
|
||
Body.call(this, inputBody, {
|
||
timeout: init.timeout || input.timeout || 0,
|
||
size: init.size || input.size || 0
|
||
});
|
||
|
||
const headers = new Headers(init.headers || input.headers || {});
|
||
|
||
if (inputBody != null && !headers.has('Content-Type')) {
|
||
const contentType = extractContentType(inputBody);
|
||
if (contentType) {
|
||
headers.append('Content-Type', contentType);
|
||
}
|
||
}
|
||
|
||
let signal = isRequest(input) ? input.signal : null;
|
||
if ('signal' in init) signal = init.signal;
|
||
|
||
if (signal != null && !isAbortSignal(signal)) {
|
||
throw new TypeError('Expected signal to be an instanceof AbortSignal');
|
||
}
|
||
|
||
this[INTERNALS$2] = {
|
||
method,
|
||
redirect: init.redirect || input.redirect || 'follow',
|
||
headers,
|
||
parsedURL,
|
||
signal
|
||
};
|
||
|
||
// node-fetch-only options
|
||
this.follow = init.follow !== undefined ? init.follow : input.follow !== undefined ? input.follow : 20;
|
||
this.compress = init.compress !== undefined ? init.compress : input.compress !== undefined ? input.compress : true;
|
||
this.counter = init.counter || input.counter || 0;
|
||
this.agent = init.agent || input.agent;
|
||
}
|
||
|
||
get method() {
|
||
return this[INTERNALS$2].method;
|
||
}
|
||
|
||
get url() {
|
||
return format_url(this[INTERNALS$2].parsedURL);
|
||
}
|
||
|
||
get headers() {
|
||
return this[INTERNALS$2].headers;
|
||
}
|
||
|
||
get redirect() {
|
||
return this[INTERNALS$2].redirect;
|
||
}
|
||
|
||
get signal() {
|
||
return this[INTERNALS$2].signal;
|
||
}
|
||
|
||
/**
|
||
* Clone this request
|
||
*
|
||
* @return Request
|
||
*/
|
||
clone() {
|
||
return new Request(this);
|
||
}
|
||
}
|
||
|
||
Body.mixIn(Request.prototype);
|
||
|
||
Object.defineProperty(Request.prototype, Symbol.toStringTag, {
|
||
value: 'Request',
|
||
writable: false,
|
||
enumerable: false,
|
||
configurable: true
|
||
});
|
||
|
||
Object.defineProperties(Request.prototype, {
|
||
method: { enumerable: true },
|
||
url: { enumerable: true },
|
||
headers: { enumerable: true },
|
||
redirect: { enumerable: true },
|
||
clone: { enumerable: true },
|
||
signal: { enumerable: true }
|
||
});
|
||
|
||
/**
|
||
* Convert a Request to Node.js http request options.
|
||
*
|
||
* @param Request A Request instance
|
||
* @return Object The options object to be passed to http.request
|
||
*/
|
||
function getNodeRequestOptions(request) {
|
||
const parsedURL = request[INTERNALS$2].parsedURL;
|
||
const headers = new Headers(request[INTERNALS$2].headers);
|
||
|
||
// fetch step 1.3
|
||
if (!headers.has('Accept')) {
|
||
headers.set('Accept', '*/*');
|
||
}
|
||
|
||
// Basic fetch
|
||
if (!parsedURL.protocol || !parsedURL.hostname) {
|
||
throw new TypeError('Only absolute URLs are supported');
|
||
}
|
||
|
||
if (!/^https?:$/.test(parsedURL.protocol)) {
|
||
throw new TypeError('Only HTTP(S) protocols are supported');
|
||
}
|
||
|
||
if (request.signal && request.body instanceof Stream.Readable && !streamDestructionSupported) {
|
||
throw new Error('Cancellation of streamed requests with AbortSignal is not supported in node < 8');
|
||
}
|
||
|
||
// HTTP-network-or-cache fetch steps 2.4-2.7
|
||
let contentLengthValue = null;
|
||
if (request.body == null && /^(POST|PUT)$/i.test(request.method)) {
|
||
contentLengthValue = '0';
|
||
}
|
||
if (request.body != null) {
|
||
const totalBytes = getTotalBytes(request);
|
||
if (typeof totalBytes === 'number') {
|
||
contentLengthValue = String(totalBytes);
|
||
}
|
||
}
|
||
if (contentLengthValue) {
|
||
headers.set('Content-Length', contentLengthValue);
|
||
}
|
||
|
||
// HTTP-network-or-cache fetch step 2.11
|
||
if (!headers.has('User-Agent')) {
|
||
headers.set('User-Agent', 'node-fetch/1.0 (+https://github.com/bitinn/node-fetch)');
|
||
}
|
||
|
||
// HTTP-network-or-cache fetch step 2.15
|
||
if (request.compress && !headers.has('Accept-Encoding')) {
|
||
headers.set('Accept-Encoding', 'gzip,deflate');
|
||
}
|
||
|
||
let agent = request.agent;
|
||
if (typeof agent === 'function') {
|
||
agent = agent(parsedURL);
|
||
}
|
||
|
||
if (!headers.has('Connection') && !agent) {
|
||
headers.set('Connection', 'close');
|
||
}
|
||
|
||
// HTTP-network fetch step 4.2
|
||
// chunked encoding is handled by Node.js
|
||
|
||
return Object.assign({}, parsedURL, {
|
||
method: request.method,
|
||
headers: exportNodeCompatibleHeaders(headers),
|
||
agent
|
||
});
|
||
}
|
||
|
||
/**
|
||
* abort-error.js
|
||
*
|
||
* AbortError interface for cancelled requests
|
||
*/
|
||
|
||
/**
|
||
* Create AbortError instance
|
||
*
|
||
* @param String message Error message for human
|
||
* @return AbortError
|
||
*/
|
||
function AbortError(message) {
|
||
Error.call(this, message);
|
||
|
||
this.type = 'aborted';
|
||
this.message = message;
|
||
|
||
// hide custom error implementation details from end-users
|
||
Error.captureStackTrace(this, this.constructor);
|
||
}
|
||
|
||
AbortError.prototype = Object.create(Error.prototype);
|
||
AbortError.prototype.constructor = AbortError;
|
||
AbortError.prototype.name = 'AbortError';
|
||
|
||
// fix an issue where "PassThrough", "resolve" aren't a named export for node <10
|
||
const PassThrough$1 = Stream.PassThrough;
|
||
const resolve_url = Url.resolve;
|
||
|
||
/**
|
||
* Fetch function
|
||
*
|
||
* @param Mixed url Absolute url or Request instance
|
||
* @param Object opts Fetch options
|
||
* @return Promise
|
||
*/
|
||
function fetch(url, opts) {
|
||
|
||
// allow custom promise
|
||
if (!fetch.Promise) {
|
||
throw new Error('native promise missing, set fetch.Promise to your favorite alternative');
|
||
}
|
||
|
||
Body.Promise = fetch.Promise;
|
||
|
||
// wrap http.request into fetch
|
||
return new fetch.Promise(function (resolve, reject) {
|
||
// build request object
|
||
const request = new Request(url, opts);
|
||
const options = getNodeRequestOptions(request);
|
||
|
||
const send = (options.protocol === 'https:' ? https : http).request;
|
||
const signal = request.signal;
|
||
|
||
let response = null;
|
||
|
||
const abort = function abort() {
|
||
let error = new AbortError('The user aborted a request.');
|
||
reject(error);
|
||
if (request.body && request.body instanceof Stream.Readable) {
|
||
request.body.destroy(error);
|
||
}
|
||
if (!response || !response.body) return;
|
||
response.body.emit('error', error);
|
||
};
|
||
|
||
if (signal && signal.aborted) {
|
||
abort();
|
||
return;
|
||
}
|
||
|
||
const abortAndFinalize = function abortAndFinalize() {
|
||
abort();
|
||
finalize();
|
||
};
|
||
|
||
// send request
|
||
const req = send(options);
|
||
let reqTimeout;
|
||
|
||
if (signal) {
|
||
signal.addEventListener('abort', abortAndFinalize);
|
||
}
|
||
|
||
function finalize() {
|
||
req.abort();
|
||
if (signal) signal.removeEventListener('abort', abortAndFinalize);
|
||
clearTimeout(reqTimeout);
|
||
}
|
||
|
||
if (request.timeout) {
|
||
req.once('socket', function (socket) {
|
||
reqTimeout = setTimeout(function () {
|
||
reject(new FetchError(`network timeout at: ${request.url}`, 'request-timeout'));
|
||
finalize();
|
||
}, request.timeout);
|
||
});
|
||
}
|
||
|
||
req.on('error', function (err) {
|
||
reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, 'system', err));
|
||
finalize();
|
||
});
|
||
|
||
req.on('response', function (res) {
|
||
clearTimeout(reqTimeout);
|
||
|
||
const headers = createHeadersLenient(res.headers);
|
||
|
||
// HTTP fetch step 5
|
||
if (fetch.isRedirect(res.statusCode)) {
|
||
// HTTP fetch step 5.2
|
||
const location = headers.get('Location');
|
||
|
||
// HTTP fetch step 5.3
|
||
const locationURL = location === null ? null : resolve_url(request.url, location);
|
||
|
||
// HTTP fetch step 5.5
|
||
switch (request.redirect) {
|
||
case 'error':
|
||
reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request.url}`, 'no-redirect'));
|
||
finalize();
|
||
return;
|
||
case 'manual':
|
||
// node-fetch-specific step: make manual redirect a bit easier to use by setting the Location header value to the resolved URL.
|
||
if (locationURL !== null) {
|
||
// handle corrupted header
|
||
try {
|
||
headers.set('Location', locationURL);
|
||
} catch (err) {
|
||
// istanbul ignore next: nodejs server prevent invalid response headers, we can't test this through normal request
|
||
reject(err);
|
||
}
|
||
}
|
||
break;
|
||
case 'follow':
|
||
// HTTP-redirect fetch step 2
|
||
if (locationURL === null) {
|
||
break;
|
||
}
|
||
|
||
// HTTP-redirect fetch step 5
|
||
if (request.counter >= request.follow) {
|
||
reject(new FetchError(`maximum redirect reached at: ${request.url}`, 'max-redirect'));
|
||
finalize();
|
||
return;
|
||
}
|
||
|
||
// HTTP-redirect fetch step 6 (counter increment)
|
||
// Create a new Request object.
|
||
const requestOpts = {
|
||
headers: new Headers(request.headers),
|
||
follow: request.follow,
|
||
counter: request.counter + 1,
|
||
agent: request.agent,
|
||
compress: request.compress,
|
||
method: request.method,
|
||
body: request.body,
|
||
signal: request.signal,
|
||
timeout: request.timeout,
|
||
size: request.size
|
||
};
|
||
|
||
// HTTP-redirect fetch step 9
|
||
if (res.statusCode !== 303 && request.body && getTotalBytes(request) === null) {
|
||
reject(new FetchError('Cannot follow redirect with body being a readable stream', 'unsupported-redirect'));
|
||
finalize();
|
||
return;
|
||
}
|
||
|
||
// HTTP-redirect fetch step 11
|
||
if (res.statusCode === 303 || (res.statusCode === 301 || res.statusCode === 302) && request.method === 'POST') {
|
||
requestOpts.method = 'GET';
|
||
requestOpts.body = undefined;
|
||
requestOpts.headers.delete('content-length');
|
||
}
|
||
|
||
// HTTP-redirect fetch step 15
|
||
resolve(fetch(new Request(locationURL, requestOpts)));
|
||
finalize();
|
||
return;
|
||
}
|
||
}
|
||
|
||
// prepare response
|
||
res.once('end', function () {
|
||
if (signal) signal.removeEventListener('abort', abortAndFinalize);
|
||
});
|
||
let body = res.pipe(new PassThrough$1());
|
||
|
||
const response_options = {
|
||
url: request.url,
|
||
status: res.statusCode,
|
||
statusText: res.statusMessage,
|
||
headers: headers,
|
||
size: request.size,
|
||
timeout: request.timeout,
|
||
counter: request.counter
|
||
};
|
||
|
||
// HTTP-network fetch step 12.1.1.3
|
||
const codings = headers.get('Content-Encoding');
|
||
|
||
// HTTP-network fetch step 12.1.1.4: handle content codings
|
||
|
||
// in following scenarios we ignore compression support
|
||
// 1. compression support is disabled
|
||
// 2. HEAD request
|
||
// 3. no Content-Encoding header
|
||
// 4. no content response (204)
|
||
// 5. content not modified response (304)
|
||
if (!request.compress || request.method === 'HEAD' || codings === null || res.statusCode === 204 || res.statusCode === 304) {
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
return;
|
||
}
|
||
|
||
// For Node v6+
|
||
// Be less strict when decoding compressed responses, since sometimes
|
||
// servers send slightly invalid responses that are still accepted
|
||
// by common browsers.
|
||
// Always using Z_SYNC_FLUSH is what cURL does.
|
||
const zlibOptions = {
|
||
flush: zlib.Z_SYNC_FLUSH,
|
||
finishFlush: zlib.Z_SYNC_FLUSH
|
||
};
|
||
|
||
// for gzip
|
||
if (codings == 'gzip' || codings == 'x-gzip') {
|
||
body = body.pipe(zlib.createGunzip(zlibOptions));
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
return;
|
||
}
|
||
|
||
// for deflate
|
||
if (codings == 'deflate' || codings == 'x-deflate') {
|
||
// handle the infamous raw deflate response from old servers
|
||
// a hack for old IIS and Apache servers
|
||
const raw = res.pipe(new PassThrough$1());
|
||
raw.once('data', function (chunk) {
|
||
// see http://stackoverflow.com/questions/37519828
|
||
if ((chunk[0] & 0x0F) === 0x08) {
|
||
body = body.pipe(zlib.createInflate());
|
||
} else {
|
||
body = body.pipe(zlib.createInflateRaw());
|
||
}
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
});
|
||
return;
|
||
}
|
||
|
||
// for br
|
||
if (codings == 'br' && typeof zlib.createBrotliDecompress === 'function') {
|
||
body = body.pipe(zlib.createBrotliDecompress());
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
return;
|
||
}
|
||
|
||
// otherwise, use response as-is
|
||
response = new Response(body, response_options);
|
||
resolve(response);
|
||
});
|
||
|
||
writeToStream(req, request);
|
||
});
|
||
}
|
||
/**
|
||
* Redirect code matching
|
||
*
|
||
* @param Number code Status code
|
||
* @return Boolean
|
||
*/
|
||
fetch.isRedirect = function (code) {
|
||
return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
|
||
};
|
||
|
||
// expose Promise
|
||
fetch.Promise = global.Promise;
|
||
|
||
module.exports = exports = fetch;
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
exports.default = exports;
|
||
exports.Headers = Headers;
|
||
exports.Request = Request;
|
||
exports.Response = Response;
|
||
exports.FetchError = FetchError;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 470:
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||
return new (P || (P = Promise))(function (resolve, reject) {
|
||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||
});
|
||
};
|
||
var __importStar = (this && this.__importStar) || function (mod) {
|
||
if (mod && mod.__esModule) return mod;
|
||
var result = {};
|
||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||
result["default"] = mod;
|
||
return result;
|
||
};
|
||
Object.defineProperty(exports, "__esModule", { value: true });
|
||
const command_1 = __webpack_require__(431);
|
||
const os = __importStar(__webpack_require__(87));
|
||
const path = __importStar(__webpack_require__(622));
|
||
/**
|
||
* The code to exit an action
|
||
*/
|
||
var ExitCode;
|
||
(function (ExitCode) {
|
||
/**
|
||
* A code indicating that the action was successful
|
||
*/
|
||
ExitCode[ExitCode["Success"] = 0] = "Success";
|
||
/**
|
||
* A code indicating that the action was a failure
|
||
*/
|
||
ExitCode[ExitCode["Failure"] = 1] = "Failure";
|
||
})(ExitCode = exports.ExitCode || (exports.ExitCode = {}));
|
||
//-----------------------------------------------------------------------
|
||
// Variables
|
||
//-----------------------------------------------------------------------
|
||
/**
|
||
* Sets env variable for this action and future actions in the job
|
||
* @param name the name of the variable to set
|
||
* @param val the value of the variable. Non-string values will be converted to a string via JSON.stringify
|
||
*/
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
function exportVariable(name, val) {
|
||
const convertedVal = command_1.toCommandValue(val);
|
||
process.env[name] = convertedVal;
|
||
command_1.issueCommand('set-env', { name }, convertedVal);
|
||
}
|
||
exports.exportVariable = exportVariable;
|
||
/**
|
||
* Registers a secret which will get masked from logs
|
||
* @param secret value of the secret
|
||
*/
|
||
function setSecret(secret) {
|
||
command_1.issueCommand('add-mask', {}, secret);
|
||
}
|
||
exports.setSecret = setSecret;
|
||
/**
|
||
* Prepends inputPath to the PATH (for this action and future actions)
|
||
* @param inputPath
|
||
*/
|
||
function addPath(inputPath) {
|
||
command_1.issueCommand('add-path', {}, inputPath);
|
||
process.env['PATH'] = `${inputPath}${path.delimiter}${process.env['PATH']}`;
|
||
}
|
||
exports.addPath = addPath;
|
||
/**
|
||
* Gets the value of an input. The value is also trimmed.
|
||
*
|
||
* @param name name of the input to get
|
||
* @param options optional. See InputOptions.
|
||
* @returns string
|
||
*/
|
||
function getInput(name, options) {
|
||
const val = process.env[`INPUT_${name.replace(/ /g, '_').toUpperCase()}`] || '';
|
||
if (options && options.required && !val) {
|
||
throw new Error(`Input required and not supplied: ${name}`);
|
||
}
|
||
return val.trim();
|
||
}
|
||
exports.getInput = getInput;
|
||
/**
|
||
* Sets the value of an output.
|
||
*
|
||
* @param name name of the output to set
|
||
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
|
||
*/
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
function setOutput(name, value) {
|
||
command_1.issueCommand('set-output', { name }, value);
|
||
}
|
||
exports.setOutput = setOutput;
|
||
/**
|
||
* Enables or disables the echoing of commands into stdout for the rest of the step.
|
||
* Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
|
||
*
|
||
*/
|
||
function setCommandEcho(enabled) {
|
||
command_1.issue('echo', enabled ? 'on' : 'off');
|
||
}
|
||
exports.setCommandEcho = setCommandEcho;
|
||
//-----------------------------------------------------------------------
|
||
// Results
|
||
//-----------------------------------------------------------------------
|
||
/**
|
||
* Sets the action status to failed.
|
||
* When the action exits it will be with an exit code of 1
|
||
* @param message add error issue message
|
||
*/
|
||
function setFailed(message) {
|
||
process.exitCode = ExitCode.Failure;
|
||
error(message);
|
||
}
|
||
exports.setFailed = setFailed;
|
||
//-----------------------------------------------------------------------
|
||
// Logging Commands
|
||
//-----------------------------------------------------------------------
|
||
/**
|
||
* Gets whether Actions Step Debug is on or not
|
||
*/
|
||
function isDebug() {
|
||
return process.env['RUNNER_DEBUG'] === '1';
|
||
}
|
||
exports.isDebug = isDebug;
|
||
/**
|
||
* Writes debug message to user log
|
||
* @param message debug message
|
||
*/
|
||
function debug(message) {
|
||
command_1.issueCommand('debug', {}, message);
|
||
}
|
||
exports.debug = debug;
|
||
/**
|
||
* Adds an error issue
|
||
* @param message error issue message. Errors will be converted to string via toString()
|
||
*/
|
||
function error(message) {
|
||
command_1.issue('error', message instanceof Error ? message.toString() : message);
|
||
}
|
||
exports.error = error;
|
||
/**
|
||
* Adds an warning issue
|
||
* @param message warning issue message. Errors will be converted to string via toString()
|
||
*/
|
||
function warning(message) {
|
||
command_1.issue('warning', message instanceof Error ? message.toString() : message);
|
||
}
|
||
exports.warning = warning;
|
||
/**
|
||
* Writes info to log with console.log.
|
||
* @param message info message
|
||
*/
|
||
function info(message) {
|
||
process.stdout.write(message + os.EOL);
|
||
}
|
||
exports.info = info;
|
||
/**
|
||
* Begin an output group.
|
||
*
|
||
* Output until the next `groupEnd` will be foldable in this group
|
||
*
|
||
* @param name The name of the output group
|
||
*/
|
||
function startGroup(name) {
|
||
command_1.issue('group', name);
|
||
}
|
||
exports.startGroup = startGroup;
|
||
/**
|
||
* End an output group.
|
||
*/
|
||
function endGroup() {
|
||
command_1.issue('endgroup');
|
||
}
|
||
exports.endGroup = endGroup;
|
||
/**
|
||
* Wrap an asynchronous function call in a group.
|
||
*
|
||
* Returns the same type as the function itself.
|
||
*
|
||
* @param name The name of the group
|
||
* @param fn The function to wrap in the group
|
||
*/
|
||
function group(name, fn) {
|
||
return __awaiter(this, void 0, void 0, function* () {
|
||
startGroup(name);
|
||
let result;
|
||
try {
|
||
result = yield fn();
|
||
}
|
||
finally {
|
||
endGroup();
|
||
}
|
||
return result;
|
||
});
|
||
}
|
||
exports.group = group;
|
||
//-----------------------------------------------------------------------
|
||
// Wrapper action state
|
||
//-----------------------------------------------------------------------
|
||
/**
|
||
* Saves state for current action, the state can only be retrieved by this action's post job execution.
|
||
*
|
||
* @param name name of the state to store
|
||
* @param value value to store. Non-string values will be converted to a string via JSON.stringify
|
||
*/
|
||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||
function saveState(name, value) {
|
||
command_1.issueCommand('save-state', { name }, value);
|
||
}
|
||
exports.saveState = saveState;
|
||
/**
|
||
* Gets the value of an state set by this action's main execution.
|
||
*
|
||
* @param name name of the state to get
|
||
* @returns string
|
||
*/
|
||
function getState(name) {
|
||
return process.env[`STATE_${name}`] || '';
|
||
}
|
||
exports.getState = getState;
|
||
//# sourceMappingURL=core.js.map
|
||
|
||
/***/ }),
|
||
|
||
/***/ 475:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = shift
|
||
|
||
function shift (stream) {
|
||
var rs = stream._readableState
|
||
if (!rs) return null
|
||
return (rs.objectMode || typeof stream._duplexState === 'number') ? stream.read() : stream.read(getStateLength(rs))
|
||
}
|
||
|
||
function getStateLength (state) {
|
||
if (state.buffer.length) {
|
||
// Since node 6.3.0 state.buffer is a BufferList not an array
|
||
if (state.buffer.head) {
|
||
return state.buffer.head.data.length
|
||
}
|
||
|
||
return state.buffer[0].length
|
||
}
|
||
|
||
return state.length
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 487:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = assert
|
||
|
||
class AssertionError extends Error {}
|
||
AssertionError.prototype.name = 'AssertionError'
|
||
|
||
/**
|
||
* Minimal assert function
|
||
* @param {any} t Value to check if falsy
|
||
* @param {string=} m Optional assertion error message
|
||
* @throws {AssertionError}
|
||
*/
|
||
function assert (t, m) {
|
||
if (!t) {
|
||
var err = new AssertionError(m)
|
||
if (Error.captureStackTrace) Error.captureStackTrace(err, assert)
|
||
throw err
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 500:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = defer;
|
||
|
||
/**
|
||
* Runs provided function on next iteration of the event loop
|
||
*
|
||
* @param {function} fn - function to run
|
||
*/
|
||
function defer(fn)
|
||
{
|
||
var nextTick = typeof setImmediate == 'function'
|
||
? setImmediate
|
||
: (
|
||
typeof process == 'object' && typeof process.nextTick == 'function'
|
||
? process.nextTick
|
||
: null
|
||
);
|
||
|
||
if (nextTick)
|
||
{
|
||
nextTick(fn);
|
||
}
|
||
else
|
||
{
|
||
setTimeout(fn, 0);
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 512:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = {"application/1d-interleaved-parityfec":{"source":"iana"},"application/3gpdash-qoe-report+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/3gpp-ims+xml":{"source":"iana","compressible":true},"application/a2l":{"source":"iana"},"application/activemessage":{"source":"iana"},"application/activity+json":{"source":"iana","compressible":true},"application/alto-costmap+json":{"source":"iana","compressible":true},"application/alto-costmapfilter+json":{"source":"iana","compressible":true},"application/alto-directory+json":{"source":"iana","compressible":true},"application/alto-endpointcost+json":{"source":"iana","compressible":true},"application/alto-endpointcostparams+json":{"source":"iana","compressible":true},"application/alto-endpointprop+json":{"source":"iana","compressible":true},"application/alto-endpointpropparams+json":{"source":"iana","compressible":true},"application/alto-error+json":{"source":"iana","compressible":true},"application/alto-networkmap+json":{"source":"iana","compressible":true},"application/alto-networkmapfilter+json":{"source":"iana","compressible":true},"application/alto-updatestreamcontrol+json":{"source":"iana","compressible":true},"application/alto-updatestreamparams+json":{"source":"iana","compressible":true},"application/aml":{"source":"iana"},"application/andrew-inset":{"source":"iana","extensions":["ez"]},"application/applefile":{"source":"iana"},"application/applixware":{"source":"apache","extensions":["aw"]},"application/atf":{"source":"iana"},"application/atfx":{"source":"iana"},"application/atom+xml":{"source":"iana","compressible":true,"extensions":["atom"]},"application/atomcat+xml":{"source":"iana","compressible":true,"extensions":["atomcat"]},"application/atomdeleted+xml":{"source":"iana","compressible":true,"extensions":["atomdeleted"]},"application/atomicmail":{"source":"iana"},"application/atomsvc+xml":{"source":"iana","compressible":true,"extensions":["atomsvc"]},"application/atsc-dwd+xml":{"source":"iana","compressible":true,"extensions":["dwd"]},"application/atsc-dynamic-event-message":{"source":"iana"},"application/atsc-held+xml":{"source":"iana","compressible":true,"extensions":["held"]},"application/atsc-rdt+json":{"source":"iana","compressible":true},"application/atsc-rsat+xml":{"source":"iana","compressible":true,"extensions":["rsat"]},"application/atxml":{"source":"iana"},"application/auth-policy+xml":{"source":"iana","compressible":true},"application/bacnet-xdd+zip":{"source":"iana","compressible":false},"application/batch-smtp":{"source":"iana"},"application/bdoc":{"compressible":false,"extensions":["bdoc"]},"application/beep+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/calendar+json":{"source":"iana","compressible":true},"application/calendar+xml":{"source":"iana","compressible":true,"extensions":["xcs"]},"application/call-completion":{"source":"iana"},"application/cals-1840":{"source":"iana"},"application/cap+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/cbor":{"source":"iana"},"application/cbor-seq":{"source":"iana"},"application/cccex":{"source":"iana"},"application/ccmp+xml":{"source":"iana","compressible":true},"application/ccxml+xml":{"source":"iana","compressible":true,"extensions":["ccxml"]},"application/cdfx+xml":{"source":"iana","compressible":true,"extensions":["cdfx"]},"application/cdmi-capability":{"source":"iana","extensions":["cdmia"]},"application/cdmi-container":{"source":"iana","extensions":["cdmic"]},"application/cdmi-domain":{"source":"iana","extensions":["cdmid"]},"application/cdmi-object":{"source":"iana","extensions":["cdmio"]},"application/cdmi-queue":{"source":"iana","extensions":["cdmiq"]},"application/cdni":{"source":"iana"},"application/cea":{"source":"iana"},"application/cea-2018+xml":{"source":"iana","compressible":true},"application/cellml+xml":{"source":"iana","compressible":true},"application/cfw":{"source":"iana"},"application/clue+xml":{"source":"iana","compressible":true},"application/clue_info+xml":{"source":"iana","compressible":true},"application/cms":{"source":"iana"},"application/cnrp+xml":{"source":"iana","compressible":true},"application/coap-group+json":{"source":"iana","compressible":true},"application/coap-payload":{"source":"iana"},"application/commonground":{"source":"iana"},"application/conference-info+xml":{"source":"iana","compressible":true},"application/cose":{"source":"iana"},"application/cose-key":{"source":"iana"},"application/cose-key-set":{"source":"iana"},"application/cpl+xml":{"source":"iana","compressible":true},"application/csrattrs":{"source":"iana"},"application/csta+xml":{"source":"iana","compressible":true},"application/cstadata+xml":{"source":"iana","compressible":true},"application/csvm+json":{"source":"iana","compressible":true},"application/cu-seeme":{"source":"apache","extensions":["cu"]},"application/cwt":{"source":"iana"},"application/cybercash":{"source":"iana"},"application/dart":{"compressible":true},"application/dash+xml":{"source":"iana","compressible":true,"extensions":["mpd"]},"application/dashdelta":{"source":"iana"},"application/davmount+xml":{"source":"iana","compressible":true,"extensions":["davmount"]},"application/dca-rft":{"source":"iana"},"application/dcd":{"source":"iana"},"application/dec-dx":{"source":"iana"},"application/dialog-info+xml":{"source":"iana","compressible":true},"application/dicom":{"source":"iana"},"application/dicom+json":{"source":"iana","compressible":true},"application/dicom+xml":{"source":"iana","compressible":true},"application/dii":{"source":"iana"},"application/dit":{"source":"iana"},"application/dns":{"source":"iana"},"application/dns+json":{"source":"iana","compressible":true},"application/dns-message":{"source":"iana"},"application/docbook+xml":{"source":"apache","compressible":true,"extensions":["dbk"]},"application/dots+cbor":{"source":"iana"},"application/dskpp+xml":{"source":"iana","compressible":true},"application/dssc+der":{"source":"iana","extensions":["dssc"]},"application/dssc+xml":{"source":"iana","compressible":true,"extensions":["xdssc"]},"application/dvcs":{"source":"iana"},"application/ecmascript":{"source":"iana","compressible":true,"extensions":["ecma","es"]},"application/edi-consent":{"source":"iana"},"application/edi-x12":{"source":"iana","compressible":false},"application/edifact":{"source":"iana","compressible":false},"application/efi":{"source":"iana"},"application/emergencycalldata.comment+xml":{"source":"iana","compressible":true},"application/emergencycalldata.control+xml":{"source":"iana","compressible":true},"application/emergencycalldata.deviceinfo+xml":{"source":"iana","compressible":true},"application/emergencycalldata.ecall.msd":{"source":"iana"},"application/emergencycalldata.providerinfo+xml":{"source":"iana","compressible":true},"application/emergencycalldata.serviceinfo+xml":{"source":"iana","compressible":true},"application/emergencycalldata.subscriberinfo+xml":{"source":"iana","compressible":true},"application/emergencycalldata.veds+xml":{"source":"iana","compressible":true},"application/emma+xml":{"source":"iana","compressible":true,"extensions":["emma"]},"application/emotionml+xml":{"source":"iana","compressible":true,"extensions":["emotionml"]},"application/encaprtp":{"source":"iana"},"application/epp+xml":{"source":"iana","compressible":true},"application/epub+zip":{"source":"iana","compressible":false,"extensions":["epub"]},"application/eshop":{"source":"iana"},"application/exi":{"source":"iana","extensions":["exi"]},"application/expect-ct-report+json":{"source":"iana","compressible":true},"application/fastinfoset":{"source":"iana"},"application/fastsoap":{"source":"iana"},"application/fdt+xml":{"source":"iana","compressible":true,"extensions":["fdt"]},"application/fhir+json":{"source":"iana","charset":"UTF-8","compressible":true},"application/fhir+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/fido.trusted-apps+json":{"compressible":true},"application/fits":{"source":"iana"},"application/flexfec":{"source":"iana"},"application/font-sfnt":{"source":"iana"},"application/font-tdpfr":{"source":"iana","extensions":["pfr"]},"application/font-woff":{"source":"iana","compressible":false},"application/framework-attributes+xml":{"source":"iana","compressible":true},"application/geo+json":{"source":"iana","compressible":true,"extensions":["geojson"]},"application/geo+json-seq":{"source":"iana"},"application/geopackage+sqlite3":{"source":"iana"},"application/geoxacml+xml":{"source":"iana","compressible":true},"application/gltf-buffer":{"source":"iana"},"application/gml+xml":{"source":"iana","compressible":true,"extensions":["gml"]},"application/gpx+xml":{"source":"apache","compressible":true,"extensions":["gpx"]},"application/gxf":{"source":"apache","extensions":["gxf"]},"application/gzip":{"source":"iana","compressible":false,"extensions":["gz"]},"application/h224":{"source":"iana"},"application/held+xml":{"source":"iana","compressible":true},"application/hjson":{"extensions":["hjson"]},"application/http":{"source":"iana"},"application/hyperstudio":{"source":"iana","extensions":["stk"]},"application/ibe-key-request+xml":{"source":"iana","compressible":true},"application/ibe-pkg-reply+xml":{"source":"iana","compressible":true},"application/ibe-pp-data":{"source":"iana"},"application/iges":{"source":"iana"},"application/im-iscomposing+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/index":{"source":"iana"},"application/index.cmd":{"source":"iana"},"application/index.obj":{"source":"iana"},"application/index.response":{"source":"iana"},"application/index.vnd":{"source":"iana"},"application/inkml+xml":{"source":"iana","compressible":true,"extensions":["ink","inkml"]},"application/iotp":{"source":"iana"},"application/ipfix":{"source":"iana","extensions":["ipfix"]},"application/ipp":{"source":"iana"},"application/isup":{"source":"iana"},"application/its+xml":{"source":"iana","compressible":true,"extensions":["its"]},"application/java-archive":{"source":"apache","compressible":false,"extensions":["jar","war","ear"]},"application/java-serialized-object":{"source":"apache","compressible":false,"extensions":["ser"]},"application/java-vm":{"source":"apache","compressible":false,"extensions":["class"]},"application/javascript":{"source":"iana","charset":"UTF-8","compressible":true,"extensions":["js","mjs"]},"application/jf2feed+json":{"source":"iana","compressible":true},"application/jose":{"source":"iana"},"application/jose+json":{"source":"iana","compressible":true},"application/jrd+json":{"source":"iana","compressible":true},"application/json":{"source":"iana","charset":"UTF-8","compressible":true,"extensions":["json","map"]},"application/json-patch+json":{"source":"iana","compressible":true},"application/json-seq":{"source":"iana"},"application/json5":{"extensions":["json5"]},"application/jsonml+json":{"source":"apache","compressible":true,"extensions":["jsonml"]},"application/jwk+json":{"source":"iana","compressible":true},"application/jwk-set+json":{"source":"iana","compressible":true},"application/jwt":{"source":"iana"},"application/kpml-request+xml":{"source":"iana","compressible":true},"application/kpml-response+xml":{"source":"iana","compressible":true},"application/ld+json":{"source":"iana","compressible":true,"extensions":["jsonld"]},"application/lgr+xml":{"source":"iana","compressible":true,"extensions":["lgr"]},"application/link-format":{"source":"iana"},"application/load-control+xml":{"source":"iana","compressible":true},"application/lost+xml":{"source":"iana","compressible":true,"extensions":["lostxml"]},"application/lostsync+xml":{"source":"iana","compressible":true},"application/lpf+zip":{"source":"iana","compressible":false},"application/lxf":{"source":"iana"},"application/mac-binhex40":{"source":"iana","extensions":["hqx"]},"application/mac-compactpro":{"source":"apache","extensions":["cpt"]},"application/macwriteii":{"source":"iana"},"application/mads+xml":{"source":"iana","compressible":true,"extensions":["mads"]},"application/manifest+json":{"charset":"UTF-8","compressible":true,"extensions":["webmanifest"]},"application/marc":{"source":"iana","extensions":["mrc"]},"application/marcxml+xml":{"source":"iana","compressible":true,"extensions":["mrcx"]},"application/mathematica":{"source":"iana","extensions":["ma","nb","mb"]},"application/mathml+xml":{"source":"iana","compressible":true,"extensions":["mathml"]},"application/mathml-content+xml":{"source":"iana","compressible":true},"application/mathml-presentation+xml":{"source":"iana","compressible":true},"application/mbms-associated-procedure-description+xml":{"source":"iana","compressible":true},"application/mbms-deregister+xml":{"source":"iana","compressible":true},"application/mbms-envelope+xml":{"source":"iana","compressible":true},"application/mbms-msk+xml":{"source":"iana","compressible":true},"application/mbms-msk-response+xml":{"source":"iana","compressible":true},"application/mbms-protection-description+xml":{"source":"iana","compressible":true},"application/mbms-reception-report+xml":{"source":"iana","compressible":true},"application/mbms-register+xml":{"source":"iana","compressible":true},"application/mbms-register-response+xml":{"source":"iana","compressible":true},"application/mbms-schedule+xml":{"source":"iana","compressible":true},"application/mbms-user-service-description+xml":{"source":"iana","compressible":true},"application/mbox":{"source":"iana","extensions":["mbox"]},"application/media-policy-dataset+xml":{"source":"iana","compressible":true},"application/media_control+xml":{"source":"iana","compressible":true},"application/mediaservercontrol+xml":{"source":"iana","compressible":true,"extensions":["mscml"]},"application/merge-patch+json":{"source":"iana","compressible":true},"application/metalink+xml":{"source":"apache","compressible":true,"extensions":["metalink"]},"application/metalink4+xml":{"source":"iana","compressible":true,"extensions":["meta4"]},"application/mets+xml":{"source":"iana","compressible":true,"extensions":["mets"]},"application/mf4":{"source":"iana"},"application/mikey":{"source":"iana"},"application/mipc":{"source":"iana"},"application/mmt-aei+xml":{"source":"iana","compressible":true,"extensions":["maei"]},"application/mmt-usd+xml":{"source":"iana","compressible":true,"extensions":["musd"]},"application/mods+xml":{"source":"iana","compressible":true,"extensions":["mods"]},"application/moss-keys":{"source":"iana"},"application/moss-signature":{"source":"iana"},"application/mosskey-data":{"source":"iana"},"application/mosskey-request":{"source":"iana"},"application/mp21":{"source":"iana","extensions":["m21","mp21"]},"application/mp4":{"source":"iana","extensions":["mp4s","m4p"]},"application/mpeg4-generic":{"source":"iana"},"application/mpeg4-iod":{"source":"iana"},"application/mpeg4-iod-xmt":{"source":"iana"},"application/mrb-consumer+xml":{"source":"iana","compressible":true,"extensions":["xdf"]},"application/mrb-publish+xml":{"source":"iana","compressible":true,"extensions":["xdf"]},"application/msc-ivr+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/msc-mixer+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/msword":{"source":"iana","compressible":false,"extensions":["doc","dot"]},"application/mud+json":{"source":"iana","compressible":true},"application/multipart-core":{"source":"iana"},"application/mxf":{"source":"iana","extensions":["mxf"]},"application/n-quads":{"source":"iana","extensions":["nq"]},"application/n-triples":{"source":"iana","extensions":["nt"]},"application/nasdata":{"source":"iana"},"application/news-checkgroups":{"source":"iana","charset":"US-ASCII"},"application/news-groupinfo":{"source":"iana","charset":"US-ASCII"},"application/news-transmission":{"source":"iana"},"application/nlsml+xml":{"source":"iana","compressible":true},"application/node":{"source":"iana","extensions":["cjs"]},"application/nss":{"source":"iana"},"application/ocsp-request":{"source":"iana"},"application/ocsp-response":{"source":"iana"},"application/octet-stream":{"source":"iana","compressible":false,"extensions":["bin","dms","lrf","mar","so","dist","distz","pkg","bpk","dump","elc","deploy","exe","dll","deb","dmg","iso","img","msi","msp","msm","buffer"]},"application/oda":{"source":"iana","extensions":["oda"]},"application/odm+xml":{"source":"iana","compressible":true},"application/odx":{"source":"iana"},"application/oebps-package+xml":{"source":"iana","compressible":true,"extensions":["opf"]},"application/ogg":{"source":"iana","compressible":false,"extensions":["ogx"]},"application/omdoc+xml":{"source":"apache","compressible":true,"extensions":["omdoc"]},"application/onenote":{"source":"apache","extensions":["onetoc","onetoc2","onetmp","onepkg"]},"application/oscore":{"source":"iana"},"application/oxps":{"source":"iana","extensions":["oxps"]},"application/p2p-overlay+xml":{"source":"iana","compressible":true,"extensions":["relo"]},"application/parityfec":{"source":"iana"},"application/passport":{"source":"iana"},"application/patch-ops-error+xml":{"source":"iana","compressible":true,"extensions":["xer"]},"application/pdf":{"source":"iana","compressible":false,"extensions":["pdf"]},"application/pdx":{"source":"iana"},"application/pem-certificate-chain":{"source":"iana"},"application/pgp-encrypted":{"source":"iana","compressible":false,"extensions":["pgp"]},"application/pgp-keys":{"source":"iana"},"application/pgp-signature":{"source":"iana","extensions":["asc","sig"]},"application/pics-rules":{"source":"apache","extensions":["prf"]},"application/pidf+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/pidf-diff+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/pkcs10":{"source":"iana","extensions":["p10"]},"application/pkcs12":{"source":"iana"},"application/pkcs7-mime":{"source":"iana","extensions":["p7m","p7c"]},"application/pkcs7-signature":{"source":"iana","extensions":["p7s"]},"application/pkcs8":{"source":"iana","extensions":["p8"]},"application/pkcs8-encrypted":{"source":"iana"},"application/pkix-attr-cert":{"source":"iana","extensions":["ac"]},"application/pkix-cert":{"source":"iana","extensions":["cer"]},"application/pkix-crl":{"source":"iana","extensions":["crl"]},"application/pkix-pkipath":{"source":"iana","extensions":["pkipath"]},"application/pkixcmp":{"source":"iana","extensions":["pki"]},"application/pls+xml":{"source":"iana","compressible":true,"extensions":["pls"]},"application/poc-settings+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/postscript":{"source":"iana","compressible":true,"extensions":["ai","eps","ps"]},"application/ppsp-tracker+json":{"source":"iana","compressible":true},"application/problem+json":{"source":"iana","compressible":true},"application/problem+xml":{"source":"iana","compressible":true},"application/provenance+xml":{"source":"iana","compressible":true,"extensions":["provx"]},"application/prs.alvestrand.titrax-sheet":{"source":"iana"},"application/prs.cww":{"source":"iana","extensions":["cww"]},"application/prs.hpub+zip":{"source":"iana","compressible":false},"application/prs.nprend":{"source":"iana"},"application/prs.plucker":{"source":"iana"},"application/prs.rdf-xml-crypt":{"source":"iana"},"application/prs.xsf+xml":{"source":"iana","compressible":true},"application/pskc+xml":{"source":"iana","compressible":true,"extensions":["pskcxml"]},"application/pvd+json":{"source":"iana","compressible":true},"application/qsig":{"source":"iana"},"application/raml+yaml":{"compressible":true,"extensions":["raml"]},"application/raptorfec":{"source":"iana"},"application/rdap+json":{"source":"iana","compressible":true},"application/rdf+xml":{"source":"iana","compressible":true,"extensions":["rdf","owl"]},"application/reginfo+xml":{"source":"iana","compressible":true,"extensions":["rif"]},"application/relax-ng-compact-syntax":{"source":"iana","extensions":["rnc"]},"application/remote-printing":{"source":"iana"},"application/reputon+json":{"source":"iana","compressible":true},"application/resource-lists+xml":{"source":"iana","compressible":true,"extensions":["rl"]},"application/resource-lists-diff+xml":{"source":"iana","compressible":true,"extensions":["rld"]},"application/rfc+xml":{"source":"iana","compressible":true},"application/riscos":{"source":"iana"},"application/rlmi+xml":{"source":"iana","compressible":true},"application/rls-services+xml":{"source":"iana","compressible":true,"extensions":["rs"]},"application/route-apd+xml":{"source":"iana","compressible":true,"extensions":["rapd"]},"application/route-s-tsid+xml":{"source":"iana","compressible":true,"extensions":["sls"]},"application/route-usd+xml":{"source":"iana","compressible":true,"extensions":["rusd"]},"application/rpki-ghostbusters":{"source":"iana","extensions":["gbr"]},"application/rpki-manifest":{"source":"iana","extensions":["mft"]},"application/rpki-publication":{"source":"iana"},"application/rpki-roa":{"source":"iana","extensions":["roa"]},"application/rpki-updown":{"source":"iana"},"application/rsd+xml":{"source":"apache","compressible":true,"extensions":["rsd"]},"application/rss+xml":{"source":"apache","compressible":true,"extensions":["rss"]},"application/rtf":{"source":"iana","compressible":true,"extensions":["rtf"]},"application/rtploopback":{"source":"iana"},"application/rtx":{"source":"iana"},"application/samlassertion+xml":{"source":"iana","compressible":true},"application/samlmetadata+xml":{"source":"iana","compressible":true},"application/sbe":{"source":"iana"},"application/sbml+xml":{"source":"iana","compressible":true,"extensions":["sbml"]},"application/scaip+xml":{"source":"iana","compressible":true},"application/scim+json":{"source":"iana","compressible":true},"application/scvp-cv-request":{"source":"iana","extensions":["scq"]},"application/scvp-cv-response":{"source":"iana","extensions":["scs"]},"application/scvp-vp-request":{"source":"iana","extensions":["spq"]},"application/scvp-vp-response":{"source":"iana","extensions":["spp"]},"application/sdp":{"source":"iana","extensions":["sdp"]},"application/secevent+jwt":{"source":"iana"},"application/senml+cbor":{"source":"iana"},"application/senml+json":{"source":"iana","compressible":true},"application/senml+xml":{"source":"iana","compressible":true,"extensions":["senmlx"]},"application/senml-etch+cbor":{"source":"iana"},"application/senml-etch+json":{"source":"iana","compressible":true},"application/senml-exi":{"source":"iana"},"application/sensml+cbor":{"source":"iana"},"application/sensml+json":{"source":"iana","compressible":true},"application/sensml+xml":{"source":"iana","compressible":true,"extensions":["sensmlx"]},"application/sensml-exi":{"source":"iana"},"application/sep+xml":{"source":"iana","compressible":true},"application/sep-exi":{"source":"iana"},"application/session-info":{"source":"iana"},"application/set-payment":{"source":"iana"},"application/set-payment-initiation":{"source":"iana","extensions":["setpay"]},"application/set-registration":{"source":"iana"},"application/set-registration-initiation":{"source":"iana","extensions":["setreg"]},"application/sgml":{"source":"iana"},"application/sgml-open-catalog":{"source":"iana"},"application/shf+xml":{"source":"iana","compressible":true,"extensions":["shf"]},"application/sieve":{"source":"iana","extensions":["siv","sieve"]},"application/simple-filter+xml":{"source":"iana","compressible":true},"application/simple-message-summary":{"source":"iana"},"application/simplesymbolcontainer":{"source":"iana"},"application/sipc":{"source":"iana"},"application/slate":{"source":"iana"},"application/smil":{"source":"iana"},"application/smil+xml":{"source":"iana","compressible":true,"extensions":["smi","smil"]},"application/smpte336m":{"source":"iana"},"application/soap+fastinfoset":{"source":"iana"},"application/soap+xml":{"source":"iana","compressible":true},"application/sparql-query":{"source":"iana","extensions":["rq"]},"application/sparql-results+xml":{"source":"iana","compressible":true,"extensions":["srx"]},"application/spirits-event+xml":{"source":"iana","compressible":true},"application/sql":{"source":"iana"},"application/srgs":{"source":"iana","extensions":["gram"]},"application/srgs+xml":{"source":"iana","compressible":true,"extensions":["grxml"]},"application/sru+xml":{"source":"iana","compressible":true,"extensions":["sru"]},"application/ssdl+xml":{"source":"apache","compressible":true,"extensions":["ssdl"]},"application/ssml+xml":{"source":"iana","compressible":true,"extensions":["ssml"]},"application/stix+json":{"source":"iana","compressible":true},"application/swid+xml":{"source":"iana","compressible":true,"extensions":["swidtag"]},"application/tamp-apex-update":{"source":"iana"},"application/tamp-apex-update-confirm":{"source":"iana"},"application/tamp-community-update":{"source":"iana"},"application/tamp-community-update-confirm":{"source":"iana"},"application/tamp-error":{"source":"iana"},"application/tamp-sequence-adjust":{"source":"iana"},"application/tamp-sequence-adjust-confirm":{"source":"iana"},"application/tamp-status-query":{"source":"iana"},"application/tamp-status-response":{"source":"iana"},"application/tamp-update":{"source":"iana"},"application/tamp-update-confirm":{"source":"iana"},"application/tar":{"compressible":true},"application/taxii+json":{"source":"iana","compressible":true},"application/td+json":{"source":"iana","compressible":true},"application/tei+xml":{"source":"iana","compressible":true,"extensions":["tei","teicorpus"]},"application/tetra_isi":{"source":"iana"},"application/thraud+xml":{"source":"iana","compressible":true,"extensions":["tfi"]},"application/timestamp-query":{"source":"iana"},"application/timestamp-reply":{"source":"iana"},"application/timestamped-data":{"source":"iana","extensions":["tsd"]},"application/tlsrpt+gzip":{"source":"iana"},"application/tlsrpt+json":{"source":"iana","compressible":true},"application/tnauthlist":{"source":"iana"},"application/toml":{"compressible":true,"extensions":["toml"]},"application/trickle-ice-sdpfrag":{"source":"iana"},"application/trig":{"source":"iana"},"application/ttml+xml":{"source":"iana","compressible":true,"extensions":["ttml"]},"application/tve-trigger":{"source":"iana"},"application/tzif":{"source":"iana"},"application/tzif-leap":{"source":"iana"},"application/ulpfec":{"source":"iana"},"application/urc-grpsheet+xml":{"source":"iana","compressible":true},"application/urc-ressheet+xml":{"source":"iana","compressible":true,"extensions":["rsheet"]},"application/urc-targetdesc+xml":{"source":"iana","compressible":true},"application/urc-uisocketdesc+xml":{"source":"iana","compressible":true},"application/vcard+json":{"source":"iana","compressible":true},"application/vcard+xml":{"source":"iana","compressible":true},"application/vemmi":{"source":"iana"},"application/vividence.scriptfile":{"source":"apache"},"application/vnd.1000minds.decision-model+xml":{"source":"iana","compressible":true,"extensions":["1km"]},"application/vnd.3gpp-prose+xml":{"source":"iana","compressible":true},"application/vnd.3gpp-prose-pc3ch+xml":{"source":"iana","compressible":true},"application/vnd.3gpp-v2x-local-service-information":{"source":"iana"},"application/vnd.3gpp.access-transfer-events+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.bsf+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.gmop+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mc-signalling-ear":{"source":"iana"},"application/vnd.3gpp.mcdata-affiliation-command+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcdata-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcdata-payload":{"source":"iana"},"application/vnd.3gpp.mcdata-service-config+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcdata-signalling":{"source":"iana"},"application/vnd.3gpp.mcdata-ue-config+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcdata-user-profile+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-affiliation-command+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-floor-request+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-location-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-mbms-usage-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-service-config+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-signed+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-ue-config+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-ue-init-config+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcptt-user-profile+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-affiliation-command+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-affiliation-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-location-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-mbms-usage-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-service-config+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-transmission-request+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-ue-config+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mcvideo-user-profile+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.mid-call+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.pic-bw-large":{"source":"iana","extensions":["plb"]},"application/vnd.3gpp.pic-bw-small":{"source":"iana","extensions":["psb"]},"application/vnd.3gpp.pic-bw-var":{"source":"iana","extensions":["pvb"]},"application/vnd.3gpp.sms":{"source":"iana"},"application/vnd.3gpp.sms+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.srvcc-ext+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.srvcc-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.state-and-event-info+xml":{"source":"iana","compressible":true},"application/vnd.3gpp.ussd+xml":{"source":"iana","compressible":true},"application/vnd.3gpp2.bcmcsinfo+xml":{"source":"iana","compressible":true},"application/vnd.3gpp2.sms":{"source":"iana"},"application/vnd.3gpp2.tcap":{"source":"iana","extensions":["tcap"]},"application/vnd.3lightssoftware.imagescal":{"source":"iana"},"application/vnd.3m.post-it-notes":{"source":"iana","extensions":["pwn"]},"application/vnd.accpac.simply.aso":{"source":"iana","extensions":["aso"]},"application/vnd.accpac.simply.imp":{"source":"iana","extensions":["imp"]},"application/vnd.acucobol":{"source":"iana","extensions":["acu"]},"application/vnd.acucorp":{"source":"iana","extensions":["atc","acutc"]},"application/vnd.adobe.air-application-installer-package+zip":{"source":"apache","compressible":false,"extensions":["air"]},"application/vnd.adobe.flash.movie":{"source":"iana"},"application/vnd.adobe.formscentral.fcdt":{"source":"iana","extensions":["fcdt"]},"application/vnd.adobe.fxp":{"source":"iana","extensions":["fxp","fxpl"]},"application/vnd.adobe.partial-upload":{"source":"iana"},"application/vnd.adobe.xdp+xml":{"source":"iana","compressible":true,"extensions":["xdp"]},"application/vnd.adobe.xfdf":{"source":"iana","extensions":["xfdf"]},"application/vnd.aether.imp":{"source":"iana"},"application/vnd.afpc.afplinedata":{"source":"iana"},"application/vnd.afpc.afplinedata-pagedef":{"source":"iana"},"application/vnd.afpc.foca-charset":{"source":"iana"},"application/vnd.afpc.foca-codedfont":{"source":"iana"},"application/vnd.afpc.foca-codepage":{"source":"iana"},"application/vnd.afpc.modca":{"source":"iana"},"application/vnd.afpc.modca-formdef":{"source":"iana"},"application/vnd.afpc.modca-mediummap":{"source":"iana"},"application/vnd.afpc.modca-objectcontainer":{"source":"iana"},"application/vnd.afpc.modca-overlay":{"source":"iana"},"application/vnd.afpc.modca-pagesegment":{"source":"iana"},"application/vnd.ah-barcode":{"source":"iana"},"application/vnd.ahead.space":{"source":"iana","extensions":["ahead"]},"application/vnd.airzip.filesecure.azf":{"source":"iana","extensions":["azf"]},"application/vnd.airzip.filesecure.azs":{"source":"iana","extensions":["azs"]},"application/vnd.amadeus+json":{"source":"iana","compressible":true},"application/vnd.amazon.ebook":{"source":"apache","extensions":["azw"]},"application/vnd.amazon.mobi8-ebook":{"source":"iana"},"application/vnd.americandynamics.acc":{"source":"iana","extensions":["acc"]},"application/vnd.amiga.ami":{"source":"iana","extensions":["ami"]},"application/vnd.amundsen.maze+xml":{"source":"iana","compressible":true},"application/vnd.android.ota":{"source":"iana"},"application/vnd.android.package-archive":{"source":"apache","compressible":false,"extensions":["apk"]},"application/vnd.anki":{"source":"iana"},"application/vnd.anser-web-certificate-issue-initiation":{"source":"iana","extensions":["cii"]},"application/vnd.anser-web-funds-transfer-initiation":{"source":"apache","extensions":["fti"]},"application/vnd.antix.game-component":{"source":"iana","extensions":["atx"]},"application/vnd.apache.thrift.binary":{"source":"iana"},"application/vnd.apache.thrift.compact":{"source":"iana"},"application/vnd.apache.thrift.json":{"source":"iana"},"application/vnd.api+json":{"source":"iana","compressible":true},"application/vnd.aplextor.warrp+json":{"source":"iana","compressible":true},"application/vnd.apothekende.reservation+json":{"source":"iana","compressible":true},"application/vnd.apple.installer+xml":{"source":"iana","compressible":true,"extensions":["mpkg"]},"application/vnd.apple.keynote":{"source":"iana","extensions":["keynote"]},"application/vnd.apple.mpegurl":{"source":"iana","extensions":["m3u8"]},"application/vnd.apple.numbers":{"source":"iana","extensions":["numbers"]},"application/vnd.apple.pages":{"source":"iana","extensions":["pages"]},"application/vnd.apple.pkpass":{"compressible":false,"extensions":["pkpass"]},"application/vnd.arastra.swi":{"source":"iana"},"application/vnd.aristanetworks.swi":{"source":"iana","extensions":["swi"]},"application/vnd.artisan+json":{"source":"iana","compressible":true},"application/vnd.artsquare":{"source":"iana"},"application/vnd.astraea-software.iota":{"source":"iana","extensions":["iota"]},"application/vnd.audiograph":{"source":"iana","extensions":["aep"]},"application/vnd.autopackage":{"source":"iana"},"application/vnd.avalon+json":{"source":"iana","compressible":true},"application/vnd.avistar+xml":{"source":"iana","compressible":true},"application/vnd.balsamiq.bmml+xml":{"source":"iana","compressible":true,"extensions":["bmml"]},"application/vnd.balsamiq.bmpr":{"source":"iana"},"application/vnd.banana-accounting":{"source":"iana"},"application/vnd.bbf.usp.error":{"source":"iana"},"application/vnd.bbf.usp.msg":{"source":"iana"},"application/vnd.bbf.usp.msg+json":{"source":"iana","compressible":true},"application/vnd.bekitzur-stech+json":{"source":"iana","compressible":true},"application/vnd.bint.med-content":{"source":"iana"},"application/vnd.biopax.rdf+xml":{"source":"iana","compressible":true},"application/vnd.blink-idb-value-wrapper":{"source":"iana"},"application/vnd.blueice.multipass":{"source":"iana","extensions":["mpm"]},"application/vnd.bluetooth.ep.oob":{"source":"iana"},"application/vnd.bluetooth.le.oob":{"source":"iana"},"application/vnd.bmi":{"source":"iana","extensions":["bmi"]},"application/vnd.bpf":{"source":"iana"},"application/vnd.bpf3":{"source":"iana"},"application/vnd.businessobjects":{"source":"iana","extensions":["rep"]},"application/vnd.byu.uapi+json":{"source":"iana","compressible":true},"application/vnd.cab-jscript":{"source":"iana"},"application/vnd.canon-cpdl":{"source":"iana"},"application/vnd.canon-lips":{"source":"iana"},"application/vnd.capasystems-pg+json":{"source":"iana","compressible":true},"application/vnd.cendio.thinlinc.clientconf":{"source":"iana"},"application/vnd.century-systems.tcp_stream":{"source":"iana"},"application/vnd.chemdraw+xml":{"source":"iana","compressible":true,"extensions":["cdxml"]},"application/vnd.chess-pgn":{"source":"iana"},"application/vnd.chipnuts.karaoke-mmd":{"source":"iana","extensions":["mmd"]},"application/vnd.ciedi":{"source":"iana"},"application/vnd.cinderella":{"source":"iana","extensions":["cdy"]},"application/vnd.cirpack.isdn-ext":{"source":"iana"},"application/vnd.citationstyles.style+xml":{"source":"iana","compressible":true,"extensions":["csl"]},"application/vnd.claymore":{"source":"iana","extensions":["cla"]},"application/vnd.cloanto.rp9":{"source":"iana","extensions":["rp9"]},"application/vnd.clonk.c4group":{"source":"iana","extensions":["c4g","c4d","c4f","c4p","c4u"]},"application/vnd.cluetrust.cartomobile-config":{"source":"iana","extensions":["c11amc"]},"application/vnd.cluetrust.cartomobile-config-pkg":{"source":"iana","extensions":["c11amz"]},"application/vnd.coffeescript":{"source":"iana"},"application/vnd.collabio.xodocuments.document":{"source":"iana"},"application/vnd.collabio.xodocuments.document-template":{"source":"iana"},"application/vnd.collabio.xodocuments.presentation":{"source":"iana"},"application/vnd.collabio.xodocuments.presentation-template":{"source":"iana"},"application/vnd.collabio.xodocuments.spreadsheet":{"source":"iana"},"application/vnd.collabio.xodocuments.spreadsheet-template":{"source":"iana"},"application/vnd.collection+json":{"source":"iana","compressible":true},"application/vnd.collection.doc+json":{"source":"iana","compressible":true},"application/vnd.collection.next+json":{"source":"iana","compressible":true},"application/vnd.comicbook+zip":{"source":"iana","compressible":false},"application/vnd.comicbook-rar":{"source":"iana"},"application/vnd.commerce-battelle":{"source":"iana"},"application/vnd.commonspace":{"source":"iana","extensions":["csp"]},"application/vnd.contact.cmsg":{"source":"iana","extensions":["cdbcmsg"]},"application/vnd.coreos.ignition+json":{"source":"iana","compressible":true},"application/vnd.cosmocaller":{"source":"iana","extensions":["cmc"]},"application/vnd.crick.clicker":{"source":"iana","extensions":["clkx"]},"application/vnd.crick.clicker.keyboard":{"source":"iana","extensions":["clkk"]},"application/vnd.crick.clicker.palette":{"source":"iana","extensions":["clkp"]},"application/vnd.crick.clicker.template":{"source":"iana","extensions":["clkt"]},"application/vnd.crick.clicker.wordbank":{"source":"iana","extensions":["clkw"]},"application/vnd.criticaltools.wbs+xml":{"source":"iana","compressible":true,"extensions":["wbs"]},"application/vnd.cryptii.pipe+json":{"source":"iana","compressible":true},"application/vnd.crypto-shade-file":{"source":"iana"},"application/vnd.ctc-posml":{"source":"iana","extensions":["pml"]},"application/vnd.ctct.ws+xml":{"source":"iana","compressible":true},"application/vnd.cups-pdf":{"source":"iana"},"application/vnd.cups-postscript":{"source":"iana"},"application/vnd.cups-ppd":{"source":"iana","extensions":["ppd"]},"application/vnd.cups-raster":{"source":"iana"},"application/vnd.cups-raw":{"source":"iana"},"application/vnd.curl":{"source":"iana"},"application/vnd.curl.car":{"source":"apache","extensions":["car"]},"application/vnd.curl.pcurl":{"source":"apache","extensions":["pcurl"]},"application/vnd.cyan.dean.root+xml":{"source":"iana","compressible":true},"application/vnd.cybank":{"source":"iana"},"application/vnd.d2l.coursepackage1p0+zip":{"source":"iana","compressible":false},"application/vnd.dart":{"source":"iana","compressible":true,"extensions":["dart"]},"application/vnd.data-vision.rdz":{"source":"iana","extensions":["rdz"]},"application/vnd.datapackage+json":{"source":"iana","compressible":true},"application/vnd.dataresource+json":{"source":"iana","compressible":true},"application/vnd.dbf":{"source":"iana"},"application/vnd.debian.binary-package":{"source":"iana"},"application/vnd.dece.data":{"source":"iana","extensions":["uvf","uvvf","uvd","uvvd"]},"application/vnd.dece.ttml+xml":{"source":"iana","compressible":true,"extensions":["uvt","uvvt"]},"application/vnd.dece.unspecified":{"source":"iana","extensions":["uvx","uvvx"]},"application/vnd.dece.zip":{"source":"iana","extensions":["uvz","uvvz"]},"application/vnd.denovo.fcselayout-link":{"source":"iana","extensions":["fe_launch"]},"application/vnd.desmume.movie":{"source":"iana"},"application/vnd.dir-bi.plate-dl-nosuffix":{"source":"iana"},"application/vnd.dm.delegation+xml":{"source":"iana","compressible":true},"application/vnd.dna":{"source":"iana","extensions":["dna"]},"application/vnd.document+json":{"source":"iana","compressible":true},"application/vnd.dolby.mlp":{"source":"apache","extensions":["mlp"]},"application/vnd.dolby.mobile.1":{"source":"iana"},"application/vnd.dolby.mobile.2":{"source":"iana"},"application/vnd.doremir.scorecloud-binary-document":{"source":"iana"},"application/vnd.dpgraph":{"source":"iana","extensions":["dpg"]},"application/vnd.dreamfactory":{"source":"iana","extensions":["dfac"]},"application/vnd.drive+json":{"source":"iana","compressible":true},"application/vnd.ds-keypoint":{"source":"apache","extensions":["kpxx"]},"application/vnd.dtg.local":{"source":"iana"},"application/vnd.dtg.local.flash":{"source":"iana"},"application/vnd.dtg.local.html":{"source":"iana"},"application/vnd.dvb.ait":{"source":"iana","extensions":["ait"]},"application/vnd.dvb.dvbisl+xml":{"source":"iana","compressible":true},"application/vnd.dvb.dvbj":{"source":"iana"},"application/vnd.dvb.esgcontainer":{"source":"iana"},"application/vnd.dvb.ipdcdftnotifaccess":{"source":"iana"},"application/vnd.dvb.ipdcesgaccess":{"source":"iana"},"application/vnd.dvb.ipdcesgaccess2":{"source":"iana"},"application/vnd.dvb.ipdcesgpdd":{"source":"iana"},"application/vnd.dvb.ipdcroaming":{"source":"iana"},"application/vnd.dvb.iptv.alfec-base":{"source":"iana"},"application/vnd.dvb.iptv.alfec-enhancement":{"source":"iana"},"application/vnd.dvb.notif-aggregate-root+xml":{"source":"iana","compressible":true},"application/vnd.dvb.notif-container+xml":{"source":"iana","compressible":true},"application/vnd.dvb.notif-generic+xml":{"source":"iana","compressible":true},"application/vnd.dvb.notif-ia-msglist+xml":{"source":"iana","compressible":true},"application/vnd.dvb.notif-ia-registration-request+xml":{"source":"iana","compressible":true},"application/vnd.dvb.notif-ia-registration-response+xml":{"source":"iana","compressible":true},"application/vnd.dvb.notif-init+xml":{"source":"iana","compressible":true},"application/vnd.dvb.pfr":{"source":"iana"},"application/vnd.dvb.service":{"source":"iana","extensions":["svc"]},"application/vnd.dxr":{"source":"iana"},"application/vnd.dynageo":{"source":"iana","extensions":["geo"]},"application/vnd.dzr":{"source":"iana"},"application/vnd.easykaraoke.cdgdownload":{"source":"iana"},"application/vnd.ecdis-update":{"source":"iana"},"application/vnd.ecip.rlp":{"source":"iana"},"application/vnd.ecowin.chart":{"source":"iana","extensions":["mag"]},"application/vnd.ecowin.filerequest":{"source":"iana"},"application/vnd.ecowin.fileupdate":{"source":"iana"},"application/vnd.ecowin.series":{"source":"iana"},"application/vnd.ecowin.seriesrequest":{"source":"iana"},"application/vnd.ecowin.seriesupdate":{"source":"iana"},"application/vnd.efi.img":{"source":"iana"},"application/vnd.efi.iso":{"source":"iana"},"application/vnd.emclient.accessrequest+xml":{"source":"iana","compressible":true},"application/vnd.enliven":{"source":"iana","extensions":["nml"]},"application/vnd.enphase.envoy":{"source":"iana"},"application/vnd.eprints.data+xml":{"source":"iana","compressible":true},"application/vnd.epson.esf":{"source":"iana","extensions":["esf"]},"application/vnd.epson.msf":{"source":"iana","extensions":["msf"]},"application/vnd.epson.quickanime":{"source":"iana","extensions":["qam"]},"application/vnd.epson.salt":{"source":"iana","extensions":["slt"]},"application/vnd.epson.ssf":{"source":"iana","extensions":["ssf"]},"application/vnd.ericsson.quickcall":{"source":"iana"},"application/vnd.espass-espass+zip":{"source":"iana","compressible":false},"application/vnd.eszigno3+xml":{"source":"iana","compressible":true,"extensions":["es3","et3"]},"application/vnd.etsi.aoc+xml":{"source":"iana","compressible":true},"application/vnd.etsi.asic-e+zip":{"source":"iana","compressible":false},"application/vnd.etsi.asic-s+zip":{"source":"iana","compressible":false},"application/vnd.etsi.cug+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvcommand+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvdiscovery+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvprofile+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvsad-bc+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvsad-cod+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvsad-npvr+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvservice+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvsync+xml":{"source":"iana","compressible":true},"application/vnd.etsi.iptvueprofile+xml":{"source":"iana","compressible":true},"application/vnd.etsi.mcid+xml":{"source":"iana","compressible":true},"application/vnd.etsi.mheg5":{"source":"iana"},"application/vnd.etsi.overload-control-policy-dataset+xml":{"source":"iana","compressible":true},"application/vnd.etsi.pstn+xml":{"source":"iana","compressible":true},"application/vnd.etsi.sci+xml":{"source":"iana","compressible":true},"application/vnd.etsi.simservs+xml":{"source":"iana","compressible":true},"application/vnd.etsi.timestamp-token":{"source":"iana"},"application/vnd.etsi.tsl+xml":{"source":"iana","compressible":true},"application/vnd.etsi.tsl.der":{"source":"iana"},"application/vnd.eudora.data":{"source":"iana"},"application/vnd.evolv.ecig.profile":{"source":"iana"},"application/vnd.evolv.ecig.settings":{"source":"iana"},"application/vnd.evolv.ecig.theme":{"source":"iana"},"application/vnd.exstream-empower+zip":{"source":"iana","compressible":false},"application/vnd.exstream-package":{"source":"iana"},"application/vnd.ezpix-album":{"source":"iana","extensions":["ez2"]},"application/vnd.ezpix-package":{"source":"iana","extensions":["ez3"]},"application/vnd.f-secure.mobile":{"source":"iana"},"application/vnd.fastcopy-disk-image":{"source":"iana"},"application/vnd.fdf":{"source":"iana","extensions":["fdf"]},"application/vnd.fdsn.mseed":{"source":"iana","extensions":["mseed"]},"application/vnd.fdsn.seed":{"source":"iana","extensions":["seed","dataless"]},"application/vnd.ffsns":{"source":"iana"},"application/vnd.ficlab.flb+zip":{"source":"iana","compressible":false},"application/vnd.filmit.zfc":{"source":"iana"},"application/vnd.fints":{"source":"iana"},"application/vnd.firemonkeys.cloudcell":{"source":"iana"},"application/vnd.flographit":{"source":"iana","extensions":["gph"]},"application/vnd.fluxtime.clip":{"source":"iana","extensions":["ftc"]},"application/vnd.font-fontforge-sfd":{"source":"iana"},"application/vnd.framemaker":{"source":"iana","extensions":["fm","frame","maker","book"]},"application/vnd.frogans.fnc":{"source":"iana","extensions":["fnc"]},"application/vnd.frogans.ltf":{"source":"iana","extensions":["ltf"]},"application/vnd.fsc.weblaunch":{"source":"iana","extensions":["fsc"]},"application/vnd.fujitsu.oasys":{"source":"iana","extensions":["oas"]},"application/vnd.fujitsu.oasys2":{"source":"iana","extensions":["oa2"]},"application/vnd.fujitsu.oasys3":{"source":"iana","extensions":["oa3"]},"application/vnd.fujitsu.oasysgp":{"source":"iana","extensions":["fg5"]},"application/vnd.fujitsu.oasysprs":{"source":"iana","extensions":["bh2"]},"application/vnd.fujixerox.art-ex":{"source":"iana"},"application/vnd.fujixerox.art4":{"source":"iana"},"application/vnd.fujixerox.ddd":{"source":"iana","extensions":["ddd"]},"application/vnd.fujixerox.docuworks":{"source":"iana","extensions":["xdw"]},"application/vnd.fujixerox.docuworks.binder":{"source":"iana","extensions":["xbd"]},"application/vnd.fujixerox.docuworks.container":{"source":"iana"},"application/vnd.fujixerox.hbpl":{"source":"iana"},"application/vnd.fut-misnet":{"source":"iana"},"application/vnd.futoin+cbor":{"source":"iana"},"application/vnd.futoin+json":{"source":"iana","compressible":true},"application/vnd.fuzzysheet":{"source":"iana","extensions":["fzs"]},"application/vnd.genomatix.tuxedo":{"source":"iana","extensions":["txd"]},"application/vnd.gentics.grd+json":{"source":"iana","compressible":true},"application/vnd.geo+json":{"source":"iana","compressible":true},"application/vnd.geocube+xml":{"source":"iana","compressible":true},"application/vnd.geogebra.file":{"source":"iana","extensions":["ggb"]},"application/vnd.geogebra.tool":{"source":"iana","extensions":["ggt"]},"application/vnd.geometry-explorer":{"source":"iana","extensions":["gex","gre"]},"application/vnd.geonext":{"source":"iana","extensions":["gxt"]},"application/vnd.geoplan":{"source":"iana","extensions":["g2w"]},"application/vnd.geospace":{"source":"iana","extensions":["g3w"]},"application/vnd.gerber":{"source":"iana"},"application/vnd.globalplatform.card-content-mgt":{"source":"iana"},"application/vnd.globalplatform.card-content-mgt-response":{"source":"iana"},"application/vnd.gmx":{"source":"iana","extensions":["gmx"]},"application/vnd.google-apps.document":{"compressible":false,"extensions":["gdoc"]},"application/vnd.google-apps.presentation":{"compressible":false,"extensions":["gslides"]},"application/vnd.google-apps.spreadsheet":{"compressible":false,"extensions":["gsheet"]},"application/vnd.google-earth.kml+xml":{"source":"iana","compressible":true,"extensions":["kml"]},"application/vnd.google-earth.kmz":{"source":"iana","compressible":false,"extensions":["kmz"]},"application/vnd.gov.sk.e-form+xml":{"source":"iana","compressible":true},"application/vnd.gov.sk.e-form+zip":{"source":"iana","compressible":false},"application/vnd.gov.sk.xmldatacontainer+xml":{"source":"iana","compressible":true},"application/vnd.grafeq":{"source":"iana","extensions":["gqf","gqs"]},"application/vnd.gridmp":{"source":"iana"},"application/vnd.groove-account":{"source":"iana","extensions":["gac"]},"application/vnd.groove-help":{"source":"iana","extensions":["ghf"]},"application/vnd.groove-identity-message":{"source":"iana","extensions":["gim"]},"application/vnd.groove-injector":{"source":"iana","extensions":["grv"]},"application/vnd.groove-tool-message":{"source":"iana","extensions":["gtm"]},"application/vnd.groove-tool-template":{"source":"iana","extensions":["tpl"]},"application/vnd.groove-vcard":{"source":"iana","extensions":["vcg"]},"application/vnd.hal+json":{"source":"iana","compressible":true},"application/vnd.hal+xml":{"source":"iana","compressible":true,"extensions":["hal"]},"application/vnd.handheld-entertainment+xml":{"source":"iana","compressible":true,"extensions":["zmm"]},"application/vnd.hbci":{"source":"iana","extensions":["hbci"]},"application/vnd.hc+json":{"source":"iana","compressible":true},"application/vnd.hcl-bireports":{"source":"iana"},"application/vnd.hdt":{"source":"iana"},"application/vnd.heroku+json":{"source":"iana","compressible":true},"application/vnd.hhe.lesson-player":{"source":"iana","extensions":["les"]},"application/vnd.hp-hpgl":{"source":"iana","extensions":["hpgl"]},"application/vnd.hp-hpid":{"source":"iana","extensions":["hpid"]},"application/vnd.hp-hps":{"source":"iana","extensions":["hps"]},"application/vnd.hp-jlyt":{"source":"iana","extensions":["jlt"]},"application/vnd.hp-pcl":{"source":"iana","extensions":["pcl"]},"application/vnd.hp-pclxl":{"source":"iana","extensions":["pclxl"]},"application/vnd.httphone":{"source":"iana"},"application/vnd.hydrostatix.sof-data":{"source":"iana","extensions":["sfd-hdstx"]},"application/vnd.hyper+json":{"source":"iana","compressible":true},"application/vnd.hyper-item+json":{"source":"iana","compressible":true},"application/vnd.hyperdrive+json":{"source":"iana","compressible":true},"application/vnd.hzn-3d-crossword":{"source":"iana"},"application/vnd.ibm.afplinedata":{"source":"iana"},"application/vnd.ibm.electronic-media":{"source":"iana"},"application/vnd.ibm.minipay":{"source":"iana","extensions":["mpy"]},"application/vnd.ibm.modcap":{"source":"iana","extensions":["afp","listafp","list3820"]},"application/vnd.ibm.rights-management":{"source":"iana","extensions":["irm"]},"application/vnd.ibm.secure-container":{"source":"iana","extensions":["sc"]},"application/vnd.iccprofile":{"source":"iana","extensions":["icc","icm"]},"application/vnd.ieee.1905":{"source":"iana"},"application/vnd.igloader":{"source":"iana","extensions":["igl"]},"application/vnd.imagemeter.folder+zip":{"source":"iana","compressible":false},"application/vnd.imagemeter.image+zip":{"source":"iana","compressible":false},"application/vnd.immervision-ivp":{"source":"iana","extensions":["ivp"]},"application/vnd.immervision-ivu":{"source":"iana","extensions":["ivu"]},"application/vnd.ims.imsccv1p1":{"source":"iana"},"application/vnd.ims.imsccv1p2":{"source":"iana"},"application/vnd.ims.imsccv1p3":{"source":"iana"},"application/vnd.ims.lis.v2.result+json":{"source":"iana","compressible":true},"application/vnd.ims.lti.v2.toolconsumerprofile+json":{"source":"iana","compressible":true},"application/vnd.ims.lti.v2.toolproxy+json":{"source":"iana","compressible":true},"application/vnd.ims.lti.v2.toolproxy.id+json":{"source":"iana","compressible":true},"application/vnd.ims.lti.v2.toolsettings+json":{"source":"iana","compressible":true},"application/vnd.ims.lti.v2.toolsettings.simple+json":{"source":"iana","compressible":true},"application/vnd.informedcontrol.rms+xml":{"source":"iana","compressible":true},"application/vnd.informix-visionary":{"source":"iana"},"application/vnd.infotech.project":{"source":"iana"},"application/vnd.infotech.project+xml":{"source":"iana","compressible":true},"application/vnd.innopath.wamp.notification":{"source":"iana"},"application/vnd.insors.igm":{"source":"iana","extensions":["igm"]},"application/vnd.intercon.formnet":{"source":"iana","extensions":["xpw","xpx"]},"application/vnd.intergeo":{"source":"iana","extensions":["i2g"]},"application/vnd.intertrust.digibox":{"source":"iana"},"application/vnd.intertrust.nncp":{"source":"iana"},"application/vnd.intu.qbo":{"source":"iana","extensions":["qbo"]},"application/vnd.intu.qfx":{"source":"iana","extensions":["qfx"]},"application/vnd.iptc.g2.catalogitem+xml":{"source":"iana","compressible":true},"application/vnd.iptc.g2.conceptitem+xml":{"source":"iana","compressible":true},"application/vnd.iptc.g2.knowledgeitem+xml":{"source":"iana","compressible":true},"application/vnd.iptc.g2.newsitem+xml":{"source":"iana","compressible":true},"application/vnd.iptc.g2.newsmessage+xml":{"source":"iana","compressible":true},"application/vnd.iptc.g2.packageitem+xml":{"source":"iana","compressible":true},"application/vnd.iptc.g2.planningitem+xml":{"source":"iana","compressible":true},"application/vnd.ipunplugged.rcprofile":{"source":"iana","extensions":["rcprofile"]},"application/vnd.irepository.package+xml":{"source":"iana","compressible":true,"extensions":["irp"]},"application/vnd.is-xpr":{"source":"iana","extensions":["xpr"]},"application/vnd.isac.fcs":{"source":"iana","extensions":["fcs"]},"application/vnd.iso11783-10+zip":{"source":"iana","compressible":false},"application/vnd.jam":{"source":"iana","extensions":["jam"]},"application/vnd.japannet-directory-service":{"source":"iana"},"application/vnd.japannet-jpnstore-wakeup":{"source":"iana"},"application/vnd.japannet-payment-wakeup":{"source":"iana"},"application/vnd.japannet-registration":{"source":"iana"},"application/vnd.japannet-registration-wakeup":{"source":"iana"},"application/vnd.japannet-setstore-wakeup":{"source":"iana"},"application/vnd.japannet-verification":{"source":"iana"},"application/vnd.japannet-verification-wakeup":{"source":"iana"},"application/vnd.jcp.javame.midlet-rms":{"source":"iana","extensions":["rms"]},"application/vnd.jisp":{"source":"iana","extensions":["jisp"]},"application/vnd.joost.joda-archive":{"source":"iana","extensions":["joda"]},"application/vnd.jsk.isdn-ngn":{"source":"iana"},"application/vnd.kahootz":{"source":"iana","extensions":["ktz","ktr"]},"application/vnd.kde.karbon":{"source":"iana","extensions":["karbon"]},"application/vnd.kde.kchart":{"source":"iana","extensions":["chrt"]},"application/vnd.kde.kformula":{"source":"iana","extensions":["kfo"]},"application/vnd.kde.kivio":{"source":"iana","extensions":["flw"]},"application/vnd.kde.kontour":{"source":"iana","extensions":["kon"]},"application/vnd.kde.kpresenter":{"source":"iana","extensions":["kpr","kpt"]},"application/vnd.kde.kspread":{"source":"iana","extensions":["ksp"]},"application/vnd.kde.kword":{"source":"iana","extensions":["kwd","kwt"]},"application/vnd.kenameaapp":{"source":"iana","extensions":["htke"]},"application/vnd.kidspiration":{"source":"iana","extensions":["kia"]},"application/vnd.kinar":{"source":"iana","extensions":["kne","knp"]},"application/vnd.koan":{"source":"iana","extensions":["skp","skd","skt","skm"]},"application/vnd.kodak-descriptor":{"source":"iana","extensions":["sse"]},"application/vnd.las":{"source":"iana"},"application/vnd.las.las+json":{"source":"iana","compressible":true},"application/vnd.las.las+xml":{"source":"iana","compressible":true,"extensions":["lasxml"]},"application/vnd.laszip":{"source":"iana"},"application/vnd.leap+json":{"source":"iana","compressible":true},"application/vnd.liberty-request+xml":{"source":"iana","compressible":true},"application/vnd.llamagraphics.life-balance.desktop":{"source":"iana","extensions":["lbd"]},"application/vnd.llamagraphics.life-balance.exchange+xml":{"source":"iana","compressible":true,"extensions":["lbe"]},"application/vnd.logipipe.circuit+zip":{"source":"iana","compressible":false},"application/vnd.loom":{"source":"iana"},"application/vnd.lotus-1-2-3":{"source":"iana","extensions":["123"]},"application/vnd.lotus-approach":{"source":"iana","extensions":["apr"]},"application/vnd.lotus-freelance":{"source":"iana","extensions":["pre"]},"application/vnd.lotus-notes":{"source":"iana","extensions":["nsf"]},"application/vnd.lotus-organizer":{"source":"iana","extensions":["org"]},"application/vnd.lotus-screencam":{"source":"iana","extensions":["scm"]},"application/vnd.lotus-wordpro":{"source":"iana","extensions":["lwp"]},"application/vnd.macports.portpkg":{"source":"iana","extensions":["portpkg"]},"application/vnd.mapbox-vector-tile":{"source":"iana"},"application/vnd.marlin.drm.actiontoken+xml":{"source":"iana","compressible":true},"application/vnd.marlin.drm.conftoken+xml":{"source":"iana","compressible":true},"application/vnd.marlin.drm.license+xml":{"source":"iana","compressible":true},"application/vnd.marlin.drm.mdcf":{"source":"iana"},"application/vnd.mason+json":{"source":"iana","compressible":true},"application/vnd.maxmind.maxmind-db":{"source":"iana"},"application/vnd.mcd":{"source":"iana","extensions":["mcd"]},"application/vnd.medcalcdata":{"source":"iana","extensions":["mc1"]},"application/vnd.mediastation.cdkey":{"source":"iana","extensions":["cdkey"]},"application/vnd.meridian-slingshot":{"source":"iana"},"application/vnd.mfer":{"source":"iana","extensions":["mwf"]},"application/vnd.mfmp":{"source":"iana","extensions":["mfm"]},"application/vnd.micro+json":{"source":"iana","compressible":true},"application/vnd.micrografx.flo":{"source":"iana","extensions":["flo"]},"application/vnd.micrografx.igx":{"source":"iana","extensions":["igx"]},"application/vnd.microsoft.portable-executable":{"source":"iana"},"application/vnd.microsoft.windows.thumbnail-cache":{"source":"iana"},"application/vnd.miele+json":{"source":"iana","compressible":true},"application/vnd.mif":{"source":"iana","extensions":["mif"]},"application/vnd.minisoft-hp3000-save":{"source":"iana"},"application/vnd.mitsubishi.misty-guard.trustweb":{"source":"iana"},"application/vnd.mobius.daf":{"source":"iana","extensions":["daf"]},"application/vnd.mobius.dis":{"source":"iana","extensions":["dis"]},"application/vnd.mobius.mbk":{"source":"iana","extensions":["mbk"]},"application/vnd.mobius.mqy":{"source":"iana","extensions":["mqy"]},"application/vnd.mobius.msl":{"source":"iana","extensions":["msl"]},"application/vnd.mobius.plc":{"source":"iana","extensions":["plc"]},"application/vnd.mobius.txf":{"source":"iana","extensions":["txf"]},"application/vnd.mophun.application":{"source":"iana","extensions":["mpn"]},"application/vnd.mophun.certificate":{"source":"iana","extensions":["mpc"]},"application/vnd.motorola.flexsuite":{"source":"iana"},"application/vnd.motorola.flexsuite.adsi":{"source":"iana"},"application/vnd.motorola.flexsuite.fis":{"source":"iana"},"application/vnd.motorola.flexsuite.gotap":{"source":"iana"},"application/vnd.motorola.flexsuite.kmr":{"source":"iana"},"application/vnd.motorola.flexsuite.ttc":{"source":"iana"},"application/vnd.motorola.flexsuite.wem":{"source":"iana"},"application/vnd.motorola.iprm":{"source":"iana"},"application/vnd.mozilla.xul+xml":{"source":"iana","compressible":true,"extensions":["xul"]},"application/vnd.ms-3mfdocument":{"source":"iana"},"application/vnd.ms-artgalry":{"source":"iana","extensions":["cil"]},"application/vnd.ms-asf":{"source":"iana"},"application/vnd.ms-cab-compressed":{"source":"iana","extensions":["cab"]},"application/vnd.ms-color.iccprofile":{"source":"apache"},"application/vnd.ms-excel":{"source":"iana","compressible":false,"extensions":["xls","xlm","xla","xlc","xlt","xlw"]},"application/vnd.ms-excel.addin.macroenabled.12":{"source":"iana","extensions":["xlam"]},"application/vnd.ms-excel.sheet.binary.macroenabled.12":{"source":"iana","extensions":["xlsb"]},"application/vnd.ms-excel.sheet.macroenabled.12":{"source":"iana","extensions":["xlsm"]},"application/vnd.ms-excel.template.macroenabled.12":{"source":"iana","extensions":["xltm"]},"application/vnd.ms-fontobject":{"source":"iana","compressible":true,"extensions":["eot"]},"application/vnd.ms-htmlhelp":{"source":"iana","extensions":["chm"]},"application/vnd.ms-ims":{"source":"iana","extensions":["ims"]},"application/vnd.ms-lrm":{"source":"iana","extensions":["lrm"]},"application/vnd.ms-office.activex+xml":{"source":"iana","compressible":true},"application/vnd.ms-officetheme":{"source":"iana","extensions":["thmx"]},"application/vnd.ms-opentype":{"source":"apache","compressible":true},"application/vnd.ms-outlook":{"compressible":false,"extensions":["msg"]},"application/vnd.ms-package.obfuscated-opentype":{"source":"apache"},"application/vnd.ms-pki.seccat":{"source":"apache","extensions":["cat"]},"application/vnd.ms-pki.stl":{"source":"apache","extensions":["stl"]},"application/vnd.ms-playready.initiator+xml":{"source":"iana","compressible":true},"application/vnd.ms-powerpoint":{"source":"iana","compressible":false,"extensions":["ppt","pps","pot"]},"application/vnd.ms-powerpoint.addin.macroenabled.12":{"source":"iana","extensions":["ppam"]},"application/vnd.ms-powerpoint.presentation.macroenabled.12":{"source":"iana","extensions":["pptm"]},"application/vnd.ms-powerpoint.slide.macroenabled.12":{"source":"iana","extensions":["sldm"]},"application/vnd.ms-powerpoint.slideshow.macroenabled.12":{"source":"iana","extensions":["ppsm"]},"application/vnd.ms-powerpoint.template.macroenabled.12":{"source":"iana","extensions":["potm"]},"application/vnd.ms-printdevicecapabilities+xml":{"source":"iana","compressible":true},"application/vnd.ms-printing.printticket+xml":{"source":"apache","compressible":true},"application/vnd.ms-printschematicket+xml":{"source":"iana","compressible":true},"application/vnd.ms-project":{"source":"iana","extensions":["mpp","mpt"]},"application/vnd.ms-tnef":{"source":"iana"},"application/vnd.ms-windows.devicepairing":{"source":"iana"},"application/vnd.ms-windows.nwprinting.oob":{"source":"iana"},"application/vnd.ms-windows.printerpairing":{"source":"iana"},"application/vnd.ms-windows.wsd.oob":{"source":"iana"},"application/vnd.ms-wmdrm.lic-chlg-req":{"source":"iana"},"application/vnd.ms-wmdrm.lic-resp":{"source":"iana"},"application/vnd.ms-wmdrm.meter-chlg-req":{"source":"iana"},"application/vnd.ms-wmdrm.meter-resp":{"source":"iana"},"application/vnd.ms-word.document.macroenabled.12":{"source":"iana","extensions":["docm"]},"application/vnd.ms-word.template.macroenabled.12":{"source":"iana","extensions":["dotm"]},"application/vnd.ms-works":{"source":"iana","extensions":["wps","wks","wcm","wdb"]},"application/vnd.ms-wpl":{"source":"iana","extensions":["wpl"]},"application/vnd.ms-xpsdocument":{"source":"iana","compressible":false,"extensions":["xps"]},"application/vnd.msa-disk-image":{"source":"iana"},"application/vnd.mseq":{"source":"iana","extensions":["mseq"]},"application/vnd.msign":{"source":"iana"},"application/vnd.multiad.creator":{"source":"iana"},"application/vnd.multiad.creator.cif":{"source":"iana"},"application/vnd.music-niff":{"source":"iana"},"application/vnd.musician":{"source":"iana","extensions":["mus"]},"application/vnd.muvee.style":{"source":"iana","extensions":["msty"]},"application/vnd.mynfc":{"source":"iana","extensions":["taglet"]},"application/vnd.ncd.control":{"source":"iana"},"application/vnd.ncd.reference":{"source":"iana"},"application/vnd.nearst.inv+json":{"source":"iana","compressible":true},"application/vnd.nervana":{"source":"iana"},"application/vnd.netfpx":{"source":"iana"},"application/vnd.neurolanguage.nlu":{"source":"iana","extensions":["nlu"]},"application/vnd.nimn":{"source":"iana"},"application/vnd.nintendo.nitro.rom":{"source":"iana"},"application/vnd.nintendo.snes.rom":{"source":"iana"},"application/vnd.nitf":{"source":"iana","extensions":["ntf","nitf"]},"application/vnd.noblenet-directory":{"source":"iana","extensions":["nnd"]},"application/vnd.noblenet-sealer":{"source":"iana","extensions":["nns"]},"application/vnd.noblenet-web":{"source":"iana","extensions":["nnw"]},"application/vnd.nokia.catalogs":{"source":"iana"},"application/vnd.nokia.conml+wbxml":{"source":"iana"},"application/vnd.nokia.conml+xml":{"source":"iana","compressible":true},"application/vnd.nokia.iptv.config+xml":{"source":"iana","compressible":true},"application/vnd.nokia.isds-radio-presets":{"source":"iana"},"application/vnd.nokia.landmark+wbxml":{"source":"iana"},"application/vnd.nokia.landmark+xml":{"source":"iana","compressible":true},"application/vnd.nokia.landmarkcollection+xml":{"source":"iana","compressible":true},"application/vnd.nokia.n-gage.ac+xml":{"source":"iana","compressible":true,"extensions":["ac"]},"application/vnd.nokia.n-gage.data":{"source":"iana","extensions":["ngdat"]},"application/vnd.nokia.n-gage.symbian.install":{"source":"iana","extensions":["n-gage"]},"application/vnd.nokia.ncd":{"source":"iana"},"application/vnd.nokia.pcd+wbxml":{"source":"iana"},"application/vnd.nokia.pcd+xml":{"source":"iana","compressible":true},"application/vnd.nokia.radio-preset":{"source":"iana","extensions":["rpst"]},"application/vnd.nokia.radio-presets":{"source":"iana","extensions":["rpss"]},"application/vnd.novadigm.edm":{"source":"iana","extensions":["edm"]},"application/vnd.novadigm.edx":{"source":"iana","extensions":["edx"]},"application/vnd.novadigm.ext":{"source":"iana","extensions":["ext"]},"application/vnd.ntt-local.content-share":{"source":"iana"},"application/vnd.ntt-local.file-transfer":{"source":"iana"},"application/vnd.ntt-local.ogw_remote-access":{"source":"iana"},"application/vnd.ntt-local.sip-ta_remote":{"source":"iana"},"application/vnd.ntt-local.sip-ta_tcp_stream":{"source":"iana"},"application/vnd.oasis.opendocument.chart":{"source":"iana","extensions":["odc"]},"application/vnd.oasis.opendocument.chart-template":{"source":"iana","extensions":["otc"]},"application/vnd.oasis.opendocument.database":{"source":"iana","extensions":["odb"]},"application/vnd.oasis.opendocument.formula":{"source":"iana","extensions":["odf"]},"application/vnd.oasis.opendocument.formula-template":{"source":"iana","extensions":["odft"]},"application/vnd.oasis.opendocument.graphics":{"source":"iana","compressible":false,"extensions":["odg"]},"application/vnd.oasis.opendocument.graphics-template":{"source":"iana","extensions":["otg"]},"application/vnd.oasis.opendocument.image":{"source":"iana","extensions":["odi"]},"application/vnd.oasis.opendocument.image-template":{"source":"iana","extensions":["oti"]},"application/vnd.oasis.opendocument.presentation":{"source":"iana","compressible":false,"extensions":["odp"]},"application/vnd.oasis.opendocument.presentation-template":{"source":"iana","extensions":["otp"]},"application/vnd.oasis.opendocument.spreadsheet":{"source":"iana","compressible":false,"extensions":["ods"]},"application/vnd.oasis.opendocument.spreadsheet-template":{"source":"iana","extensions":["ots"]},"application/vnd.oasis.opendocument.text":{"source":"iana","compressible":false,"extensions":["odt"]},"application/vnd.oasis.opendocument.text-master":{"source":"iana","extensions":["odm"]},"application/vnd.oasis.opendocument.text-template":{"source":"iana","extensions":["ott"]},"application/vnd.oasis.opendocument.text-web":{"source":"iana","extensions":["oth"]},"application/vnd.obn":{"source":"iana"},"application/vnd.ocf+cbor":{"source":"iana"},"application/vnd.oci.image.manifest.v1+json":{"source":"iana","compressible":true},"application/vnd.oftn.l10n+json":{"source":"iana","compressible":true},"application/vnd.oipf.contentaccessdownload+xml":{"source":"iana","compressible":true},"application/vnd.oipf.contentaccessstreaming+xml":{"source":"iana","compressible":true},"application/vnd.oipf.cspg-hexbinary":{"source":"iana"},"application/vnd.oipf.dae.svg+xml":{"source":"iana","compressible":true},"application/vnd.oipf.dae.xhtml+xml":{"source":"iana","compressible":true},"application/vnd.oipf.mippvcontrolmessage+xml":{"source":"iana","compressible":true},"application/vnd.oipf.pae.gem":{"source":"iana"},"application/vnd.oipf.spdiscovery+xml":{"source":"iana","compressible":true},"application/vnd.oipf.spdlist+xml":{"source":"iana","compressible":true},"application/vnd.oipf.ueprofile+xml":{"source":"iana","compressible":true},"application/vnd.oipf.userprofile+xml":{"source":"iana","compressible":true},"application/vnd.olpc-sugar":{"source":"iana","extensions":["xo"]},"application/vnd.oma-scws-config":{"source":"iana"},"application/vnd.oma-scws-http-request":{"source":"iana"},"application/vnd.oma-scws-http-response":{"source":"iana"},"application/vnd.oma.bcast.associated-procedure-parameter+xml":{"source":"iana","compressible":true},"application/vnd.oma.bcast.drm-trigger+xml":{"source":"iana","compressible":true},"application/vnd.oma.bcast.imd+xml":{"source":"iana","compressible":true},"application/vnd.oma.bcast.ltkm":{"source":"iana"},"application/vnd.oma.bcast.notification+xml":{"source":"iana","compressible":true},"application/vnd.oma.bcast.provisioningtrigger":{"source":"iana"},"application/vnd.oma.bcast.sgboot":{"source":"iana"},"application/vnd.oma.bcast.sgdd+xml":{"source":"iana","compressible":true},"application/vnd.oma.bcast.sgdu":{"source":"iana"},"application/vnd.oma.bcast.simple-symbol-container":{"source":"iana"},"application/vnd.oma.bcast.smartcard-trigger+xml":{"source":"iana","compressible":true},"application/vnd.oma.bcast.sprov+xml":{"source":"iana","compressible":true},"application/vnd.oma.bcast.stkm":{"source":"iana"},"application/vnd.oma.cab-address-book+xml":{"source":"iana","compressible":true},"application/vnd.oma.cab-feature-handler+xml":{"source":"iana","compressible":true},"application/vnd.oma.cab-pcc+xml":{"source":"iana","compressible":true},"application/vnd.oma.cab-subs-invite+xml":{"source":"iana","compressible":true},"application/vnd.oma.cab-user-prefs+xml":{"source":"iana","compressible":true},"application/vnd.oma.dcd":{"source":"iana"},"application/vnd.oma.dcdc":{"source":"iana"},"application/vnd.oma.dd2+xml":{"source":"iana","compressible":true,"extensions":["dd2"]},"application/vnd.oma.drm.risd+xml":{"source":"iana","compressible":true},"application/vnd.oma.group-usage-list+xml":{"source":"iana","compressible":true},"application/vnd.oma.lwm2m+json":{"source":"iana","compressible":true},"application/vnd.oma.lwm2m+tlv":{"source":"iana"},"application/vnd.oma.pal+xml":{"source":"iana","compressible":true},"application/vnd.oma.poc.detailed-progress-report+xml":{"source":"iana","compressible":true},"application/vnd.oma.poc.final-report+xml":{"source":"iana","compressible":true},"application/vnd.oma.poc.groups+xml":{"source":"iana","compressible":true},"application/vnd.oma.poc.invocation-descriptor+xml":{"source":"iana","compressible":true},"application/vnd.oma.poc.optimized-progress-report+xml":{"source":"iana","compressible":true},"application/vnd.oma.push":{"source":"iana"},"application/vnd.oma.scidm.messages+xml":{"source":"iana","compressible":true},"application/vnd.oma.xcap-directory+xml":{"source":"iana","compressible":true},"application/vnd.omads-email+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/vnd.omads-file+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/vnd.omads-folder+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/vnd.omaloc-supl-init":{"source":"iana"},"application/vnd.onepager":{"source":"iana"},"application/vnd.onepagertamp":{"source":"iana"},"application/vnd.onepagertamx":{"source":"iana"},"application/vnd.onepagertat":{"source":"iana"},"application/vnd.onepagertatp":{"source":"iana"},"application/vnd.onepagertatx":{"source":"iana"},"application/vnd.openblox.game+xml":{"source":"iana","compressible":true,"extensions":["obgx"]},"application/vnd.openblox.game-binary":{"source":"iana"},"application/vnd.openeye.oeb":{"source":"iana"},"application/vnd.openofficeorg.extension":{"source":"apache","extensions":["oxt"]},"application/vnd.openstreetmap.data+xml":{"source":"iana","compressible":true,"extensions":["osm"]},"application/vnd.openxmlformats-officedocument.custom-properties+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.customxmlproperties+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.drawing+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.drawingml.chart+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.drawingml.chartshapes+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.drawingml.diagramcolors+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.drawingml.diagramdata+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.drawingml.diagramlayout+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.drawingml.diagramstyle+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.extended-properties+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.commentauthors+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.comments+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.handoutmaster+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.notesmaster+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.notesslide+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.presentation":{"source":"iana","compressible":false,"extensions":["pptx"]},"application/vnd.openxmlformats-officedocument.presentationml.presentation.main+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.presprops+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.slide":{"source":"iana","extensions":["sldx"]},"application/vnd.openxmlformats-officedocument.presentationml.slide+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.slidelayout+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.slidemaster+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.slideshow":{"source":"iana","extensions":["ppsx"]},"application/vnd.openxmlformats-officedocument.presentationml.slideshow.main+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.slideupdateinfo+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.tablestyles+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.tags+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.template":{"source":"iana","extensions":["potx"]},"application/vnd.openxmlformats-officedocument.presentationml.template.main+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.presentationml.viewprops+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.calcchain+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.chartsheet+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.connections+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.dialogsheet+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.externallink+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcachedefinition+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.pivotcacherecords+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.pivottable+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.querytable+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionheaders+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.revisionlog+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedstrings+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet":{"source":"iana","compressible":false,"extensions":["xlsx"]},"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.sheetmetadata+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.tablesinglecells+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.template":{"source":"iana","extensions":["xltx"]},"application/vnd.openxmlformats-officedocument.spreadsheetml.template.main+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.usernames+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.volatiledependencies+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.theme+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.themeoverride+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.vmldrawing":{"source":"iana"},"application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.document":{"source":"iana","compressible":false,"extensions":["docx"]},"application/vnd.openxmlformats-officedocument.wordprocessingml.document.glossary+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.fonttable+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.template":{"source":"iana","extensions":["dotx"]},"application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-officedocument.wordprocessingml.websettings+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-package.core-properties+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-package.digital-signature-xmlsignature+xml":{"source":"iana","compressible":true},"application/vnd.openxmlformats-package.relationships+xml":{"source":"iana","compressible":true},"application/vnd.oracle.resource+json":{"source":"iana","compressible":true},"application/vnd.orange.indata":{"source":"iana"},"application/vnd.osa.netdeploy":{"source":"iana"},"application/vnd.osgeo.mapguide.package":{"source":"iana","extensions":["mgp"]},"application/vnd.osgi.bundle":{"source":"iana"},"application/vnd.osgi.dp":{"source":"iana","extensions":["dp"]},"application/vnd.osgi.subsystem":{"source":"iana","extensions":["esa"]},"application/vnd.otps.ct-kip+xml":{"source":"iana","compressible":true},"application/vnd.oxli.countgraph":{"source":"iana"},"application/vnd.pagerduty+json":{"source":"iana","compressible":true},"application/vnd.palm":{"source":"iana","extensions":["pdb","pqa","oprc"]},"application/vnd.panoply":{"source":"iana"},"application/vnd.paos.xml":{"source":"iana"},"application/vnd.patentdive":{"source":"iana"},"application/vnd.patientecommsdoc":{"source":"iana"},"application/vnd.pawaafile":{"source":"iana","extensions":["paw"]},"application/vnd.pcos":{"source":"iana"},"application/vnd.pg.format":{"source":"iana","extensions":["str"]},"application/vnd.pg.osasli":{"source":"iana","extensions":["ei6"]},"application/vnd.piaccess.application-licence":{"source":"iana"},"application/vnd.picsel":{"source":"iana","extensions":["efif"]},"application/vnd.pmi.widget":{"source":"iana","extensions":["wg"]},"application/vnd.poc.group-advertisement+xml":{"source":"iana","compressible":true},"application/vnd.pocketlearn":{"source":"iana","extensions":["plf"]},"application/vnd.powerbuilder6":{"source":"iana","extensions":["pbd"]},"application/vnd.powerbuilder6-s":{"source":"iana"},"application/vnd.powerbuilder7":{"source":"iana"},"application/vnd.powerbuilder7-s":{"source":"iana"},"application/vnd.powerbuilder75":{"source":"iana"},"application/vnd.powerbuilder75-s":{"source":"iana"},"application/vnd.preminet":{"source":"iana"},"application/vnd.previewsystems.box":{"source":"iana","extensions":["box"]},"application/vnd.proteus.magazine":{"source":"iana","extensions":["mgz"]},"application/vnd.psfs":{"source":"iana"},"application/vnd.publishare-delta-tree":{"source":"iana","extensions":["qps"]},"application/vnd.pvi.ptid1":{"source":"iana","extensions":["ptid"]},"application/vnd.pwg-multiplexed":{"source":"iana"},"application/vnd.pwg-xhtml-print+xml":{"source":"iana","compressible":true},"application/vnd.qualcomm.brew-app-res":{"source":"iana"},"application/vnd.quarantainenet":{"source":"iana"},"application/vnd.quark.quarkxpress":{"source":"iana","extensions":["qxd","qxt","qwd","qwt","qxl","qxb"]},"application/vnd.quobject-quoxdocument":{"source":"iana"},"application/vnd.radisys.moml+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-audit+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-audit-conf+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-audit-conn+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-audit-dialog+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-audit-stream+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-conf+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-dialog+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-dialog-base+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-dialog-fax-detect+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-dialog-fax-sendrecv+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-dialog-group+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-dialog-speech+xml":{"source":"iana","compressible":true},"application/vnd.radisys.msml-dialog-transform+xml":{"source":"iana","compressible":true},"application/vnd.rainstor.data":{"source":"iana"},"application/vnd.rapid":{"source":"iana"},"application/vnd.rar":{"source":"iana"},"application/vnd.realvnc.bed":{"source":"iana","extensions":["bed"]},"application/vnd.recordare.musicxml":{"source":"iana","extensions":["mxl"]},"application/vnd.recordare.musicxml+xml":{"source":"iana","compressible":true,"extensions":["musicxml"]},"application/vnd.renlearn.rlprint":{"source":"iana"},"application/vnd.restful+json":{"source":"iana","compressible":true},"application/vnd.rig.cryptonote":{"source":"iana","extensions":["cryptonote"]},"application/vnd.rim.cod":{"source":"apache","extensions":["cod"]},"application/vnd.rn-realmedia":{"source":"apache","extensions":["rm"]},"application/vnd.rn-realmedia-vbr":{"source":"apache","extensions":["rmvb"]},"application/vnd.route66.link66+xml":{"source":"iana","compressible":true,"extensions":["link66"]},"application/vnd.rs-274x":{"source":"iana"},"application/vnd.ruckus.download":{"source":"iana"},"application/vnd.s3sms":{"source":"iana"},"application/vnd.sailingtracker.track":{"source":"iana","extensions":["st"]},"application/vnd.sar":{"source":"iana"},"application/vnd.sbm.cid":{"source":"iana"},"application/vnd.sbm.mid2":{"source":"iana"},"application/vnd.scribus":{"source":"iana"},"application/vnd.sealed.3df":{"source":"iana"},"application/vnd.sealed.csf":{"source":"iana"},"application/vnd.sealed.doc":{"source":"iana"},"application/vnd.sealed.eml":{"source":"iana"},"application/vnd.sealed.mht":{"source":"iana"},"application/vnd.sealed.net":{"source":"iana"},"application/vnd.sealed.ppt":{"source":"iana"},"application/vnd.sealed.tiff":{"source":"iana"},"application/vnd.sealed.xls":{"source":"iana"},"application/vnd.sealedmedia.softseal.html":{"source":"iana"},"application/vnd.sealedmedia.softseal.pdf":{"source":"iana"},"application/vnd.seemail":{"source":"iana","extensions":["see"]},"application/vnd.sema":{"source":"iana","extensions":["sema"]},"application/vnd.semd":{"source":"iana","extensions":["semd"]},"application/vnd.semf":{"source":"iana","extensions":["semf"]},"application/vnd.shade-save-file":{"source":"iana"},"application/vnd.shana.informed.formdata":{"source":"iana","extensions":["ifm"]},"application/vnd.shana.informed.formtemplate":{"source":"iana","extensions":["itp"]},"application/vnd.shana.informed.interchange":{"source":"iana","extensions":["iif"]},"application/vnd.shana.informed.package":{"source":"iana","extensions":["ipk"]},"application/vnd.shootproof+json":{"source":"iana","compressible":true},"application/vnd.shopkick+json":{"source":"iana","compressible":true},"application/vnd.shp":{"source":"iana"},"application/vnd.shx":{"source":"iana"},"application/vnd.sigrok.session":{"source":"iana"},"application/vnd.simtech-mindmapper":{"source":"iana","extensions":["twd","twds"]},"application/vnd.siren+json":{"source":"iana","compressible":true},"application/vnd.smaf":{"source":"iana","extensions":["mmf"]},"application/vnd.smart.notebook":{"source":"iana"},"application/vnd.smart.teacher":{"source":"iana","extensions":["teacher"]},"application/vnd.snesdev-page-table":{"source":"iana"},"application/vnd.software602.filler.form+xml":{"source":"iana","compressible":true,"extensions":["fo"]},"application/vnd.software602.filler.form-xml-zip":{"source":"iana"},"application/vnd.solent.sdkm+xml":{"source":"iana","compressible":true,"extensions":["sdkm","sdkd"]},"application/vnd.spotfire.dxp":{"source":"iana","extensions":["dxp"]},"application/vnd.spotfire.sfs":{"source":"iana","extensions":["sfs"]},"application/vnd.sqlite3":{"source":"iana"},"application/vnd.sss-cod":{"source":"iana"},"application/vnd.sss-dtf":{"source":"iana"},"application/vnd.sss-ntf":{"source":"iana"},"application/vnd.stardivision.calc":{"source":"apache","extensions":["sdc"]},"application/vnd.stardivision.draw":{"source":"apache","extensions":["sda"]},"application/vnd.stardivision.impress":{"source":"apache","extensions":["sdd"]},"application/vnd.stardivision.math":{"source":"apache","extensions":["smf"]},"application/vnd.stardivision.writer":{"source":"apache","extensions":["sdw","vor"]},"application/vnd.stardivision.writer-global":{"source":"apache","extensions":["sgl"]},"application/vnd.stepmania.package":{"source":"iana","extensions":["smzip"]},"application/vnd.stepmania.stepchart":{"source":"iana","extensions":["sm"]},"application/vnd.street-stream":{"source":"iana"},"application/vnd.sun.wadl+xml":{"source":"iana","compressible":true,"extensions":["wadl"]},"application/vnd.sun.xml.calc":{"source":"apache","extensions":["sxc"]},"application/vnd.sun.xml.calc.template":{"source":"apache","extensions":["stc"]},"application/vnd.sun.xml.draw":{"source":"apache","extensions":["sxd"]},"application/vnd.sun.xml.draw.template":{"source":"apache","extensions":["std"]},"application/vnd.sun.xml.impress":{"source":"apache","extensions":["sxi"]},"application/vnd.sun.xml.impress.template":{"source":"apache","extensions":["sti"]},"application/vnd.sun.xml.math":{"source":"apache","extensions":["sxm"]},"application/vnd.sun.xml.writer":{"source":"apache","extensions":["sxw"]},"application/vnd.sun.xml.writer.global":{"source":"apache","extensions":["sxg"]},"application/vnd.sun.xml.writer.template":{"source":"apache","extensions":["stw"]},"application/vnd.sus-calendar":{"source":"iana","extensions":["sus","susp"]},"application/vnd.svd":{"source":"iana","extensions":["svd"]},"application/vnd.swiftview-ics":{"source":"iana"},"application/vnd.symbian.install":{"source":"apache","extensions":["sis","sisx"]},"application/vnd.syncml+xml":{"source":"iana","charset":"UTF-8","compressible":true,"extensions":["xsm"]},"application/vnd.syncml.dm+wbxml":{"source":"iana","charset":"UTF-8","extensions":["bdm"]},"application/vnd.syncml.dm+xml":{"source":"iana","charset":"UTF-8","compressible":true,"extensions":["xdm"]},"application/vnd.syncml.dm.notification":{"source":"iana"},"application/vnd.syncml.dmddf+wbxml":{"source":"iana"},"application/vnd.syncml.dmddf+xml":{"source":"iana","charset":"UTF-8","compressible":true,"extensions":["ddf"]},"application/vnd.syncml.dmtnds+wbxml":{"source":"iana"},"application/vnd.syncml.dmtnds+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/vnd.syncml.ds.notification":{"source":"iana"},"application/vnd.tableschema+json":{"source":"iana","compressible":true},"application/vnd.tao.intent-module-archive":{"source":"iana","extensions":["tao"]},"application/vnd.tcpdump.pcap":{"source":"iana","extensions":["pcap","cap","dmp"]},"application/vnd.think-cell.ppttc+json":{"source":"iana","compressible":true},"application/vnd.tmd.mediaflex.api+xml":{"source":"iana","compressible":true},"application/vnd.tml":{"source":"iana"},"application/vnd.tmobile-livetv":{"source":"iana","extensions":["tmo"]},"application/vnd.tri.onesource":{"source":"iana"},"application/vnd.trid.tpt":{"source":"iana","extensions":["tpt"]},"application/vnd.triscape.mxs":{"source":"iana","extensions":["mxs"]},"application/vnd.trueapp":{"source":"iana","extensions":["tra"]},"application/vnd.truedoc":{"source":"iana"},"application/vnd.ubisoft.webplayer":{"source":"iana"},"application/vnd.ufdl":{"source":"iana","extensions":["ufd","ufdl"]},"application/vnd.uiq.theme":{"source":"iana","extensions":["utz"]},"application/vnd.umajin":{"source":"iana","extensions":["umj"]},"application/vnd.unity":{"source":"iana","extensions":["unityweb"]},"application/vnd.uoml+xml":{"source":"iana","compressible":true,"extensions":["uoml"]},"application/vnd.uplanet.alert":{"source":"iana"},"application/vnd.uplanet.alert-wbxml":{"source":"iana"},"application/vnd.uplanet.bearer-choice":{"source":"iana"},"application/vnd.uplanet.bearer-choice-wbxml":{"source":"iana"},"application/vnd.uplanet.cacheop":{"source":"iana"},"application/vnd.uplanet.cacheop-wbxml":{"source":"iana"},"application/vnd.uplanet.channel":{"source":"iana"},"application/vnd.uplanet.channel-wbxml":{"source":"iana"},"application/vnd.uplanet.list":{"source":"iana"},"application/vnd.uplanet.list-wbxml":{"source":"iana"},"application/vnd.uplanet.listcmd":{"source":"iana"},"application/vnd.uplanet.listcmd-wbxml":{"source":"iana"},"application/vnd.uplanet.signal":{"source":"iana"},"application/vnd.uri-map":{"source":"iana"},"application/vnd.valve.source.material":{"source":"iana"},"application/vnd.vcx":{"source":"iana","extensions":["vcx"]},"application/vnd.vd-study":{"source":"iana"},"application/vnd.vectorworks":{"source":"iana"},"application/vnd.vel+json":{"source":"iana","compressible":true},"application/vnd.verimatrix.vcas":{"source":"iana"},"application/vnd.veryant.thin":{"source":"iana"},"application/vnd.ves.encrypted":{"source":"iana"},"application/vnd.vidsoft.vidconference":{"source":"iana"},"application/vnd.visio":{"source":"iana","extensions":["vsd","vst","vss","vsw"]},"application/vnd.visionary":{"source":"iana","extensions":["vis"]},"application/vnd.vividence.scriptfile":{"source":"iana"},"application/vnd.vsf":{"source":"iana","extensions":["vsf"]},"application/vnd.wap.sic":{"source":"iana"},"application/vnd.wap.slc":{"source":"iana"},"application/vnd.wap.wbxml":{"source":"iana","charset":"UTF-8","extensions":["wbxml"]},"application/vnd.wap.wmlc":{"source":"iana","extensions":["wmlc"]},"application/vnd.wap.wmlscriptc":{"source":"iana","extensions":["wmlsc"]},"application/vnd.webturbo":{"source":"iana","extensions":["wtb"]},"application/vnd.wfa.p2p":{"source":"iana"},"application/vnd.wfa.wsc":{"source":"iana"},"application/vnd.windows.devicepairing":{"source":"iana"},"application/vnd.wmc":{"source":"iana"},"application/vnd.wmf.bootstrap":{"source":"iana"},"application/vnd.wolfram.mathematica":{"source":"iana"},"application/vnd.wolfram.mathematica.package":{"source":"iana"},"application/vnd.wolfram.player":{"source":"iana","extensions":["nbp"]},"application/vnd.wordperfect":{"source":"iana","extensions":["wpd"]},"application/vnd.wqd":{"source":"iana","extensions":["wqd"]},"application/vnd.wrq-hp3000-labelled":{"source":"iana"},"application/vnd.wt.stf":{"source":"iana","extensions":["stf"]},"application/vnd.wv.csp+wbxml":{"source":"iana"},"application/vnd.wv.csp+xml":{"source":"iana","compressible":true},"application/vnd.wv.ssp+xml":{"source":"iana","compressible":true},"application/vnd.xacml+json":{"source":"iana","compressible":true},"application/vnd.xara":{"source":"iana","extensions":["xar"]},"application/vnd.xfdl":{"source":"iana","extensions":["xfdl"]},"application/vnd.xfdl.webform":{"source":"iana"},"application/vnd.xmi+xml":{"source":"iana","compressible":true},"application/vnd.xmpie.cpkg":{"source":"iana"},"application/vnd.xmpie.dpkg":{"source":"iana"},"application/vnd.xmpie.plan":{"source":"iana"},"application/vnd.xmpie.ppkg":{"source":"iana"},"application/vnd.xmpie.xlim":{"source":"iana"},"application/vnd.yamaha.hv-dic":{"source":"iana","extensions":["hvd"]},"application/vnd.yamaha.hv-script":{"source":"iana","extensions":["hvs"]},"application/vnd.yamaha.hv-voice":{"source":"iana","extensions":["hvp"]},"application/vnd.yamaha.openscoreformat":{"source":"iana","extensions":["osf"]},"application/vnd.yamaha.openscoreformat.osfpvg+xml":{"source":"iana","compressible":true,"extensions":["osfpvg"]},"application/vnd.yamaha.remote-setup":{"source":"iana"},"application/vnd.yamaha.smaf-audio":{"source":"iana","extensions":["saf"]},"application/vnd.yamaha.smaf-phrase":{"source":"iana","extensions":["spf"]},"application/vnd.yamaha.through-ngn":{"source":"iana"},"application/vnd.yamaha.tunnel-udpencap":{"source":"iana"},"application/vnd.yaoweme":{"source":"iana"},"application/vnd.yellowriver-custom-menu":{"source":"iana","extensions":["cmp"]},"application/vnd.youtube.yt":{"source":"iana"},"application/vnd.zul":{"source":"iana","extensions":["zir","zirz"]},"application/vnd.zzazz.deck+xml":{"source":"iana","compressible":true,"extensions":["zaz"]},"application/voicexml+xml":{"source":"iana","compressible":true,"extensions":["vxml"]},"application/voucher-cms+json":{"source":"iana","compressible":true},"application/vq-rtcpxr":{"source":"iana"},"application/wasm":{"compressible":true,"extensions":["wasm"]},"application/watcherinfo+xml":{"source":"iana","compressible":true},"application/webpush-options+json":{"source":"iana","compressible":true},"application/whoispp-query":{"source":"iana"},"application/whoispp-response":{"source":"iana"},"application/widget":{"source":"iana","extensions":["wgt"]},"application/winhlp":{"source":"apache","extensions":["hlp"]},"application/wita":{"source":"iana"},"application/wordperfect5.1":{"source":"iana"},"application/wsdl+xml":{"source":"iana","compressible":true,"extensions":["wsdl"]},"application/wspolicy+xml":{"source":"iana","compressible":true,"extensions":["wspolicy"]},"application/x-7z-compressed":{"source":"apache","compressible":false,"extensions":["7z"]},"application/x-abiword":{"source":"apache","extensions":["abw"]},"application/x-ace-compressed":{"source":"apache","extensions":["ace"]},"application/x-amf":{"source":"apache"},"application/x-apple-diskimage":{"source":"apache","extensions":["dmg"]},"application/x-arj":{"compressible":false,"extensions":["arj"]},"application/x-authorware-bin":{"source":"apache","extensions":["aab","x32","u32","vox"]},"application/x-authorware-map":{"source":"apache","extensions":["aam"]},"application/x-authorware-seg":{"source":"apache","extensions":["aas"]},"application/x-bcpio":{"source":"apache","extensions":["bcpio"]},"application/x-bdoc":{"compressible":false,"extensions":["bdoc"]},"application/x-bittorrent":{"source":"apache","extensions":["torrent"]},"application/x-blorb":{"source":"apache","extensions":["blb","blorb"]},"application/x-bzip":{"source":"apache","compressible":false,"extensions":["bz"]},"application/x-bzip2":{"source":"apache","compressible":false,"extensions":["bz2","boz"]},"application/x-cbr":{"source":"apache","extensions":["cbr","cba","cbt","cbz","cb7"]},"application/x-cdlink":{"source":"apache","extensions":["vcd"]},"application/x-cfs-compressed":{"source":"apache","extensions":["cfs"]},"application/x-chat":{"source":"apache","extensions":["chat"]},"application/x-chess-pgn":{"source":"apache","extensions":["pgn"]},"application/x-chrome-extension":{"extensions":["crx"]},"application/x-cocoa":{"source":"nginx","extensions":["cco"]},"application/x-compress":{"source":"apache"},"application/x-conference":{"source":"apache","extensions":["nsc"]},"application/x-cpio":{"source":"apache","extensions":["cpio"]},"application/x-csh":{"source":"apache","extensions":["csh"]},"application/x-deb":{"compressible":false},"application/x-debian-package":{"source":"apache","extensions":["deb","udeb"]},"application/x-dgc-compressed":{"source":"apache","extensions":["dgc"]},"application/x-director":{"source":"apache","extensions":["dir","dcr","dxr","cst","cct","cxt","w3d","fgd","swa"]},"application/x-doom":{"source":"apache","extensions":["wad"]},"application/x-dtbncx+xml":{"source":"apache","compressible":true,"extensions":["ncx"]},"application/x-dtbook+xml":{"source":"apache","compressible":true,"extensions":["dtb"]},"application/x-dtbresource+xml":{"source":"apache","compressible":true,"extensions":["res"]},"application/x-dvi":{"source":"apache","compressible":false,"extensions":["dvi"]},"application/x-envoy":{"source":"apache","extensions":["evy"]},"application/x-eva":{"source":"apache","extensions":["eva"]},"application/x-font-bdf":{"source":"apache","extensions":["bdf"]},"application/x-font-dos":{"source":"apache"},"application/x-font-framemaker":{"source":"apache"},"application/x-font-ghostscript":{"source":"apache","extensions":["gsf"]},"application/x-font-libgrx":{"source":"apache"},"application/x-font-linux-psf":{"source":"apache","extensions":["psf"]},"application/x-font-pcf":{"source":"apache","extensions":["pcf"]},"application/x-font-snf":{"source":"apache","extensions":["snf"]},"application/x-font-speedo":{"source":"apache"},"application/x-font-sunos-news":{"source":"apache"},"application/x-font-type1":{"source":"apache","extensions":["pfa","pfb","pfm","afm"]},"application/x-font-vfont":{"source":"apache"},"application/x-freearc":{"source":"apache","extensions":["arc"]},"application/x-futuresplash":{"source":"apache","extensions":["spl"]},"application/x-gca-compressed":{"source":"apache","extensions":["gca"]},"application/x-glulx":{"source":"apache","extensions":["ulx"]},"application/x-gnumeric":{"source":"apache","extensions":["gnumeric"]},"application/x-gramps-xml":{"source":"apache","extensions":["gramps"]},"application/x-gtar":{"source":"apache","extensions":["gtar"]},"application/x-gzip":{"source":"apache"},"application/x-hdf":{"source":"apache","extensions":["hdf"]},"application/x-httpd-php":{"compressible":true,"extensions":["php"]},"application/x-install-instructions":{"source":"apache","extensions":["install"]},"application/x-iso9660-image":{"source":"apache","extensions":["iso"]},"application/x-java-archive-diff":{"source":"nginx","extensions":["jardiff"]},"application/x-java-jnlp-file":{"source":"apache","compressible":false,"extensions":["jnlp"]},"application/x-javascript":{"compressible":true},"application/x-keepass2":{"extensions":["kdbx"]},"application/x-latex":{"source":"apache","compressible":false,"extensions":["latex"]},"application/x-lua-bytecode":{"extensions":["luac"]},"application/x-lzh-compressed":{"source":"apache","extensions":["lzh","lha"]},"application/x-makeself":{"source":"nginx","extensions":["run"]},"application/x-mie":{"source":"apache","extensions":["mie"]},"application/x-mobipocket-ebook":{"source":"apache","extensions":["prc","mobi"]},"application/x-mpegurl":{"compressible":false},"application/x-ms-application":{"source":"apache","extensions":["application"]},"application/x-ms-shortcut":{"source":"apache","extensions":["lnk"]},"application/x-ms-wmd":{"source":"apache","extensions":["wmd"]},"application/x-ms-wmz":{"source":"apache","extensions":["wmz"]},"application/x-ms-xbap":{"source":"apache","extensions":["xbap"]},"application/x-msaccess":{"source":"apache","extensions":["mdb"]},"application/x-msbinder":{"source":"apache","extensions":["obd"]},"application/x-mscardfile":{"source":"apache","extensions":["crd"]},"application/x-msclip":{"source":"apache","extensions":["clp"]},"application/x-msdos-program":{"extensions":["exe"]},"application/x-msdownload":{"source":"apache","extensions":["exe","dll","com","bat","msi"]},"application/x-msmediaview":{"source":"apache","extensions":["mvb","m13","m14"]},"application/x-msmetafile":{"source":"apache","extensions":["wmf","wmz","emf","emz"]},"application/x-msmoney":{"source":"apache","extensions":["mny"]},"application/x-mspublisher":{"source":"apache","extensions":["pub"]},"application/x-msschedule":{"source":"apache","extensions":["scd"]},"application/x-msterminal":{"source":"apache","extensions":["trm"]},"application/x-mswrite":{"source":"apache","extensions":["wri"]},"application/x-netcdf":{"source":"apache","extensions":["nc","cdf"]},"application/x-ns-proxy-autoconfig":{"compressible":true,"extensions":["pac"]},"application/x-nzb":{"source":"apache","extensions":["nzb"]},"application/x-perl":{"source":"nginx","extensions":["pl","pm"]},"application/x-pilot":{"source":"nginx","extensions":["prc","pdb"]},"application/x-pkcs12":{"source":"apache","compressible":false,"extensions":["p12","pfx"]},"application/x-pkcs7-certificates":{"source":"apache","extensions":["p7b","spc"]},"application/x-pkcs7-certreqresp":{"source":"apache","extensions":["p7r"]},"application/x-pki-message":{"source":"iana"},"application/x-rar-compressed":{"source":"apache","compressible":false,"extensions":["rar"]},"application/x-redhat-package-manager":{"source":"nginx","extensions":["rpm"]},"application/x-research-info-systems":{"source":"apache","extensions":["ris"]},"application/x-sea":{"source":"nginx","extensions":["sea"]},"application/x-sh":{"source":"apache","compressible":true,"extensions":["sh"]},"application/x-shar":{"source":"apache","extensions":["shar"]},"application/x-shockwave-flash":{"source":"apache","compressible":false,"extensions":["swf"]},"application/x-silverlight-app":{"source":"apache","extensions":["xap"]},"application/x-sql":{"source":"apache","extensions":["sql"]},"application/x-stuffit":{"source":"apache","compressible":false,"extensions":["sit"]},"application/x-stuffitx":{"source":"apache","extensions":["sitx"]},"application/x-subrip":{"source":"apache","extensions":["srt"]},"application/x-sv4cpio":{"source":"apache","extensions":["sv4cpio"]},"application/x-sv4crc":{"source":"apache","extensions":["sv4crc"]},"application/x-t3vm-image":{"source":"apache","extensions":["t3"]},"application/x-tads":{"source":"apache","extensions":["gam"]},"application/x-tar":{"source":"apache","compressible":true,"extensions":["tar"]},"application/x-tcl":{"source":"apache","extensions":["tcl","tk"]},"application/x-tex":{"source":"apache","extensions":["tex"]},"application/x-tex-tfm":{"source":"apache","extensions":["tfm"]},"application/x-texinfo":{"source":"apache","extensions":["texinfo","texi"]},"application/x-tgif":{"source":"apache","extensions":["obj"]},"application/x-ustar":{"source":"apache","extensions":["ustar"]},"application/x-virtualbox-hdd":{"compressible":true,"extensions":["hdd"]},"application/x-virtualbox-ova":{"compressible":true,"extensions":["ova"]},"application/x-virtualbox-ovf":{"compressible":true,"extensions":["ovf"]},"application/x-virtualbox-vbox":{"compressible":true,"extensions":["vbox"]},"application/x-virtualbox-vbox-extpack":{"compressible":false,"extensions":["vbox-extpack"]},"application/x-virtualbox-vdi":{"compressible":true,"extensions":["vdi"]},"application/x-virtualbox-vhd":{"compressible":true,"extensions":["vhd"]},"application/x-virtualbox-vmdk":{"compressible":true,"extensions":["vmdk"]},"application/x-wais-source":{"source":"apache","extensions":["src"]},"application/x-web-app-manifest+json":{"compressible":true,"extensions":["webapp"]},"application/x-www-form-urlencoded":{"source":"iana","compressible":true},"application/x-x509-ca-cert":{"source":"iana","extensions":["der","crt","pem"]},"application/x-x509-ca-ra-cert":{"source":"iana"},"application/x-x509-next-ca-cert":{"source":"iana"},"application/x-xfig":{"source":"apache","extensions":["fig"]},"application/x-xliff+xml":{"source":"apache","compressible":true,"extensions":["xlf"]},"application/x-xpinstall":{"source":"apache","compressible":false,"extensions":["xpi"]},"application/x-xz":{"source":"apache","extensions":["xz"]},"application/x-zmachine":{"source":"apache","extensions":["z1","z2","z3","z4","z5","z6","z7","z8"]},"application/x400-bp":{"source":"iana"},"application/xacml+xml":{"source":"iana","compressible":true},"application/xaml+xml":{"source":"apache","compressible":true,"extensions":["xaml"]},"application/xcap-att+xml":{"source":"iana","compressible":true,"extensions":["xav"]},"application/xcap-caps+xml":{"source":"iana","compressible":true,"extensions":["xca"]},"application/xcap-diff+xml":{"source":"iana","compressible":true,"extensions":["xdf"]},"application/xcap-el+xml":{"source":"iana","compressible":true,"extensions":["xel"]},"application/xcap-error+xml":{"source":"iana","compressible":true,"extensions":["xer"]},"application/xcap-ns+xml":{"source":"iana","compressible":true,"extensions":["xns"]},"application/xcon-conference-info+xml":{"source":"iana","compressible":true},"application/xcon-conference-info-diff+xml":{"source":"iana","compressible":true},"application/xenc+xml":{"source":"iana","compressible":true,"extensions":["xenc"]},"application/xhtml+xml":{"source":"iana","compressible":true,"extensions":["xhtml","xht"]},"application/xhtml-voice+xml":{"source":"apache","compressible":true},"application/xliff+xml":{"source":"iana","compressible":true,"extensions":["xlf"]},"application/xml":{"source":"iana","compressible":true,"extensions":["xml","xsl","xsd","rng"]},"application/xml-dtd":{"source":"iana","compressible":true,"extensions":["dtd"]},"application/xml-external-parsed-entity":{"source":"iana"},"application/xml-patch+xml":{"source":"iana","compressible":true},"application/xmpp+xml":{"source":"iana","compressible":true},"application/xop+xml":{"source":"iana","compressible":true,"extensions":["xop"]},"application/xproc+xml":{"source":"apache","compressible":true,"extensions":["xpl"]},"application/xslt+xml":{"source":"iana","compressible":true,"extensions":["xslt"]},"application/xspf+xml":{"source":"apache","compressible":true,"extensions":["xspf"]},"application/xv+xml":{"source":"iana","compressible":true,"extensions":["mxml","xhvml","xvml","xvm"]},"application/yang":{"source":"iana","extensions":["yang"]},"application/yang-data+json":{"source":"iana","compressible":true},"application/yang-data+xml":{"source":"iana","compressible":true},"application/yang-patch+json":{"source":"iana","compressible":true},"application/yang-patch+xml":{"source":"iana","compressible":true},"application/yin+xml":{"source":"iana","compressible":true,"extensions":["yin"]},"application/zip":{"source":"iana","compressible":false,"extensions":["zip"]},"application/zlib":{"source":"iana"},"application/zstd":{"source":"iana"},"audio/1d-interleaved-parityfec":{"source":"iana"},"audio/32kadpcm":{"source":"iana"},"audio/3gpp":{"source":"iana","compressible":false,"extensions":["3gpp"]},"audio/3gpp2":{"source":"iana"},"audio/aac":{"source":"iana"},"audio/ac3":{"source":"iana"},"audio/adpcm":{"source":"apache","extensions":["adp"]},"audio/amr":{"source":"iana"},"audio/amr-wb":{"source":"iana"},"audio/amr-wb+":{"source":"iana"},"audio/aptx":{"source":"iana"},"audio/asc":{"source":"iana"},"audio/atrac-advanced-lossless":{"source":"iana"},"audio/atrac-x":{"source":"iana"},"audio/atrac3":{"source":"iana"},"audio/basic":{"source":"iana","compressible":false,"extensions":["au","snd"]},"audio/bv16":{"source":"iana"},"audio/bv32":{"source":"iana"},"audio/clearmode":{"source":"iana"},"audio/cn":{"source":"iana"},"audio/dat12":{"source":"iana"},"audio/dls":{"source":"iana"},"audio/dsr-es201108":{"source":"iana"},"audio/dsr-es202050":{"source":"iana"},"audio/dsr-es202211":{"source":"iana"},"audio/dsr-es202212":{"source":"iana"},"audio/dv":{"source":"iana"},"audio/dvi4":{"source":"iana"},"audio/eac3":{"source":"iana"},"audio/encaprtp":{"source":"iana"},"audio/evrc":{"source":"iana"},"audio/evrc-qcp":{"source":"iana"},"audio/evrc0":{"source":"iana"},"audio/evrc1":{"source":"iana"},"audio/evrcb":{"source":"iana"},"audio/evrcb0":{"source":"iana"},"audio/evrcb1":{"source":"iana"},"audio/evrcnw":{"source":"iana"},"audio/evrcnw0":{"source":"iana"},"audio/evrcnw1":{"source":"iana"},"audio/evrcwb":{"source":"iana"},"audio/evrcwb0":{"source":"iana"},"audio/evrcwb1":{"source":"iana"},"audio/evs":{"source":"iana"},"audio/flexfec":{"source":"iana"},"audio/fwdred":{"source":"iana"},"audio/g711-0":{"source":"iana"},"audio/g719":{"source":"iana"},"audio/g722":{"source":"iana"},"audio/g7221":{"source":"iana"},"audio/g723":{"source":"iana"},"audio/g726-16":{"source":"iana"},"audio/g726-24":{"source":"iana"},"audio/g726-32":{"source":"iana"},"audio/g726-40":{"source":"iana"},"audio/g728":{"source":"iana"},"audio/g729":{"source":"iana"},"audio/g7291":{"source":"iana"},"audio/g729d":{"source":"iana"},"audio/g729e":{"source":"iana"},"audio/gsm":{"source":"iana"},"audio/gsm-efr":{"source":"iana"},"audio/gsm-hr-08":{"source":"iana"},"audio/ilbc":{"source":"iana"},"audio/ip-mr_v2.5":{"source":"iana"},"audio/isac":{"source":"apache"},"audio/l16":{"source":"iana"},"audio/l20":{"source":"iana"},"audio/l24":{"source":"iana","compressible":false},"audio/l8":{"source":"iana"},"audio/lpc":{"source":"iana"},"audio/melp":{"source":"iana"},"audio/melp1200":{"source":"iana"},"audio/melp2400":{"source":"iana"},"audio/melp600":{"source":"iana"},"audio/mhas":{"source":"iana"},"audio/midi":{"source":"apache","extensions":["mid","midi","kar","rmi"]},"audio/mobile-xmf":{"source":"iana","extensions":["mxmf"]},"audio/mp3":{"compressible":false,"extensions":["mp3"]},"audio/mp4":{"source":"iana","compressible":false,"extensions":["m4a","mp4a"]},"audio/mp4a-latm":{"source":"iana"},"audio/mpa":{"source":"iana"},"audio/mpa-robust":{"source":"iana"},"audio/mpeg":{"source":"iana","compressible":false,"extensions":["mpga","mp2","mp2a","mp3","m2a","m3a"]},"audio/mpeg4-generic":{"source":"iana"},"audio/musepack":{"source":"apache"},"audio/ogg":{"source":"iana","compressible":false,"extensions":["oga","ogg","spx"]},"audio/opus":{"source":"iana"},"audio/parityfec":{"source":"iana"},"audio/pcma":{"source":"iana"},"audio/pcma-wb":{"source":"iana"},"audio/pcmu":{"source":"iana"},"audio/pcmu-wb":{"source":"iana"},"audio/prs.sid":{"source":"iana"},"audio/qcelp":{"source":"iana"},"audio/raptorfec":{"source":"iana"},"audio/red":{"source":"iana"},"audio/rtp-enc-aescm128":{"source":"iana"},"audio/rtp-midi":{"source":"iana"},"audio/rtploopback":{"source":"iana"},"audio/rtx":{"source":"iana"},"audio/s3m":{"source":"apache","extensions":["s3m"]},"audio/silk":{"source":"apache","extensions":["sil"]},"audio/smv":{"source":"iana"},"audio/smv-qcp":{"source":"iana"},"audio/smv0":{"source":"iana"},"audio/sp-midi":{"source":"iana"},"audio/speex":{"source":"iana"},"audio/t140c":{"source":"iana"},"audio/t38":{"source":"iana"},"audio/telephone-event":{"source":"iana"},"audio/tetra_acelp":{"source":"iana"},"audio/tetra_acelp_bb":{"source":"iana"},"audio/tone":{"source":"iana"},"audio/uemclip":{"source":"iana"},"audio/ulpfec":{"source":"iana"},"audio/usac":{"source":"iana"},"audio/vdvi":{"source":"iana"},"audio/vmr-wb":{"source":"iana"},"audio/vnd.3gpp.iufp":{"source":"iana"},"audio/vnd.4sb":{"source":"iana"},"audio/vnd.audiokoz":{"source":"iana"},"audio/vnd.celp":{"source":"iana"},"audio/vnd.cisco.nse":{"source":"iana"},"audio/vnd.cmles.radio-events":{"source":"iana"},"audio/vnd.cns.anp1":{"source":"iana"},"audio/vnd.cns.inf1":{"source":"iana"},"audio/vnd.dece.audio":{"source":"iana","extensions":["uva","uvva"]},"audio/vnd.digital-winds":{"source":"iana","extensions":["eol"]},"audio/vnd.dlna.adts":{"source":"iana"},"audio/vnd.dolby.heaac.1":{"source":"iana"},"audio/vnd.dolby.heaac.2":{"source":"iana"},"audio/vnd.dolby.mlp":{"source":"iana"},"audio/vnd.dolby.mps":{"source":"iana"},"audio/vnd.dolby.pl2":{"source":"iana"},"audio/vnd.dolby.pl2x":{"source":"iana"},"audio/vnd.dolby.pl2z":{"source":"iana"},"audio/vnd.dolby.pulse.1":{"source":"iana"},"audio/vnd.dra":{"source":"iana","extensions":["dra"]},"audio/vnd.dts":{"source":"iana","extensions":["dts"]},"audio/vnd.dts.hd":{"source":"iana","extensions":["dtshd"]},"audio/vnd.dts.uhd":{"source":"iana"},"audio/vnd.dvb.file":{"source":"iana"},"audio/vnd.everad.plj":{"source":"iana"},"audio/vnd.hns.audio":{"source":"iana"},"audio/vnd.lucent.voice":{"source":"iana","extensions":["lvp"]},"audio/vnd.ms-playready.media.pya":{"source":"iana","extensions":["pya"]},"audio/vnd.nokia.mobile-xmf":{"source":"iana"},"audio/vnd.nortel.vbk":{"source":"iana"},"audio/vnd.nuera.ecelp4800":{"source":"iana","extensions":["ecelp4800"]},"audio/vnd.nuera.ecelp7470":{"source":"iana","extensions":["ecelp7470"]},"audio/vnd.nuera.ecelp9600":{"source":"iana","extensions":["ecelp9600"]},"audio/vnd.octel.sbc":{"source":"iana"},"audio/vnd.presonus.multitrack":{"source":"iana"},"audio/vnd.qcelp":{"source":"iana"},"audio/vnd.rhetorex.32kadpcm":{"source":"iana"},"audio/vnd.rip":{"source":"iana","extensions":["rip"]},"audio/vnd.rn-realaudio":{"compressible":false},"audio/vnd.sealedmedia.softseal.mpeg":{"source":"iana"},"audio/vnd.vmx.cvsd":{"source":"iana"},"audio/vnd.wave":{"compressible":false},"audio/vorbis":{"source":"iana","compressible":false},"audio/vorbis-config":{"source":"iana"},"audio/wav":{"compressible":false,"extensions":["wav"]},"audio/wave":{"compressible":false,"extensions":["wav"]},"audio/webm":{"source":"apache","compressible":false,"extensions":["weba"]},"audio/x-aac":{"source":"apache","compressible":false,"extensions":["aac"]},"audio/x-aiff":{"source":"apache","extensions":["aif","aiff","aifc"]},"audio/x-caf":{"source":"apache","compressible":false,"extensions":["caf"]},"audio/x-flac":{"source":"apache","extensions":["flac"]},"audio/x-m4a":{"source":"nginx","extensions":["m4a"]},"audio/x-matroska":{"source":"apache","extensions":["mka"]},"audio/x-mpegurl":{"source":"apache","extensions":["m3u"]},"audio/x-ms-wax":{"source":"apache","extensions":["wax"]},"audio/x-ms-wma":{"source":"apache","extensions":["wma"]},"audio/x-pn-realaudio":{"source":"apache","extensions":["ram","ra"]},"audio/x-pn-realaudio-plugin":{"source":"apache","extensions":["rmp"]},"audio/x-realaudio":{"source":"nginx","extensions":["ra"]},"audio/x-tta":{"source":"apache"},"audio/x-wav":{"source":"apache","extensions":["wav"]},"audio/xm":{"source":"apache","extensions":["xm"]},"chemical/x-cdx":{"source":"apache","extensions":["cdx"]},"chemical/x-cif":{"source":"apache","extensions":["cif"]},"chemical/x-cmdf":{"source":"apache","extensions":["cmdf"]},"chemical/x-cml":{"source":"apache","extensions":["cml"]},"chemical/x-csml":{"source":"apache","extensions":["csml"]},"chemical/x-pdb":{"source":"apache"},"chemical/x-xyz":{"source":"apache","extensions":["xyz"]},"font/collection":{"source":"iana","extensions":["ttc"]},"font/otf":{"source":"iana","compressible":true,"extensions":["otf"]},"font/sfnt":{"source":"iana"},"font/ttf":{"source":"iana","compressible":true,"extensions":["ttf"]},"font/woff":{"source":"iana","extensions":["woff"]},"font/woff2":{"source":"iana","extensions":["woff2"]},"image/aces":{"source":"iana","extensions":["exr"]},"image/apng":{"compressible":false,"extensions":["apng"]},"image/avci":{"source":"iana"},"image/avcs":{"source":"iana"},"image/bmp":{"source":"iana","compressible":true,"extensions":["bmp"]},"image/cgm":{"source":"iana","extensions":["cgm"]},"image/dicom-rle":{"source":"iana","extensions":["drle"]},"image/emf":{"source":"iana","extensions":["emf"]},"image/fits":{"source":"iana","extensions":["fits"]},"image/g3fax":{"source":"iana","extensions":["g3"]},"image/gif":{"source":"iana","compressible":false,"extensions":["gif"]},"image/heic":{"source":"iana","extensions":["heic"]},"image/heic-sequence":{"source":"iana","extensions":["heics"]},"image/heif":{"source":"iana","extensions":["heif"]},"image/heif-sequence":{"source":"iana","extensions":["heifs"]},"image/hej2k":{"source":"iana","extensions":["hej2"]},"image/hsj2":{"source":"iana","extensions":["hsj2"]},"image/ief":{"source":"iana","extensions":["ief"]},"image/jls":{"source":"iana","extensions":["jls"]},"image/jp2":{"source":"iana","compressible":false,"extensions":["jp2","jpg2"]},"image/jpeg":{"source":"iana","compressible":false,"extensions":["jpeg","jpg","jpe"]},"image/jph":{"source":"iana","extensions":["jph"]},"image/jphc":{"source":"iana","extensions":["jhc"]},"image/jpm":{"source":"iana","compressible":false,"extensions":["jpm"]},"image/jpx":{"source":"iana","compressible":false,"extensions":["jpx","jpf"]},"image/jxr":{"source":"iana","extensions":["jxr"]},"image/jxra":{"source":"iana","extensions":["jxra"]},"image/jxrs":{"source":"iana","extensions":["jxrs"]},"image/jxs":{"source":"iana","extensions":["jxs"]},"image/jxsc":{"source":"iana","extensions":["jxsc"]},"image/jxsi":{"source":"iana","extensions":["jxsi"]},"image/jxss":{"source":"iana","extensions":["jxss"]},"image/ktx":{"source":"iana","extensions":["ktx"]},"image/naplps":{"source":"iana"},"image/pjpeg":{"compressible":false},"image/png":{"source":"iana","compressible":false,"extensions":["png"]},"image/prs.btif":{"source":"iana","extensions":["btif"]},"image/prs.pti":{"source":"iana","extensions":["pti"]},"image/pwg-raster":{"source":"iana"},"image/sgi":{"source":"apache","extensions":["sgi"]},"image/svg+xml":{"source":"iana","compressible":true,"extensions":["svg","svgz"]},"image/t38":{"source":"iana","extensions":["t38"]},"image/tiff":{"source":"iana","compressible":false,"extensions":["tif","tiff"]},"image/tiff-fx":{"source":"iana","extensions":["tfx"]},"image/vnd.adobe.photoshop":{"source":"iana","compressible":true,"extensions":["psd"]},"image/vnd.airzip.accelerator.azv":{"source":"iana","extensions":["azv"]},"image/vnd.cns.inf2":{"source":"iana"},"image/vnd.dece.graphic":{"source":"iana","extensions":["uvi","uvvi","uvg","uvvg"]},"image/vnd.djvu":{"source":"iana","extensions":["djvu","djv"]},"image/vnd.dvb.subtitle":{"source":"iana","extensions":["sub"]},"image/vnd.dwg":{"source":"iana","extensions":["dwg"]},"image/vnd.dxf":{"source":"iana","extensions":["dxf"]},"image/vnd.fastbidsheet":{"source":"iana","extensions":["fbs"]},"image/vnd.fpx":{"source":"iana","extensions":["fpx"]},"image/vnd.fst":{"source":"iana","extensions":["fst"]},"image/vnd.fujixerox.edmics-mmr":{"source":"iana","extensions":["mmr"]},"image/vnd.fujixerox.edmics-rlc":{"source":"iana","extensions":["rlc"]},"image/vnd.globalgraphics.pgb":{"source":"iana"},"image/vnd.microsoft.icon":{"source":"iana","extensions":["ico"]},"image/vnd.mix":{"source":"iana"},"image/vnd.mozilla.apng":{"source":"iana"},"image/vnd.ms-dds":{"extensions":["dds"]},"image/vnd.ms-modi":{"source":"iana","extensions":["mdi"]},"image/vnd.ms-photo":{"source":"apache","extensions":["wdp"]},"image/vnd.net-fpx":{"source":"iana","extensions":["npx"]},"image/vnd.radiance":{"source":"iana"},"image/vnd.sealed.png":{"source":"iana"},"image/vnd.sealedmedia.softseal.gif":{"source":"iana"},"image/vnd.sealedmedia.softseal.jpg":{"source":"iana"},"image/vnd.svf":{"source":"iana"},"image/vnd.tencent.tap":{"source":"iana","extensions":["tap"]},"image/vnd.valve.source.texture":{"source":"iana","extensions":["vtf"]},"image/vnd.wap.wbmp":{"source":"iana","extensions":["wbmp"]},"image/vnd.xiff":{"source":"iana","extensions":["xif"]},"image/vnd.zbrush.pcx":{"source":"iana","extensions":["pcx"]},"image/webp":{"source":"apache","extensions":["webp"]},"image/wmf":{"source":"iana","extensions":["wmf"]},"image/x-3ds":{"source":"apache","extensions":["3ds"]},"image/x-cmu-raster":{"source":"apache","extensions":["ras"]},"image/x-cmx":{"source":"apache","extensions":["cmx"]},"image/x-freehand":{"source":"apache","extensions":["fh","fhc","fh4","fh5","fh7"]},"image/x-icon":{"source":"apache","compressible":true,"extensions":["ico"]},"image/x-jng":{"source":"nginx","extensions":["jng"]},"image/x-mrsid-image":{"source":"apache","extensions":["sid"]},"image/x-ms-bmp":{"source":"nginx","compressible":true,"extensions":["bmp"]},"image/x-pcx":{"source":"apache","extensions":["pcx"]},"image/x-pict":{"source":"apache","extensions":["pic","pct"]},"image/x-portable-anymap":{"source":"apache","extensions":["pnm"]},"image/x-portable-bitmap":{"source":"apache","extensions":["pbm"]},"image/x-portable-graymap":{"source":"apache","extensions":["pgm"]},"image/x-portable-pixmap":{"source":"apache","extensions":["ppm"]},"image/x-rgb":{"source":"apache","extensions":["rgb"]},"image/x-tga":{"source":"apache","extensions":["tga"]},"image/x-xbitmap":{"source":"apache","extensions":["xbm"]},"image/x-xcf":{"compressible":false},"image/x-xpixmap":{"source":"apache","extensions":["xpm"]},"image/x-xwindowdump":{"source":"apache","extensions":["xwd"]},"message/cpim":{"source":"iana"},"message/delivery-status":{"source":"iana"},"message/disposition-notification":{"source":"iana","extensions":["disposition-notification"]},"message/external-body":{"source":"iana"},"message/feedback-report":{"source":"iana"},"message/global":{"source":"iana","extensions":["u8msg"]},"message/global-delivery-status":{"source":"iana","extensions":["u8dsn"]},"message/global-disposition-notification":{"source":"iana","extensions":["u8mdn"]},"message/global-headers":{"source":"iana","extensions":["u8hdr"]},"message/http":{"source":"iana","compressible":false},"message/imdn+xml":{"source":"iana","compressible":true},"message/news":{"source":"iana"},"message/partial":{"source":"iana","compressible":false},"message/rfc822":{"source":"iana","compressible":true,"extensions":["eml","mime"]},"message/s-http":{"source":"iana"},"message/sip":{"source":"iana"},"message/sipfrag":{"source":"iana"},"message/tracking-status":{"source":"iana"},"message/vnd.si.simp":{"source":"iana"},"message/vnd.wfa.wsc":{"source":"iana","extensions":["wsc"]},"model/3mf":{"source":"iana","extensions":["3mf"]},"model/gltf+json":{"source":"iana","compressible":true,"extensions":["gltf"]},"model/gltf-binary":{"source":"iana","compressible":true,"extensions":["glb"]},"model/iges":{"source":"iana","compressible":false,"extensions":["igs","iges"]},"model/mesh":{"source":"iana","compressible":false,"extensions":["msh","mesh","silo"]},"model/mtl":{"source":"iana","extensions":["mtl"]},"model/obj":{"source":"iana","extensions":["obj"]},"model/stl":{"source":"iana","extensions":["stl"]},"model/vnd.collada+xml":{"source":"iana","compressible":true,"extensions":["dae"]},"model/vnd.dwf":{"source":"iana","extensions":["dwf"]},"model/vnd.flatland.3dml":{"source":"iana"},"model/vnd.gdl":{"source":"iana","extensions":["gdl"]},"model/vnd.gs-gdl":{"source":"apache"},"model/vnd.gs.gdl":{"source":"iana"},"model/vnd.gtw":{"source":"iana","extensions":["gtw"]},"model/vnd.moml+xml":{"source":"iana","compressible":true},"model/vnd.mts":{"source":"iana","extensions":["mts"]},"model/vnd.opengex":{"source":"iana","extensions":["ogex"]},"model/vnd.parasolid.transmit.binary":{"source":"iana","extensions":["x_b"]},"model/vnd.parasolid.transmit.text":{"source":"iana","extensions":["x_t"]},"model/vnd.rosette.annotated-data-model":{"source":"iana"},"model/vnd.usdz+zip":{"source":"iana","compressible":false,"extensions":["usdz"]},"model/vnd.valve.source.compiled-map":{"source":"iana","extensions":["bsp"]},"model/vnd.vtu":{"source":"iana","extensions":["vtu"]},"model/vrml":{"source":"iana","compressible":false,"extensions":["wrl","vrml"]},"model/x3d+binary":{"source":"apache","compressible":false,"extensions":["x3db","x3dbz"]},"model/x3d+fastinfoset":{"source":"iana","extensions":["x3db"]},"model/x3d+vrml":{"source":"apache","compressible":false,"extensions":["x3dv","x3dvz"]},"model/x3d+xml":{"source":"iana","compressible":true,"extensions":["x3d","x3dz"]},"model/x3d-vrml":{"source":"iana","extensions":["x3dv"]},"multipart/alternative":{"source":"iana","compressible":false},"multipart/appledouble":{"source":"iana"},"multipart/byteranges":{"source":"iana"},"multipart/digest":{"source":"iana"},"multipart/encrypted":{"source":"iana","compressible":false},"multipart/form-data":{"source":"iana","compressible":false},"multipart/header-set":{"source":"iana"},"multipart/mixed":{"source":"iana"},"multipart/multilingual":{"source":"iana"},"multipart/parallel":{"source":"iana"},"multipart/related":{"source":"iana","compressible":false},"multipart/report":{"source":"iana"},"multipart/signed":{"source":"iana","compressible":false},"multipart/vnd.bint.med-plus":{"source":"iana"},"multipart/voice-message":{"source":"iana"},"multipart/x-mixed-replace":{"source":"iana"},"text/1d-interleaved-parityfec":{"source":"iana"},"text/cache-manifest":{"source":"iana","compressible":true,"extensions":["appcache","manifest"]},"text/calendar":{"source":"iana","extensions":["ics","ifb"]},"text/calender":{"compressible":true},"text/cmd":{"compressible":true},"text/coffeescript":{"extensions":["coffee","litcoffee"]},"text/css":{"source":"iana","charset":"UTF-8","compressible":true,"extensions":["css"]},"text/csv":{"source":"iana","compressible":true,"extensions":["csv"]},"text/csv-schema":{"source":"iana"},"text/directory":{"source":"iana"},"text/dns":{"source":"iana"},"text/ecmascript":{"source":"iana"},"text/encaprtp":{"source":"iana"},"text/enriched":{"source":"iana"},"text/flexfec":{"source":"iana"},"text/fwdred":{"source":"iana"},"text/grammar-ref-list":{"source":"iana"},"text/html":{"source":"iana","compressible":true,"extensions":["html","htm","shtml"]},"text/jade":{"extensions":["jade"]},"text/javascript":{"source":"iana","compressible":true},"text/jcr-cnd":{"source":"iana"},"text/jsx":{"compressible":true,"extensions":["jsx"]},"text/less":{"compressible":true,"extensions":["less"]},"text/markdown":{"source":"iana","compressible":true,"extensions":["markdown","md"]},"text/mathml":{"source":"nginx","extensions":["mml"]},"text/mdx":{"compressible":true,"extensions":["mdx"]},"text/mizar":{"source":"iana"},"text/n3":{"source":"iana","charset":"UTF-8","compressible":true,"extensions":["n3"]},"text/parameters":{"source":"iana","charset":"UTF-8"},"text/parityfec":{"source":"iana"},"text/plain":{"source":"iana","compressible":true,"extensions":["txt","text","conf","def","list","log","in","ini"]},"text/provenance-notation":{"source":"iana","charset":"UTF-8"},"text/prs.fallenstein.rst":{"source":"iana"},"text/prs.lines.tag":{"source":"iana","extensions":["dsc"]},"text/prs.prop.logic":{"source":"iana"},"text/raptorfec":{"source":"iana"},"text/red":{"source":"iana"},"text/rfc822-headers":{"source":"iana"},"text/richtext":{"source":"iana","compressible":true,"extensions":["rtx"]},"text/rtf":{"source":"iana","compressible":true,"extensions":["rtf"]},"text/rtp-enc-aescm128":{"source":"iana"},"text/rtploopback":{"source":"iana"},"text/rtx":{"source":"iana"},"text/sgml":{"source":"iana","extensions":["sgml","sgm"]},"text/shex":{"extensions":["shex"]},"text/slim":{"extensions":["slim","slm"]},"text/strings":{"source":"iana"},"text/stylus":{"extensions":["stylus","styl"]},"text/t140":{"source":"iana"},"text/tab-separated-values":{"source":"iana","compressible":true,"extensions":["tsv"]},"text/troff":{"source":"iana","extensions":["t","tr","roff","man","me","ms"]},"text/turtle":{"source":"iana","charset":"UTF-8","extensions":["ttl"]},"text/ulpfec":{"source":"iana"},"text/uri-list":{"source":"iana","compressible":true,"extensions":["uri","uris","urls"]},"text/vcard":{"source":"iana","compressible":true,"extensions":["vcard"]},"text/vnd.a":{"source":"iana"},"text/vnd.abc":{"source":"iana"},"text/vnd.ascii-art":{"source":"iana"},"text/vnd.curl":{"source":"iana","extensions":["curl"]},"text/vnd.curl.dcurl":{"source":"apache","extensions":["dcurl"]},"text/vnd.curl.mcurl":{"source":"apache","extensions":["mcurl"]},"text/vnd.curl.scurl":{"source":"apache","extensions":["scurl"]},"text/vnd.debian.copyright":{"source":"iana","charset":"UTF-8"},"text/vnd.dmclientscript":{"source":"iana"},"text/vnd.dvb.subtitle":{"source":"iana","extensions":["sub"]},"text/vnd.esmertec.theme-descriptor":{"source":"iana","charset":"UTF-8"},"text/vnd.ficlab.flt":{"source":"iana"},"text/vnd.fly":{"source":"iana","extensions":["fly"]},"text/vnd.fmi.flexstor":{"source":"iana","extensions":["flx"]},"text/vnd.gml":{"source":"iana"},"text/vnd.graphviz":{"source":"iana","extensions":["gv"]},"text/vnd.hgl":{"source":"iana"},"text/vnd.in3d.3dml":{"source":"iana","extensions":["3dml"]},"text/vnd.in3d.spot":{"source":"iana","extensions":["spot"]},"text/vnd.iptc.newsml":{"source":"iana"},"text/vnd.iptc.nitf":{"source":"iana"},"text/vnd.latex-z":{"source":"iana"},"text/vnd.motorola.reflex":{"source":"iana"},"text/vnd.ms-mediapackage":{"source":"iana"},"text/vnd.net2phone.commcenter.command":{"source":"iana"},"text/vnd.radisys.msml-basic-layout":{"source":"iana"},"text/vnd.senx.warpscript":{"source":"iana"},"text/vnd.si.uricatalogue":{"source":"iana"},"text/vnd.sosi":{"source":"iana"},"text/vnd.sun.j2me.app-descriptor":{"source":"iana","charset":"UTF-8","extensions":["jad"]},"text/vnd.trolltech.linguist":{"source":"iana","charset":"UTF-8"},"text/vnd.wap.si":{"source":"iana"},"text/vnd.wap.sl":{"source":"iana"},"text/vnd.wap.wml":{"source":"iana","extensions":["wml"]},"text/vnd.wap.wmlscript":{"source":"iana","extensions":["wmls"]},"text/vtt":{"source":"iana","charset":"UTF-8","compressible":true,"extensions":["vtt"]},"text/x-asm":{"source":"apache","extensions":["s","asm"]},"text/x-c":{"source":"apache","extensions":["c","cc","cxx","cpp","h","hh","dic"]},"text/x-component":{"source":"nginx","extensions":["htc"]},"text/x-fortran":{"source":"apache","extensions":["f","for","f77","f90"]},"text/x-gwt-rpc":{"compressible":true},"text/x-handlebars-template":{"extensions":["hbs"]},"text/x-java-source":{"source":"apache","extensions":["java"]},"text/x-jquery-tmpl":{"compressible":true},"text/x-lua":{"extensions":["lua"]},"text/x-markdown":{"compressible":true,"extensions":["mkd"]},"text/x-nfo":{"source":"apache","extensions":["nfo"]},"text/x-opml":{"source":"apache","extensions":["opml"]},"text/x-org":{"compressible":true,"extensions":["org"]},"text/x-pascal":{"source":"apache","extensions":["p","pas"]},"text/x-processing":{"compressible":true,"extensions":["pde"]},"text/x-sass":{"extensions":["sass"]},"text/x-scss":{"extensions":["scss"]},"text/x-setext":{"source":"apache","extensions":["etx"]},"text/x-sfv":{"source":"apache","extensions":["sfv"]},"text/x-suse-ymp":{"compressible":true,"extensions":["ymp"]},"text/x-uuencode":{"source":"apache","extensions":["uu"]},"text/x-vcalendar":{"source":"apache","extensions":["vcs"]},"text/x-vcard":{"source":"apache","extensions":["vcf"]},"text/xml":{"source":"iana","compressible":true,"extensions":["xml"]},"text/xml-external-parsed-entity":{"source":"iana"},"text/yaml":{"extensions":["yaml","yml"]},"video/1d-interleaved-parityfec":{"source":"iana"},"video/3gpp":{"source":"iana","extensions":["3gp","3gpp"]},"video/3gpp-tt":{"source":"iana"},"video/3gpp2":{"source":"iana","extensions":["3g2"]},"video/bmpeg":{"source":"iana"},"video/bt656":{"source":"iana"},"video/celb":{"source":"iana"},"video/dv":{"source":"iana"},"video/encaprtp":{"source":"iana"},"video/flexfec":{"source":"iana"},"video/h261":{"source":"iana","extensions":["h261"]},"video/h263":{"source":"iana","extensions":["h263"]},"video/h263-1998":{"source":"iana"},"video/h263-2000":{"source":"iana"},"video/h264":{"source":"iana","extensions":["h264"]},"video/h264-rcdo":{"source":"iana"},"video/h264-svc":{"source":"iana"},"video/h265":{"source":"iana"},"video/iso.segment":{"source":"iana"},"video/jpeg":{"source":"iana","extensions":["jpgv"]},"video/jpeg2000":{"source":"iana"},"video/jpm":{"source":"apache","extensions":["jpm","jpgm"]},"video/mj2":{"source":"iana","extensions":["mj2","mjp2"]},"video/mp1s":{"source":"iana"},"video/mp2p":{"source":"iana"},"video/mp2t":{"source":"iana","extensions":["ts"]},"video/mp4":{"source":"iana","compressible":false,"extensions":["mp4","mp4v","mpg4"]},"video/mp4v-es":{"source":"iana"},"video/mpeg":{"source":"iana","compressible":false,"extensions":["mpeg","mpg","mpe","m1v","m2v"]},"video/mpeg4-generic":{"source":"iana"},"video/mpv":{"source":"iana"},"video/nv":{"source":"iana"},"video/ogg":{"source":"iana","compressible":false,"extensions":["ogv"]},"video/parityfec":{"source":"iana"},"video/pointer":{"source":"iana"},"video/quicktime":{"source":"iana","compressible":false,"extensions":["qt","mov"]},"video/raptorfec":{"source":"iana"},"video/raw":{"source":"iana"},"video/rtp-enc-aescm128":{"source":"iana"},"video/rtploopback":{"source":"iana"},"video/rtx":{"source":"iana"},"video/smpte291":{"source":"iana"},"video/smpte292m":{"source":"iana"},"video/ulpfec":{"source":"iana"},"video/vc1":{"source":"iana"},"video/vc2":{"source":"iana"},"video/vnd.cctv":{"source":"iana"},"video/vnd.dece.hd":{"source":"iana","extensions":["uvh","uvvh"]},"video/vnd.dece.mobile":{"source":"iana","extensions":["uvm","uvvm"]},"video/vnd.dece.mp4":{"source":"iana"},"video/vnd.dece.pd":{"source":"iana","extensions":["uvp","uvvp"]},"video/vnd.dece.sd":{"source":"iana","extensions":["uvs","uvvs"]},"video/vnd.dece.video":{"source":"iana","extensions":["uvv","uvvv"]},"video/vnd.directv.mpeg":{"source":"iana"},"video/vnd.directv.mpeg-tts":{"source":"iana"},"video/vnd.dlna.mpeg-tts":{"source":"iana"},"video/vnd.dvb.file":{"source":"iana","extensions":["dvb"]},"video/vnd.fvt":{"source":"iana","extensions":["fvt"]},"video/vnd.hns.video":{"source":"iana"},"video/vnd.iptvforum.1dparityfec-1010":{"source":"iana"},"video/vnd.iptvforum.1dparityfec-2005":{"source":"iana"},"video/vnd.iptvforum.2dparityfec-1010":{"source":"iana"},"video/vnd.iptvforum.2dparityfec-2005":{"source":"iana"},"video/vnd.iptvforum.ttsavc":{"source":"iana"},"video/vnd.iptvforum.ttsmpeg2":{"source":"iana"},"video/vnd.motorola.video":{"source":"iana"},"video/vnd.motorola.videop":{"source":"iana"},"video/vnd.mpegurl":{"source":"iana","extensions":["mxu","m4u"]},"video/vnd.ms-playready.media.pyv":{"source":"iana","extensions":["pyv"]},"video/vnd.nokia.interleaved-multimedia":{"source":"iana"},"video/vnd.nokia.mp4vr":{"source":"iana"},"video/vnd.nokia.videovoip":{"source":"iana"},"video/vnd.objectvideo":{"source":"iana"},"video/vnd.radgamettools.bink":{"source":"iana"},"video/vnd.radgamettools.smacker":{"source":"iana"},"video/vnd.sealed.mpeg1":{"source":"iana"},"video/vnd.sealed.mpeg4":{"source":"iana"},"video/vnd.sealed.swf":{"source":"iana"},"video/vnd.sealedmedia.softseal.mov":{"source":"iana"},"video/vnd.uvvu.mp4":{"source":"iana","extensions":["uvu","uvvu"]},"video/vnd.vivo":{"source":"iana","extensions":["viv"]},"video/vnd.youtube.yt":{"source":"iana"},"video/vp8":{"source":"iana"},"video/webm":{"source":"apache","compressible":false,"extensions":["webm"]},"video/x-f4v":{"source":"apache","extensions":["f4v"]},"video/x-fli":{"source":"apache","extensions":["fli"]},"video/x-flv":{"source":"apache","compressible":false,"extensions":["flv"]},"video/x-m4v":{"source":"apache","extensions":["m4v"]},"video/x-matroska":{"source":"apache","compressible":false,"extensions":["mkv","mk3d","mks"]},"video/x-mng":{"source":"apache","extensions":["mng"]},"video/x-ms-asf":{"source":"apache","extensions":["asf","asx"]},"video/x-ms-vob":{"source":"apache","extensions":["vob"]},"video/x-ms-wm":{"source":"apache","extensions":["wm"]},"video/x-ms-wmv":{"source":"apache","compressible":false,"extensions":["wmv"]},"video/x-ms-wmx":{"source":"apache","extensions":["wmx"]},"video/x-ms-wvx":{"source":"apache","extensions":["wvx"]},"video/x-msvideo":{"source":"apache","extensions":["avi"]},"video/x-sgi-movie":{"source":"apache","extensions":["movie"]},"video/x-smv":{"source":"apache","extensions":["smv"]},"x-conference/x-cooltalk":{"source":"apache","extensions":["ice"]},"x-shader/x-fragment":{"compressible":true},"x-shader/x-vertex":{"compressible":true}};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 547:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var util = __webpack_require__(669);
|
||
var Stream = __webpack_require__(413).Stream;
|
||
var DelayedStream = __webpack_require__(152);
|
||
|
||
module.exports = CombinedStream;
|
||
function CombinedStream() {
|
||
this.writable = false;
|
||
this.readable = true;
|
||
this.dataSize = 0;
|
||
this.maxDataSize = 2 * 1024 * 1024;
|
||
this.pauseStreams = true;
|
||
|
||
this._released = false;
|
||
this._streams = [];
|
||
this._currentStream = null;
|
||
this._insideLoop = false;
|
||
this._pendingNext = false;
|
||
}
|
||
util.inherits(CombinedStream, Stream);
|
||
|
||
CombinedStream.create = function(options) {
|
||
var combinedStream = new this();
|
||
|
||
options = options || {};
|
||
for (var option in options) {
|
||
combinedStream[option] = options[option];
|
||
}
|
||
|
||
return combinedStream;
|
||
};
|
||
|
||
CombinedStream.isStreamLike = function(stream) {
|
||
return (typeof stream !== 'function')
|
||
&& (typeof stream !== 'string')
|
||
&& (typeof stream !== 'boolean')
|
||
&& (typeof stream !== 'number')
|
||
&& (!Buffer.isBuffer(stream));
|
||
};
|
||
|
||
CombinedStream.prototype.append = function(stream) {
|
||
var isStreamLike = CombinedStream.isStreamLike(stream);
|
||
|
||
if (isStreamLike) {
|
||
if (!(stream instanceof DelayedStream)) {
|
||
var newStream = DelayedStream.create(stream, {
|
||
maxDataSize: Infinity,
|
||
pauseStream: this.pauseStreams,
|
||
});
|
||
stream.on('data', this._checkDataSize.bind(this));
|
||
stream = newStream;
|
||
}
|
||
|
||
this._handleErrors(stream);
|
||
|
||
if (this.pauseStreams) {
|
||
stream.pause();
|
||
}
|
||
}
|
||
|
||
this._streams.push(stream);
|
||
return this;
|
||
};
|
||
|
||
CombinedStream.prototype.pipe = function(dest, options) {
|
||
Stream.prototype.pipe.call(this, dest, options);
|
||
this.resume();
|
||
return dest;
|
||
};
|
||
|
||
CombinedStream.prototype._getNext = function() {
|
||
this._currentStream = null;
|
||
|
||
if (this._insideLoop) {
|
||
this._pendingNext = true;
|
||
return; // defer call
|
||
}
|
||
|
||
this._insideLoop = true;
|
||
try {
|
||
do {
|
||
this._pendingNext = false;
|
||
this._realGetNext();
|
||
} while (this._pendingNext);
|
||
} finally {
|
||
this._insideLoop = false;
|
||
}
|
||
};
|
||
|
||
CombinedStream.prototype._realGetNext = function() {
|
||
var stream = this._streams.shift();
|
||
|
||
|
||
if (typeof stream == 'undefined') {
|
||
this.end();
|
||
return;
|
||
}
|
||
|
||
if (typeof stream !== 'function') {
|
||
this._pipeNext(stream);
|
||
return;
|
||
}
|
||
|
||
var getStream = stream;
|
||
getStream(function(stream) {
|
||
var isStreamLike = CombinedStream.isStreamLike(stream);
|
||
if (isStreamLike) {
|
||
stream.on('data', this._checkDataSize.bind(this));
|
||
this._handleErrors(stream);
|
||
}
|
||
|
||
this._pipeNext(stream);
|
||
}.bind(this));
|
||
};
|
||
|
||
CombinedStream.prototype._pipeNext = function(stream) {
|
||
this._currentStream = stream;
|
||
|
||
var isStreamLike = CombinedStream.isStreamLike(stream);
|
||
if (isStreamLike) {
|
||
stream.on('end', this._getNext.bind(this));
|
||
stream.pipe(this, {end: false});
|
||
return;
|
||
}
|
||
|
||
var value = stream;
|
||
this.write(value);
|
||
this._getNext();
|
||
};
|
||
|
||
CombinedStream.prototype._handleErrors = function(stream) {
|
||
var self = this;
|
||
stream.on('error', function(err) {
|
||
self._emitError(err);
|
||
});
|
||
};
|
||
|
||
CombinedStream.prototype.write = function(data) {
|
||
this.emit('data', data);
|
||
};
|
||
|
||
CombinedStream.prototype.pause = function() {
|
||
if (!this.pauseStreams) {
|
||
return;
|
||
}
|
||
|
||
if(this.pauseStreams && this._currentStream && typeof(this._currentStream.pause) == 'function') this._currentStream.pause();
|
||
this.emit('pause');
|
||
};
|
||
|
||
CombinedStream.prototype.resume = function() {
|
||
if (!this._released) {
|
||
this._released = true;
|
||
this.writable = true;
|
||
this._getNext();
|
||
}
|
||
|
||
if(this.pauseStreams && this._currentStream && typeof(this._currentStream.resume) == 'function') this._currentStream.resume();
|
||
this.emit('resume');
|
||
};
|
||
|
||
CombinedStream.prototype.end = function() {
|
||
this._reset();
|
||
this.emit('end');
|
||
};
|
||
|
||
CombinedStream.prototype.destroy = function() {
|
||
this._reset();
|
||
this.emit('close');
|
||
};
|
||
|
||
CombinedStream.prototype._reset = function() {
|
||
this.writable = false;
|
||
this._streams = [];
|
||
this._currentStream = null;
|
||
};
|
||
|
||
CombinedStream.prototype._checkDataSize = function() {
|
||
this._updateDataSize();
|
||
if (this.dataSize <= this.maxDataSize) {
|
||
return;
|
||
}
|
||
|
||
var message =
|
||
'DelayedStream#maxDataSize of ' + this.maxDataSize + ' bytes exceeded.';
|
||
this._emitError(new Error(message));
|
||
};
|
||
|
||
CombinedStream.prototype._updateDataSize = function() {
|
||
this.dataSize = 0;
|
||
|
||
var self = this;
|
||
this._streams.forEach(function(stream) {
|
||
if (!stream.dataSize) {
|
||
return;
|
||
}
|
||
|
||
self.dataSize += stream.dataSize;
|
||
});
|
||
|
||
if (this._currentStream && this._currentStream.dataSize) {
|
||
this.dataSize += this._currentStream.dataSize;
|
||
}
|
||
};
|
||
|
||
CombinedStream.prototype._emitError = function(err) {
|
||
this._reset();
|
||
this.emit('error', err);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 563:
|
||
/***/ (function(module) {
|
||
|
||
"use strict";
|
||
|
||
|
||
const codes = {};
|
||
|
||
function createErrorType(code, message, Base) {
|
||
if (!Base) {
|
||
Base = Error
|
||
}
|
||
|
||
function getMessage (arg1, arg2, arg3) {
|
||
if (typeof message === 'string') {
|
||
return message
|
||
} else {
|
||
return message(arg1, arg2, arg3)
|
||
}
|
||
}
|
||
|
||
class NodeError extends Base {
|
||
constructor (arg1, arg2, arg3) {
|
||
super(getMessage(arg1, arg2, arg3));
|
||
}
|
||
}
|
||
|
||
NodeError.prototype.name = Base.name;
|
||
NodeError.prototype.code = code;
|
||
|
||
codes[code] = NodeError;
|
||
}
|
||
|
||
// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
|
||
function oneOf(expected, thing) {
|
||
if (Array.isArray(expected)) {
|
||
const len = expected.length;
|
||
expected = expected.map((i) => String(i));
|
||
if (len > 2) {
|
||
return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
|
||
expected[len - 1];
|
||
} else if (len === 2) {
|
||
return `one of ${thing} ${expected[0]} or ${expected[1]}`;
|
||
} else {
|
||
return `of ${thing} ${expected[0]}`;
|
||
}
|
||
} else {
|
||
return `of ${thing} ${String(expected)}`;
|
||
}
|
||
}
|
||
|
||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
|
||
function startsWith(str, search, pos) {
|
||
return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
|
||
}
|
||
|
||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
|
||
function endsWith(str, search, this_len) {
|
||
if (this_len === undefined || this_len > str.length) {
|
||
this_len = str.length;
|
||
}
|
||
return str.substring(this_len - search.length, this_len) === search;
|
||
}
|
||
|
||
// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
|
||
function includes(str, search, start) {
|
||
if (typeof start !== 'number') {
|
||
start = 0;
|
||
}
|
||
|
||
if (start + search.length > str.length) {
|
||
return false;
|
||
} else {
|
||
return str.indexOf(search, start) !== -1;
|
||
}
|
||
}
|
||
|
||
createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
|
||
return 'The value "' + value + '" is invalid for option "' + name + '"'
|
||
}, TypeError);
|
||
createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
|
||
// determiner: 'must be' or 'must not be'
|
||
let determiner;
|
||
if (typeof expected === 'string' && startsWith(expected, 'not ')) {
|
||
determiner = 'must not be';
|
||
expected = expected.replace(/^not /, '');
|
||
} else {
|
||
determiner = 'must be';
|
||
}
|
||
|
||
let msg;
|
||
if (endsWith(name, ' argument')) {
|
||
// For cases like 'first argument'
|
||
msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
|
||
} else {
|
||
const type = includes(name, '.') ? 'property' : 'argument';
|
||
msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
|
||
}
|
||
|
||
msg += `. Received type ${typeof actual}`;
|
||
return msg;
|
||
}, TypeError);
|
||
createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
|
||
createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
|
||
return 'The ' + name + ' method is not implemented'
|
||
});
|
||
createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
|
||
createErrorType('ERR_STREAM_DESTROYED', function (name) {
|
||
return 'Cannot call ' + name + ' after a stream was destroyed';
|
||
});
|
||
createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
|
||
createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
|
||
createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
|
||
createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
|
||
createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
|
||
return 'Unknown encoding: ' + arg
|
||
}, TypeError);
|
||
createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
|
||
|
||
module.exports.codes = codes;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 566:
|
||
/***/ (function(module) {
|
||
|
||
// API
|
||
module.exports = abort;
|
||
|
||
/**
|
||
* Aborts leftover active jobs
|
||
*
|
||
* @param {object} state - current state object
|
||
*/
|
||
function abort(state)
|
||
{
|
||
Object.keys(state.jobs).forEach(clean.bind(state));
|
||
|
||
// reset leftover jobs
|
||
state.jobs = {};
|
||
}
|
||
|
||
/**
|
||
* Cleans up leftover job by invoking abort function for the provided job id
|
||
*
|
||
* @this state
|
||
* @param {string|number} key - job id to abort
|
||
*/
|
||
function clean(key)
|
||
{
|
||
if (typeof this.jobs[key] == 'function')
|
||
{
|
||
this.jobs[key]();
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 574:
|
||
/***/ (function(module, exports, __webpack_require__) {
|
||
|
||
var Stream = __webpack_require__(413);
|
||
if (process.env.READABLE_STREAM === 'disable' && Stream) {
|
||
module.exports = Stream.Readable;
|
||
Object.assign(module.exports, Stream);
|
||
module.exports.Stream = Stream;
|
||
} else {
|
||
exports = module.exports = __webpack_require__(226);
|
||
exports.Stream = Stream || exports;
|
||
exports.Readable = exports;
|
||
exports.Writable = __webpack_require__(241);
|
||
exports.Duplex = __webpack_require__(831);
|
||
exports.Transform = __webpack_require__(925);
|
||
exports.PassThrough = __webpack_require__(882);
|
||
exports.finished = __webpack_require__(287);
|
||
exports.pipeline = __webpack_require__(238);
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 581:
|
||
/***/ (function(module) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var has = Object.prototype.hasOwnProperty;
|
||
var isArray = Array.isArray;
|
||
|
||
var hexTable = (function () {
|
||
var array = [];
|
||
for (var i = 0; i < 256; ++i) {
|
||
array.push('%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase());
|
||
}
|
||
|
||
return array;
|
||
}());
|
||
|
||
var compactQueue = function compactQueue(queue) {
|
||
while (queue.length > 1) {
|
||
var item = queue.pop();
|
||
var obj = item.obj[item.prop];
|
||
|
||
if (isArray(obj)) {
|
||
var compacted = [];
|
||
|
||
for (var j = 0; j < obj.length; ++j) {
|
||
if (typeof obj[j] !== 'undefined') {
|
||
compacted.push(obj[j]);
|
||
}
|
||
}
|
||
|
||
item.obj[item.prop] = compacted;
|
||
}
|
||
}
|
||
};
|
||
|
||
var arrayToObject = function arrayToObject(source, options) {
|
||
var obj = options && options.plainObjects ? Object.create(null) : {};
|
||
for (var i = 0; i < source.length; ++i) {
|
||
if (typeof source[i] !== 'undefined') {
|
||
obj[i] = source[i];
|
||
}
|
||
}
|
||
|
||
return obj;
|
||
};
|
||
|
||
var merge = function merge(target, source, options) {
|
||
/* eslint no-param-reassign: 0 */
|
||
if (!source) {
|
||
return target;
|
||
}
|
||
|
||
if (typeof source !== 'object') {
|
||
if (isArray(target)) {
|
||
target.push(source);
|
||
} else if (target && typeof target === 'object') {
|
||
if ((options && (options.plainObjects || options.allowPrototypes)) || !has.call(Object.prototype, source)) {
|
||
target[source] = true;
|
||
}
|
||
} else {
|
||
return [target, source];
|
||
}
|
||
|
||
return target;
|
||
}
|
||
|
||
if (!target || typeof target !== 'object') {
|
||
return [target].concat(source);
|
||
}
|
||
|
||
var mergeTarget = target;
|
||
if (isArray(target) && !isArray(source)) {
|
||
mergeTarget = arrayToObject(target, options);
|
||
}
|
||
|
||
if (isArray(target) && isArray(source)) {
|
||
source.forEach(function (item, i) {
|
||
if (has.call(target, i)) {
|
||
var targetItem = target[i];
|
||
if (targetItem && typeof targetItem === 'object' && item && typeof item === 'object') {
|
||
target[i] = merge(targetItem, item, options);
|
||
} else {
|
||
target.push(item);
|
||
}
|
||
} else {
|
||
target[i] = item;
|
||
}
|
||
});
|
||
return target;
|
||
}
|
||
|
||
return Object.keys(source).reduce(function (acc, key) {
|
||
var value = source[key];
|
||
|
||
if (has.call(acc, key)) {
|
||
acc[key] = merge(acc[key], value, options);
|
||
} else {
|
||
acc[key] = value;
|
||
}
|
||
return acc;
|
||
}, mergeTarget);
|
||
};
|
||
|
||
var assign = function assignSingleSource(target, source) {
|
||
return Object.keys(source).reduce(function (acc, key) {
|
||
acc[key] = source[key];
|
||
return acc;
|
||
}, target);
|
||
};
|
||
|
||
var decode = function (str, decoder, charset) {
|
||
var strWithoutPlus = str.replace(/\+/g, ' ');
|
||
if (charset === 'iso-8859-1') {
|
||
// unescape never throws, no try...catch needed:
|
||
return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
|
||
}
|
||
// utf-8
|
||
try {
|
||
return decodeURIComponent(strWithoutPlus);
|
||
} catch (e) {
|
||
return strWithoutPlus;
|
||
}
|
||
};
|
||
|
||
var encode = function encode(str, defaultEncoder, charset) {
|
||
// This code was originally written by Brian White (mscdex) for the io.js core querystring library.
|
||
// It has been adapted here for stricter adherence to RFC 3986
|
||
if (str.length === 0) {
|
||
return str;
|
||
}
|
||
|
||
var string = str;
|
||
if (typeof str === 'symbol') {
|
||
string = Symbol.prototype.toString.call(str);
|
||
} else if (typeof str !== 'string') {
|
||
string = String(str);
|
||
}
|
||
|
||
if (charset === 'iso-8859-1') {
|
||
return escape(string).replace(/%u[0-9a-f]{4}/gi, function ($0) {
|
||
return '%26%23' + parseInt($0.slice(2), 16) + '%3B';
|
||
});
|
||
}
|
||
|
||
var out = '';
|
||
for (var i = 0; i < string.length; ++i) {
|
||
var c = string.charCodeAt(i);
|
||
|
||
if (
|
||
c === 0x2D // -
|
||
|| c === 0x2E // .
|
||
|| c === 0x5F // _
|
||
|| c === 0x7E // ~
|
||
|| (c >= 0x30 && c <= 0x39) // 0-9
|
||
|| (c >= 0x41 && c <= 0x5A) // a-z
|
||
|| (c >= 0x61 && c <= 0x7A) // A-Z
|
||
) {
|
||
out += string.charAt(i);
|
||
continue;
|
||
}
|
||
|
||
if (c < 0x80) {
|
||
out = out + hexTable[c];
|
||
continue;
|
||
}
|
||
|
||
if (c < 0x800) {
|
||
out = out + (hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)]);
|
||
continue;
|
||
}
|
||
|
||
if (c < 0xD800 || c >= 0xE000) {
|
||
out = out + (hexTable[0xE0 | (c >> 12)] + hexTable[0x80 | ((c >> 6) & 0x3F)] + hexTable[0x80 | (c & 0x3F)]);
|
||
continue;
|
||
}
|
||
|
||
i += 1;
|
||
c = 0x10000 + (((c & 0x3FF) << 10) | (string.charCodeAt(i) & 0x3FF));
|
||
out += hexTable[0xF0 | (c >> 18)]
|
||
+ hexTable[0x80 | ((c >> 12) & 0x3F)]
|
||
+ hexTable[0x80 | ((c >> 6) & 0x3F)]
|
||
+ hexTable[0x80 | (c & 0x3F)];
|
||
}
|
||
|
||
return out;
|
||
};
|
||
|
||
var compact = function compact(value) {
|
||
var queue = [{ obj: { o: value }, prop: 'o' }];
|
||
var refs = [];
|
||
|
||
for (var i = 0; i < queue.length; ++i) {
|
||
var item = queue[i];
|
||
var obj = item.obj[item.prop];
|
||
|
||
var keys = Object.keys(obj);
|
||
for (var j = 0; j < keys.length; ++j) {
|
||
var key = keys[j];
|
||
var val = obj[key];
|
||
if (typeof val === 'object' && val !== null && refs.indexOf(val) === -1) {
|
||
queue.push({ obj: obj, prop: key });
|
||
refs.push(val);
|
||
}
|
||
}
|
||
}
|
||
|
||
compactQueue(queue);
|
||
|
||
return value;
|
||
};
|
||
|
||
var isRegExp = function isRegExp(obj) {
|
||
return Object.prototype.toString.call(obj) === '[object RegExp]';
|
||
};
|
||
|
||
var isBuffer = function isBuffer(obj) {
|
||
if (!obj || typeof obj !== 'object') {
|
||
return false;
|
||
}
|
||
|
||
return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
|
||
};
|
||
|
||
var combine = function combine(a, b) {
|
||
return [].concat(a, b);
|
||
};
|
||
|
||
var maybeMap = function maybeMap(val, fn) {
|
||
if (isArray(val)) {
|
||
var mapped = [];
|
||
for (var i = 0; i < val.length; i += 1) {
|
||
mapped.push(fn(val[i]));
|
||
}
|
||
return mapped;
|
||
}
|
||
return fn(val);
|
||
};
|
||
|
||
module.exports = {
|
||
arrayToObject: arrayToObject,
|
||
assign: assign,
|
||
combine: combine,
|
||
compact: compact,
|
||
decode: decode,
|
||
encode: encode,
|
||
isBuffer: isBuffer,
|
||
isRegExp: isRegExp,
|
||
maybeMap: maybeMap,
|
||
merge: merge
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 589:
|
||
/***/ (function(module) {
|
||
|
||
"use strict";
|
||
|
||
|
||
const BYTE_UNITS = [
|
||
'B',
|
||
'kB',
|
||
'MB',
|
||
'GB',
|
||
'TB',
|
||
'PB',
|
||
'EB',
|
||
'ZB',
|
||
'YB'
|
||
];
|
||
|
||
const BIBYTE_UNITS = [
|
||
'B',
|
||
'kiB',
|
||
'MiB',
|
||
'GiB',
|
||
'TiB',
|
||
'PiB',
|
||
'EiB',
|
||
'ZiB',
|
||
'YiB'
|
||
];
|
||
|
||
const BIT_UNITS = [
|
||
'b',
|
||
'kbit',
|
||
'Mbit',
|
||
'Gbit',
|
||
'Tbit',
|
||
'Pbit',
|
||
'Ebit',
|
||
'Zbit',
|
||
'Ybit'
|
||
];
|
||
|
||
const BIBIT_UNITS = [
|
||
'b',
|
||
'kibit',
|
||
'Mibit',
|
||
'Gibit',
|
||
'Tibit',
|
||
'Pibit',
|
||
'Eibit',
|
||
'Zibit',
|
||
'Yibit'
|
||
];
|
||
|
||
/*
|
||
Formats the given number using `Number#toLocaleString`.
|
||
- If locale is a string, the value is expected to be a locale-key (for example: `de`).
|
||
- If locale is true, the system default locale is used for translation.
|
||
- If no value for locale is specified, the number is returned unmodified.
|
||
*/
|
||
const toLocaleString = (number, locale) => {
|
||
let result = number;
|
||
if (typeof locale === 'string') {
|
||
result = number.toLocaleString(locale);
|
||
} else if (locale === true) {
|
||
result = number.toLocaleString();
|
||
}
|
||
|
||
return result;
|
||
};
|
||
|
||
module.exports = (number, options) => {
|
||
if (!Number.isFinite(number)) {
|
||
throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
|
||
}
|
||
|
||
options = Object.assign({bits: false, binary: false}, options);
|
||
const UNITS = options.bits ?
|
||
(options.binary ? BIBIT_UNITS : BIT_UNITS) :
|
||
(options.binary ? BIBYTE_UNITS : BYTE_UNITS);
|
||
|
||
if (options.signed && number === 0) {
|
||
return ' 0 ' + UNITS[0];
|
||
}
|
||
|
||
const isNegative = number < 0;
|
||
const prefix = isNegative ? '-' : (options.signed ? '+' : '');
|
||
|
||
if (isNegative) {
|
||
number = -number;
|
||
}
|
||
|
||
if (number < 1) {
|
||
const numberString = toLocaleString(number, options.locale);
|
||
return prefix + numberString + ' ' + UNITS[0];
|
||
}
|
||
|
||
const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
|
||
// eslint-disable-next-line unicorn/prefer-exponentiation-operator
|
||
number = Number((number / Math.pow(options.binary ? 1024 : 1000, exponent)).toPrecision(3));
|
||
const numberString = toLocaleString(number, options.locale);
|
||
|
||
const unit = UNITS[exponent];
|
||
|
||
return prefix + numberString + ' ' + unit;
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 605:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("http");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 614:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("events");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 622:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("path");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 669:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("util");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 674:
|
||
/***/ (function(__unusedmodule, 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__(149).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) : '';
|
||
}
|
||
|
||
/***/ }),
|
||
|
||
/***/ 689:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
try {
|
||
var util = __webpack_require__(669);
|
||
/* istanbul ignore next */
|
||
if (typeof util.inherits !== 'function') throw '';
|
||
module.exports = util.inherits;
|
||
} catch (e) {
|
||
/* istanbul ignore next */
|
||
module.exports = __webpack_require__(315);
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 722:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
const fs = __webpack_require__(747)
|
||
const path = __webpack_require__(622)
|
||
|
||
const { readdir, lstat } = fs.promises
|
||
|
||
/**
|
||
* pathFilter lets you filter files based on a resolved `filepath`.
|
||
* @callback pathFilter
|
||
* @param {String} filepath - The resolved `filepath` of the file to test for filtering.
|
||
*
|
||
* @return {Boolean} Return false to filter the given `filepath` and true to include it.
|
||
*/
|
||
const pathFilter = filepath => true
|
||
|
||
/**
|
||
* statFilter lets you filter files based on a lstat object.
|
||
* @callback statFilter
|
||
* @param {Object} st - A fs.Stats instance.
|
||
*
|
||
* @return {Boolean} Return false to filter the given `filepath` and true to include it.
|
||
*/
|
||
const statFilter = filepath => true
|
||
|
||
/**
|
||
* FWStats is the object that the okdistribute/folder-walker module returns by default.
|
||
*
|
||
* @typedef FWStats
|
||
* @property {String} root - The filepath of the directory where the walk started.
|
||
* @property {String} filepath - The resolved filepath.
|
||
* @property {Object} stat - A fs.Stats instance.
|
||
* @property {String} relname - The relative path to `root`.
|
||
* @property {String} basename - The resolved filepath of the files containing directory.
|
||
*/
|
||
|
||
/**
|
||
* shaper lets you change the shape of the returned file data from walk-time stats.
|
||
* @callback shaper
|
||
* @param {FWStats} fwStats - The same status object returned from folder-walker.
|
||
*
|
||
* @return {*} - Whatever you want returned from the directory walk.
|
||
*/
|
||
const shaper = ({ root, filepath, stat, relname, basename }) => filepath
|
||
|
||
/**
|
||
* Options object
|
||
*
|
||
* @typedef Opts
|
||
* @property {pathFilter} [pathFilter] - A pathFilter cb.
|
||
* @property {statFilter} [statFilter] - A statFilter cb.
|
||
* @property {Number} [maxDepth=Infinity] - The maximum number of folders to walk down into.
|
||
* @property {shaper} [shaper] - A shaper cb.
|
||
*/
|
||
|
||
/**
|
||
* Create an async generator that iterates over all folders and directories inside of `dirs`.
|
||
*
|
||
* @async
|
||
* @generator
|
||
* @function
|
||
* @public
|
||
* @param {String|String[]} dirs - The path of the directory to walk, or an array of directory paths.
|
||
* @param {?(Opts)} opts - Options used for the directory walk.
|
||
*
|
||
* @yields {Promise<String|any>} - An async iterator that returns anything.
|
||
*/
|
||
async function * asyncFolderWalker (dirs, opts) {
|
||
opts = Object.assign({
|
||
fs,
|
||
pathFilter,
|
||
statFilter,
|
||
maxDepth: Infinity,
|
||
shaper
|
||
}, opts)
|
||
|
||
const roots = [dirs].flat().filter(opts.pathFilter)
|
||
const pending = []
|
||
|
||
while (roots.length) {
|
||
const root = roots.shift()
|
||
pending.push(root)
|
||
|
||
while (pending.length) {
|
||
const current = pending.shift()
|
||
if (typeof current === 'undefined') continue
|
||
const st = await lstat(current)
|
||
if ((!st.isDirectory() || depthLimiter(current, root, opts.maxDepth)) && opts.statFilter(st)) {
|
||
yield opts.shaper(fwShape(root, current, st))
|
||
continue
|
||
}
|
||
|
||
const files = await readdir(current)
|
||
files.sort()
|
||
|
||
for (const file of files) {
|
||
var next = path.join(current, file)
|
||
if (opts.pathFilter(next)) pending.unshift(next)
|
||
}
|
||
if (current === root || !opts.statFilter(st)) continue
|
||
else yield opts.shaper(fwShape(root, current, st))
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Generates the same shape as the folder-walker module.
|
||
*
|
||
* @function
|
||
* @private
|
||
* @param {String} root - Root filepath.
|
||
* @param {String} name - Target filepath.
|
||
* @param {Object} st - fs.Stat object.
|
||
*
|
||
* @return {FWStats} - Folder walker object.
|
||
*/
|
||
function fwShape (root, name, st) {
|
||
return {
|
||
root: root,
|
||
filepath: name,
|
||
stat: st,
|
||
relname: root === name ? path.basename(name) : path.relative(root, name),
|
||
basename: path.basename(name)
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Test if we are at maximum directory depth.
|
||
*
|
||
* @private
|
||
* @function
|
||
* @param {String} filePath - The resolved path of the target fille.
|
||
* @param {String} relativeTo - The root directory of the current walk.
|
||
* @param {Number} maxDepth - The maximum number of folders to descend into.
|
||
*
|
||
* @returns {Boolean} - Return true to signal stop descending.
|
||
*/
|
||
function depthLimiter (filePath, relativeTo, maxDepth) {
|
||
if (maxDepth === Infinity) return false
|
||
const rootDepth = relativeTo.split(path.sep).length
|
||
const fileDepth = filePath.split(path.sep).length
|
||
return fileDepth - rootDepth > maxDepth
|
||
}
|
||
|
||
/**
|
||
* Async iterable collector
|
||
*
|
||
* @async
|
||
* @function
|
||
* @private
|
||
*/
|
||
async function all (iterator) {
|
||
const collect = []
|
||
|
||
for await (const result of iterator) {
|
||
collect.push(result)
|
||
}
|
||
|
||
return collect
|
||
}
|
||
|
||
/**
|
||
* allFiles gives you all files from the directory walk as an array.
|
||
*
|
||
* @async
|
||
* @function
|
||
* @public
|
||
* @param {String|String[]} dirs - The path of the directory to walk, or an array of directory paths.
|
||
* @param {?(Opts)} opts - Options used for the directory walk.
|
||
*
|
||
* @returns {Promise<String[]|any>} - An async iterator that returns anything.
|
||
*/
|
||
async function allFiles (...args) {
|
||
return all(asyncFolderWalker(...args))
|
||
}
|
||
|
||
module.exports = {
|
||
asyncFolderWalker,
|
||
allFiles,
|
||
all
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 740:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = class FixedFIFO {
|
||
constructor (hwm) {
|
||
if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two')
|
||
this.buffer = new Array(hwm)
|
||
this.mask = hwm - 1
|
||
this.top = 0
|
||
this.btm = 0
|
||
this.next = null
|
||
}
|
||
|
||
push (data) {
|
||
if (this.buffer[this.top] !== undefined) return false
|
||
this.buffer[this.top] = data
|
||
this.top = (this.top + 1) & this.mask
|
||
return true
|
||
}
|
||
|
||
shift () {
|
||
const last = this.buffer[this.btm]
|
||
if (last === undefined) return undefined
|
||
this.buffer[this.btm] = undefined
|
||
this.btm = (this.btm + 1) & this.mask
|
||
return last
|
||
}
|
||
|
||
isEmpty () {
|
||
return this.buffer[this.btm] === undefined
|
||
}
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 745:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
const { EventEmitter } = __webpack_require__(614)
|
||
const STREAM_DESTROYED = new Error('Stream was destroyed')
|
||
|
||
const FIFO = __webpack_require__(134)
|
||
|
||
/* eslint-disable no-multi-spaces */
|
||
|
||
const MAX = ((1 << 25) - 1)
|
||
|
||
// Shared state
|
||
const OPENING = 0b001
|
||
const DESTROYING = 0b010
|
||
const DESTROYED = 0b100
|
||
|
||
const NOT_OPENING = MAX ^ OPENING
|
||
|
||
// Read state
|
||
const READ_ACTIVE = 0b0000000000001 << 3
|
||
const READ_PRIMARY = 0b0000000000010 << 3
|
||
const READ_SYNC = 0b0000000000100 << 3
|
||
const READ_QUEUED = 0b0000000001000 << 3
|
||
const READ_RESUMED = 0b0000000010000 << 3
|
||
const READ_PIPE_DRAINED = 0b0000000100000 << 3
|
||
const READ_ENDING = 0b0000001000000 << 3
|
||
const READ_EMIT_DATA = 0b0000010000000 << 3
|
||
const READ_EMIT_READABLE = 0b0000100000000 << 3
|
||
const READ_EMITTED_READABLE = 0b0001000000000 << 3
|
||
const READ_DONE = 0b0010000000000 << 3
|
||
const READ_NEXT_TICK = 0b0100000000001 << 3 // also active
|
||
const READ_NEEDS_PUSH = 0b1000000000000 << 3
|
||
|
||
const READ_NOT_ACTIVE = MAX ^ READ_ACTIVE
|
||
const READ_NON_PRIMARY = MAX ^ READ_PRIMARY
|
||
const READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH)
|
||
const READ_NOT_SYNC = MAX ^ READ_SYNC
|
||
const READ_PUSHED = MAX ^ READ_NEEDS_PUSH
|
||
const READ_PAUSED = MAX ^ READ_RESUMED
|
||
const READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE)
|
||
const READ_NOT_ENDING = MAX ^ READ_ENDING
|
||
const READ_PIPE_NOT_DRAINED = MAX ^ (READ_RESUMED | READ_PIPE_DRAINED)
|
||
const READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK
|
||
|
||
// Write state
|
||
const WRITE_ACTIVE = 0b000000001 << 16
|
||
const WRITE_PRIMARY = 0b000000010 << 16
|
||
const WRITE_SYNC = 0b000000100 << 16
|
||
const WRITE_QUEUED = 0b000001000 << 16
|
||
const WRITE_UNDRAINED = 0b000010000 << 16
|
||
const WRITE_DONE = 0b000100000 << 16
|
||
const WRITE_EMIT_DRAIN = 0b001000000 << 16
|
||
const WRITE_NEXT_TICK = 0b010000001 << 16 // also active
|
||
const WRITE_FINISHING = 0b100000000 << 16
|
||
|
||
const WRITE_NOT_ACTIVE = MAX ^ WRITE_ACTIVE
|
||
const WRITE_NOT_SYNC = MAX ^ WRITE_SYNC
|
||
const WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY
|
||
const WRITE_NOT_FINISHING = MAX ^ WRITE_FINISHING
|
||
const WRITE_DRAINED = MAX ^ WRITE_UNDRAINED
|
||
const WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED
|
||
const WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK
|
||
|
||
// Combined shared state
|
||
const ACTIVE = READ_ACTIVE | WRITE_ACTIVE
|
||
const NOT_ACTIVE = MAX ^ ACTIVE
|
||
const DONE = READ_DONE | WRITE_DONE
|
||
const DESTROY_STATUS = DESTROYING | DESTROYED
|
||
const OPEN_STATUS = DESTROY_STATUS | OPENING
|
||
const AUTO_DESTROY = DESTROY_STATUS | DONE
|
||
const NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY
|
||
|
||
// Combined read state
|
||
const READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE
|
||
const READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED
|
||
const READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED
|
||
const READ_ACTIVE_AND_SYNC = READ_ACTIVE | READ_SYNC
|
||
const READ_ACTIVE_AND_SYNC_AND_NEEDS_PUSH = READ_ACTIVE | READ_SYNC | READ_NEEDS_PUSH
|
||
const READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE
|
||
const READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED
|
||
const READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED
|
||
const READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE
|
||
const SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH
|
||
const READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE
|
||
|
||
// Combined write state
|
||
const WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE
|
||
const WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED
|
||
const WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE
|
||
const WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE
|
||
const WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED
|
||
const WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE
|
||
const WRITE_ACTIVE_AND_SYNC = WRITE_ACTIVE | WRITE_SYNC
|
||
const WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED
|
||
const WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE
|
||
|
||
const asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator')
|
||
|
||
class WritableState {
|
||
constructor (stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
|
||
this.stream = stream
|
||
this.queue = new FIFO()
|
||
this.highWaterMark = highWaterMark
|
||
this.buffered = 0
|
||
this.error = null
|
||
this.pipeline = null
|
||
this.byteLength = byteLengthWritable || byteLength || defaultByteLength
|
||
this.map = mapWritable || map
|
||
this.afterWrite = afterWrite.bind(this)
|
||
}
|
||
|
||
get ended () {
|
||
return (this.stream._duplexState & WRITE_DONE) !== 0
|
||
}
|
||
|
||
push (data) {
|
||
if (this.map !== null) data = this.map(data)
|
||
|
||
this.buffered += this.byteLength(data)
|
||
this.queue.push(data)
|
||
|
||
if (this.buffered < this.highWaterMark) {
|
||
this.stream._duplexState |= WRITE_QUEUED
|
||
return true
|
||
}
|
||
|
||
this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED
|
||
return false
|
||
}
|
||
|
||
shift () {
|
||
const data = this.queue.shift()
|
||
const stream = this.stream
|
||
|
||
this.buffered -= this.byteLength(data)
|
||
if (this.buffered === 0) stream._duplexState &= WRITE_NOT_QUEUED
|
||
|
||
return data
|
||
}
|
||
|
||
end (data) {
|
||
if (typeof data === 'function') this.stream.once('finish', data)
|
||
else if (data !== undefined && data !== null) this.push(data)
|
||
this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY
|
||
}
|
||
|
||
autoBatch (data, cb) {
|
||
const buffer = []
|
||
const stream = this.stream
|
||
|
||
buffer.push(data)
|
||
while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {
|
||
buffer.push(stream._writableState.shift())
|
||
}
|
||
|
||
if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null)
|
||
stream._writev(buffer, cb)
|
||
}
|
||
|
||
update () {
|
||
const stream = this.stream
|
||
|
||
while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
|
||
const data = this.shift()
|
||
stream._duplexState |= WRITE_ACTIVE_AND_SYNC
|
||
stream._write(data, this.afterWrite)
|
||
stream._duplexState &= WRITE_NOT_SYNC
|
||
}
|
||
|
||
if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()
|
||
}
|
||
|
||
updateNonPrimary () {
|
||
const stream = this.stream
|
||
|
||
if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
|
||
stream._duplexState = (stream._duplexState | WRITE_ACTIVE) & WRITE_NOT_FINISHING
|
||
stream._final(afterFinal.bind(this))
|
||
return
|
||
}
|
||
|
||
if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
|
||
if ((stream._duplexState & ACTIVE) === 0) {
|
||
stream._duplexState |= ACTIVE
|
||
stream._destroy(afterDestroy.bind(this))
|
||
}
|
||
return
|
||
}
|
||
|
||
if ((stream._duplexState & OPEN_STATUS) === OPENING) {
|
||
stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING
|
||
stream._open(afterOpen.bind(this))
|
||
}
|
||
}
|
||
|
||
updateNextTick () {
|
||
if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return
|
||
this.stream._duplexState |= WRITE_NEXT_TICK
|
||
process.nextTick(updateWriteNT, this)
|
||
}
|
||
}
|
||
|
||
class ReadableState {
|
||
constructor (stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
|
||
this.stream = stream
|
||
this.queue = new FIFO()
|
||
this.highWaterMark = highWaterMark
|
||
this.buffered = 0
|
||
this.error = null
|
||
this.pipeline = null
|
||
this.byteLength = byteLengthReadable || byteLength || defaultByteLength
|
||
this.map = mapReadable || map
|
||
this.pipeTo = null
|
||
this.afterRead = afterRead.bind(this)
|
||
}
|
||
|
||
get ended () {
|
||
return (this.stream._duplexState & READ_DONE) !== 0
|
||
}
|
||
|
||
pipe (pipeTo, cb) {
|
||
if (this.pipeTo !== null) throw new Error('Can only pipe to one destination')
|
||
|
||
this.stream._duplexState |= READ_PIPE_DRAINED
|
||
this.pipeTo = pipeTo
|
||
this.pipeline = new Pipeline(this.stream, pipeTo, cb || null)
|
||
|
||
if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes
|
||
|
||
if (isStreamx(pipeTo)) {
|
||
pipeTo._writableState.pipeline = this.pipeline
|
||
if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes
|
||
pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself
|
||
} else {
|
||
const onerror = this.pipeline.done.bind(this.pipeline, pipeTo)
|
||
const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool arg
|
||
pipeTo.on('error', onerror)
|
||
pipeTo.on('close', onclose)
|
||
pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline))
|
||
}
|
||
|
||
pipeTo.on('drain', afterDrain.bind(this))
|
||
this.stream.emit('piping', pipeTo)
|
||
pipeTo.emit('pipe', this.stream)
|
||
}
|
||
|
||
push (data) {
|
||
const stream = this.stream
|
||
|
||
if (data === null) {
|
||
this.highWaterMark = 0
|
||
stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED
|
||
return false
|
||
}
|
||
|
||
if (this.map !== null) data = this.map(data)
|
||
this.buffered += this.byteLength(data)
|
||
this.queue.push(data)
|
||
|
||
stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED
|
||
|
||
return this.buffered < this.highWaterMark
|
||
}
|
||
|
||
shift () {
|
||
const data = this.queue.shift()
|
||
|
||
this.buffered -= this.byteLength(data)
|
||
if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED
|
||
return data
|
||
}
|
||
|
||
unshift (data) {
|
||
let tail
|
||
const pending = []
|
||
|
||
while ((tail === this.queue.shift()) !== undefined) {
|
||
pending.push(tail)
|
||
}
|
||
|
||
this.push(data)
|
||
|
||
for (let i = 0; i < pending.length; i++) {
|
||
this.queue.push(pending[i])
|
||
}
|
||
}
|
||
|
||
read () {
|
||
const stream = this.stream
|
||
|
||
if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {
|
||
const data = this.shift()
|
||
if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data)
|
||
if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED
|
||
return data
|
||
}
|
||
|
||
return null
|
||
}
|
||
|
||
drain () {
|
||
const stream = this.stream
|
||
|
||
while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {
|
||
const data = this.shift()
|
||
if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data)
|
||
if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED
|
||
}
|
||
}
|
||
|
||
update () {
|
||
const stream = this.stream
|
||
|
||
this.drain()
|
||
|
||
while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === 0) {
|
||
stream._duplexState |= READ_ACTIVE_AND_SYNC_AND_NEEDS_PUSH
|
||
stream._read(this.afterRead)
|
||
stream._duplexState &= READ_NOT_SYNC
|
||
if ((stream._duplexState & READ_ACTIVE) === 0) this.drain()
|
||
}
|
||
|
||
if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {
|
||
stream._duplexState |= READ_EMITTED_READABLE
|
||
stream.emit('readable')
|
||
}
|
||
|
||
if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()
|
||
}
|
||
|
||
updateNonPrimary () {
|
||
const stream = this.stream
|
||
|
||
if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {
|
||
stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING
|
||
stream.emit('end')
|
||
if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING
|
||
if (this.pipeTo !== null) this.pipeTo.end()
|
||
}
|
||
|
||
if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
|
||
if ((stream._duplexState & ACTIVE) === 0) {
|
||
stream._duplexState |= ACTIVE
|
||
stream._destroy(afterDestroy.bind(this))
|
||
}
|
||
return
|
||
}
|
||
|
||
if ((stream._duplexState & OPEN_STATUS) === OPENING) {
|
||
stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING
|
||
stream._open(afterOpen.bind(this))
|
||
}
|
||
}
|
||
|
||
updateNextTick () {
|
||
if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return
|
||
this.stream._duplexState |= READ_NEXT_TICK
|
||
process.nextTick(updateReadNT, this)
|
||
}
|
||
}
|
||
|
||
class TransformState {
|
||
constructor (stream) {
|
||
this.data = null
|
||
this.afterTransform = afterTransform.bind(stream)
|
||
this.afterFinal = null
|
||
}
|
||
}
|
||
|
||
class Pipeline {
|
||
constructor (src, dst, cb) {
|
||
this.from = src
|
||
this.to = dst
|
||
this.afterPipe = cb
|
||
this.error = null
|
||
this.pipeToFinished = false
|
||
}
|
||
|
||
finished () {
|
||
this.pipeToFinished = true
|
||
}
|
||
|
||
done (stream, err) {
|
||
if (err) this.error = err
|
||
|
||
if (stream === this.to) {
|
||
this.to = null
|
||
|
||
if (this.from !== null) {
|
||
if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {
|
||
this.from.destroy(new Error('Writable stream closed prematurely'))
|
||
}
|
||
return
|
||
}
|
||
}
|
||
|
||
if (stream === this.from) {
|
||
this.from = null
|
||
|
||
if (this.to !== null) {
|
||
if ((stream._duplexState & READ_DONE) === 0) {
|
||
this.to.destroy(new Error('Readable stream closed before ending'))
|
||
}
|
||
return
|
||
}
|
||
}
|
||
|
||
if (this.afterPipe !== null) this.afterPipe(this.error)
|
||
this.to = this.from = this.afterPipe = null
|
||
}
|
||
}
|
||
|
||
function afterDrain () {
|
||
this.stream._duplexState |= READ_PIPE_DRAINED
|
||
if ((this.stream._duplexState & READ_ACTIVE_AND_SYNC) === 0) this.updateNextTick()
|
||
}
|
||
|
||
function afterFinal (err) {
|
||
const stream = this.stream
|
||
if (err) stream.destroy(err)
|
||
if ((stream._duplexState & DESTROY_STATUS) === 0) {
|
||
stream._duplexState |= WRITE_DONE
|
||
stream.emit('finish')
|
||
}
|
||
if ((stream._duplexState & AUTO_DESTROY) === DONE) {
|
||
stream._duplexState |= DESTROYING
|
||
}
|
||
|
||
stream._duplexState &= WRITE_NOT_ACTIVE
|
||
this.update()
|
||
}
|
||
|
||
function afterDestroy (err) {
|
||
const stream = this.stream
|
||
|
||
if (!err && this.error !== STREAM_DESTROYED) err = this.error
|
||
if (err) stream.emit('error', err)
|
||
stream._duplexState |= DESTROYED
|
||
stream.emit('close')
|
||
|
||
const rs = stream._readableState
|
||
const ws = stream._writableState
|
||
|
||
if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err)
|
||
if (ws !== null && ws.pipeline !== null) ws.pipeline.done(stream, err)
|
||
}
|
||
|
||
function afterWrite (err) {
|
||
const stream = this.stream
|
||
|
||
if (err) stream.destroy(err)
|
||
stream._duplexState &= WRITE_NOT_ACTIVE
|
||
|
||
if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {
|
||
stream._duplexState &= WRITE_DRAINED
|
||
if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {
|
||
stream.emit('drain')
|
||
}
|
||
}
|
||
|
||
if ((stream._duplexState & WRITE_SYNC) === 0) this.update()
|
||
}
|
||
|
||
function afterRead (err) {
|
||
if (err) this.stream.destroy(err)
|
||
this.stream._duplexState &= READ_NOT_ACTIVE
|
||
if ((this.stream._duplexState & READ_SYNC) === 0) this.update()
|
||
}
|
||
|
||
function updateReadNT (rs) {
|
||
rs.stream._duplexState &= READ_NOT_NEXT_TICK
|
||
rs.update()
|
||
}
|
||
|
||
function updateWriteNT (ws) {
|
||
ws.stream._duplexState &= WRITE_NOT_NEXT_TICK
|
||
ws.update()
|
||
}
|
||
|
||
function afterOpen (err) {
|
||
const stream = this.stream
|
||
|
||
if (err) stream.destroy(err)
|
||
|
||
if ((stream._duplexState & DESTROYING) === 0) {
|
||
if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY
|
||
if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY
|
||
stream.emit('open')
|
||
}
|
||
|
||
stream._duplexState &= NOT_ACTIVE
|
||
|
||
if (stream._writableState !== null) {
|
||
stream._writableState.update()
|
||
}
|
||
|
||
if (stream._readableState !== null) {
|
||
stream._readableState.update()
|
||
}
|
||
}
|
||
|
||
function afterTransform (err, data) {
|
||
if (data !== undefined && data !== null) this.push(data)
|
||
this._writableState.afterWrite(err)
|
||
}
|
||
|
||
class Stream extends EventEmitter {
|
||
constructor (opts) {
|
||
super()
|
||
|
||
this._duplexState = 0
|
||
this._readableState = null
|
||
this._writableState = null
|
||
|
||
if (opts) {
|
||
if (opts.open) this._open = opts.open
|
||
if (opts.destroy) this._destroy = opts.destroy
|
||
if (opts.predestroy) this._predestroy = opts.predestroy
|
||
}
|
||
}
|
||
|
||
_open (cb) {
|
||
cb(null)
|
||
}
|
||
|
||
_destroy (cb) {
|
||
cb(null)
|
||
}
|
||
|
||
_predestroy () {
|
||
// does nothing
|
||
}
|
||
|
||
get readable () {
|
||
return this._readableState !== null ? true : undefined
|
||
}
|
||
|
||
get writable () {
|
||
return this._writableState !== null ? true : undefined
|
||
}
|
||
|
||
get destroyed () {
|
||
return (this._duplexState & DESTROYED) !== 0
|
||
}
|
||
|
||
get destroying () {
|
||
return (this._duplexState & DESTROY_STATUS) !== 0
|
||
}
|
||
|
||
destroy (err) {
|
||
if ((this._duplexState & DESTROY_STATUS) === 0) {
|
||
if (!err) err = STREAM_DESTROYED
|
||
this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY
|
||
this._predestroy()
|
||
if (this._readableState !== null) {
|
||
this._readableState.error = err
|
||
this._readableState.updateNextTick()
|
||
}
|
||
if (this._writableState !== null) {
|
||
this._writableState.error = err
|
||
this._writableState.updateNextTick()
|
||
}
|
||
}
|
||
}
|
||
|
||
on (name, fn) {
|
||
if (this._readableState !== null) {
|
||
if (name === 'data') {
|
||
this._duplexState |= (READ_EMIT_DATA | READ_RESUMED)
|
||
this._readableState.updateNextTick()
|
||
}
|
||
if (name === 'readable') {
|
||
this._duplexState |= READ_EMIT_READABLE
|
||
this._readableState.updateNextTick()
|
||
}
|
||
}
|
||
|
||
if (this._writableState !== null) {
|
||
if (name === 'drain') {
|
||
this._duplexState |= WRITE_EMIT_DRAIN
|
||
this._writableState.updateNextTick()
|
||
}
|
||
}
|
||
|
||
return super.on(name, fn)
|
||
}
|
||
}
|
||
|
||
class Readable extends Stream {
|
||
constructor (opts) {
|
||
super(opts)
|
||
|
||
this._duplexState |= OPENING | WRITE_DONE
|
||
this._readableState = new ReadableState(this, opts)
|
||
|
||
if (opts) {
|
||
if (opts.read) this._read = opts.read
|
||
}
|
||
}
|
||
|
||
_read (cb) {
|
||
cb(null)
|
||
}
|
||
|
||
pipe (dest, cb) {
|
||
this._readableState.pipe(dest, cb)
|
||
this._readableState.updateNextTick()
|
||
return dest
|
||
}
|
||
|
||
read () {
|
||
this._readableState.updateNextTick()
|
||
return this._readableState.read()
|
||
}
|
||
|
||
push (data) {
|
||
this._readableState.updateNextTick()
|
||
return this._readableState.push(data)
|
||
}
|
||
|
||
unshift (data) {
|
||
this._readableState.updateNextTick()
|
||
return this._readableState.unshift(data)
|
||
}
|
||
|
||
resume () {
|
||
this._duplexState |= READ_RESUMED
|
||
this._readableState.updateNextTick()
|
||
}
|
||
|
||
pause () {
|
||
this._duplexState &= READ_PAUSED
|
||
}
|
||
|
||
static _fromAsyncIterator (ite) {
|
||
let destroy
|
||
|
||
const rs = new Readable({
|
||
read (cb) {
|
||
ite.next().then(push).then(cb.bind(null, null)).catch(cb)
|
||
},
|
||
predestroy () {
|
||
destroy = ite.return()
|
||
},
|
||
destroy (cb) {
|
||
destroy.then(cb.bind(null, null)).catch(cb)
|
||
}
|
||
})
|
||
|
||
return rs
|
||
|
||
function push (data) {
|
||
if (data.done) rs.push(null)
|
||
else rs.push(data.value)
|
||
}
|
||
}
|
||
|
||
static from (data) {
|
||
if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator]())
|
||
if (!Array.isArray(data)) data = data === undefined ? [] : [data]
|
||
|
||
let i = 0
|
||
return new Readable({
|
||
read (cb) {
|
||
this.push(i === data.length ? null : data[i++])
|
||
cb(null)
|
||
}
|
||
})
|
||
}
|
||
|
||
static isBackpressured (rs) {
|
||
return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark
|
||
}
|
||
|
||
[asyncIterator] () {
|
||
const stream = this
|
||
|
||
let error = null
|
||
let promiseResolve = null
|
||
let promiseReject = null
|
||
|
||
this.on('error', (err) => { error = err })
|
||
this.on('readable', onreadable)
|
||
this.on('close', onclose)
|
||
|
||
return {
|
||
[asyncIterator] () {
|
||
return this
|
||
},
|
||
next () {
|
||
return new Promise(function (resolve, reject) {
|
||
promiseResolve = resolve
|
||
promiseReject = reject
|
||
const data = stream.read()
|
||
if (data !== null) ondata(data)
|
||
else if ((stream._duplexState & DESTROYED) !== 0) ondata(null)
|
||
})
|
||
},
|
||
return () {
|
||
return destroy(null)
|
||
},
|
||
throw (err) {
|
||
return destroy(err)
|
||
}
|
||
}
|
||
|
||
function onreadable () {
|
||
if (promiseResolve !== null) ondata(stream.read())
|
||
}
|
||
|
||
function onclose () {
|
||
if (promiseResolve !== null) ondata(null)
|
||
}
|
||
|
||
function ondata (data) {
|
||
if (promiseReject === null) return
|
||
if (error) promiseReject(error)
|
||
else if (data === null && (stream._duplexState & READ_DONE) === 0) promiseReject(STREAM_DESTROYED)
|
||
else promiseResolve({ value: data, done: data === null })
|
||
promiseReject = promiseResolve = null
|
||
}
|
||
|
||
function destroy (err) {
|
||
stream.destroy(err)
|
||
return new Promise((resolve, reject) => {
|
||
if (stream._duplexState & DESTROYED) return resolve()
|
||
stream.once('close', function () {
|
||
if (err) reject(err)
|
||
else resolve({ value: undefined, done: true })
|
||
})
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
class Writable extends Stream {
|
||
constructor (opts) {
|
||
super(opts)
|
||
|
||
this._duplexState |= OPENING | READ_DONE
|
||
this._writableState = new WritableState(this, opts)
|
||
|
||
if (opts) {
|
||
if (opts.writev) this._writev = opts.writev
|
||
if (opts.write) this._write = opts.write
|
||
if (opts.final) this._final = opts.final
|
||
}
|
||
}
|
||
|
||
_writev (batch, cb) {
|
||
cb(null)
|
||
}
|
||
|
||
_write (data, cb) {
|
||
this._writableState.autoBatch(data, cb)
|
||
}
|
||
|
||
_final (cb) {
|
||
cb(null)
|
||
}
|
||
|
||
static isBackpressured (ws) {
|
||
return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0
|
||
}
|
||
|
||
write (data) {
|
||
this._writableState.updateNextTick()
|
||
return this._writableState.push(data)
|
||
}
|
||
|
||
end (data) {
|
||
this._writableState.updateNextTick()
|
||
this._writableState.end(data)
|
||
}
|
||
}
|
||
|
||
class Duplex extends Readable { // and Writable
|
||
constructor (opts) {
|
||
super(opts)
|
||
|
||
this._duplexState = OPENING
|
||
this._writableState = new WritableState(this, opts)
|
||
|
||
if (opts) {
|
||
if (opts.writev) this._writev = opts.writev
|
||
if (opts.write) this._write = opts.write
|
||
if (opts.final) this._final = opts.final
|
||
}
|
||
}
|
||
|
||
_writev (batch, cb) {
|
||
cb(null)
|
||
}
|
||
|
||
_write (data, cb) {
|
||
this._writableState.autoBatch(data, cb)
|
||
}
|
||
|
||
_final (cb) {
|
||
cb(null)
|
||
}
|
||
|
||
write (data) {
|
||
this._writableState.updateNextTick()
|
||
return this._writableState.push(data)
|
||
}
|
||
|
||
end (data) {
|
||
this._writableState.updateNextTick()
|
||
this._writableState.end(data)
|
||
}
|
||
}
|
||
|
||
class Transform extends Duplex {
|
||
constructor (opts) {
|
||
super(opts)
|
||
this._transformState = new TransformState(this)
|
||
|
||
if (opts) {
|
||
if (opts.transform) this._transform = opts.transform
|
||
if (opts.flush) this._flush = opts.flush
|
||
}
|
||
}
|
||
|
||
_write (data, cb) {
|
||
if (this._readableState.buffered >= this._readableState.highWaterMark) {
|
||
this._transformState.data = data
|
||
} else {
|
||
this._transform(data, this._transformState.afterTransform)
|
||
}
|
||
}
|
||
|
||
_read (cb) {
|
||
if (this._transformState.data !== null) {
|
||
const data = this._transformState.data
|
||
this._transformState.data = null
|
||
cb(null)
|
||
this._transform(data, this._transformState.afterTransform)
|
||
} else {
|
||
cb(null)
|
||
}
|
||
}
|
||
|
||
_transform (data, cb) {
|
||
cb(null, data)
|
||
}
|
||
|
||
_flush (cb) {
|
||
cb(null)
|
||
}
|
||
|
||
_final (cb) {
|
||
this._transformState.afterFinal = cb
|
||
this._flush(transformAfterFlush.bind(this))
|
||
}
|
||
}
|
||
|
||
class PassThrough extends Transform {}
|
||
|
||
function transformAfterFlush (err, data) {
|
||
const cb = this._transformState.afterFinal
|
||
if (err) return cb(err)
|
||
if (data !== null && data !== undefined) this.push(data)
|
||
this.push(null)
|
||
cb(null)
|
||
}
|
||
|
||
function isStream (stream) {
|
||
return !!stream._readableState || !!stream._writableState
|
||
}
|
||
|
||
function isStreamx (stream) {
|
||
return typeof stream._duplexState === 'number' && isStream(stream)
|
||
}
|
||
|
||
function defaultByteLength (data) {
|
||
return Buffer.isBuffer(data) ? data.length : 1024
|
||
}
|
||
|
||
function noop () {}
|
||
|
||
module.exports = {
|
||
isStream,
|
||
isStreamx,
|
||
Stream,
|
||
Writable,
|
||
Readable,
|
||
Duplex,
|
||
Transform,
|
||
// Export PassThrough for compatibility with Node.js core's stream module
|
||
PassThrough
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 746:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var pump = __webpack_require__(453)
|
||
var inherits = __webpack_require__(689)
|
||
var Duplexify = __webpack_require__(394)
|
||
|
||
var toArray = function(args) {
|
||
if (!args.length) return []
|
||
return Array.isArray(args[0]) ? args[0] : Array.prototype.slice.call(args)
|
||
}
|
||
|
||
var define = function(opts) {
|
||
var Pumpify = function() {
|
||
var streams = toArray(arguments)
|
||
if (!(this instanceof Pumpify)) return new Pumpify(streams)
|
||
Duplexify.call(this, null, null, opts)
|
||
if (streams.length) this.setPipeline(streams)
|
||
}
|
||
|
||
inherits(Pumpify, Duplexify)
|
||
|
||
Pumpify.prototype.setPipeline = function() {
|
||
var streams = toArray(arguments)
|
||
var self = this
|
||
var ended = false
|
||
var w = streams[0]
|
||
var r = streams[streams.length-1]
|
||
|
||
r = r.readable ? r : null
|
||
w = w.writable ? w : null
|
||
|
||
var onclose = function() {
|
||
streams[0].emit('error', new Error('stream was destroyed'))
|
||
}
|
||
|
||
this.on('close', onclose)
|
||
this.on('prefinish', function() {
|
||
if (!ended) self.cork()
|
||
})
|
||
|
||
pump(streams, function(err) {
|
||
self.removeListener('close', onclose)
|
||
if (err) return self.destroy(err.message === 'premature close' ? null : err)
|
||
ended = true
|
||
// pump ends after the last stream is not writable *but*
|
||
// pumpify still forwards the readable part so we need to catch errors
|
||
// still, so reenable autoDestroy in this case
|
||
if (self._autoDestroy === false) self._autoDestroy = true
|
||
self.uncork()
|
||
})
|
||
|
||
if (this.destroyed) return onclose()
|
||
this.setWritable(w)
|
||
this.setReadable(r)
|
||
}
|
||
|
||
return Pumpify
|
||
}
|
||
|
||
module.exports = define({autoDestroy:false, destroy:false})
|
||
module.exports.obj = define({autoDestroy: false, destroy:false, objectMode:true, highWaterMark:16})
|
||
module.exports.ctor = define
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 747:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("fs");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 751:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var defer = __webpack_require__(500);
|
||
|
||
// API
|
||
module.exports = async;
|
||
|
||
/**
|
||
* Runs provided callback asynchronously
|
||
* even if callback itself is not
|
||
*
|
||
* @param {function} callback - callback to invoke
|
||
* @returns {function} - augmented callback
|
||
*/
|
||
function async(callback)
|
||
{
|
||
var isAsync = false;
|
||
|
||
// check if async happened
|
||
defer(function() { isAsync = true; });
|
||
|
||
return function async_callback(err, result)
|
||
{
|
||
if (isAsync)
|
||
{
|
||
callback(err, result);
|
||
}
|
||
else
|
||
{
|
||
defer(function nextTick_callback()
|
||
{
|
||
callback(err, result);
|
||
});
|
||
}
|
||
};
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 755:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var utils = __webpack_require__(581);
|
||
|
||
var has = Object.prototype.hasOwnProperty;
|
||
var isArray = Array.isArray;
|
||
|
||
var defaults = {
|
||
allowDots: false,
|
||
allowPrototypes: false,
|
||
arrayLimit: 20,
|
||
charset: 'utf-8',
|
||
charsetSentinel: false,
|
||
comma: false,
|
||
decoder: utils.decode,
|
||
delimiter: '&',
|
||
depth: 5,
|
||
ignoreQueryPrefix: false,
|
||
interpretNumericEntities: false,
|
||
parameterLimit: 1000,
|
||
parseArrays: true,
|
||
plainObjects: false,
|
||
strictNullHandling: false
|
||
};
|
||
|
||
var interpretNumericEntities = function (str) {
|
||
return str.replace(/&#(\d+);/g, function ($0, numberStr) {
|
||
return String.fromCharCode(parseInt(numberStr, 10));
|
||
});
|
||
};
|
||
|
||
var parseArrayValue = function (val, options) {
|
||
if (val && typeof val === 'string' && options.comma && val.indexOf(',') > -1) {
|
||
return val.split(',');
|
||
}
|
||
|
||
return val;
|
||
};
|
||
|
||
// This is what browsers will submit when the ✓ character occurs in an
|
||
// application/x-www-form-urlencoded body and the encoding of the page containing
|
||
// the form is iso-8859-1, or when the submitted form has an accept-charset
|
||
// attribute of iso-8859-1. Presumably also with other charsets that do not contain
|
||
// the ✓ character, such as us-ascii.
|
||
var isoSentinel = 'utf8=%26%2310003%3B'; // encodeURIComponent('✓')
|
||
|
||
// These are the percent-encoded utf-8 octets representing a checkmark, indicating that the request actually is utf-8 encoded.
|
||
var charsetSentinel = 'utf8=%E2%9C%93'; // encodeURIComponent('✓')
|
||
|
||
var parseValues = function parseQueryStringValues(str, options) {
|
||
var obj = {};
|
||
var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, '') : str;
|
||
var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
|
||
var parts = cleanStr.split(options.delimiter, limit);
|
||
var skipIndex = -1; // Keep track of where the utf8 sentinel was found
|
||
var i;
|
||
|
||
var charset = options.charset;
|
||
if (options.charsetSentinel) {
|
||
for (i = 0; i < parts.length; ++i) {
|
||
if (parts[i].indexOf('utf8=') === 0) {
|
||
if (parts[i] === charsetSentinel) {
|
||
charset = 'utf-8';
|
||
} else if (parts[i] === isoSentinel) {
|
||
charset = 'iso-8859-1';
|
||
}
|
||
skipIndex = i;
|
||
i = parts.length; // The eslint settings do not allow break;
|
||
}
|
||
}
|
||
}
|
||
|
||
for (i = 0; i < parts.length; ++i) {
|
||
if (i === skipIndex) {
|
||
continue;
|
||
}
|
||
var part = parts[i];
|
||
|
||
var bracketEqualsPos = part.indexOf(']=');
|
||
var pos = bracketEqualsPos === -1 ? part.indexOf('=') : bracketEqualsPos + 1;
|
||
|
||
var key, val;
|
||
if (pos === -1) {
|
||
key = options.decoder(part, defaults.decoder, charset, 'key');
|
||
val = options.strictNullHandling ? null : '';
|
||
} else {
|
||
key = options.decoder(part.slice(0, pos), defaults.decoder, charset, 'key');
|
||
val = utils.maybeMap(
|
||
parseArrayValue(part.slice(pos + 1), options),
|
||
function (encodedVal) {
|
||
return options.decoder(encodedVal, defaults.decoder, charset, 'value');
|
||
}
|
||
);
|
||
}
|
||
|
||
if (val && options.interpretNumericEntities && charset === 'iso-8859-1') {
|
||
val = interpretNumericEntities(val);
|
||
}
|
||
|
||
if (part.indexOf('[]=') > -1) {
|
||
val = isArray(val) ? [val] : val;
|
||
}
|
||
|
||
if (has.call(obj, key)) {
|
||
obj[key] = utils.combine(obj[key], val);
|
||
} else {
|
||
obj[key] = val;
|
||
}
|
||
}
|
||
|
||
return obj;
|
||
};
|
||
|
||
var parseObject = function (chain, val, options, valuesParsed) {
|
||
var leaf = valuesParsed ? val : parseArrayValue(val, options);
|
||
|
||
for (var i = chain.length - 1; i >= 0; --i) {
|
||
var obj;
|
||
var root = chain[i];
|
||
|
||
if (root === '[]' && options.parseArrays) {
|
||
obj = [].concat(leaf);
|
||
} else {
|
||
obj = options.plainObjects ? Object.create(null) : {};
|
||
var cleanRoot = root.charAt(0) === '[' && root.charAt(root.length - 1) === ']' ? root.slice(1, -1) : root;
|
||
var index = parseInt(cleanRoot, 10);
|
||
if (!options.parseArrays && cleanRoot === '') {
|
||
obj = { 0: leaf };
|
||
} else if (
|
||
!isNaN(index)
|
||
&& root !== cleanRoot
|
||
&& String(index) === cleanRoot
|
||
&& index >= 0
|
||
&& (options.parseArrays && index <= options.arrayLimit)
|
||
) {
|
||
obj = [];
|
||
obj[index] = leaf;
|
||
} else {
|
||
obj[cleanRoot] = leaf;
|
||
}
|
||
}
|
||
|
||
leaf = obj; // eslint-disable-line no-param-reassign
|
||
}
|
||
|
||
return leaf;
|
||
};
|
||
|
||
var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
|
||
if (!givenKey) {
|
||
return;
|
||
}
|
||
|
||
// Transform dot notation to bracket notation
|
||
var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, '[$1]') : givenKey;
|
||
|
||
// The regex chunks
|
||
|
||
var brackets = /(\[[^[\]]*])/;
|
||
var child = /(\[[^[\]]*])/g;
|
||
|
||
// Get the parent
|
||
|
||
var segment = options.depth > 0 && brackets.exec(key);
|
||
var parent = segment ? key.slice(0, segment.index) : key;
|
||
|
||
// Stash the parent if it exists
|
||
|
||
var keys = [];
|
||
if (parent) {
|
||
// If we aren't using plain objects, optionally prefix keys that would overwrite object prototype properties
|
||
if (!options.plainObjects && has.call(Object.prototype, parent)) {
|
||
if (!options.allowPrototypes) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
keys.push(parent);
|
||
}
|
||
|
||
// Loop through children appending to the array until we hit depth
|
||
|
||
var i = 0;
|
||
while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
|
||
i += 1;
|
||
if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
|
||
if (!options.allowPrototypes) {
|
||
return;
|
||
}
|
||
}
|
||
keys.push(segment[1]);
|
||
}
|
||
|
||
// If there's a remainder, just add whatever is left
|
||
|
||
if (segment) {
|
||
keys.push('[' + key.slice(segment.index) + ']');
|
||
}
|
||
|
||
return parseObject(keys, val, options, valuesParsed);
|
||
};
|
||
|
||
var normalizeParseOptions = function normalizeParseOptions(opts) {
|
||
if (!opts) {
|
||
return defaults;
|
||
}
|
||
|
||
if (opts.decoder !== null && opts.decoder !== undefined && typeof opts.decoder !== 'function') {
|
||
throw new TypeError('Decoder has to be a function.');
|
||
}
|
||
|
||
if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
|
||
throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
|
||
}
|
||
var charset = typeof opts.charset === 'undefined' ? defaults.charset : opts.charset;
|
||
|
||
return {
|
||
allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,
|
||
allowPrototypes: typeof opts.allowPrototypes === 'boolean' ? opts.allowPrototypes : defaults.allowPrototypes,
|
||
arrayLimit: typeof opts.arrayLimit === 'number' ? opts.arrayLimit : defaults.arrayLimit,
|
||
charset: charset,
|
||
charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
|
||
comma: typeof opts.comma === 'boolean' ? opts.comma : defaults.comma,
|
||
decoder: typeof opts.decoder === 'function' ? opts.decoder : defaults.decoder,
|
||
delimiter: typeof opts.delimiter === 'string' || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults.delimiter,
|
||
// eslint-disable-next-line no-implicit-coercion, no-extra-parens
|
||
depth: (typeof opts.depth === 'number' || opts.depth === false) ? +opts.depth : defaults.depth,
|
||
ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
|
||
interpretNumericEntities: typeof opts.interpretNumericEntities === 'boolean' ? opts.interpretNumericEntities : defaults.interpretNumericEntities,
|
||
parameterLimit: typeof opts.parameterLimit === 'number' ? opts.parameterLimit : defaults.parameterLimit,
|
||
parseArrays: opts.parseArrays !== false,
|
||
plainObjects: typeof opts.plainObjects === 'boolean' ? opts.plainObjects : defaults.plainObjects,
|
||
strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling
|
||
};
|
||
};
|
||
|
||
module.exports = function (str, opts) {
|
||
var options = normalizeParseOptions(opts);
|
||
|
||
if (str === '' || str === null || typeof str === 'undefined') {
|
||
return options.plainObjects ? Object.create(null) : {};
|
||
}
|
||
|
||
var tempObj = typeof str === 'string' ? parseValues(str, options) : str;
|
||
var obj = options.plainObjects ? Object.create(null) : {};
|
||
|
||
// Iterate over the keys and setup the new object
|
||
|
||
var keys = Object.keys(tempObj);
|
||
for (var i = 0; i < keys.length; ++i) {
|
||
var key = keys[i];
|
||
var newObj = parseKeys(key, tempObj[key], options, typeof str === 'string');
|
||
obj = utils.merge(obj, newObj, options);
|
||
}
|
||
|
||
return utils.compact(obj);
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 761:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("zlib");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 779:
|
||
/***/ (function(__unusedmodule, exports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
/*!
|
||
* mime-types
|
||
* Copyright(c) 2014 Jonathan Ong
|
||
* Copyright(c) 2015 Douglas Christopher Wilson
|
||
* MIT Licensed
|
||
*/
|
||
|
||
|
||
|
||
/**
|
||
* Module dependencies.
|
||
* @private
|
||
*/
|
||
|
||
var db = __webpack_require__(852)
|
||
var extname = __webpack_require__(622).extname
|
||
|
||
/**
|
||
* Module variables.
|
||
* @private
|
||
*/
|
||
|
||
var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
|
||
var TEXT_TYPE_REGEXP = /^text\//i
|
||
|
||
/**
|
||
* Module exports.
|
||
* @public
|
||
*/
|
||
|
||
exports.charset = charset
|
||
exports.charsets = { lookup: charset }
|
||
exports.contentType = contentType
|
||
exports.extension = extension
|
||
exports.extensions = Object.create(null)
|
||
exports.lookup = lookup
|
||
exports.types = Object.create(null)
|
||
|
||
// Populate the extensions/types maps
|
||
populateMaps(exports.extensions, exports.types)
|
||
|
||
/**
|
||
* Get the default charset for a MIME type.
|
||
*
|
||
* @param {string} type
|
||
* @return {boolean|string}
|
||
*/
|
||
|
||
function charset (type) {
|
||
if (!type || typeof type !== 'string') {
|
||
return false
|
||
}
|
||
|
||
// TODO: use media-typer
|
||
var match = EXTRACT_TYPE_REGEXP.exec(type)
|
||
var mime = match && db[match[1].toLowerCase()]
|
||
|
||
if (mime && mime.charset) {
|
||
return mime.charset
|
||
}
|
||
|
||
// default text/* to utf-8
|
||
if (match && TEXT_TYPE_REGEXP.test(match[1])) {
|
||
return 'UTF-8'
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
/**
|
||
* Create a full Content-Type header given a MIME type or extension.
|
||
*
|
||
* @param {string} str
|
||
* @return {boolean|string}
|
||
*/
|
||
|
||
function contentType (str) {
|
||
// TODO: should this even be in this module?
|
||
if (!str || typeof str !== 'string') {
|
||
return false
|
||
}
|
||
|
||
var mime = str.indexOf('/') === -1
|
||
? exports.lookup(str)
|
||
: str
|
||
|
||
if (!mime) {
|
||
return false
|
||
}
|
||
|
||
// TODO: use content-type or other module
|
||
if (mime.indexOf('charset') === -1) {
|
||
var charset = exports.charset(mime)
|
||
if (charset) mime += '; charset=' + charset.toLowerCase()
|
||
}
|
||
|
||
return mime
|
||
}
|
||
|
||
/**
|
||
* Get the default extension for a MIME type.
|
||
*
|
||
* @param {string} type
|
||
* @return {boolean|string}
|
||
*/
|
||
|
||
function extension (type) {
|
||
if (!type || typeof type !== 'string') {
|
||
return false
|
||
}
|
||
|
||
// TODO: use media-typer
|
||
var match = EXTRACT_TYPE_REGEXP.exec(type)
|
||
|
||
// get extensions
|
||
var exts = match && exports.extensions[match[1].toLowerCase()]
|
||
|
||
if (!exts || !exts.length) {
|
||
return false
|
||
}
|
||
|
||
return exts[0]
|
||
}
|
||
|
||
/**
|
||
* Lookup the MIME type for a file path/extension.
|
||
*
|
||
* @param {string} path
|
||
* @return {boolean|string}
|
||
*/
|
||
|
||
function lookup (path) {
|
||
if (!path || typeof path !== 'string') {
|
||
return false
|
||
}
|
||
|
||
// get the extension ("ext" or ".ext" or full path)
|
||
var extension = extname('x.' + path)
|
||
.toLowerCase()
|
||
.substr(1)
|
||
|
||
if (!extension) {
|
||
return false
|
||
}
|
||
|
||
return exports.types[extension] || false
|
||
}
|
||
|
||
/**
|
||
* Populate the extensions and types maps.
|
||
* @private
|
||
*/
|
||
|
||
function populateMaps (extensions, types) {
|
||
// source preference (least -> most)
|
||
var preference = ['nginx', 'apache', undefined, 'iana']
|
||
|
||
Object.keys(db).forEach(function forEachMimeType (type) {
|
||
var mime = db[type]
|
||
var exts = mime.extensions
|
||
|
||
if (!exts || !exts.length) {
|
||
return
|
||
}
|
||
|
||
// mime -> extensions
|
||
extensions[type] = exts
|
||
|
||
// extension -> mime
|
||
for (var i = 0; i < exts.length; i++) {
|
||
var extension = exts[i]
|
||
|
||
if (types[extension]) {
|
||
var from = preference.indexOf(db[types[extension]].source)
|
||
var to = preference.indexOf(mime.source)
|
||
|
||
if (types[extension] !== 'application/octet-stream' &&
|
||
(from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
|
||
// skip the remapping
|
||
continue
|
||
}
|
||
}
|
||
|
||
// set the extension -> mime
|
||
types[extension] = type
|
||
}
|
||
})
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 823:
|
||
/***/ (function(module) {
|
||
|
||
async function handleResponse (response) {
|
||
const contentType = response.headers.get('Content-Type');
|
||
const isJSON = contentType && contentType.match(/json/);
|
||
const data = isJSON ? await response.json() : await response.text();
|
||
if (response.ok) return data;
|
||
else {
|
||
return isJSON
|
||
? Promise.reject(new JSONHTTPError(response, data))
|
||
: Promise.reject(new TextHTTPError(response, data));
|
||
}
|
||
}
|
||
|
||
class HTTPError extends Error {
|
||
constructor (response) {
|
||
super(response.statusText);
|
||
this.name = this.constructor.name;
|
||
if (typeof Error.captureStackTrace === 'function') {
|
||
Error.captureStackTrace(this, this.constructor);
|
||
} else {
|
||
this.stack = new Error(response.statusText).stack;
|
||
}
|
||
this.status = response.status;
|
||
}
|
||
}
|
||
|
||
class TextHTTPError extends HTTPError {
|
||
constructor (response, data) {
|
||
super(response);
|
||
this.data = data;
|
||
}
|
||
}
|
||
|
||
class JSONHTTPError extends HTTPError {
|
||
constructor (response, json) {
|
||
super(response);
|
||
this.json = json;
|
||
}
|
||
}
|
||
|
||
module.exports = {
|
||
handleResponse,
|
||
HTTPError,
|
||
TextHTTPError,
|
||
JSONHTTPError
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 831:
|
||
/***/ (function(module, __unusedexports, __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 objectKeys = Object.keys || function (obj) {
|
||
var keys = [];
|
||
|
||
for (var key in obj) {
|
||
keys.push(key);
|
||
}
|
||
|
||
return keys;
|
||
};
|
||
/*</replacement>*/
|
||
|
||
|
||
module.exports = Duplex;
|
||
|
||
var Readable = __webpack_require__(226);
|
||
|
||
var Writable = __webpack_require__(241);
|
||
|
||
__webpack_require__(689)(Duplex, Readable);
|
||
|
||
{
|
||
// Allow the keys array to be GC'ed.
|
||
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);
|
||
this.allowHalfOpen = true;
|
||
|
||
if (options) {
|
||
if (options.readable === false) this.readable = false;
|
||
if (options.writable === false) this.writable = false;
|
||
|
||
if (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 get() {
|
||
return this._writableState.highWaterMark;
|
||
}
|
||
});
|
||
Object.defineProperty(Duplex.prototype, 'writableBuffer', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState && this._writableState.getBuffer();
|
||
}
|
||
});
|
||
Object.defineProperty(Duplex.prototype, 'writableLength', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
return this._writableState.length;
|
||
}
|
||
}); // the no-half-open enforcer
|
||
|
||
function onend() {
|
||
// If the writable side ended, then we're ok.
|
||
if (this._writableState.ended) return; // no more data can be written.
|
||
// But allow more writes to happen in this tick.
|
||
|
||
process.nextTick(onEndNT, this);
|
||
}
|
||
|
||
function onEndNT(self) {
|
||
self.end();
|
||
}
|
||
|
||
Object.defineProperty(Duplex.prototype, 'destroyed', {
|
||
// making it explicit this property is not enumerable
|
||
// because otherwise some prototype manipulation in
|
||
// userland will fail
|
||
enumerable: false,
|
||
get: function get() {
|
||
if (this._readableState === undefined || this._writableState === undefined) {
|
||
return false;
|
||
}
|
||
|
||
return this._readableState.destroyed && this._writableState.destroyed;
|
||
},
|
||
set: function set(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;
|
||
}
|
||
});
|
||
|
||
/***/ }),
|
||
|
||
/***/ 835:
|
||
/***/ (function(module) {
|
||
|
||
module.exports = require("url");
|
||
|
||
/***/ }),
|
||
|
||
/***/ 852:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
/*!
|
||
* mime-db
|
||
* Copyright(c) 2014 Jonathan Ong
|
||
* MIT Licensed
|
||
*/
|
||
|
||
/**
|
||
* Module exports.
|
||
*/
|
||
|
||
module.exports = __webpack_require__(512)
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 882:
|
||
/***/ (function(module, __unusedexports, __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__(925);
|
||
|
||
__webpack_require__(689)(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);
|
||
};
|
||
|
||
/***/ }),
|
||
|
||
/***/ 892:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var iterate = __webpack_require__(157)
|
||
, initState = __webpack_require__(147)
|
||
, terminator = __webpack_require__(939)
|
||
;
|
||
|
||
// Public API
|
||
module.exports = serialOrdered;
|
||
// sorting helpers
|
||
module.exports.ascending = ascending;
|
||
module.exports.descending = descending;
|
||
|
||
/**
|
||
* Runs iterator over provided sorted array elements in series
|
||
*
|
||
* @param {array|object} list - array or object (named list) to iterate over
|
||
* @param {function} iterator - iterator to run
|
||
* @param {function} sortMethod - custom sort function
|
||
* @param {function} callback - invoked when all elements processed
|
||
* @returns {function} - jobs terminator
|
||
*/
|
||
function serialOrdered(list, iterator, sortMethod, callback)
|
||
{
|
||
var state = initState(list, sortMethod);
|
||
|
||
iterate(list, iterator, state, function iteratorHandler(error, result)
|
||
{
|
||
if (error)
|
||
{
|
||
callback(error, result);
|
||
return;
|
||
}
|
||
|
||
state.index++;
|
||
|
||
// are we there yet?
|
||
if (state.index < (state['keyedList'] || list).length)
|
||
{
|
||
iterate(list, iterator, state, iteratorHandler);
|
||
return;
|
||
}
|
||
|
||
// done here
|
||
callback(null, state.results);
|
||
});
|
||
|
||
return terminator.bind(state, callback);
|
||
}
|
||
|
||
/*
|
||
* -- Sort methods
|
||
*/
|
||
|
||
/**
|
||
* sort helper to sort array elements in ascending order
|
||
*
|
||
* @param {mixed} a - an item to compare
|
||
* @param {mixed} b - an item to compare
|
||
* @returns {number} - comparison result
|
||
*/
|
||
function ascending(a, b)
|
||
{
|
||
return a < b ? -1 : a > b ? 1 : 0;
|
||
}
|
||
|
||
/**
|
||
* sort helper to sort array elements in descending order
|
||
*
|
||
* @param {mixed} a - an item to compare
|
||
* @param {mixed} b - an item to compare
|
||
* @returns {number} - comparison result
|
||
*/
|
||
function descending(a, b)
|
||
{
|
||
return -1 * ascending(a, b);
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 896:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
|
||
|
||
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
|
||
|
||
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
|
||
|
||
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
||
|
||
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
|
||
|
||
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
||
|
||
var _require = __webpack_require__(293),
|
||
Buffer = _require.Buffer;
|
||
|
||
var _require2 = __webpack_require__(669),
|
||
inspect = _require2.inspect;
|
||
|
||
var custom = inspect && inspect.custom || 'inspect';
|
||
|
||
function copyBuffer(src, target, offset) {
|
||
Buffer.prototype.copy.call(src, target, offset);
|
||
}
|
||
|
||
module.exports =
|
||
/*#__PURE__*/
|
||
function () {
|
||
function BufferList() {
|
||
_classCallCheck(this, BufferList);
|
||
|
||
this.head = null;
|
||
this.tail = null;
|
||
this.length = 0;
|
||
}
|
||
|
||
_createClass(BufferList, [{
|
||
key: "push",
|
||
value: 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;
|
||
}
|
||
}, {
|
||
key: "unshift",
|
||
value: function unshift(v) {
|
||
var entry = {
|
||
data: v,
|
||
next: this.head
|
||
};
|
||
if (this.length === 0) this.tail = entry;
|
||
this.head = entry;
|
||
++this.length;
|
||
}
|
||
}, {
|
||
key: "shift",
|
||
value: 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;
|
||
}
|
||
}, {
|
||
key: "clear",
|
||
value: function clear() {
|
||
this.head = this.tail = null;
|
||
this.length = 0;
|
||
}
|
||
}, {
|
||
key: "join",
|
||
value: 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;
|
||
}
|
||
}, {
|
||
key: "concat",
|
||
value: function concat(n) {
|
||
if (this.length === 0) return Buffer.alloc(0);
|
||
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;
|
||
} // Consumes a specified amount of bytes or characters from the buffered data.
|
||
|
||
}, {
|
||
key: "consume",
|
||
value: function consume(n, hasStrings) {
|
||
var ret;
|
||
|
||
if (n < this.head.data.length) {
|
||
// `slice` is the same for buffers and strings.
|
||
ret = this.head.data.slice(0, n);
|
||
this.head.data = this.head.data.slice(n);
|
||
} else if (n === this.head.data.length) {
|
||
// First chunk is a perfect match.
|
||
ret = this.shift();
|
||
} else {
|
||
// Result spans more than one buffer.
|
||
ret = hasStrings ? this._getString(n) : this._getBuffer(n);
|
||
}
|
||
|
||
return ret;
|
||
}
|
||
}, {
|
||
key: "first",
|
||
value: function first() {
|
||
return this.head.data;
|
||
} // Consumes a specified amount of characters from the buffered data.
|
||
|
||
}, {
|
||
key: "_getString",
|
||
value: function _getString(n) {
|
||
var p = this.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) this.head = p.next;else this.head = this.tail = null;
|
||
} else {
|
||
this.head = p;
|
||
p.data = str.slice(nb);
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
++c;
|
||
}
|
||
|
||
this.length -= c;
|
||
return ret;
|
||
} // Consumes a specified amount of bytes from the buffered data.
|
||
|
||
}, {
|
||
key: "_getBuffer",
|
||
value: function _getBuffer(n) {
|
||
var ret = Buffer.allocUnsafe(n);
|
||
var p = this.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) this.head = p.next;else this.head = this.tail = null;
|
||
} else {
|
||
this.head = p;
|
||
p.data = buf.slice(nb);
|
||
}
|
||
|
||
break;
|
||
}
|
||
|
||
++c;
|
||
}
|
||
|
||
this.length -= c;
|
||
return ret;
|
||
} // Make sure the linked list only shows the minimal necessary information.
|
||
|
||
}, {
|
||
key: custom,
|
||
value: function value(_, options) {
|
||
return inspect(this, _objectSpread({}, options, {
|
||
// Only inspect one level.
|
||
depth: 0,
|
||
// It should not recurse.
|
||
customInspect: false
|
||
}));
|
||
}
|
||
}]);
|
||
|
||
return BufferList;
|
||
}();
|
||
|
||
/***/ }),
|
||
|
||
/***/ 897:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
"use strict";
|
||
|
||
|
||
var utils = __webpack_require__(581);
|
||
var formats = __webpack_require__(13);
|
||
var has = Object.prototype.hasOwnProperty;
|
||
|
||
var arrayPrefixGenerators = {
|
||
brackets: function brackets(prefix) {
|
||
return prefix + '[]';
|
||
},
|
||
comma: 'comma',
|
||
indices: function indices(prefix, key) {
|
||
return prefix + '[' + key + ']';
|
||
},
|
||
repeat: function repeat(prefix) {
|
||
return prefix;
|
||
}
|
||
};
|
||
|
||
var isArray = Array.isArray;
|
||
var push = Array.prototype.push;
|
||
var pushToArray = function (arr, valueOrArray) {
|
||
push.apply(arr, isArray(valueOrArray) ? valueOrArray : [valueOrArray]);
|
||
};
|
||
|
||
var toISO = Date.prototype.toISOString;
|
||
|
||
var defaultFormat = formats['default'];
|
||
var defaults = {
|
||
addQueryPrefix: false,
|
||
allowDots: false,
|
||
charset: 'utf-8',
|
||
charsetSentinel: false,
|
||
delimiter: '&',
|
||
encode: true,
|
||
encoder: utils.encode,
|
||
encodeValuesOnly: false,
|
||
format: defaultFormat,
|
||
formatter: formats.formatters[defaultFormat],
|
||
// deprecated
|
||
indices: false,
|
||
serializeDate: function serializeDate(date) {
|
||
return toISO.call(date);
|
||
},
|
||
skipNulls: false,
|
||
strictNullHandling: false
|
||
};
|
||
|
||
var isNonNullishPrimitive = function isNonNullishPrimitive(v) {
|
||
return typeof v === 'string'
|
||
|| typeof v === 'number'
|
||
|| typeof v === 'boolean'
|
||
|| typeof v === 'symbol'
|
||
|| typeof v === 'bigint';
|
||
};
|
||
|
||
var stringify = function stringify(
|
||
object,
|
||
prefix,
|
||
generateArrayPrefix,
|
||
strictNullHandling,
|
||
skipNulls,
|
||
encoder,
|
||
filter,
|
||
sort,
|
||
allowDots,
|
||
serializeDate,
|
||
formatter,
|
||
encodeValuesOnly,
|
||
charset
|
||
) {
|
||
var obj = object;
|
||
if (typeof filter === 'function') {
|
||
obj = filter(prefix, obj);
|
||
} else if (obj instanceof Date) {
|
||
obj = serializeDate(obj);
|
||
} else if (generateArrayPrefix === 'comma' && isArray(obj)) {
|
||
obj = utils.maybeMap(obj, function (value) {
|
||
if (value instanceof Date) {
|
||
return serializeDate(value);
|
||
}
|
||
return value;
|
||
}).join(',');
|
||
}
|
||
|
||
if (obj === null) {
|
||
if (strictNullHandling) {
|
||
return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, 'key') : prefix;
|
||
}
|
||
|
||
obj = '';
|
||
}
|
||
|
||
if (isNonNullishPrimitive(obj) || utils.isBuffer(obj)) {
|
||
if (encoder) {
|
||
var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults.encoder, charset, 'key');
|
||
return [formatter(keyValue) + '=' + formatter(encoder(obj, defaults.encoder, charset, 'value'))];
|
||
}
|
||
return [formatter(prefix) + '=' + formatter(String(obj))];
|
||
}
|
||
|
||
var values = [];
|
||
|
||
if (typeof obj === 'undefined') {
|
||
return values;
|
||
}
|
||
|
||
var objKeys;
|
||
if (isArray(filter)) {
|
||
objKeys = filter;
|
||
} else {
|
||
var keys = Object.keys(obj);
|
||
objKeys = sort ? keys.sort(sort) : keys;
|
||
}
|
||
|
||
for (var i = 0; i < objKeys.length; ++i) {
|
||
var key = objKeys[i];
|
||
var value = obj[key];
|
||
|
||
if (skipNulls && value === null) {
|
||
continue;
|
||
}
|
||
|
||
var keyPrefix = isArray(obj)
|
||
? typeof generateArrayPrefix === 'function' ? generateArrayPrefix(prefix, key) : prefix
|
||
: prefix + (allowDots ? '.' + key : '[' + key + ']');
|
||
|
||
pushToArray(values, stringify(
|
||
value,
|
||
keyPrefix,
|
||
generateArrayPrefix,
|
||
strictNullHandling,
|
||
skipNulls,
|
||
encoder,
|
||
filter,
|
||
sort,
|
||
allowDots,
|
||
serializeDate,
|
||
formatter,
|
||
encodeValuesOnly,
|
||
charset
|
||
));
|
||
}
|
||
|
||
return values;
|
||
};
|
||
|
||
var normalizeStringifyOptions = function normalizeStringifyOptions(opts) {
|
||
if (!opts) {
|
||
return defaults;
|
||
}
|
||
|
||
if (opts.encoder !== null && opts.encoder !== undefined && typeof opts.encoder !== 'function') {
|
||
throw new TypeError('Encoder has to be a function.');
|
||
}
|
||
|
||
var charset = opts.charset || defaults.charset;
|
||
if (typeof opts.charset !== 'undefined' && opts.charset !== 'utf-8' && opts.charset !== 'iso-8859-1') {
|
||
throw new TypeError('The charset option must be either utf-8, iso-8859-1, or undefined');
|
||
}
|
||
|
||
var format = formats['default'];
|
||
if (typeof opts.format !== 'undefined') {
|
||
if (!has.call(formats.formatters, opts.format)) {
|
||
throw new TypeError('Unknown format option provided.');
|
||
}
|
||
format = opts.format;
|
||
}
|
||
var formatter = formats.formatters[format];
|
||
|
||
var filter = defaults.filter;
|
||
if (typeof opts.filter === 'function' || isArray(opts.filter)) {
|
||
filter = opts.filter;
|
||
}
|
||
|
||
return {
|
||
addQueryPrefix: typeof opts.addQueryPrefix === 'boolean' ? opts.addQueryPrefix : defaults.addQueryPrefix,
|
||
allowDots: typeof opts.allowDots === 'undefined' ? defaults.allowDots : !!opts.allowDots,
|
||
charset: charset,
|
||
charsetSentinel: typeof opts.charsetSentinel === 'boolean' ? opts.charsetSentinel : defaults.charsetSentinel,
|
||
delimiter: typeof opts.delimiter === 'undefined' ? defaults.delimiter : opts.delimiter,
|
||
encode: typeof opts.encode === 'boolean' ? opts.encode : defaults.encode,
|
||
encoder: typeof opts.encoder === 'function' ? opts.encoder : defaults.encoder,
|
||
encodeValuesOnly: typeof opts.encodeValuesOnly === 'boolean' ? opts.encodeValuesOnly : defaults.encodeValuesOnly,
|
||
filter: filter,
|
||
formatter: formatter,
|
||
serializeDate: typeof opts.serializeDate === 'function' ? opts.serializeDate : defaults.serializeDate,
|
||
skipNulls: typeof opts.skipNulls === 'boolean' ? opts.skipNulls : defaults.skipNulls,
|
||
sort: typeof opts.sort === 'function' ? opts.sort : null,
|
||
strictNullHandling: typeof opts.strictNullHandling === 'boolean' ? opts.strictNullHandling : defaults.strictNullHandling
|
||
};
|
||
};
|
||
|
||
module.exports = function (object, opts) {
|
||
var obj = object;
|
||
var options = normalizeStringifyOptions(opts);
|
||
|
||
var objKeys;
|
||
var filter;
|
||
|
||
if (typeof options.filter === 'function') {
|
||
filter = options.filter;
|
||
obj = filter('', obj);
|
||
} else if (isArray(options.filter)) {
|
||
filter = options.filter;
|
||
objKeys = filter;
|
||
}
|
||
|
||
var keys = [];
|
||
|
||
if (typeof obj !== 'object' || obj === null) {
|
||
return '';
|
||
}
|
||
|
||
var arrayFormat;
|
||
if (opts && opts.arrayFormat in arrayPrefixGenerators) {
|
||
arrayFormat = opts.arrayFormat;
|
||
} else if (opts && 'indices' in opts) {
|
||
arrayFormat = opts.indices ? 'indices' : 'repeat';
|
||
} else {
|
||
arrayFormat = 'indices';
|
||
}
|
||
|
||
var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
|
||
|
||
if (!objKeys) {
|
||
objKeys = Object.keys(obj);
|
||
}
|
||
|
||
if (options.sort) {
|
||
objKeys.sort(options.sort);
|
||
}
|
||
|
||
for (var i = 0; i < objKeys.length; ++i) {
|
||
var key = objKeys[i];
|
||
|
||
if (options.skipNulls && obj[key] === null) {
|
||
continue;
|
||
}
|
||
pushToArray(keys, stringify(
|
||
obj[key],
|
||
key,
|
||
generateArrayPrefix,
|
||
options.strictNullHandling,
|
||
options.skipNulls,
|
||
options.encode ? options.encoder : null,
|
||
options.filter,
|
||
options.sort,
|
||
options.allowDots,
|
||
options.serializeDate,
|
||
options.formatter,
|
||
options.encodeValuesOnly,
|
||
options.charset
|
||
));
|
||
}
|
||
|
||
var joined = keys.join(options.delimiter);
|
||
var prefix = options.addQueryPrefix === true ? '?' : '';
|
||
|
||
if (options.charsetSentinel) {
|
||
if (options.charset === 'iso-8859-1') {
|
||
// encodeURIComponent('✓'), the "numeric entity" representation of a checkmark
|
||
prefix += 'utf8=%26%2310003%3B&';
|
||
} else {
|
||
// encodeURIComponent('✓')
|
||
prefix += 'utf8=%E2%9C%93&';
|
||
}
|
||
}
|
||
|
||
return joined.length > 0 ? prefix + joined : '';
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 917:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
|
||
/**
|
||
* For Node.js, simply re-export the core `util.deprecate` function.
|
||
*/
|
||
|
||
module.exports = __webpack_require__(669).deprecate;
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 920:
|
||
/***/ (function(__unusedmodule, exports) {
|
||
|
||
"use strict";
|
||
|
||
class AssertionError extends Error {}
|
||
AssertionError.prototype.name = 'AssertionError'
|
||
|
||
/**
|
||
* Minimal assert function
|
||
* @param {any} t Value to check if falsy
|
||
* @param {string=} m Optional assertion error message
|
||
* @throws {AssertionError}
|
||
*/
|
||
function assert (t, m) {
|
||
if (!t) {
|
||
var err = new AssertionError(m)
|
||
if (Error.captureStackTrace) Error.captureStackTrace(err, assert)
|
||
throw err
|
||
}
|
||
}
|
||
Object.defineProperty(exports, '__esModule', {value: true}).default = assert
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 925:
|
||
/***/ (function(module, __unusedexports, __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 _require$codes = __webpack_require__(563).codes,
|
||
ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
|
||
ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
|
||
ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
|
||
ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
|
||
|
||
var Duplex = __webpack_require__(831);
|
||
|
||
__webpack_require__(689)(Transform, Duplex);
|
||
|
||
function afterTransform(er, data) {
|
||
var ts = this._transformState;
|
||
ts.transforming = false;
|
||
var cb = ts.writecb;
|
||
|
||
if (cb === null) {
|
||
return this.emit('error', new ERR_MULTIPLE_CALLBACK());
|
||
}
|
||
|
||
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._readableState.destroyed) {
|
||
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) {
|
||
cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
|
||
};
|
||
|
||
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.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) {
|
||
Duplex.prototype._destroy.call(this, err, function (err2) {
|
||
cb(err2);
|
||
});
|
||
};
|
||
|
||
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); // TODO(BridgeAR): Write a test for these two error cases
|
||
// if there's nothing in the write buffer, then that means
|
||
// that nothing more will ever be provided
|
||
|
||
if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
|
||
if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
|
||
return stream.push(null);
|
||
}
|
||
|
||
/***/ }),
|
||
|
||
/***/ 928:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var CombinedStream = __webpack_require__(547);
|
||
var util = __webpack_require__(669);
|
||
var path = __webpack_require__(622);
|
||
var http = __webpack_require__(605);
|
||
var https = __webpack_require__(211);
|
||
var parseUrl = __webpack_require__(835).parse;
|
||
var fs = __webpack_require__(747);
|
||
var mime = __webpack_require__(779);
|
||
var asynckit = __webpack_require__(334);
|
||
var populate = __webpack_require__(69);
|
||
|
||
// Public API
|
||
module.exports = FormData;
|
||
|
||
// make it a Stream
|
||
util.inherits(FormData, CombinedStream);
|
||
|
||
/**
|
||
* Create readable "multipart/form-data" streams.
|
||
* Can be used to submit forms
|
||
* and file uploads to other web applications.
|
||
*
|
||
* @constructor
|
||
* @param {Object} options - Properties to be added/overriden for FormData and CombinedStream
|
||
*/
|
||
function FormData(options) {
|
||
if (!(this instanceof FormData)) {
|
||
return new FormData(options);
|
||
}
|
||
|
||
this._overheadLength = 0;
|
||
this._valueLength = 0;
|
||
this._valuesToMeasure = [];
|
||
|
||
CombinedStream.call(this);
|
||
|
||
options = options || {};
|
||
for (var option in options) {
|
||
this[option] = options[option];
|
||
}
|
||
}
|
||
|
||
FormData.LINE_BREAK = '\r\n';
|
||
FormData.DEFAULT_CONTENT_TYPE = 'application/octet-stream';
|
||
|
||
FormData.prototype.append = function(field, value, options) {
|
||
|
||
options = options || {};
|
||
|
||
// allow filename as single option
|
||
if (typeof options == 'string') {
|
||
options = {filename: options};
|
||
}
|
||
|
||
var append = CombinedStream.prototype.append.bind(this);
|
||
|
||
// all that streamy business can't handle numbers
|
||
if (typeof value == 'number') {
|
||
value = '' + value;
|
||
}
|
||
|
||
// https://github.com/felixge/node-form-data/issues/38
|
||
if (util.isArray(value)) {
|
||
// Please convert your array into string
|
||
// the way web server expects it
|
||
this._error(new Error('Arrays are not supported.'));
|
||
return;
|
||
}
|
||
|
||
var header = this._multiPartHeader(field, value, options);
|
||
var footer = this._multiPartFooter();
|
||
|
||
append(header);
|
||
append(value);
|
||
append(footer);
|
||
|
||
// pass along options.knownLength
|
||
this._trackLength(header, value, options);
|
||
};
|
||
|
||
FormData.prototype._trackLength = function(header, value, options) {
|
||
var valueLength = 0;
|
||
|
||
// used w/ getLengthSync(), when length is known.
|
||
// e.g. for streaming directly from a remote server,
|
||
// w/ a known file a size, and not wanting to wait for
|
||
// incoming file to finish to get its size.
|
||
if (options.knownLength != null) {
|
||
valueLength += +options.knownLength;
|
||
} else if (Buffer.isBuffer(value)) {
|
||
valueLength = value.length;
|
||
} else if (typeof value === 'string') {
|
||
valueLength = Buffer.byteLength(value);
|
||
}
|
||
|
||
this._valueLength += valueLength;
|
||
|
||
// @check why add CRLF? does this account for custom/multiple CRLFs?
|
||
this._overheadLength +=
|
||
Buffer.byteLength(header) +
|
||
FormData.LINE_BREAK.length;
|
||
|
||
// empty or either doesn't have path or not an http response
|
||
if (!value || ( !value.path && !(value.readable && value.hasOwnProperty('httpVersion')) )) {
|
||
return;
|
||
}
|
||
|
||
// no need to bother with the length
|
||
if (!options.knownLength) {
|
||
this._valuesToMeasure.push(value);
|
||
}
|
||
};
|
||
|
||
FormData.prototype._lengthRetriever = function(value, callback) {
|
||
|
||
if (value.hasOwnProperty('fd')) {
|
||
|
||
// take read range into a account
|
||
// `end` = Infinity –> read file till the end
|
||
//
|
||
// TODO: Looks like there is bug in Node fs.createReadStream
|
||
// it doesn't respect `end` options without `start` options
|
||
// Fix it when node fixes it.
|
||
// https://github.com/joyent/node/issues/7819
|
||
if (value.end != undefined && value.end != Infinity && value.start != undefined) {
|
||
|
||
// when end specified
|
||
// no need to calculate range
|
||
// inclusive, starts with 0
|
||
callback(null, value.end + 1 - (value.start ? value.start : 0));
|
||
|
||
// not that fast snoopy
|
||
} else {
|
||
// still need to fetch file size from fs
|
||
fs.stat(value.path, function(err, stat) {
|
||
|
||
var fileSize;
|
||
|
||
if (err) {
|
||
callback(err);
|
||
return;
|
||
}
|
||
|
||
// update final size based on the range options
|
||
fileSize = stat.size - (value.start ? value.start : 0);
|
||
callback(null, fileSize);
|
||
});
|
||
}
|
||
|
||
// or http response
|
||
} else if (value.hasOwnProperty('httpVersion')) {
|
||
callback(null, +value.headers['content-length']);
|
||
|
||
// or request stream http://github.com/mikeal/request
|
||
} else if (value.hasOwnProperty('httpModule')) {
|
||
// wait till response come back
|
||
value.on('response', function(response) {
|
||
value.pause();
|
||
callback(null, +response.headers['content-length']);
|
||
});
|
||
value.resume();
|
||
|
||
// something else
|
||
} else {
|
||
callback('Unknown stream');
|
||
}
|
||
};
|
||
|
||
FormData.prototype._multiPartHeader = function(field, value, options) {
|
||
// custom header specified (as string)?
|
||
// it becomes responsible for boundary
|
||
// (e.g. to handle extra CRLFs on .NET servers)
|
||
if (typeof options.header == 'string') {
|
||
return options.header;
|
||
}
|
||
|
||
var contentDisposition = this._getContentDisposition(value, options);
|
||
var contentType = this._getContentType(value, options);
|
||
|
||
var contents = '';
|
||
var headers = {
|
||
// add custom disposition as third element or keep it two elements if not
|
||
'Content-Disposition': ['form-data', 'name="' + field + '"'].concat(contentDisposition || []),
|
||
// if no content type. allow it to be empty array
|
||
'Content-Type': [].concat(contentType || [])
|
||
};
|
||
|
||
// allow custom headers.
|
||
if (typeof options.header == 'object') {
|
||
populate(headers, options.header);
|
||
}
|
||
|
||
var header;
|
||
for (var prop in headers) {
|
||
if (!headers.hasOwnProperty(prop)) continue;
|
||
header = headers[prop];
|
||
|
||
// skip nullish headers.
|
||
if (header == null) {
|
||
continue;
|
||
}
|
||
|
||
// convert all headers to arrays.
|
||
if (!Array.isArray(header)) {
|
||
header = [header];
|
||
}
|
||
|
||
// add non-empty headers.
|
||
if (header.length) {
|
||
contents += prop + ': ' + header.join('; ') + FormData.LINE_BREAK;
|
||
}
|
||
}
|
||
|
||
return '--' + this.getBoundary() + FormData.LINE_BREAK + contents + FormData.LINE_BREAK;
|
||
};
|
||
|
||
FormData.prototype._getContentDisposition = function(value, options) {
|
||
|
||
var filename
|
||
, contentDisposition
|
||
;
|
||
|
||
if (typeof options.filepath === 'string') {
|
||
// custom filepath for relative paths
|
||
filename = path.normalize(options.filepath).replace(/\\/g, '/');
|
||
} else if (options.filename || value.name || value.path) {
|
||
// custom filename take precedence
|
||
// formidable and the browser add a name property
|
||
// fs- and request- streams have path property
|
||
filename = path.basename(options.filename || value.name || value.path);
|
||
} else if (value.readable && value.hasOwnProperty('httpVersion')) {
|
||
// or try http response
|
||
filename = path.basename(value.client._httpMessage.path || '');
|
||
}
|
||
|
||
if (filename) {
|
||
contentDisposition = 'filename="' + filename + '"';
|
||
}
|
||
|
||
return contentDisposition;
|
||
};
|
||
|
||
FormData.prototype._getContentType = function(value, options) {
|
||
|
||
// use custom content-type above all
|
||
var contentType = options.contentType;
|
||
|
||
// or try `name` from formidable, browser
|
||
if (!contentType && value.name) {
|
||
contentType = mime.lookup(value.name);
|
||
}
|
||
|
||
// or try `path` from fs-, request- streams
|
||
if (!contentType && value.path) {
|
||
contentType = mime.lookup(value.path);
|
||
}
|
||
|
||
// or if it's http-reponse
|
||
if (!contentType && value.readable && value.hasOwnProperty('httpVersion')) {
|
||
contentType = value.headers['content-type'];
|
||
}
|
||
|
||
// or guess it from the filepath or filename
|
||
if (!contentType && (options.filepath || options.filename)) {
|
||
contentType = mime.lookup(options.filepath || options.filename);
|
||
}
|
||
|
||
// fallback to the default content type if `value` is not simple value
|
||
if (!contentType && typeof value == 'object') {
|
||
contentType = FormData.DEFAULT_CONTENT_TYPE;
|
||
}
|
||
|
||
return contentType;
|
||
};
|
||
|
||
FormData.prototype._multiPartFooter = function() {
|
||
return function(next) {
|
||
var footer = FormData.LINE_BREAK;
|
||
|
||
var lastPart = (this._streams.length === 0);
|
||
if (lastPart) {
|
||
footer += this._lastBoundary();
|
||
}
|
||
|
||
next(footer);
|
||
}.bind(this);
|
||
};
|
||
|
||
FormData.prototype._lastBoundary = function() {
|
||
return '--' + this.getBoundary() + '--' + FormData.LINE_BREAK;
|
||
};
|
||
|
||
FormData.prototype.getHeaders = function(userHeaders) {
|
||
var header;
|
||
var formHeaders = {
|
||
'content-type': 'multipart/form-data; boundary=' + this.getBoundary()
|
||
};
|
||
|
||
for (header in userHeaders) {
|
||
if (userHeaders.hasOwnProperty(header)) {
|
||
formHeaders[header.toLowerCase()] = userHeaders[header];
|
||
}
|
||
}
|
||
|
||
return formHeaders;
|
||
};
|
||
|
||
FormData.prototype.getBoundary = function() {
|
||
if (!this._boundary) {
|
||
this._generateBoundary();
|
||
}
|
||
|
||
return this._boundary;
|
||
};
|
||
|
||
FormData.prototype.getBuffer = function() {
|
||
var dataBuffer = new Buffer.alloc( 0 );
|
||
var boundary = this.getBoundary();
|
||
|
||
// Create the form content. Add Line breaks to the end of data.
|
||
for (var i = 0, len = this._streams.length; i < len; i++) {
|
||
if (typeof this._streams[i] !== 'function') {
|
||
|
||
// Add content to the buffer.
|
||
if(Buffer.isBuffer(this._streams[i])) {
|
||
dataBuffer = Buffer.concat( [dataBuffer, this._streams[i]]);
|
||
}else {
|
||
dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(this._streams[i])]);
|
||
}
|
||
|
||
// Add break after content.
|
||
if (typeof this._streams[i] !== 'string' || this._streams[i].substring( 2, boundary.length + 2 ) !== boundary) {
|
||
dataBuffer = Buffer.concat( [dataBuffer, Buffer.from(FormData.LINE_BREAK)] );
|
||
}
|
||
}
|
||
}
|
||
|
||
// Add the footer and return the Buffer object.
|
||
return Buffer.concat( [dataBuffer, Buffer.from(this._lastBoundary())] );
|
||
};
|
||
|
||
FormData.prototype._generateBoundary = function() {
|
||
// This generates a 50 character boundary similar to those used by Firefox.
|
||
// They are optimized for boyer-moore parsing.
|
||
var boundary = '--------------------------';
|
||
for (var i = 0; i < 24; i++) {
|
||
boundary += Math.floor(Math.random() * 10).toString(16);
|
||
}
|
||
|
||
this._boundary = boundary;
|
||
};
|
||
|
||
// Note: getLengthSync DOESN'T calculate streams length
|
||
// As workaround one can calculate file size manually
|
||
// and add it as knownLength option
|
||
FormData.prototype.getLengthSync = function() {
|
||
var knownLength = this._overheadLength + this._valueLength;
|
||
|
||
// Don't get confused, there are 3 "internal" streams for each keyval pair
|
||
// so it basically checks if there is any value added to the form
|
||
if (this._streams.length) {
|
||
knownLength += this._lastBoundary().length;
|
||
}
|
||
|
||
// https://github.com/form-data/form-data/issues/40
|
||
if (!this.hasKnownLength()) {
|
||
// Some async length retrievers are present
|
||
// therefore synchronous length calculation is false.
|
||
// Please use getLength(callback) to get proper length
|
||
this._error(new Error('Cannot calculate proper length in synchronous way.'));
|
||
}
|
||
|
||
return knownLength;
|
||
};
|
||
|
||
// Public API to check if length of added values is known
|
||
// https://github.com/form-data/form-data/issues/196
|
||
// https://github.com/form-data/form-data/issues/262
|
||
FormData.prototype.hasKnownLength = function() {
|
||
var hasKnownLength = true;
|
||
|
||
if (this._valuesToMeasure.length) {
|
||
hasKnownLength = false;
|
||
}
|
||
|
||
return hasKnownLength;
|
||
};
|
||
|
||
FormData.prototype.getLength = function(cb) {
|
||
var knownLength = this._overheadLength + this._valueLength;
|
||
|
||
if (this._streams.length) {
|
||
knownLength += this._lastBoundary().length;
|
||
}
|
||
|
||
if (!this._valuesToMeasure.length) {
|
||
process.nextTick(cb.bind(this, null, knownLength));
|
||
return;
|
||
}
|
||
|
||
asynckit.parallel(this._valuesToMeasure, this._lengthRetriever, function(err, values) {
|
||
if (err) {
|
||
cb(err);
|
||
return;
|
||
}
|
||
|
||
values.forEach(function(length) {
|
||
knownLength += length;
|
||
});
|
||
|
||
cb(null, knownLength);
|
||
});
|
||
};
|
||
|
||
FormData.prototype.submit = function(params, cb) {
|
||
var request
|
||
, options
|
||
, defaults = {method: 'post'}
|
||
;
|
||
|
||
// parse provided url if it's string
|
||
// or treat it as options object
|
||
if (typeof params == 'string') {
|
||
|
||
params = parseUrl(params);
|
||
options = populate({
|
||
port: params.port,
|
||
path: params.pathname,
|
||
host: params.hostname,
|
||
protocol: params.protocol
|
||
}, defaults);
|
||
|
||
// use custom params
|
||
} else {
|
||
|
||
options = populate(params, defaults);
|
||
// if no port provided use default one
|
||
if (!options.port) {
|
||
options.port = options.protocol == 'https:' ? 443 : 80;
|
||
}
|
||
}
|
||
|
||
// put that good code in getHeaders to some use
|
||
options.headers = this.getHeaders(params.headers);
|
||
|
||
// https if specified, fallback to http in any other case
|
||
if (options.protocol == 'https:') {
|
||
request = https.request(options);
|
||
} else {
|
||
request = http.request(options);
|
||
}
|
||
|
||
// get content length and fire away
|
||
this.getLength(function(err, length) {
|
||
if (err) {
|
||
this._error(err);
|
||
return;
|
||
}
|
||
|
||
// add content length
|
||
request.setHeader('Content-Length', length);
|
||
|
||
this.pipe(request);
|
||
if (cb) {
|
||
var onResponse;
|
||
|
||
var callback = function (error, responce) {
|
||
request.removeListener('error', callback);
|
||
request.removeListener('response', onResponse);
|
||
|
||
return cb.call(this, error, responce);
|
||
};
|
||
|
||
onResponse = callback.bind(this, null);
|
||
|
||
request.on('error', callback);
|
||
request.on('response', onResponse);
|
||
}
|
||
}.bind(this));
|
||
|
||
return request;
|
||
};
|
||
|
||
FormData.prototype._error = function(err) {
|
||
if (!this.error) {
|
||
this.error = err;
|
||
this.pause();
|
||
this.emit('error', err);
|
||
}
|
||
};
|
||
|
||
FormData.prototype.toString = function () {
|
||
return '[object FormData]';
|
||
};
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 939:
|
||
/***/ (function(module, __unusedexports, __webpack_require__) {
|
||
|
||
var abort = __webpack_require__(566)
|
||
, async = __webpack_require__(751)
|
||
;
|
||
|
||
// API
|
||
module.exports = terminator;
|
||
|
||
/**
|
||
* Terminates jobs in the attached state context
|
||
*
|
||
* @this AsyncKitState#
|
||
* @param {function} callback - final callback to invoke after termination
|
||
*/
|
||
function terminator(callback)
|
||
{
|
||
if (!Object.keys(this.jobs).length)
|
||
{
|
||
return;
|
||
}
|
||
|
||
// fast forward iteration index
|
||
this.index = this.size;
|
||
|
||
// abort jobs
|
||
abort(this);
|
||
|
||
// send back results we have so far
|
||
async(callback)(null, this.results);
|
||
}
|
||
|
||
|
||
/***/ }),
|
||
|
||
/***/ 979:
|
||
/***/ (function(module) {
|
||
|
||
/**
|
||
* Simple timer lets you record start and stop times, with an elapsed time getter.
|
||
*/
|
||
class SimpleTimer {
|
||
constructor (startTime) {
|
||
this.start = startTime || Date.now()
|
||
this.end = null
|
||
this.stopped = false
|
||
}
|
||
|
||
get elapsed () {
|
||
if (this.stopped) {
|
||
return this.end - this.start
|
||
} else {
|
||
return Date.now() - this.start
|
||
}
|
||
}
|
||
|
||
stop () {
|
||
if (this.stopped) return
|
||
this.stopped = true
|
||
this.end = Date.now()
|
||
}
|
||
|
||
toString () {
|
||
return this.elapsed
|
||
}
|
||
|
||
toJSON () {
|
||
return this.elapsed
|
||
}
|
||
}
|
||
|
||
module.exports = SimpleTimer
|
||
|
||
|
||
/***/ })
|
||
|
||
/******/ });
|
||
//# sourceMappingURL=index.js.map
|