diff --git a/action.yml b/action.yml index c3d6990..57b2ce7 100644 --- a/action.yml +++ b/action.yml @@ -43,6 +43,10 @@ inputs: description: "Use github actions/cache as fallback" required: false default: "true" + error-on-s3-exception: + description: "Whether to mark the job as failed or not depending on S3 exceptions." + required: false + default: "false" # zip-option: # description: zip options # required: false diff --git a/dist/restore/index.js b/dist/restore/index.js index 918e947..21c3c05 100644 --- a/dist/restore/index.js +++ b/dist/restore/index.js @@ -50646,75 +50646,3328 @@ function range(a, b, str) { /***/ 7124: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -const { Transform } = __nccwpck_require__(1642) +const { Transform } = __nccwpck_require__(2672) + +class Block extends Transform { + constructor (size, opts = {}) { + super(opts) + + if (typeof size === 'object') { + opts = size + size = opts.size + } + + this.size = size || 512 + + const { nopad, zeroPadding = true } = opts + + if (nopad) this._zeroPadding = false + else this._zeroPadding = !!zeroPadding + + this._buffered = [] + this._bufferedBytes = 0 + } + + _transform (buf, enc, next) { + this._bufferedBytes += buf.length + this._buffered.push(buf) + + while (this._bufferedBytes >= this.size) { + this._bufferedBytes -= this.size + + // Assemble the buffers that will compose the final block + const blockBufs = [] + let blockBufsBytes = 0 + while (blockBufsBytes < this.size) { + const b = this._buffered.shift() + + if (blockBufsBytes + b.length <= this.size) { + blockBufs.push(b) + blockBufsBytes += b.length + } else { + // If the last buffer is larger than needed for the block, just + // use the needed part + const neededSize = this.size - blockBufsBytes + blockBufs.push(b.slice(0, neededSize)) + blockBufsBytes += neededSize + this._buffered.unshift(b.slice(neededSize)) + } + } + + // Then concat just those buffers, leaving the rest untouched in _buffered + this.push(Buffer.concat(blockBufs, this.size)) + } + next() + } + + _flush () { + if (this._bufferedBytes && this._zeroPadding) { + const zeroes = Buffer.alloc(this.size - this._bufferedBytes) + this._buffered.push(zeroes) + this.push(Buffer.concat(this._buffered)) + this._buffered = null + } else if (this._bufferedBytes) { + this.push(Buffer.concat(this._buffered)) + this._buffered = null + } + this.push(null) + } +} + +module.exports = Block + + +/***/ }), + +/***/ 8891: +/***/ ((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.q = codes; + + +/***/ }), + +/***/ 1153: +/***/ ((module, __unused_webpack_exports, __nccwpck_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. + +/**/ + +var objectKeys = Object.keys || function (obj) { + var keys = []; + + for (var key in obj) { + keys.push(key); + } + + return keys; +}; +/**/ + + +module.exports = Duplex; + +var Readable = __nccwpck_require__(184); + +var Writable = __nccwpck_require__(4423); + +__nccwpck_require__(4124)(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; + } +}); + +/***/ }), + +/***/ 4896: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = __nccwpck_require__(8971); + +__nccwpck_require__(4124)(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); +}; + +/***/ }), + +/***/ 184: +/***/ ((module, __unused_webpack_exports, __nccwpck_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; +/**/ + +var Duplex; +/**/ + +Readable.ReadableState = ReadableState; +/**/ + +var EE = (__nccwpck_require__(2361).EventEmitter); + +var EElistenerCount = function EElistenerCount(emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + +/**/ + + +var Stream = __nccwpck_require__(8933); +/**/ + + +var Buffer = (__nccwpck_require__(4300).Buffer); + +var OurUint8Array = global.Uint8Array || function () {}; + +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} + +function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; +} +/**/ + + +var debugUtil = __nccwpck_require__(3837); + +var debug; + +if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); +} else { + debug = function debug() {}; +} +/**/ + + +var BufferList = __nccwpck_require__(6305); + +var destroyImpl = __nccwpck_require__(6138); + +var _require = __nccwpck_require__(1802), + getHighWaterMark = _require.getHighWaterMark; + +var _require$codes = (__nccwpck_require__(8891)/* .codes */ .q), + 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; + +__nccwpck_require__(4124)(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 || __nccwpck_require__(1153); + 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 = (__nccwpck_require__(4841)/* .StringDecoder */ .s); + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} + +function Readable(options) { + Duplex = Duplex || __nccwpck_require__(1153); + 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 = (__nccwpck_require__(4841)/* .StringDecoder */ .s); + 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 = __nccwpck_require__(3276); + } + + 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 = __nccwpck_require__(2173); + } + + 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; +} + +/***/ }), + +/***/ 8971: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = (__nccwpck_require__(8891)/* .codes */ .q), + 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 = __nccwpck_require__(1153); + +__nccwpck_require__(4124)(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); +} + +/***/ }), + +/***/ 4423: +/***/ ((module, __unused_webpack_exports, __nccwpck_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; +/* */ + +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); + }; +} +/* */ + +/**/ + + +var Duplex; +/**/ + +Writable.WritableState = WritableState; +/**/ + +var internalUtil = { + deprecate: __nccwpck_require__(7127) +}; +/**/ + +/**/ + +var Stream = __nccwpck_require__(8933); +/**/ + + +var Buffer = (__nccwpck_require__(4300).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 = __nccwpck_require__(6138); + +var _require = __nccwpck_require__(1802), + getHighWaterMark = _require.getHighWaterMark; + +var _require$codes = (__nccwpck_require__(8891)/* .codes */ .q), + 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; + +__nccwpck_require__(4124)(Writable, Stream); + +function nop() {} + +function WritableState(options, stream, isDuplex) { + Duplex = Duplex || __nccwpck_require__(1153); + 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 || __nccwpck_require__(1153); // 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); +}; + +/***/ }), + +/***/ 3276: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = __nccwpck_require__(5927); + +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; + +/***/ }), + +/***/ 6305: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = __nccwpck_require__(4300), + Buffer = _require.Buffer; + +var _require2 = __nccwpck_require__(3837), + 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; +}(); + +/***/ }), + +/***/ 6138: +/***/ ((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 +}; -class Block extends Transform { - constructor (size, opts = {}) { - super(opts) +/***/ }), - if (typeof size === 'object') { - opts = size - size = opts.size +/***/ 5927: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = (__nccwpck_require__(8891)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.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]; } - this.size = size || 512 + callback.apply(this, args); + }; +} - const { nopad, zeroPadding = true } = opts +function noop() {} - if (nopad) this._zeroPadding = false - else this._zeroPadding = !!zeroPadding +function isRequest(stream) { + return stream.setHeader && typeof stream.abort === 'function'; +} - this._buffered = [] - this._bufferedBytes = 0 +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); } - _transform (buf, enc, next) { - this._bufferedBytes += buf.length - this._buffered.push(buf) + 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); + }; +} - while (this._bufferedBytes >= this.size) { - this._bufferedBytes -= this.size +module.exports = eos; - // Assemble the buffers that will compose the final block - const blockBufs = [] - let blockBufsBytes = 0 - while (blockBufsBytes < this.size) { - const b = this._buffered.shift() +/***/ }), - if (blockBufsBytes + b.length <= this.size) { - blockBufs.push(b) - blockBufsBytes += b.length +/***/ 2173: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = (__nccwpck_require__(8891)/* .codes.ERR_INVALID_ARG_TYPE */ .q.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 { - // If the last buffer is larger than needed for the block, just - // use the needed part - const neededSize = this.size - blockBufsBytes - blockBufs.push(b.slice(0, neededSize)) - blockBufsBytes += neededSize - this._buffered.unshift(b.slice(neededSize)) + reading = false; } + } catch (err) { + readable.destroy(err); } + }); + return _next2.apply(this, arguments); + } - // Then concat just those buffers, leaving the rest untouched in _buffered - this.push(Buffer.concat(blockBufs, this.size)) - } - next() + return readable; +} + +module.exports = from; + +/***/ }), + +/***/ 2468: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = (__nccwpck_require__(8891)/* .codes */ .q), + 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 = __nccwpck_require__(5927); + 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]; } - _flush () { - if (this._bufferedBytes && this._zeroPadding) { - const zeroes = Buffer.alloc(this.size - this._bufferedBytes) - this._buffered.push(zeroes) - this.push(Buffer.concat(this._buffered)) - this._buffered = null - } else if (this._bufferedBytes) { - this.push(Buffer.concat(this._buffered)) - this._buffered = null - } - this.push(null) + 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 = Block +module.exports = pipeline; + +/***/ }), + +/***/ 1802: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(8891)/* .codes.ERR_INVALID_OPT_VALUE */ .q.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 +}; + +/***/ }), + +/***/ 8933: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +module.exports = __nccwpck_require__(2781); + + +/***/ }), + +/***/ 2672: +/***/ ((module, exports, __nccwpck_require__) => { + +var Stream = __nccwpck_require__(2781); +if (process.env.READABLE_STREAM === 'disable' && Stream) { + module.exports = Stream.Readable; + Object.assign(module.exports, Stream); + module.exports.Stream = Stream; +} else { + exports = module.exports = __nccwpck_require__(184); + exports.Stream = Stream || exports; + exports.Readable = exports; + exports.Writable = __nccwpck_require__(4423); + exports.Duplex = __nccwpck_require__(1153); + exports.Transform = __nccwpck_require__(8971); + exports.PassThrough = __nccwpck_require__(4896); + exports.finished = __nccwpck_require__(5927); + exports.pipeline = __nccwpck_require__(2468); +} /***/ }), @@ -50925,40 +54178,6 @@ function expand(str, isTop) { -/***/ }), - -/***/ 9107: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); - -var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; - -var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined"; - -var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null; - -var isWebWorker = (typeof self === "undefined" ? "undefined" : _typeof(self)) === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope"; - -/** - * @see https://github.com/jsdom/jsdom/releases/tag/12.0.0 - * @see https://github.com/jsdom/jsdom/issues/1537 - */ -var isJsDom = typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom")); - -var isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined"; - -exports.isBrowser = isBrowser; -exports.isWebWorker = isWebWorker; -exports.isNode = isNode; -exports.isJsDom = isJsDom; -exports.isDeno = isDeno; - /***/ }), /***/ 4024: @@ -52144,21 +55363,11 @@ Builder.prototype.j2x = function(jObj, level) { let attrStr = ''; let val = ''; for (let key in jObj) { - if(!Object.prototype.hasOwnProperty.call(jObj, key)) continue; if (typeof jObj[key] === 'undefined') { - // supress undefined node only if it is not an attribute - if (this.isAttribute(key)) { - val += ''; - } + // supress undefined node } else if (jObj[key] === null) { - // null attribute should be ignored by the attribute list, but should not cause the tag closing - if (this.isAttribute(key)) { - val += ''; - } else if (key[0] === '?') { - val += this.indentate(level) + '<' + key + '?' + this.tagEndChar; - } else { - val += this.indentate(level) + '<' + key + '/' + this.tagEndChar; - } + if(key[0] === "?") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar; + else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar; // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar; } else if (jObj[key] instanceof Date) { val += this.buildTextValNode(jObj[key], key, '', level); @@ -52251,8 +55460,7 @@ Builder.prototype.buildObjectNode = function(val, key, attrStr, level) { tagEndExp = ""; } - // attrStr is an empty string in case the attribute came as undefined or null - if ((attrStr || attrStr === '') && val.indexOf('<') === -1) { + if (attrStr && val.indexOf('<') === -1) { return ( this.indentate(level) + '<' + key + attrStr + piClosingChar + '>' + val + tagEndExp ); } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) { return this.indentate(level) + `` + this.newLine; @@ -52325,7 +55533,7 @@ function indentate(level) { } function isAttribute(name /*, options*/) { - if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) { + if (name.startsWith(this.options.attributeNamePrefix)) { return name.substr(this.attrPrefixLen); } else { return false; @@ -52363,8 +55571,6 @@ function arrToStr(arr, options, jPath, indentation) { for (let i = 0; i < arr.length; i++) { const tagObj = arr[i]; const tagName = propName(tagObj); - if(tagName === undefined) continue; - let newJPath = ""; if (jPath.length === 0) newJPath = tagName else newJPath = `${jPath}.${tagName}`; @@ -52434,7 +55640,6 @@ function propName(obj) { const keys = Object.keys(obj); for (let i = 0; i < keys.length; i++) { const key = keys[i]; - if(!obj.hasOwnProperty(key)) continue; if (key !== ":@") return key; } } @@ -52443,7 +55648,6 @@ function attr_to_str(attrMap, options) { let attrStr = ""; if (attrMap && !options.ignoreAttributes) { for (let attr in attrMap) { - if(!attrMap.hasOwnProperty(attr)) continue; let attrVal = options.attributeValueProcessor(attr, attrMap[attr]); attrVal = replaceEntitiesValue(attrVal, options); if (attrVal === true && options.suppressBooleanAttributes) { @@ -52480,9 +55684,7 @@ module.exports = toXml; /***/ }), /***/ 6072: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -const util = __nccwpck_require__(8280); +/***/ ((module) => { //TODO: handle comments function readDocType(xmlData, i){ @@ -52505,7 +55707,7 @@ function readDocType(xmlData, i){ i += 7; [entityName, val,i] = readEntityExp(xmlData,i+1); if(val.indexOf("&") === -1) //Parameter entities are not supported - entities[ validateEntityName(entityName) ] = { + entities[ entityName ] = { regx : RegExp( `&${entityName};`,"g"), val: val }; @@ -52626,16 +55828,8 @@ function isNotation(xmlData, i){ return false } -function validateEntityName(name){ - if (util.isName(name)) - return name; - else - throw new Error(`Invalid entity name ${name}`); -} - module.exports = readDocType; - /***/ }), /***/ 2821: @@ -52704,9 +55898,9 @@ const xmlNode = __nccwpck_require__(7462); const readDocType = __nccwpck_require__(6072); const toNumber = __nccwpck_require__(4526); -// const regx = -// '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)' -// .replace(/NAME/g, util.nameRegexp); +const regx = + '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)' + .replace(/NAME/g, util.nameRegexp); //const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g"); //const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g"); @@ -52963,13 +56157,14 @@ const parseXml = function(xmlData) { textData = this.saveTextToParentTag(textData, currentNode, jPath); - let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true); - if(val == undefined) val = ""; - //cdata should be set even if it is 0 length string if(this.options.cdataPropName){ + // let val = this.parseTextData(tagExp, this.options.cdataPropName, jPath + "." + this.options.cdataPropName, true, false, true); + // if(!val) val = ""; currentNode.add(this.options.cdataPropName, [ { [this.options.textNodeName] : tagExp } ]); }else{ + let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true); + if(val == undefined) val = ""; currentNode.add(this.options.textNodeName, val); } @@ -52977,7 +56172,6 @@ const parseXml = function(xmlData) { }else {//Opening tag let result = readTagExp(xmlData,i, this.options.removeNSPrefix); let tagName= result.tagName; - const rawTagName = result.rawTagName; let tagExp = result.tagExp; let attrExpPresent = result.attrExpPresent; let closeIndex = result.closeIndex; @@ -53003,7 +56197,7 @@ const parseXml = function(xmlData) { if(tagName !== xmlObj.tagname){ jPath += jPath ? "." + tagName : tagName; } - if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) { + if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) { //TODO: namespace let tagContent = ""; //self-closing tag if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){ @@ -53016,8 +56210,8 @@ const parseXml = function(xmlData) { //normal tag else{ //read until closing tag is found - const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1); - if(!result) throw new Error(`Unexpected end of ${rawTagName}`); + const result = this.readStopNodeData(xmlData, tagName, closeIndex + 1); + if(!result) throw new Error(`Unexpected end of ${tagName}`); i = result.i; tagContent = result.tagContent; } @@ -53039,7 +56233,6 @@ const parseXml = function(xmlData) { if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){ if(tagName[tagName.length - 1] === "/"){ //remove trailing '/' tagName = tagName.substr(0, tagName.length - 1); - jPath = jPath.substr(0, jPath.length - 1); tagExp = tagName; }else{ tagExp = tagExp.substr(0, tagExp.length - 1); @@ -53198,11 +56391,10 @@ function readTagExp(xmlData,i, removeNSPrefix, closingChar = ">"){ let tagName = tagExp; let attrExpPresent = true; if(separatorIndex !== -1){//separate tag name and attributes expression - tagName = tagExp.substring(0, separatorIndex); - tagExp = tagExp.substring(separatorIndex + 1).trimStart(); + tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, ''); + tagExp = tagExp.substr(separatorIndex + 1); } - const rawTagName = tagName; if(removeNSPrefix){ const colonIndex = tagName.indexOf(":"); if(colonIndex !== -1){ @@ -53216,7 +56408,6 @@ function readTagExp(xmlData,i, removeNSPrefix, closingChar = ">"){ tagExp: tagExp, closeIndex: closeIndex, attrExpPresent: attrExpPresent, - rawTagName: rawTagName, } } /** @@ -75069,7 +78260,6 @@ module.exports = { stringify, stripBom } /*! * mime-db * Copyright(c) 2014 Jonathan Ong - * Copyright(c) 2015-2022 Douglas Christopher Wilson * MIT Licensed */ @@ -76435,35 +79625,230 @@ class InvalidDateError extends ExtendableError {} exports.InvalidDateError = InvalidDateError; class InvalidPrefixError extends ExtendableError {} -/** - * InvalidBucketPolicyError generated when the given bucket policy is invalid. - */ -exports.InvalidPrefixError = InvalidPrefixError; -class InvalidBucketPolicyError extends ExtendableError {} +/** + * InvalidBucketPolicyError generated when the given bucket policy is invalid. + */ +exports.InvalidPrefixError = InvalidPrefixError; +class InvalidBucketPolicyError extends ExtendableError {} + +/** + * IncorrectSizeError generated when total data read mismatches with + * the input size. + */ +exports.InvalidBucketPolicyError = InvalidBucketPolicyError; +class IncorrectSizeError extends ExtendableError {} + +/** + * InvalidXMLError generated when an unknown XML is found. + */ +exports.IncorrectSizeError = IncorrectSizeError; +class InvalidXMLError extends ExtendableError {} + +/** + * S3Error is generated for errors returned from S3 server. + * see getErrorTransformer for details + */ +exports.InvalidXMLError = InvalidXMLError; +class S3Error extends ExtendableError {} +exports.S3Error = S3Error; +class IsValidBucketNameError extends ExtendableError {} +exports.IsValidBucketNameError = IsValidBucketNameError; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ExtendableError","Error","constructor","message","opt","name","AnonymousRequestError","exports","InvalidArgumentError","InvalidPortError","InvalidEndpointError","InvalidBucketNameError","InvalidObjectNameError","AccessKeyRequiredError","SecretKeyRequiredError","ExpiresParamError","InvalidDateError","InvalidPrefixError","InvalidBucketPolicyError","IncorrectSizeError","InvalidXMLError","S3Error","IsValidBucketNameError"],"sources":["errors.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/// <reference lib=\"ES2022.Error\" />\n\nclass ExtendableError extends Error {\n  constructor(message?: string, opt?: ErrorOptions) {\n    // error Option {cause?: unknown} is a 'nice to have',\n    // don't use it internally\n    super(message, opt)\n    // set error name, otherwise it's always 'Error'\n    this.name = this.constructor.name\n  }\n}\n\n/**\n * AnonymousRequestError is generated for anonymous keys on specific\n * APIs. NOTE: PresignedURL generation always requires access keys.\n */\nexport class AnonymousRequestError extends ExtendableError {}\n\n/**\n * InvalidArgumentError is generated for all invalid arguments.\n */\nexport class InvalidArgumentError extends ExtendableError {}\n\n/**\n * InvalidPortError is generated when a non integer value is provided\n * for ports.\n */\nexport class InvalidPortError extends ExtendableError {}\n\n/**\n * InvalidEndpointError is generated when an invalid end point value is\n * provided which does not follow domain standards.\n */\nexport class InvalidEndpointError extends ExtendableError {}\n\n/**\n * InvalidBucketNameError is generated when an invalid bucket name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html\n */\nexport class InvalidBucketNameError extends ExtendableError {}\n\n/**\n * InvalidObjectNameError is generated when an invalid object name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html\n */\nexport class InvalidObjectNameError extends ExtendableError {}\n\n/**\n * AccessKeyRequiredError generated by signature methods when access\n * key is not found.\n */\nexport class AccessKeyRequiredError extends ExtendableError {}\n\n/**\n * SecretKeyRequiredError generated by signature methods when secret\n * key is not found.\n */\nexport class SecretKeyRequiredError extends ExtendableError {}\n\n/**\n * ExpiresParamError generated when expires parameter value is not\n * well within stipulated limits.\n */\nexport class ExpiresParamError extends ExtendableError {}\n\n/**\n * InvalidDateError generated when invalid date is found.\n */\nexport class InvalidDateError extends ExtendableError {}\n\n/**\n * InvalidPrefixError generated when object prefix provided is invalid\n * or does not conform to AWS S3 object key restrictions.\n */\nexport class InvalidPrefixError extends ExtendableError {}\n\n/**\n * InvalidBucketPolicyError generated when the given bucket policy is invalid.\n */\nexport class InvalidBucketPolicyError extends ExtendableError {}\n\n/**\n * IncorrectSizeError generated when total data read mismatches with\n * the input size.\n */\nexport class IncorrectSizeError extends ExtendableError {}\n\n/**\n * InvalidXMLError generated when an unknown XML is found.\n */\nexport class InvalidXMLError extends ExtendableError {}\n\n/**\n * S3Error is generated for errors returned from S3 server.\n * see getErrorTransformer for details\n */\nexport class S3Error extends ExtendableError {}\n\nexport class IsValidBucketNameError extends ExtendableError {}\n"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,MAAMA,eAAe,SAASC,KAAK,CAAC;EAClCC,WAAWA,CAACC,OAAgB,EAAEC,GAAkB,EAAE;IAChD;IACA;IACA,KAAK,CAACD,OAAO,EAAEC,GAAG,CAAC;IACnB;IACA,IAAI,CAACC,IAAI,GAAG,IAAI,CAACH,WAAW,CAACG,IAAI;EACnC;AACF;;AAEA;AACA;AACA;AACA;AACO,MAAMC,qBAAqB,SAASN,eAAe,CAAC;;AAE3D;AACA;AACA;AAFAO,OAAA,CAAAD,qBAAA,GAAAA,qBAAA;AAGO,MAAME,oBAAoB,SAASR,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AAHAO,OAAA,CAAAC,oBAAA,GAAAA,oBAAA;AAIO,MAAMC,gBAAgB,SAAST,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAE,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,oBAAoB,SAASV,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAG,oBAAA,GAAAA,oBAAA;AAKO,MAAMC,sBAAsB,SAASX,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAI,sBAAA,GAAAA,sBAAA;AAKO,MAAMC,sBAAsB,SAASZ,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAK,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASb,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAM,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASd,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAO,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,iBAAiB,SAASf,eAAe,CAAC;;AAEvD;AACA;AACA;AAFAO,OAAA,CAAAQ,iBAAA,GAAAA,iBAAA;AAGO,MAAMC,gBAAgB,SAAShB,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAS,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,kBAAkB,SAASjB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAU,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,wBAAwB,SAASlB,eAAe,CAAC;;AAE9D;AACA;AACA;AACA;AAHAO,OAAA,CAAAW,wBAAA,GAAAA,wBAAA;AAIO,MAAMC,kBAAkB,SAASnB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAY,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,eAAe,SAASpB,eAAe,CAAC;;AAErD;AACA;AACA;AACA;AAHAO,OAAA,CAAAa,eAAA,GAAAA,eAAA;AAIO,MAAMC,OAAO,SAASrB,eAAe,CAAC;AAAEO,OAAA,CAAAc,OAAA,GAAAA,OAAA;AAExC,MAAMC,sBAAsB,SAAStB,eAAe,CAAC;AAAEO,OAAA,CAAAe,sBAAA,GAAAA,sBAAA"} + +/***/ }), + +/***/ 2895: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +var Stream = _interopRequireWildcard(__nccwpck_require__(2781), true); +var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); +var _helper = __nccwpck_require__(9921); +var transformers = _interopRequireWildcard(__nccwpck_require__(9237), true); +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } +/* + * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +class extensions { + constructor(client) { + this.client = client; + } + + // List the objects in the bucket using S3 ListObjects V2 With Metadata + // + // __Arguments__ + // * `bucketName` _string_: name of the bucket + // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`) + // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`) + // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`) + // + // __Return Value__ + // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format: + // * `obj.name` _string_: name of the object + // * `obj.prefix` _string_: name of the object prefix + // * `obj.size` _number_: size of the object + // * `obj.etag` _string_: etag of the object + // * `obj.lastModified` _Date_: modified time stamp + // * `obj.metadata` _object_: metadata of the object + + listObjectsV2WithMetadata(bucketName, prefix, recursive, startAfter) { + if (prefix === undefined) { + prefix = ''; + } + if (recursive === undefined) { + recursive = false; + } + if (startAfter === undefined) { + startAfter = ''; + } + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidPrefix)(prefix)) { + throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`); + } + if (!(0, _helper.isString)(prefix)) { + throw new TypeError('prefix should be of type "string"'); + } + if (!(0, _helper.isBoolean)(recursive)) { + throw new TypeError('recursive should be of type "boolean"'); + } + if (!(0, _helper.isString)(startAfter)) { + throw new TypeError('startAfter should be of type "string"'); + } + // if recursive is false set delimiter to '/' + var delimiter = recursive ? '' : '/'; + var continuationToken = ''; + var objects = []; + var ended = false; + var readStream = Stream.Readable({ + objectMode: true + }); + readStream._read = () => { + // push one object per _read() + if (objects.length) { + readStream.push(objects.shift()); + return; + } + if (ended) { + return readStream.push(null); + } + // if there are no objects to push do query for the next batch of objects + this.listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, 1000, startAfter).on('error', e => readStream.emit('error', e)).on('data', result => { + if (result.isTruncated) { + continuationToken = result.nextContinuationToken; + } else { + ended = true; + } + objects = result.objects; + readStream._read(); + }); + }; + return readStream; + } + + // listObjectsV2WithMetadataQuery - (List Objects V2 with metadata) - List some or all (up to 1000) of the objects in a bucket. + // + // You can use the request parameters as selection criteria to return a subset of the objects in a bucket. + // request parameters :- + // * `bucketName` _string_: name of the bucket + // * `prefix` _string_: Limits the response to keys that begin with the specified prefix. + // * `continuation-token` _string_: Used to continue iterating over a set of objects. + // * `delimiter` _string_: A delimiter is a character you use to group keys. + // * `max-keys` _number_: Sets the maximum number of keys returned in the response body. + // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket. -/** - * IncorrectSizeError generated when total data read mismatches with - * the input size. - */ -exports.InvalidBucketPolicyError = InvalidBucketPolicyError; -class IncorrectSizeError extends ExtendableError {} + listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isString)(prefix)) { + throw new TypeError('prefix should be of type "string"'); + } + if (!(0, _helper.isString)(continuationToken)) { + throw new TypeError('continuationToken should be of type "string"'); + } + if (!(0, _helper.isString)(delimiter)) { + throw new TypeError('delimiter should be of type "string"'); + } + if (!(0, _helper.isNumber)(maxKeys)) { + throw new TypeError('maxKeys should be of type "number"'); + } + if (!(0, _helper.isString)(startAfter)) { + throw new TypeError('startAfter should be of type "string"'); + } + var queries = []; -/** - * InvalidXMLError generated when an unknown XML is found. - */ -exports.IncorrectSizeError = IncorrectSizeError; -class InvalidXMLError extends ExtendableError {} + // Call for listing objects v2 API + queries.push(`list-type=2`); + queries.push(`encoding-type=url`); + // escape every value in query string, except maxKeys + queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`); + queries.push(`delimiter=${(0, _helper.uriEscape)(delimiter)}`); + queries.push(`metadata=true`); + if (continuationToken) { + continuationToken = (0, _helper.uriEscape)(continuationToken); + queries.push(`continuation-token=${continuationToken}`); + } + // Set start-after + if (startAfter) { + startAfter = (0, _helper.uriEscape)(startAfter); + queries.push(`start-after=${startAfter}`); + } + // no need to escape maxKeys + if (maxKeys) { + if (maxKeys >= 1000) { + maxKeys = 1000; + } + queries.push(`max-keys=${maxKeys}`); + } + queries.sort(); + var query = ''; + if (queries.length > 0) { + query = `${queries.join('&')}`; + } + var method = 'GET'; + var transformer = transformers.getListObjectsV2WithMetadataTransformer(); + this.client.makeRequest({ + method, + bucketName, + query + }, '', [200], '', true, (e, response) => { + if (e) { + return transformer.emit('error', e); + } + (0, _helper.pipesetup)(response, transformer); + }); + return transformer; + } +} -/** - * S3Error is generated for errors returned from S3 server. - * see getErrorTransformer for details - */ -exports.InvalidXMLError = InvalidXMLError; -class S3Error extends ExtendableError {} -exports.S3Error = S3Error; -class IsValidBucketNameError extends ExtendableError {} -exports.IsValidBucketNameError = IsValidBucketNameError; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ExtendableError","Error","constructor","message","opt","name","AnonymousRequestError","exports","InvalidArgumentError","InvalidPortError","InvalidEndpointError","InvalidBucketNameError","InvalidObjectNameError","AccessKeyRequiredError","SecretKeyRequiredError","ExpiresParamError","InvalidDateError","InvalidPrefixError","InvalidBucketPolicyError","IncorrectSizeError","InvalidXMLError","S3Error","IsValidBucketNameError"],"sources":["errors.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/// <reference lib=\"ES2022.Error\" />\n\nclass ExtendableError extends Error {\n  constructor(message?: string, opt?: ErrorOptions) {\n    // error Option {cause?: unknown} is a 'nice to have',\n    // don't use it internally\n    super(message, opt)\n    // set error name, otherwise it's always 'Error'\n    this.name = this.constructor.name\n  }\n}\n\n/**\n * AnonymousRequestError is generated for anonymous keys on specific\n * APIs. NOTE: PresignedURL generation always requires access keys.\n */\nexport class AnonymousRequestError extends ExtendableError {}\n\n/**\n * InvalidArgumentError is generated for all invalid arguments.\n */\nexport class InvalidArgumentError extends ExtendableError {}\n\n/**\n * InvalidPortError is generated when a non integer value is provided\n * for ports.\n */\nexport class InvalidPortError extends ExtendableError {}\n\n/**\n * InvalidEndpointError is generated when an invalid end point value is\n * provided which does not follow domain standards.\n */\nexport class InvalidEndpointError extends ExtendableError {}\n\n/**\n * InvalidBucketNameError is generated when an invalid bucket name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html\n */\nexport class InvalidBucketNameError extends ExtendableError {}\n\n/**\n * InvalidObjectNameError is generated when an invalid object name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html\n */\nexport class InvalidObjectNameError extends ExtendableError {}\n\n/**\n * AccessKeyRequiredError generated by signature methods when access\n * key is not found.\n */\nexport class AccessKeyRequiredError extends ExtendableError {}\n\n/**\n * SecretKeyRequiredError generated by signature methods when secret\n * key is not found.\n */\nexport class SecretKeyRequiredError extends ExtendableError {}\n\n/**\n * ExpiresParamError generated when expires parameter value is not\n * well within stipulated limits.\n */\nexport class ExpiresParamError extends ExtendableError {}\n\n/**\n * InvalidDateError generated when invalid date is found.\n */\nexport class InvalidDateError extends ExtendableError {}\n\n/**\n * InvalidPrefixError generated when object prefix provided is invalid\n * or does not conform to AWS S3 object key restrictions.\n */\nexport class InvalidPrefixError extends ExtendableError {}\n\n/**\n * InvalidBucketPolicyError generated when the given bucket policy is invalid.\n */\nexport class InvalidBucketPolicyError extends ExtendableError {}\n\n/**\n * IncorrectSizeError generated when total data read mismatches with\n * the input size.\n */\nexport class IncorrectSizeError extends ExtendableError {}\n\n/**\n * InvalidXMLError generated when an unknown XML is found.\n */\nexport class InvalidXMLError extends ExtendableError {}\n\n/**\n * S3Error is generated for errors returned from S3 server.\n * see getErrorTransformer for details\n */\nexport class S3Error extends ExtendableError {\n  code?: string\n}\n\nexport class IsValidBucketNameError extends ExtendableError {}\n"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,MAAMA,eAAe,SAASC,KAAK,CAAC;EAClCC,WAAWA,CAACC,OAAgB,EAAEC,GAAkB,EAAE;IAChD;IACA;IACA,KAAK,CAACD,OAAO,EAAEC,GAAG,CAAC;IACnB;IACA,IAAI,CAACC,IAAI,GAAG,IAAI,CAACH,WAAW,CAACG,IAAI;EACnC;AACF;;AAEA;AACA;AACA;AACA;AACO,MAAMC,qBAAqB,SAASN,eAAe,CAAC;;AAE3D;AACA;AACA;AAFAO,OAAA,CAAAD,qBAAA,GAAAA,qBAAA;AAGO,MAAME,oBAAoB,SAASR,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AAHAO,OAAA,CAAAC,oBAAA,GAAAA,oBAAA;AAIO,MAAMC,gBAAgB,SAAST,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAE,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,oBAAoB,SAASV,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAG,oBAAA,GAAAA,oBAAA;AAKO,MAAMC,sBAAsB,SAASX,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAI,sBAAA,GAAAA,sBAAA;AAKO,MAAMC,sBAAsB,SAASZ,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAK,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASb,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAM,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASd,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAO,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,iBAAiB,SAASf,eAAe,CAAC;;AAEvD;AACA;AACA;AAFAO,OAAA,CAAAQ,iBAAA,GAAAA,iBAAA;AAGO,MAAMC,gBAAgB,SAAShB,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAS,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,kBAAkB,SAASjB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAU,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,wBAAwB,SAASlB,eAAe,CAAC;;AAE9D;AACA;AACA;AACA;AAHAO,OAAA,CAAAW,wBAAA,GAAAA,wBAAA;AAIO,MAAMC,kBAAkB,SAASnB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAY,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,eAAe,SAASpB,eAAe,CAAC;;AAErD;AACA;AACA;AACA;AAHAO,OAAA,CAAAa,eAAA,GAAAA,eAAA;AAIO,MAAMC,OAAO,SAASrB,eAAe,CAAC;AAE5CO,OAAA,CAAAc,OAAA,GAAAA,OAAA;AAEM,MAAMC,sBAAsB,SAAStB,eAAe,CAAC;AAAEO,OAAA,CAAAe,sBAAA,GAAAA,sBAAA"} +// deprecated default export, please use named exports. +// keep for backward compatibility. +// eslint-disable-next-line import/no-default-export +exports.extensions = extensions; +var _default = extensions; +exports["default"] = _default; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Stream","_interopRequireWildcard","require","errors","_helper","transformers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","extensions","constructor","client","listObjectsV2WithMetadata","bucketName","prefix","recursive","startAfter","undefined","isValidBucketName","InvalidBucketNameError","isValidPrefix","InvalidPrefixError","isString","TypeError","isBoolean","delimiter","continuationToken","objects","ended","readStream","Readable","objectMode","_read","length","push","shift","listObjectsV2WithMetadataQuery","on","e","emit","result","isTruncated","nextContinuationToken","maxKeys","isNumber","queries","uriEscape","sort","query","join","method","transformer","getListObjectsV2WithMetadataTransformer","makeRequest","response","pipesetup","exports","_default"],"sources":["extensions.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Stream from 'node:stream'\n\nimport * as errors from './errors.ts'\nimport {\n  isBoolean,\n  isNumber,\n  isString,\n  isValidBucketName,\n  isValidPrefix,\n  pipesetup,\n  uriEscape,\n} from './internal/helper.ts'\nimport * as transformers from './transformers.js'\n\nexport class extensions {\n  constructor(client) {\n    this.client = client\n  }\n\n  // List the objects in the bucket using S3 ListObjects V2 With Metadata\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  //   * `obj.name` _string_: name of the object\n  //   * `obj.prefix` _string_: name of the object prefix\n  //   * `obj.size` _number_: size of the object\n  //   * `obj.etag` _string_: etag of the object\n  //   * `obj.lastModified` _Date_: modified time stamp\n  //   * `obj.metadata` _object_: metadata of the object\n\n  listObjectsV2WithMetadata(bucketName, prefix, recursive, startAfter) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    // if recursive is false set delimiter to '/'\n    var delimiter = recursive ? '' : '/'\n    var continuationToken = ''\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, 1000, startAfter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            continuationToken = result.nextContinuationToken\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // listObjectsV2WithMetadataQuery - (List Objects V2 with metadata) - List some or all (up to 1000) of the objects in a bucket.\n  //\n  // You can use the request parameters as selection criteria to return a subset of the objects in a bucket.\n  // request parameters :-\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: Limits the response to keys that begin with the specified prefix.\n  // * `continuation-token` _string_: Used to continue iterating over a set of objects.\n  // * `delimiter` _string_: A delimiter is a character you use to group keys.\n  // * `max-keys` _number_: Sets the maximum number of keys returned in the response body.\n  // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket.\n\n  listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(continuationToken)) {\n      throw new TypeError('continuationToken should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    if (!isNumber(maxKeys)) {\n      throw new TypeError('maxKeys should be of type \"number\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    var queries = []\n\n    // Call for listing objects v2 API\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n    queries.push(`metadata=true`)\n\n    if (continuationToken) {\n      continuationToken = uriEscape(continuationToken)\n      queries.push(`continuation-token=${continuationToken}`)\n    }\n    // Set start-after\n    if (startAfter) {\n      startAfter = uriEscape(startAfter)\n      queries.push(`start-after=${startAfter}`)\n    }\n    // no need to escape maxKeys\n    if (maxKeys) {\n      if (maxKeys >= 1000) {\n        maxKeys = 1000\n      }\n      queries.push(`max-keys=${maxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListObjectsV2WithMetadataTransformer()\n    this.client.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default extensions\n"],"mappings":"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"} /***/ }), @@ -76698,34 +80083,6 @@ exports.SelectResults = SelectResults; /***/ }), -/***/ 3826: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.callbackify = callbackify; -// wrapper an async function that support callback style API. -// It will preserve 'this'. -function callbackify(fn) { - return function () { - const args = [...arguments]; - const callback = args.pop(); - - // If the last argument is a function, assume it's the callback. - if (typeof callback === 'function') { - return fn.apply(this, args).then(result => callback(null, result), err => callback(err)); - } - return fn.apply(this, arguments); - }; -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjYWxsYmFja2lmeSIsImZuIiwiYXJncyIsImFyZ3VtZW50cyIsImNhbGxiYWNrIiwicG9wIiwiYXBwbHkiLCJ0aGVuIiwicmVzdWx0IiwiZXJyIl0sInNvdXJjZXMiOlsiY2FsbGJhY2tpZnkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gd3JhcHBlciBhbiBhc3luYyBmdW5jdGlvbiB0aGF0IHN1cHBvcnQgY2FsbGJhY2sgc3R5bGUgQVBJLlxuLy8gSXQgd2lsbCBwcmVzZXJ2ZSAndGhpcycuXG5leHBvcnQgZnVuY3Rpb24gY2FsbGJhY2tpZnkoZm4pIHtcbiAgcmV0dXJuIGZ1bmN0aW9uICgpIHtcbiAgICBjb25zdCBhcmdzID0gWy4uLmFyZ3VtZW50c11cbiAgICBjb25zdCBjYWxsYmFjayA9IGFyZ3MucG9wKClcblxuICAgIC8vIElmIHRoZSBsYXN0IGFyZ3VtZW50IGlzIGEgZnVuY3Rpb24sIGFzc3VtZSBpdCdzIHRoZSBjYWxsYmFjay5cbiAgICBpZiAodHlwZW9mIGNhbGxiYWNrID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJncykudGhlbihcbiAgICAgICAgKHJlc3VsdCkgPT4gY2FsbGJhY2sobnVsbCwgcmVzdWx0KSxcbiAgICAgICAgKGVycikgPT4gY2FsbGJhY2soZXJyKSxcbiAgICAgIClcbiAgICB9XG5cbiAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJndW1lbnRzKVxuICB9XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBO0FBQ0E7QUFDTyxTQUFTQSxXQUFXQSxDQUFDQyxFQUFFLEVBQUU7RUFDOUIsT0FBTyxZQUFZO0lBQ2pCLE1BQU1DLElBQUksR0FBRyxDQUFDLEdBQUdDLFNBQVMsQ0FBQztJQUMzQixNQUFNQyxRQUFRLEdBQUdGLElBQUksQ0FBQ0csR0FBRyxDQUFDLENBQUM7O0lBRTNCO0lBQ0EsSUFBSSxPQUFPRCxRQUFRLEtBQUssVUFBVSxFQUFFO01BQ2xDLE9BQU9ILEVBQUUsQ0FBQ0ssS0FBSyxDQUFDLElBQUksRUFBRUosSUFBSSxDQUFDLENBQUNLLElBQUksQ0FDN0JDLE1BQU0sSUFBS0osUUFBUSxDQUFDLElBQUksRUFBRUksTUFBTSxDQUFDLEVBQ2pDQyxHQUFHLElBQUtMLFFBQVEsQ0FBQ0ssR0FBRyxDQUN2QixDQUFDO0lBQ0g7SUFFQSxPQUFPUixFQUFFLENBQUNLLEtBQUssQ0FBQyxJQUFJLEVBQUVILFNBQVMsQ0FBQztFQUNsQyxDQUFDO0FBQ0gifQ== - -/***/ }), - /***/ 5586: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { @@ -76737,25 +80094,16 @@ Object.defineProperty(exports, "__esModule", ({ })); var http = _interopRequireWildcard(__nccwpck_require__(3685), true); var https = _interopRequireWildcard(__nccwpck_require__(5687), true); -var _browserOrNode = __nccwpck_require__(9107); var _lodash = __nccwpck_require__(250); -var qs = _interopRequireWildcard(__nccwpck_require__(293), true); -var _xml2js = __nccwpck_require__(4659); var _CredentialProvider = __nccwpck_require__(6570); var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); -var _helpers = __nccwpck_require__(9455); -var _signing = __nccwpck_require__(2029); -var _extensions = __nccwpck_require__(1159); var _helper = __nccwpck_require__(9921); -var _request = __nccwpck_require__(9093); -var _response = __nccwpck_require__(2644); var _s3Endpoints = __nccwpck_require__(6314); -var xmlParsers = _interopRequireWildcard(__nccwpck_require__(4040), true); function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } // will be replaced by bundler. const Package = { - version: "7.1.3" || 0 + version: "7.1.1" || 0 }; const requestOptionProperties = ['agent', 'ca', 'cert', 'ciphers', 'clientCertEngine', 'crl', 'dhparam', 'ecdhCurve', 'family', 'honorCipherOrder', 'key', 'passphrase', 'pfx', 'rejectUnauthorized', 'secureOptions', 'secureProtocol', 'servername', 'sessionIdContext']; class TypedClient { @@ -76877,14 +80225,6 @@ class TypedClient { this.enableSHA256 = !this.anonymous && !params.useSSL; this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined; this.reqOptions = {}; - this.clientExtensions = new _extensions.Extensions(this); - } - - /** - * Minio extensions that aren't necessary present for Amazon S3 compatible storage servers - */ - get extensions() { - return this.clientExtensions; } /** @@ -77034,581 +80374,9 @@ class TypedClient { } } } - /** - * log the request, response, error - */ - logHTTP(reqOptions, response, err) { - // if no logStream available return. - if (!this.logStream) { - return; - } - if (!(0, _helper.isObject)(reqOptions)) { - throw new TypeError('reqOptions should be of type "object"'); - } - if (response && !(0, _helper.isReadableStream)(response)) { - throw new TypeError('response should be of type "Stream"'); - } - if (err && !(err instanceof Error)) { - throw new TypeError('err should be of type "Error"'); - } - const logStream = this.logStream; - const logHeaders = headers => { - Object.entries(headers).forEach(([k, v]) => { - if (k == 'authorization') { - if ((0, _helper.isString)(v)) { - const redactor = new RegExp('Signature=([0-9a-f]+)'); - v = v.replace(redactor, 'Signature=**REDACTED**'); - } - } - logStream.write(`${k}: ${v}\n`); - }); - logStream.write('\n'); - }; - logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\n`); - logHeaders(reqOptions.headers); - if (response) { - this.logStream.write(`RESPONSE: ${response.statusCode}\n`); - logHeaders(response.headers); - } - if (err) { - logStream.write('ERROR BODY:\n'); - const errJSON = JSON.stringify(err, null, '\t'); - logStream.write(`${errJSON}\n`); - } - } - - /** - * Enable tracing - */ - traceOn(stream) { - if (!stream) { - stream = process.stdout; - } - this.logStream = stream; - } - - /** - * Disable tracing - */ - traceOff() { - this.logStream = undefined; - } - - /** - * makeRequest is the primitive used by the apis for making S3 requests. - * payload can be empty string in case of no payload. - * statusCode is the expected statusCode. If response.statusCode does not match - * we parse the XML error and call the callback with the error message. - * - * A valid region is passed by the calls - listBuckets, makeBucket and getBucketRegion. - * - * @internal - */ - async makeRequestAsync(options, payload = '', expectedCodes = [200], region = '') { - if (!(0, _helper.isObject)(options)) { - throw new TypeError('options should be of type "object"'); - } - if (!(0, _helper.isString)(payload) && !(0, _helper.isObject)(payload)) { - // Buffer is of type 'object' - throw new TypeError('payload should be of type "string" or "Buffer"'); - } - expectedCodes.forEach(statusCode => { - if (!(0, _helper.isNumber)(statusCode)) { - throw new TypeError('statusCode should be of type "number"'); - } - }); - if (!(0, _helper.isString)(region)) { - throw new TypeError('region should be of type "string"'); - } - if (!options.headers) { - options.headers = {}; - } - if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') { - options.headers['content-length'] = payload.length.toString(); - } - const sha256sum = this.enableSHA256 ? (0, _helper.toSha256)(payload) : ''; - return this.makeRequestStreamAsync(options, payload, sha256sum, expectedCodes, region); - } - - /** - * new request with promise - * - * No need to drain response, response body is not valid - */ - async makeRequestAsyncOmit(options, payload = '', statusCodes = [200], region = '') { - const res = await this.makeRequestAsync(options, payload, statusCodes, region); - await (0, _response.drainResponse)(res); - return res; - } - - /** - * makeRequestStream will be used directly instead of makeRequest in case the payload - * is available as a stream. for ex. putObject - * - * @internal - */ - async makeRequestStreamAsync(options, body, sha256sum, statusCodes, region) { - if (!(0, _helper.isObject)(options)) { - throw new TypeError('options should be of type "object"'); - } - if (!(Buffer.isBuffer(body) || typeof body === 'string' || (0, _helper.isReadableStream)(body))) { - throw new errors.InvalidArgumentError(`stream should be a Buffer, string or readable Stream, got ${typeof body} instead`); - } - if (!(0, _helper.isString)(sha256sum)) { - throw new TypeError('sha256sum should be of type "string"'); - } - statusCodes.forEach(statusCode => { - if (!(0, _helper.isNumber)(statusCode)) { - throw new TypeError('statusCode should be of type "number"'); - } - }); - if (!(0, _helper.isString)(region)) { - throw new TypeError('region should be of type "string"'); - } - // sha256sum will be empty for anonymous or https requests - if (!this.enableSHA256 && sha256sum.length !== 0) { - throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`); - } - // sha256sum should be valid for non-anonymous http requests. - if (this.enableSHA256 && sha256sum.length !== 64) { - throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`); - } - await this.checkAndRefreshCreds(); - - // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - region = region || (await this.getBucketRegionAsync(options.bucketName)); - const reqOptions = this.getRequestOptions({ - ...options, - region - }); - if (!this.anonymous) { - // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation. - if (!this.enableSHA256) { - sha256sum = 'UNSIGNED-PAYLOAD'; - } - const date = new Date(); - reqOptions.headers['x-amz-date'] = (0, _helper.makeDateLong)(date); - reqOptions.headers['x-amz-content-sha256'] = sha256sum; - if (this.sessionToken) { - reqOptions.headers['x-amz-security-token'] = this.sessionToken; - } - reqOptions.headers.authorization = (0, _signing.signV4)(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum); - } - const response = await (0, _request.request)(this.transport, reqOptions, body); - if (!response.statusCode) { - throw new Error("BUG: response doesn't have a statusCode"); - } - if (!statusCodes.includes(response.statusCode)) { - // For an incorrect region, S3 server always sends back 400. - // But we will do cache invalidation for all errors so that, - // in future, if AWS S3 decides to send a different status code or - // XML error code we will still work fine. - // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - delete this.regionMap[options.bucketName]; - const err = await xmlParsers.parseResponseError(response); - this.logHTTP(reqOptions, response, err); - throw err; - } - this.logHTTP(reqOptions, response); - return response; - } - - /** - * gets the region of the bucket - * - * @param bucketName - * - * @internal - */ - async getBucketRegionAsync(bucketName) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`); - } - - // Region is set with constructor, return the region right here. - if (this.region) { - return this.region; - } - const cached = this.regionMap[bucketName]; - if (cached) { - return cached; - } - const extractRegionAsync = async response => { - const body = await (0, _response.readAsString)(response); - const region = xmlParsers.parseBucketRegion(body) || _helpers.DEFAULT_REGION; - this.regionMap[bucketName] = region; - return region; - }; - const method = 'GET'; - const query = 'location'; - // `getBucketLocation` behaves differently in following ways for - // different environments. - // - // - For nodejs env we default to path style requests. - // - For browser env path style requests on buckets yields CORS - // error. To circumvent this problem we make a virtual host - // style request signed with 'us-east-1'. This request fails - // with an error 'AuthorizationHeaderMalformed', additionally - // the error XML also provides Region of the bucket. To validate - // this region is proper we retry the same request with the newly - // obtained region. - const pathStyle = this.pathStyle && !_browserOrNode.isBrowser; - let region; - try { - const res = await this.makeRequestAsync({ - method, - bucketName, - query, - pathStyle - }, '', [200], _helpers.DEFAULT_REGION); - return extractRegionAsync(res); - } catch (e) { - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - if (!(e.name === 'AuthorizationHeaderMalformed')) { - throw e; - } - // @ts-expect-error we set extra properties on error object - region = e.Region; - if (!region) { - throw e; - } - } - const res = await this.makeRequestAsync({ - method, - bucketName, - query, - pathStyle - }, '', [200], region); - return await extractRegionAsync(res); - } - - /** - * makeRequest is the primitive used by the apis for making S3 requests. - * payload can be empty string in case of no payload. - * statusCode is the expected statusCode. If response.statusCode does not match - * we parse the XML error and call the callback with the error message. - * A valid region is passed by the calls - listBuckets, makeBucket and - * getBucketRegion. - * - * @deprecated use `makeRequestAsync` instead - */ - makeRequest(options, payload = '', expectedCodes = [200], region = '', returnResponse, cb) { - let prom; - if (returnResponse) { - prom = this.makeRequestAsync(options, payload, expectedCodes, region); - } else { - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-expect-error compatible for old behaviour - prom = this.makeRequestAsyncOmit(options, payload, expectedCodes, region); - } - prom.then(result => cb(null, result), err => { - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - cb(err); - }); - } - - /** - * makeRequestStream will be used directly instead of makeRequest in case the payload - * is available as a stream. for ex. putObject - * - * @deprecated use `makeRequestStreamAsync` instead - */ - makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb) { - const executor = async () => { - const res = await this.makeRequestStreamAsync(options, stream, sha256sum, statusCodes, region); - if (!returnResponse) { - await (0, _response.drainResponse)(res); - } - return res; - }; - executor().then(result => cb(null, result), - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - err => cb(err)); - } - - /** - * @deprecated use `getBucketRegionAsync` instead - */ - getBucketRegion(bucketName, cb) { - return this.getBucketRegionAsync(bucketName).then(result => cb(null, result), - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - err => cb(err)); - } - - /** - * @deprecated use promise style API - */ - - async removeBucket(bucketName) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - const method = 'DELETE'; - await this.makeRequestAsyncOmit({ - method, - bucketName - }, '', [204]); - delete this.regionMap[bucketName]; - } - - /** - * Stat information of the object. - */ - async statObject(bucketName, objectName, statOpts = {}) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isObject)(statOpts)) { - throw new errors.InvalidArgumentError('statOpts should be of type "object"'); - } - const query = qs.stringify(statOpts); - const method = 'HEAD'; - const res = await this.makeRequestAsyncOmit({ - method, - bucketName, - objectName, - query - }); - return { - size: parseInt(res.headers['content-length']), - metaData: (0, _helper.extractMetadata)(res.headers), - lastModified: new Date(res.headers['last-modified']), - versionId: (0, _helper.getVersionId)(res.headers), - etag: (0, _helper.sanitizeETag)(res.headers.etag) - }; - } - - /** - * Remove the specified object. - * @deprecated use new promise style API - */ - - /** - * @deprecated use new promise style API - */ // @ts-ignore - async removeObject(bucketName, objectName, removeOpts = {}) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isObject)(removeOpts)) { - throw new errors.InvalidArgumentError('removeOpts should be of type "object"'); - } - const method = 'DELETE'; - const headers = {}; - if (removeOpts.governanceBypass) { - headers['X-Amz-Bypass-Governance-Retention'] = true; - } - if (removeOpts.forceDelete) { - headers['x-minio-force-delete'] = true; - } - const queryParams = {}; - if (removeOpts.versionId) { - queryParams.versionId = `${removeOpts.versionId}`; - } - const query = qs.stringify(queryParams); - await this.makeRequestAsyncOmit({ - method, - bucketName, - objectName, - headers, - query - }, '', [200, 204]); - } - - // Calls implemented below are related to multipart. - - /** - * Initiate a new multipart upload. - * @internal - */ - async initiateNewMultipartUpload(bucketName, objectName, headers) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isObject)(headers)) { - throw new errors.InvalidObjectNameError('contentType should be of type "object"'); - } - const method = 'POST'; - const query = 'uploads'; - const res = await this.makeRequestAsync({ - method, - bucketName, - objectName, - query, - headers - }); - const body = await (0, _response.readAsBuffer)(res); - return (0, xmlParsers.parseInitiateMultipart)(body.toString()); - } - - /** - * Internal Method to abort a multipart upload request in case of any errors. - * - * @param bucketName - Bucket Name - * @param objectName - Object Name - * @param uploadId - id of a multipart upload to cancel during compose object sequence. - */ - async abortMultipartUpload(bucketName, objectName, uploadId) { - const method = 'DELETE'; - const query = `uploadId=${uploadId}`; - const requestOptions = { - method, - bucketName, - objectName: objectName, - query - }; - await this.makeRequestAsyncOmit(requestOptions, '', [204]); - } - - /** - * Get part-info of all parts of an incomplete upload specified by uploadId. - */ - async listParts(bucketName, objectName, uploadId) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isString)(uploadId)) { - throw new TypeError('uploadId should be of type "string"'); - } - if (!uploadId) { - throw new errors.InvalidArgumentError('uploadId cannot be empty'); - } - const parts = []; - let marker = 0; - let result; - do { - result = await this.listPartsQuery(bucketName, objectName, uploadId, marker); - marker = result.marker; - parts.push(...result.parts); - } while (result.isTruncated); - return parts; - } - - /** - * Called by listParts to fetch a batch of part-info - */ - async listPartsQuery(bucketName, objectName, uploadId, marker) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isString)(uploadId)) { - throw new TypeError('uploadId should be of type "string"'); - } - if (!(0, _helper.isNumber)(marker)) { - throw new TypeError('marker should be of type "number"'); - } - if (!uploadId) { - throw new errors.InvalidArgumentError('uploadId cannot be empty'); - } - let query = `uploadId=${(0, _helper.uriEscape)(uploadId)}`; - if (marker) { - query += `&part-number-marker=${marker}`; - } - const method = 'GET'; - const res = await this.makeRequestAsync({ - method, - bucketName, - objectName, - query - }); - return xmlParsers.parseListParts(await (0, _response.readAsString)(res)); - } - async listBuckets() { - const method = 'GET'; - const httpRes = await this.makeRequestAsync({ - method - }, '', [200], _helpers.DEFAULT_REGION); - const xmlResult = await (0, _response.readAsString)(httpRes); - return xmlParsers.parseListBucket(xmlResult); - } - async removeBucketReplication(bucketName) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - const method = 'DELETE'; - const query = 'replication'; - await this.makeRequestAsyncOmit({ - method, - bucketName, - query - }, '', [200, 204], ''); - } - async setBucketReplication(bucketName, replicationConfig) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isObject)(replicationConfig)) { - throw new errors.InvalidArgumentError('replicationConfig should be of type "object"'); - } else { - if (_lodash.isEmpty(replicationConfig.role)) { - throw new errors.InvalidArgumentError('Role cannot be empty'); - } else if (replicationConfig.role && !(0, _helper.isString)(replicationConfig.role)) { - throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role); - } - if (_lodash.isEmpty(replicationConfig.rules)) { - throw new errors.InvalidArgumentError('Minimum one replication rule must be specified'); - } - } - const method = 'PUT'; - const query = 'replication'; - const headers = {}; - const replicationParamsConfig = { - ReplicationConfiguration: { - Role: replicationConfig.role, - Rule: replicationConfig.rules - } - }; - const builder = new _xml2js.Builder({ - renderOpts: { - pretty: false - }, - headless: true - }); - const payload = builder.buildObject(replicationParamsConfig); - headers['Content-MD5'] = (0, _helper.toMd5)(payload); - await this.makeRequestAsyncOmit({ - method, - bucketName, - query, - headers - }, payload); - } - async getBucketReplication(bucketName) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - const method = 'GET'; - const query = 'replication'; - const httpRes = await this.makeRequestAsync({ - method, - bucketName, - query - }, '', [200, 204]); - const xmlResult = await (0, _response.readAsString)(httpRes); - return xmlParsers.parseReplicationConfig(xmlResult); - } } exports.TypedClient = TypedClient; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["http","_interopRequireWildcard","require","https","_browserOrNode","_lodash","qs","_xml2js","_CredentialProvider","errors","_helpers","_signing","_extensions","_helper","_request","_response","_s3Endpoints","xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","Package","version","requestOptionProperties","TypedClient","partSize","maximumPartSize","maxObjectSize","constructor","params","secure","undefined","Error","useSSL","port","isValidEndpoint","endPoint","InvalidEndpointError","isValidPort","InvalidArgumentError","isBoolean","region","isString","host","toLowerCase","protocol","transport","transportAgent","globalAgent","isObject","libraryComments","process","platform","arch","libraryAgent","userAgent","pathStyle","accessKey","secretKey","sessionToken","anonymous","credentialsProvider","regionMap","overRidePartSize","enableSHA256","s3AccelerateEndpoint","reqOptions","clientExtensions","Extensions","extensions","setS3TransferAccelerate","setRequestOptions","options","TypeError","_","pick","getAccelerateEndPointIfSet","bucketName","objectName","isEmpty","includes","getRequestOptions","opts","method","headers","query","agent","virtualHostStyle","isVirtualHostStyle","path","uriResourceEscape","isAmazonEndpoint","accelerateEndPoint","getS3Endpoint","k","v","entries","assign","mapValues","pickBy","isDefined","toString","setCredentialsProvider","CredentialProvider","checkAndRefreshCreds","credentialsConf","getCredentials","getAccessKey","getSecretKey","getSessionToken","e","cause","logHTTP","response","err","logStream","isReadableStream","logHeaders","forEach","redactor","RegExp","replace","write","statusCode","errJSON","JSON","stringify","traceOn","stream","stdout","traceOff","makeRequestAsync","payload","expectedCodes","isNumber","length","sha256sum","toSha256","makeRequestStreamAsync","makeRequestAsyncOmit","statusCodes","res","drainResponse","body","Buffer","isBuffer","getBucketRegionAsync","date","Date","makeDateLong","authorization","signV4","request","parseResponseError","isValidBucketName","InvalidBucketNameError","cached","extractRegionAsync","readAsString","parseBucketRegion","DEFAULT_REGION","isBrowser","name","Region","makeRequest","returnResponse","cb","prom","then","result","makeRequestStream","executor","getBucketRegion","removeBucket","statObject","statOpts","isValidObjectName","InvalidObjectNameError","size","parseInt","metaData","extractMetadata","lastModified","versionId","getVersionId","etag","sanitizeETag","removeObject","removeOpts","governanceBypass","forceDelete","queryParams","initiateNewMultipartUpload","readAsBuffer","parseInitiateMultipart","abortMultipartUpload","uploadId","requestOptions","listParts","parts","marker","listPartsQuery","push","isTruncated","uriEscape","parseListParts","listBuckets","httpRes","xmlResult","parseListBucket","removeBucketReplication","setBucketReplication","replicationConfig","role","rules","replicationParamsConfig","ReplicationConfiguration","Role","Rule","builder","xml2js","Builder","renderOpts","pretty","headless","buildObject","toMd5","getBucketReplication","parseReplicationConfig","exports"],"sources":["client.ts"],"sourcesContent":["import * as http from 'node:http'\nimport * as https from 'node:https'\nimport type * as stream from 'node:stream'\n\nimport { isBrowser } from 'browser-or-node'\nimport _ from 'lodash'\nimport * as qs from 'query-string'\nimport xml2js from 'xml2js'\n\nimport { CredentialProvider } from '../CredentialProvider.ts'\nimport * as errors from '../errors.ts'\nimport { DEFAULT_REGION } from '../helpers.ts'\nimport { signV4 } from '../signing.ts'\nimport { Extensions } from './extensions.ts'\nimport {\n  extractMetadata,\n  getVersionId,\n  isAmazonEndpoint,\n  isBoolean,\n  isDefined,\n  isEmpty,\n  isNumber,\n  isObject,\n  isReadableStream,\n  isString,\n  isValidBucketName,\n  isValidEndpoint,\n  isValidObjectName,\n  isValidPort,\n  isVirtualHostStyle,\n  makeDateLong,\n  sanitizeETag,\n  toMd5,\n  toSha256,\n  uriEscape,\n  uriResourceEscape,\n} from './helper.ts'\nimport { request } from './request.ts'\nimport { drainResponse, readAsBuffer, readAsString } from './response.ts'\nimport type { Region } from './s3-endpoints.ts'\nimport { getS3Endpoint } from './s3-endpoints.ts'\nimport type {\n  Binary,\n  BucketItemFromList,\n  BucketItemStat,\n  IRequest,\n  ReplicationConfig,\n  ReplicationConfigOpts,\n  RequestHeaders,\n  ResponseHeader,\n  ResultCallback,\n  StatObjectOpts,\n  Transport,\n} from './type.ts'\nimport type { UploadedPart } from './xml-parser.ts'\nimport * as xmlParsers from './xml-parser.ts'\nimport { parseInitiateMultipart } from './xml-parser.ts'\n\n// will be replaced by bundler.\nconst Package = { version: process.env.MINIO_JS_PACKAGE_VERSION || 'development' }\n\nconst requestOptionProperties = [\n  'agent',\n  'ca',\n  'cert',\n  'ciphers',\n  'clientCertEngine',\n  'crl',\n  'dhparam',\n  'ecdhCurve',\n  'family',\n  'honorCipherOrder',\n  'key',\n  'passphrase',\n  'pfx',\n  'rejectUnauthorized',\n  'secureOptions',\n  'secureProtocol',\n  'servername',\n  'sessionIdContext',\n] as const\n\nexport interface ClientOptions {\n  endPoint: string\n  accessKey: string\n  secretKey: string\n  useSSL?: boolean\n  port?: number\n  region?: Region\n  transport?: Transport\n  sessionToken?: string\n  partSize?: number\n  pathStyle?: boolean\n  credentialsProvider?: CredentialProvider\n  s3AccelerateEndpoint?: string\n  transportAgent?: http.Agent\n}\n\nexport type RequestOption = Partial<IRequest> & {\n  method: string\n  bucketName?: string\n  objectName?: string\n  query?: string\n  pathStyle?: boolean\n}\n\nexport type NoResultCallback = (error: unknown) => void\n\nexport interface RemoveOptions {\n  versionId?: string\n  governanceBypass?: boolean\n  forceDelete?: boolean\n}\n\nexport class TypedClient {\n  protected transport: Transport\n  protected host: string\n  protected port: number\n  protected protocol: string\n  protected accessKey: string\n  protected secretKey: string\n  protected sessionToken?: string\n  protected userAgent: string\n  protected anonymous: boolean\n  protected pathStyle: boolean\n  protected regionMap: Record<string, string>\n  public region?: string\n  protected credentialsProvider?: CredentialProvider\n  partSize: number = 64 * 1024 * 1024\n  protected overRidePartSize?: boolean\n\n  protected maximumPartSize = 5 * 1024 * 1024 * 1024\n  protected maxObjectSize = 5 * 1024 * 1024 * 1024 * 1024\n  public enableSHA256: boolean\n  protected s3AccelerateEndpoint?: string\n  protected reqOptions: Record<string, unknown>\n\n  protected transportAgent: http.Agent\n  private readonly clientExtensions: Extensions\n\n  constructor(params: ClientOptions) {\n    // @ts-expect-error deprecated property\n    if (params.secure !== undefined) {\n      throw new Error('\"secure\" option deprecated, \"useSSL\" should be used instead')\n    }\n    // Default values if not specified.\n    if (params.useSSL === undefined) {\n      params.useSSL = true\n    }\n    if (!params.port) {\n      params.port = 0\n    }\n    // Validate input params.\n    if (!isValidEndpoint(params.endPoint)) {\n      throw new errors.InvalidEndpointError(`Invalid endPoint : ${params.endPoint}`)\n    }\n    if (!isValidPort(params.port)) {\n      throw new errors.InvalidArgumentError(`Invalid port : ${params.port}`)\n    }\n    if (!isBoolean(params.useSSL)) {\n      throw new errors.InvalidArgumentError(\n        `Invalid useSSL flag type : ${params.useSSL}, expected to be of type \"boolean\"`,\n      )\n    }\n\n    // Validate region only if its set.\n    if (params.region) {\n      if (!isString(params.region)) {\n        throw new errors.InvalidArgumentError(`Invalid region : ${params.region}`)\n      }\n    }\n\n    const host = params.endPoint.toLowerCase()\n    let port = params.port\n    let protocol: string\n    let transport\n    let transportAgent: http.Agent\n    // Validate if configuration is not using SSL\n    // for constructing relevant endpoints.\n    if (params.useSSL) {\n      // Defaults to secure.\n      transport = https\n      protocol = 'https:'\n      port = port || 443\n      transportAgent = https.globalAgent\n    } else {\n      transport = http\n      protocol = 'http:'\n      port = port || 80\n      transportAgent = http.globalAgent\n    }\n\n    // if custom transport is set, use it.\n    if (params.transport) {\n      if (!isObject(params.transport)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transport type : ${params.transport}, expected to be type \"object\"`,\n        )\n      }\n      transport = params.transport\n    }\n\n    // if custom transport agent is set, use it.\n    if (params.transportAgent) {\n      if (!isObject(params.transportAgent)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transportAgent type: ${params.transportAgent}, expected to be type \"object\"`,\n        )\n      }\n\n      transportAgent = params.transportAgent\n    }\n\n    // User Agent should always following the below style.\n    // Please open an issue to discuss any new changes here.\n    //\n    //       MinIO (OS; ARCH) LIB/VER APP/VER\n    //\n    const libraryComments = `(${process.platform}; ${process.arch})`\n    const libraryAgent = `MinIO ${libraryComments} minio-js/${Package.version}`\n    // User agent block ends.\n\n    this.transport = transport\n    this.transportAgent = transportAgent\n    this.host = host\n    this.port = port\n    this.protocol = protocol\n    this.userAgent = `${libraryAgent}`\n\n    // Default path style is true\n    if (params.pathStyle === undefined) {\n      this.pathStyle = true\n    } else {\n      this.pathStyle = params.pathStyle\n    }\n\n    this.accessKey = params.accessKey ?? ''\n    this.secretKey = params.secretKey ?? ''\n    this.sessionToken = params.sessionToken\n    this.anonymous = !this.accessKey || !this.secretKey\n\n    if (params.credentialsProvider) {\n      this.credentialsProvider = params.credentialsProvider\n    }\n\n    this.regionMap = {}\n    if (params.region) {\n      this.region = params.region\n    }\n\n    if (params.partSize) {\n      this.partSize = params.partSize\n      this.overRidePartSize = true\n    }\n    if (this.partSize < 5 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be greater than 5MB`)\n    }\n    if (this.partSize > 5 * 1024 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be less than 5GB`)\n    }\n\n    // SHA256 is enabled only for authenticated http requests. If the request is authenticated\n    // and the connection is https we use x-amz-content-sha256=UNSIGNED-PAYLOAD\n    // header for signature calculation.\n    this.enableSHA256 = !this.anonymous && !params.useSSL\n\n    this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined\n    this.reqOptions = {}\n    this.clientExtensions = new Extensions(this)\n  }\n\n  /**\n   * Minio extensions that aren't necessary present for Amazon S3 compatible storage servers\n   */\n  get extensions() {\n    return this.clientExtensions\n  }\n\n  /**\n   * @param endPoint - valid S3 acceleration end point\n   */\n  setS3TransferAccelerate(endPoint: string) {\n    this.s3AccelerateEndpoint = endPoint\n  }\n\n  /**\n   * Sets the supported request options.\n   */\n  public setRequestOptions(options: Pick<https.RequestOptions, (typeof requestOptionProperties)[number]>) {\n    if (!isObject(options)) {\n      throw new TypeError('request options should be of type \"object\"')\n    }\n    this.reqOptions = _.pick(options, requestOptionProperties)\n  }\n\n  /**\n   *  This is s3 Specific and does not hold validity in any other Object storage.\n   */\n  private getAccelerateEndPointIfSet(bucketName?: string, objectName?: string) {\n    if (!isEmpty(this.s3AccelerateEndpoint) && !isEmpty(bucketName) && !isEmpty(objectName)) {\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      // Disable transfer acceleration for non-compliant bucket names.\n      if (bucketName.includes('.')) {\n        throw new Error(`Transfer Acceleration is not supported for non compliant bucket:${bucketName}`)\n      }\n      // If transfer acceleration is requested set new host.\n      // For more details about enabling transfer acceleration read here.\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      return this.s3AccelerateEndpoint\n    }\n    return false\n  }\n\n  /**\n   * returns options object that can be used with http.request()\n   * Takes care of constructing virtual-host-style or path-style hostname\n   */\n  protected getRequestOptions(\n    opts: RequestOption & { region: string },\n  ): IRequest & { host: string; headers: Record<string, string> } {\n    const method = opts.method\n    const region = opts.region\n    const bucketName = opts.bucketName\n    let objectName = opts.objectName\n    const headers = opts.headers\n    const query = opts.query\n\n    let reqOptions = {\n      method,\n      headers: {} as RequestHeaders,\n      protocol: this.protocol,\n      // If custom transportAgent was supplied earlier, we'll inject it here\n      agent: this.transportAgent,\n    }\n\n    // Verify if virtual host supported.\n    let virtualHostStyle\n    if (bucketName) {\n      virtualHostStyle = isVirtualHostStyle(this.host, this.protocol, bucketName, this.pathStyle)\n    }\n\n    let path = '/'\n    let host = this.host\n\n    let port: undefined | number\n    if (this.port) {\n      port = this.port\n    }\n\n    if (objectName) {\n      objectName = uriResourceEscape(objectName)\n    }\n\n    // For Amazon S3 endpoint, get endpoint based on region.\n    if (isAmazonEndpoint(host)) {\n      const accelerateEndPoint = this.getAccelerateEndPointIfSet(bucketName, objectName)\n      if (accelerateEndPoint) {\n        host = `${accelerateEndPoint}`\n      } else {\n        host = getS3Endpoint(region)\n      }\n    }\n\n    if (virtualHostStyle && !opts.pathStyle) {\n      // For all hosts which support virtual host style, `bucketName`\n      // is part of the hostname in the following format:\n      //\n      //  var host = 'bucketName.example.com'\n      //\n      if (bucketName) {\n        host = `${bucketName}.${host}`\n      }\n      if (objectName) {\n        path = `/${objectName}`\n      }\n    } else {\n      // For all S3 compatible storage services we will fallback to\n      // path style requests, where `bucketName` is part of the URI\n      // path.\n      if (bucketName) {\n        path = `/${bucketName}`\n      }\n      if (objectName) {\n        path = `/${bucketName}/${objectName}`\n      }\n    }\n\n    if (query) {\n      path += `?${query}`\n    }\n    reqOptions.headers.host = host\n    if ((reqOptions.protocol === 'http:' && port !== 80) || (reqOptions.protocol === 'https:' && port !== 443)) {\n      reqOptions.headers.host = `${host}:${port}`\n    }\n    reqOptions.headers['user-agent'] = this.userAgent\n    if (headers) {\n      // have all header keys in lower case - to make signing easy\n      for (const [k, v] of Object.entries(headers)) {\n        reqOptions.headers[k.toLowerCase()] = v\n      }\n    }\n\n    // Use any request option specified in minioClient.setRequestOptions()\n    reqOptions = Object.assign({}, this.reqOptions, reqOptions)\n\n    return {\n      ...reqOptions,\n      headers: _.mapValues(_.pickBy(reqOptions.headers, isDefined), (v) => v.toString()),\n      host,\n      port,\n      path,\n    } satisfies https.RequestOptions\n  }\n\n  public async setCredentialsProvider(credentialsProvider: CredentialProvider) {\n    if (!(credentialsProvider instanceof CredentialProvider)) {\n      throw new Error('Unable to get credentials. Expected instance of CredentialProvider')\n    }\n    this.credentialsProvider = credentialsProvider\n    await this.checkAndRefreshCreds()\n  }\n\n  private async checkAndRefreshCreds() {\n    if (this.credentialsProvider) {\n      try {\n        const credentialsConf = await this.credentialsProvider.getCredentials()\n        this.accessKey = credentialsConf.getAccessKey()\n        this.secretKey = credentialsConf.getSecretKey()\n        this.sessionToken = credentialsConf.getSessionToken()\n      } catch (e) {\n        throw new Error(`Unable to get credentials: ${e}`, { cause: e })\n      }\n    }\n  }\n\n  private logStream?: stream.Writable\n\n  /**\n   * log the request, response, error\n   */\n  private logHTTP(reqOptions: IRequest, response: http.IncomingMessage | null, err?: unknown) {\n    // if no logStream available return.\n    if (!this.logStream) {\n      return\n    }\n    if (!isObject(reqOptions)) {\n      throw new TypeError('reqOptions should be of type \"object\"')\n    }\n    if (response && !isReadableStream(response)) {\n      throw new TypeError('response should be of type \"Stream\"')\n    }\n    if (err && !(err instanceof Error)) {\n      throw new TypeError('err should be of type \"Error\"')\n    }\n    const logStream = this.logStream\n    const logHeaders = (headers: RequestHeaders) => {\n      Object.entries(headers).forEach(([k, v]) => {\n        if (k == 'authorization') {\n          if (isString(v)) {\n            const redactor = new RegExp('Signature=([0-9a-f]+)')\n            v = v.replace(redactor, 'Signature=**REDACTED**')\n          }\n        }\n        logStream.write(`${k}: ${v}\\n`)\n      })\n      logStream.write('\\n')\n    }\n    logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\\n`)\n    logHeaders(reqOptions.headers)\n    if (response) {\n      this.logStream.write(`RESPONSE: ${response.statusCode}\\n`)\n      logHeaders(response.headers as RequestHeaders)\n    }\n    if (err) {\n      logStream.write('ERROR BODY:\\n')\n      const errJSON = JSON.stringify(err, null, '\\t')\n      logStream.write(`${errJSON}\\n`)\n    }\n  }\n\n  /**\n   * Enable tracing\n   */\n  public traceOn(stream?: stream.Writable) {\n    if (!stream) {\n      stream = process.stdout\n    }\n    this.logStream = stream\n  }\n\n  /**\n   * Disable tracing\n   */\n  public traceOff() {\n    this.logStream = undefined\n  }\n\n  /**\n   * makeRequest is the primitive used by the apis for making S3 requests.\n   * payload can be empty string in case of no payload.\n   * statusCode is the expected statusCode. If response.statusCode does not match\n   * we parse the XML error and call the callback with the error message.\n   *\n   * A valid region is passed by the calls - listBuckets, makeBucket and getBucketRegion.\n   *\n   * @internal\n   */\n  async makeRequestAsync(\n    options: RequestOption,\n    payload: Binary = '',\n    expectedCodes: number[] = [200],\n    region = '',\n  ): Promise<http.IncomingMessage> {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!isString(payload) && !isObject(payload)) {\n      // Buffer is of type 'object'\n      throw new TypeError('payload should be of type \"string\" or \"Buffer\"')\n    }\n    expectedCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!options.headers) {\n      options.headers = {}\n    }\n    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') {\n      options.headers['content-length'] = payload.length.toString()\n    }\n    const sha256sum = this.enableSHA256 ? toSha256(payload) : ''\n    return this.makeRequestStreamAsync(options, payload, sha256sum, expectedCodes, region)\n  }\n\n  /**\n   * new request with promise\n   *\n   * No need to drain response, response body is not valid\n   */\n  async makeRequestAsyncOmit(\n    options: RequestOption,\n    payload: Binary = '',\n    statusCodes: number[] = [200],\n    region = '',\n  ): Promise<Omit<http.IncomingMessage, 'on'>> {\n    const res = await this.makeRequestAsync(options, payload, statusCodes, region)\n    await drainResponse(res)\n    return res\n  }\n\n  /**\n   * makeRequestStream will be used directly instead of makeRequest in case the payload\n   * is available as a stream. for ex. putObject\n   *\n   * @internal\n   */\n  async makeRequestStreamAsync(\n    options: RequestOption,\n    body: stream.Readable | Binary,\n    sha256sum: string,\n    statusCodes: number[],\n    region: string,\n  ): Promise<http.IncomingMessage> {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!(Buffer.isBuffer(body) || typeof body === 'string' || isReadableStream(body))) {\n      throw new errors.InvalidArgumentError(\n        `stream should be a Buffer, string or readable Stream, got ${typeof body} instead`,\n      )\n    }\n    if (!isString(sha256sum)) {\n      throw new TypeError('sha256sum should be of type \"string\"')\n    }\n    statusCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    // sha256sum will be empty for anonymous or https requests\n    if (!this.enableSHA256 && sha256sum.length !== 0) {\n      throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`)\n    }\n    // sha256sum should be valid for non-anonymous http requests.\n    if (this.enableSHA256 && sha256sum.length !== 64) {\n      throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`)\n    }\n\n    await this.checkAndRefreshCreds()\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    region = region || (await this.getBucketRegionAsync(options.bucketName!))\n\n    const reqOptions = this.getRequestOptions({ ...options, region })\n    if (!this.anonymous) {\n      // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation.\n      if (!this.enableSHA256) {\n        sha256sum = 'UNSIGNED-PAYLOAD'\n      }\n      const date = new Date()\n      reqOptions.headers['x-amz-date'] = makeDateLong(date)\n      reqOptions.headers['x-amz-content-sha256'] = sha256sum\n      if (this.sessionToken) {\n        reqOptions.headers['x-amz-security-token'] = this.sessionToken\n      }\n      reqOptions.headers.authorization = signV4(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum)\n    }\n\n    const response = await request(this.transport, reqOptions, body)\n    if (!response.statusCode) {\n      throw new Error(\"BUG: response doesn't have a statusCode\")\n    }\n\n    if (!statusCodes.includes(response.statusCode)) {\n      // For an incorrect region, S3 server always sends back 400.\n      // But we will do cache invalidation for all errors so that,\n      // in future, if AWS S3 decides to send a different status code or\n      // XML error code we will still work fine.\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      delete this.regionMap[options.bucketName!]\n\n      const err = await xmlParsers.parseResponseError(response)\n      this.logHTTP(reqOptions, response, err)\n      throw err\n    }\n\n    this.logHTTP(reqOptions, response)\n\n    return response\n  }\n\n  /**\n   * gets the region of the bucket\n   *\n   * @param bucketName\n   *\n   * @internal\n   */\n  protected async getBucketRegionAsync(bucketName: string): Promise<string> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`)\n    }\n\n    // Region is set with constructor, return the region right here.\n    if (this.region) {\n      return this.region\n    }\n\n    const cached = this.regionMap[bucketName]\n    if (cached) {\n      return cached\n    }\n\n    const extractRegionAsync = async (response: http.IncomingMessage) => {\n      const body = await readAsString(response)\n      const region = xmlParsers.parseBucketRegion(body) || DEFAULT_REGION\n      this.regionMap[bucketName] = region\n      return region\n    }\n\n    const method = 'GET'\n    const query = 'location'\n    // `getBucketLocation` behaves differently in following ways for\n    // different environments.\n    //\n    // - For nodejs env we default to path style requests.\n    // - For browser env path style requests on buckets yields CORS\n    //   error. To circumvent this problem we make a virtual host\n    //   style request signed with 'us-east-1'. This request fails\n    //   with an error 'AuthorizationHeaderMalformed', additionally\n    //   the error XML also provides Region of the bucket. To validate\n    //   this region is proper we retry the same request with the newly\n    //   obtained region.\n    const pathStyle = this.pathStyle && !isBrowser\n    let region: string\n    try {\n      const res = await this.makeRequestAsync({ method, bucketName, query, pathStyle }, '', [200], DEFAULT_REGION)\n      return extractRegionAsync(res)\n    } catch (e) {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      if (!(e.name === 'AuthorizationHeaderMalformed')) {\n        throw e\n      }\n      // @ts-expect-error we set extra properties on error object\n      region = e.Region as string\n      if (!region) {\n        throw e\n      }\n    }\n\n    const res = await this.makeRequestAsync({ method, bucketName, query, pathStyle }, '', [200], region)\n    return await extractRegionAsync(res)\n  }\n\n  /**\n   * makeRequest is the primitive used by the apis for making S3 requests.\n   * payload can be empty string in case of no payload.\n   * statusCode is the expected statusCode. If response.statusCode does not match\n   * we parse the XML error and call the callback with the error message.\n   * A valid region is passed by the calls - listBuckets, makeBucket and\n   * getBucketRegion.\n   *\n   * @deprecated use `makeRequestAsync` instead\n   */\n  makeRequest(\n    options: RequestOption,\n    payload: Binary = '',\n    expectedCodes: number[] = [200],\n    region = '',\n    returnResponse: boolean,\n    cb: (cb: unknown, result: http.IncomingMessage) => void,\n  ) {\n    let prom: Promise<http.IncomingMessage>\n    if (returnResponse) {\n      prom = this.makeRequestAsync(options, payload, expectedCodes, region)\n    } else {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-expect-error compatible for old behaviour\n      prom = this.makeRequestAsyncOmit(options, payload, expectedCodes, region)\n    }\n\n    prom.then(\n      (result) => cb(null, result),\n      (err) => {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        cb(err)\n      },\n    )\n  }\n\n  /**\n   * makeRequestStream will be used directly instead of makeRequest in case the payload\n   * is available as a stream. for ex. putObject\n   *\n   * @deprecated use `makeRequestStreamAsync` instead\n   */\n  makeRequestStream(\n    options: RequestOption,\n    stream: stream.Readable | Buffer,\n    sha256sum: string,\n    statusCodes: number[],\n    region: string,\n    returnResponse: boolean,\n    cb: (cb: unknown, result: http.IncomingMessage) => void,\n  ) {\n    const executor = async () => {\n      const res = await this.makeRequestStreamAsync(options, stream, sha256sum, statusCodes, region)\n      if (!returnResponse) {\n        await drainResponse(res)\n      }\n\n      return res\n    }\n\n    executor().then(\n      (result) => cb(null, result),\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      (err) => cb(err),\n    )\n  }\n\n  /**\n   * @deprecated use `getBucketRegionAsync` instead\n   */\n  getBucketRegion(bucketName: string, cb: (err: unknown, region: string) => void) {\n    return this.getBucketRegionAsync(bucketName).then(\n      (result) => cb(null, result),\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      (err) => cb(err),\n    )\n  }\n\n  async removeBucket(bucketName: string): Promise<void>\n\n  /**\n   * @deprecated use promise style API\n   */\n  removeBucket(bucketName: string, callback: NoResultCallback): void\n\n  async removeBucket(bucketName: string): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    await this.makeRequestAsyncOmit({ method, bucketName }, '', [204])\n    delete this.regionMap[bucketName]\n  }\n\n  /**\n   * Stat information of the object.\n   */\n  async statObject(bucketName: string, objectName: string, statOpts: StatObjectOpts = {}): Promise<BucketItemStat> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isObject(statOpts)) {\n      throw new errors.InvalidArgumentError('statOpts should be of type \"object\"')\n    }\n\n    const query = qs.stringify(statOpts)\n    const method = 'HEAD'\n    const res = await this.makeRequestAsyncOmit({ method, bucketName, objectName, query })\n\n    return {\n      size: parseInt(res.headers['content-length'] as string),\n      metaData: extractMetadata(res.headers as ResponseHeader),\n      lastModified: new Date(res.headers['last-modified'] as string),\n      versionId: getVersionId(res.headers as ResponseHeader),\n      etag: sanitizeETag(res.headers.etag),\n    }\n  }\n\n  /**\n   * Remove the specified object.\n   * @deprecated use new promise style API\n   */\n  removeObject(bucketName: string, objectName: string, removeOpts: RemoveOptions, callback: NoResultCallback): void\n  /**\n   * @deprecated use new promise style API\n   */\n  // @ts-ignore\n  removeObject(bucketName: string, objectName: string, callback: NoResultCallback): void\n  async removeObject(bucketName: string, objectName: string, removeOpts?: RemoveOptions): Promise<void>\n\n  async removeObject(bucketName: string, objectName: string, removeOpts: RemoveOptions = {}): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n\n    const method = 'DELETE'\n\n    const headers: RequestHeaders = {}\n    if (removeOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n    if (removeOpts.forceDelete) {\n      headers['x-minio-force-delete'] = true\n    }\n\n    const queryParams: Record<string, string> = {}\n    if (removeOpts.versionId) {\n      queryParams.versionId = `${removeOpts.versionId}`\n    }\n    const query = qs.stringify(queryParams)\n\n    await this.makeRequestAsyncOmit({ method, bucketName, objectName, headers, query }, '', [200, 204])\n  }\n\n  // Calls implemented below are related to multipart.\n\n  /**\n   * Initiate a new multipart upload.\n   * @internal\n   */\n  async initiateNewMultipartUpload(bucketName: string, objectName: string, headers: RequestHeaders): Promise<string> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(headers)) {\n      throw new errors.InvalidObjectNameError('contentType should be of type \"object\"')\n    }\n    const method = 'POST'\n    const query = 'uploads'\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query, headers })\n    const body = await readAsBuffer(res)\n    return parseInitiateMultipart(body.toString())\n  }\n\n  /**\n   * Internal Method to abort a multipart upload request in case of any errors.\n   *\n   * @param bucketName - Bucket Name\n   * @param objectName - Object Name\n   * @param uploadId - id of a multipart upload to cancel during compose object sequence.\n   */\n  async abortMultipartUpload(bucketName: string, objectName: string, uploadId: string): Promise<void> {\n    const method = 'DELETE'\n    const query = `uploadId=${uploadId}`\n\n    const requestOptions = { method, bucketName, objectName: objectName, query }\n    await this.makeRequestAsyncOmit(requestOptions, '', [204])\n  }\n\n  /**\n   * Get part-info of all parts of an incomplete upload specified by uploadId.\n   */\n  protected async listParts(bucketName: string, objectName: string, uploadId: string): Promise<UploadedPart[]> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    const parts: UploadedPart[] = []\n    let marker = 0\n    let result\n    do {\n      result = await this.listPartsQuery(bucketName, objectName, uploadId, marker)\n      marker = result.marker\n      parts.push(...result.parts)\n    } while (result.isTruncated)\n\n    return parts\n  }\n\n  /**\n   * Called by listParts to fetch a batch of part-info\n   */\n  private async listPartsQuery(bucketName: string, objectName: string, uploadId: string, marker: number) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isNumber(marker)) {\n      throw new TypeError('marker should be of type \"number\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    let query = `uploadId=${uriEscape(uploadId)}`\n    if (marker) {\n      query += `&part-number-marker=${marker}`\n    }\n\n    const method = 'GET'\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query })\n    return xmlParsers.parseListParts(await readAsString(res))\n  }\n\n  async listBuckets(): Promise<BucketItemFromList[]> {\n    const method = 'GET'\n    const httpRes = await this.makeRequestAsync({ method }, '', [200], DEFAULT_REGION)\n    const xmlResult = await readAsString(httpRes)\n    return xmlParsers.parseListBucket(xmlResult)\n  }\n\n  async removeBucketReplication(bucketName: string): Promise<void>\n  removeBucketReplication(bucketName: string, callback: NoResultCallback): void\n  async removeBucketReplication(bucketName: string): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'replication'\n    await this.makeRequestAsyncOmit({ method, bucketName, query }, '', [200, 204], '')\n  }\n\n  setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts, callback: NoResultCallback): void\n  async setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts): Promise<void>\n  async setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(replicationConfig)) {\n      throw new errors.InvalidArgumentError('replicationConfig should be of type \"object\"')\n    } else {\n      if (_.isEmpty(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Role cannot be empty')\n      } else if (replicationConfig.role && !isString(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role)\n      }\n      if (_.isEmpty(replicationConfig.rules)) {\n        throw new errors.InvalidArgumentError('Minimum one replication rule must be specified')\n      }\n    }\n    const method = 'PUT'\n    const query = 'replication'\n    const headers: Record<string, string> = {}\n\n    const replicationParamsConfig = {\n      ReplicationConfiguration: {\n        Role: replicationConfig.role,\n        Rule: replicationConfig.rules,\n      },\n    }\n\n    const builder = new xml2js.Builder({ renderOpts: { pretty: false }, headless: true })\n    const payload = builder.buildObject(replicationParamsConfig)\n    headers['Content-MD5'] = toMd5(payload)\n    await this.makeRequestAsyncOmit({ method, bucketName, query, headers }, payload)\n  }\n\n  getBucketReplication(bucketName: string, callback: ResultCallback<ReplicationConfig>): void\n  async getBucketReplication(bucketName: string): Promise<ReplicationConfig>\n  async getBucketReplication(bucketName: string) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'replication'\n\n    const httpRes = await this.makeRequestAsync({ method, bucketName, query }, '', [200, 204])\n    const xmlResult = await readAsString(httpRes)\n    return xmlParsers.parseReplicationConfig(xmlResult)\n  }\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["http","_interopRequireWildcard","require","https","_lodash","_CredentialProvider","errors","_helper","_s3Endpoints","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","Package","version","requestOptionProperties","TypedClient","partSize","maximumPartSize","maxObjectSize","constructor","params","secure","undefined","Error","useSSL","port","isValidEndpoint","endPoint","InvalidEndpointError","isValidPort","InvalidArgumentError","isBoolean","region","isString","host","toLowerCase","protocol","transport","transportAgent","globalAgent","isObject","libraryComments","process","platform","arch","libraryAgent","userAgent","pathStyle","accessKey","secretKey","sessionToken","anonymous","credentialsProvider","regionMap","overRidePartSize","enableSHA256","s3AccelerateEndpoint","reqOptions","setS3TransferAccelerate","setRequestOptions","options","TypeError","_","pick","getAccelerateEndPointIfSet","bucketName","objectName","isEmpty","includes","getRequestOptions","opts","method","headers","query","agent","virtualHostStyle","isVirtualHostStyle","path","uriResourceEscape","isAmazonEndpoint","accelerateEndPoint","getS3Endpoint","k","v","entries","assign","mapValues","pickBy","isDefined","toString","setCredentialsProvider","CredentialProvider","checkAndRefreshCreds","credentialsConf","getCredentials","getAccessKey","getSecretKey","getSessionToken","e","cause","exports"],"sources":["client.ts"],"sourcesContent":["import * as http from 'node:http'\nimport * as https from 'node:https'\n\nimport _ from 'lodash'\n\nimport { CredentialProvider } from '../CredentialProvider.ts'\nimport * as errors from '../errors.ts'\nimport {\n  isAmazonEndpoint,\n  isBoolean,\n  isDefined,\n  isEmpty,\n  isObject,\n  isString,\n  isValidEndpoint,\n  isValidPort,\n  isVirtualHostStyle,\n  uriResourceEscape,\n} from './helper.ts'\nimport type { Region } from './s3-endpoints.ts'\nimport { getS3Endpoint } from './s3-endpoints.ts'\nimport type { IRequest, RequestHeaders, Transport } from './type.ts'\n\n// will be replaced by bundler.\nconst Package = { version: process.env.MINIO_JS_PACKAGE_VERSION || 'development' }\n\nconst requestOptionProperties = [\n  'agent',\n  'ca',\n  'cert',\n  'ciphers',\n  'clientCertEngine',\n  'crl',\n  'dhparam',\n  'ecdhCurve',\n  'family',\n  'honorCipherOrder',\n  'key',\n  'passphrase',\n  'pfx',\n  'rejectUnauthorized',\n  'secureOptions',\n  'secureProtocol',\n  'servername',\n  'sessionIdContext',\n] as const\n\nexport interface ClientOptions {\n  endPoint: string\n  accessKey: string\n  secretKey: string\n  useSSL?: boolean\n  port?: number\n  region?: Region\n  transport?: Transport\n  sessionToken?: string\n  partSize?: number\n  pathStyle?: boolean\n  credentialsProvider?: CredentialProvider\n  s3AccelerateEndpoint?: string\n  transportAgent?: http.Agent\n}\n\nexport type RequestOption = Partial<IRequest> & {\n  method: string\n  bucketName?: string\n  objectName?: string\n  region?: string\n  query?: string\n  pathStyle?: boolean\n}\n\nexport class TypedClient {\n  protected transport: Transport\n  protected host: string\n  protected port: number\n  protected protocol: string\n  protected accessKey: string\n  protected secretKey: string\n  protected sessionToken?: string\n  protected userAgent: string\n  protected anonymous: boolean\n  protected pathStyle: boolean\n  protected regionMap: Record<string, string>\n  public region?: string\n  protected credentialsProvider?: CredentialProvider\n  partSize: number = 64 * 1024 * 1024\n  protected overRidePartSize?: boolean\n\n  protected maximumPartSize = 5 * 1024 * 1024 * 1024\n  protected maxObjectSize = 5 * 1024 * 1024 * 1024 * 1024\n  public enableSHA256: boolean\n  protected s3AccelerateEndpoint?: string\n  protected reqOptions: Record<string, unknown>\n\n  protected transportAgent: http.Agent\n\n  constructor(params: ClientOptions) {\n    // @ts-expect-error deprecated property\n    if (params.secure !== undefined) {\n      throw new Error('\"secure\" option deprecated, \"useSSL\" should be used instead')\n    }\n    // Default values if not specified.\n    if (params.useSSL === undefined) {\n      params.useSSL = true\n    }\n    if (!params.port) {\n      params.port = 0\n    }\n    // Validate input params.\n    if (!isValidEndpoint(params.endPoint)) {\n      throw new errors.InvalidEndpointError(`Invalid endPoint : ${params.endPoint}`)\n    }\n    if (!isValidPort(params.port)) {\n      throw new errors.InvalidArgumentError(`Invalid port : ${params.port}`)\n    }\n    if (!isBoolean(params.useSSL)) {\n      throw new errors.InvalidArgumentError(\n        `Invalid useSSL flag type : ${params.useSSL}, expected to be of type \"boolean\"`,\n      )\n    }\n\n    // Validate region only if its set.\n    if (params.region) {\n      if (!isString(params.region)) {\n        throw new errors.InvalidArgumentError(`Invalid region : ${params.region}`)\n      }\n    }\n\n    const host = params.endPoint.toLowerCase()\n    let port = params.port\n    let protocol: string\n    let transport\n    let transportAgent: http.Agent\n    // Validate if configuration is not using SSL\n    // for constructing relevant endpoints.\n    if (params.useSSL) {\n      // Defaults to secure.\n      transport = https\n      protocol = 'https:'\n      port = port || 443\n      transportAgent = https.globalAgent\n    } else {\n      transport = http\n      protocol = 'http:'\n      port = port || 80\n      transportAgent = http.globalAgent\n    }\n\n    // if custom transport is set, use it.\n    if (params.transport) {\n      if (!isObject(params.transport)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transport type : ${params.transport}, expected to be type \"object\"`,\n        )\n      }\n      transport = params.transport\n    }\n\n    // if custom transport agent is set, use it.\n    if (params.transportAgent) {\n      if (!isObject(params.transportAgent)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transportAgent type: ${params.transportAgent}, expected to be type \"object\"`,\n        )\n      }\n\n      transportAgent = params.transportAgent\n    }\n\n    // User Agent should always following the below style.\n    // Please open an issue to discuss any new changes here.\n    //\n    //       MinIO (OS; ARCH) LIB/VER APP/VER\n    //\n    const libraryComments = `(${process.platform}; ${process.arch})`\n    const libraryAgent = `MinIO ${libraryComments} minio-js/${Package.version}`\n    // User agent block ends.\n\n    this.transport = transport\n    this.transportAgent = transportAgent\n    this.host = host\n    this.port = port\n    this.protocol = protocol\n    this.userAgent = `${libraryAgent}`\n\n    // Default path style is true\n    if (params.pathStyle === undefined) {\n      this.pathStyle = true\n    } else {\n      this.pathStyle = params.pathStyle\n    }\n\n    this.accessKey = params.accessKey ?? ''\n    this.secretKey = params.secretKey ?? ''\n    this.sessionToken = params.sessionToken\n    this.anonymous = !this.accessKey || !this.secretKey\n\n    if (params.credentialsProvider) {\n      this.credentialsProvider = params.credentialsProvider\n    }\n\n    this.regionMap = {}\n    if (params.region) {\n      this.region = params.region\n    }\n\n    if (params.partSize) {\n      this.partSize = params.partSize\n      this.overRidePartSize = true\n    }\n    if (this.partSize < 5 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be greater than 5MB`)\n    }\n    if (this.partSize > 5 * 1024 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be less than 5GB`)\n    }\n\n    // SHA256 is enabled only for authenticated http requests. If the request is authenticated\n    // and the connection is https we use x-amz-content-sha256=UNSIGNED-PAYLOAD\n    // header for signature calculation.\n    this.enableSHA256 = !this.anonymous && !params.useSSL\n\n    this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined\n    this.reqOptions = {}\n  }\n\n  /**\n   * @param endPoint - valid S3 acceleration end point\n   */\n  setS3TransferAccelerate(endPoint: string) {\n    this.s3AccelerateEndpoint = endPoint\n  }\n\n  /**\n   * Sets the supported request options.\n   */\n  public setRequestOptions(options: Pick<https.RequestOptions, (typeof requestOptionProperties)[number]>) {\n    if (!isObject(options)) {\n      throw new TypeError('request options should be of type \"object\"')\n    }\n    this.reqOptions = _.pick(options, requestOptionProperties)\n  }\n\n  /**\n   *  This is s3 Specific and does not hold validity in any other Object storage.\n   */\n  private getAccelerateEndPointIfSet(bucketName?: string, objectName?: string) {\n    if (!isEmpty(this.s3AccelerateEndpoint) && !isEmpty(bucketName) && !isEmpty(objectName)) {\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      // Disable transfer acceleration for non-compliant bucket names.\n      if (bucketName.includes('.')) {\n        throw new Error(`Transfer Acceleration is not supported for non compliant bucket:${bucketName}`)\n      }\n      // If transfer acceleration is requested set new host.\n      // For more details about enabling transfer acceleration read here.\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      return this.s3AccelerateEndpoint\n    }\n    return false\n  }\n\n  /**\n   * returns options object that can be used with http.request()\n   * Takes care of constructing virtual-host-style or path-style hostname\n   */\n  protected getRequestOptions(opts: RequestOption): IRequest & { host: string; headers: Record<string, string> } {\n    const method = opts.method\n    const region = opts.region\n    const bucketName = opts.bucketName\n    let objectName = opts.objectName\n    const headers = opts.headers\n    const query = opts.query\n\n    let reqOptions = {\n      method,\n      headers: {} as RequestHeaders,\n      protocol: this.protocol,\n      // If custom transportAgent was supplied earlier, we'll inject it here\n      agent: this.transportAgent,\n    }\n\n    // Verify if virtual host supported.\n    let virtualHostStyle\n    if (bucketName) {\n      virtualHostStyle = isVirtualHostStyle(this.host, this.protocol, bucketName, this.pathStyle)\n    }\n\n    let path = '/'\n    let host = this.host\n\n    let port: undefined | number\n    if (this.port) {\n      port = this.port\n    }\n\n    if (objectName) {\n      objectName = uriResourceEscape(objectName)\n    }\n\n    // For Amazon S3 endpoint, get endpoint based on region.\n    if (isAmazonEndpoint(host)) {\n      const accelerateEndPoint = this.getAccelerateEndPointIfSet(bucketName, objectName)\n      if (accelerateEndPoint) {\n        host = `${accelerateEndPoint}`\n      } else {\n        host = getS3Endpoint(region!)\n      }\n    }\n\n    if (virtualHostStyle && !opts.pathStyle) {\n      // For all hosts which support virtual host style, `bucketName`\n      // is part of the hostname in the following format:\n      //\n      //  var host = 'bucketName.example.com'\n      //\n      if (bucketName) {\n        host = `${bucketName}.${host}`\n      }\n      if (objectName) {\n        path = `/${objectName}`\n      }\n    } else {\n      // For all S3 compatible storage services we will fallback to\n      // path style requests, where `bucketName` is part of the URI\n      // path.\n      if (bucketName) {\n        path = `/${bucketName}`\n      }\n      if (objectName) {\n        path = `/${bucketName}/${objectName}`\n      }\n    }\n\n    if (query) {\n      path += `?${query}`\n    }\n    reqOptions.headers.host = host\n    if ((reqOptions.protocol === 'http:' && port !== 80) || (reqOptions.protocol === 'https:' && port !== 443)) {\n      reqOptions.headers.host = `${host}:${port}`\n    }\n    reqOptions.headers['user-agent'] = this.userAgent\n    if (headers) {\n      // have all header keys in lower case - to make signing easy\n      for (const [k, v] of Object.entries(headers)) {\n        reqOptions.headers[k.toLowerCase()] = v\n      }\n    }\n\n    // Use any request option specified in minioClient.setRequestOptions()\n    reqOptions = Object.assign({}, this.reqOptions, reqOptions)\n\n    return {\n      ...reqOptions,\n      headers: _.mapValues(_.pickBy(reqOptions.headers, isDefined), (v) => v.toString()),\n      host,\n      port,\n      path,\n    } satisfies https.RequestOptions\n  }\n\n  public async setCredentialsProvider(credentialsProvider: CredentialProvider) {\n    if (!(credentialsProvider instanceof CredentialProvider)) {\n      throw new Error('Unable to get credentials. Expected instance of CredentialProvider')\n    }\n    this.credentialsProvider = credentialsProvider\n    await this.checkAndRefreshCreds()\n  }\n\n  private async checkAndRefreshCreds() {\n    if (this.credentialsProvider) {\n      try {\n        const credentialsConf = await this.credentialsProvider.getCredentials()\n        this.accessKey = credentialsConf.getAccessKey()\n        this.secretKey = credentialsConf.getSecretKey()\n        this.sessionToken = credentialsConf.getSessionToken()\n      } catch (e) {\n        throw new Error(`Unable to get credentials: ${e}`, { cause: e })\n      }\n    }\n  }\n}\n"],"mappings":"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"} /***/ }), @@ -77650,135 +80418,6 @@ exports.CopyConditions = CopyConditions; /***/ }), -/***/ 1159: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -var stream = _interopRequireWildcard(__nccwpck_require__(2781), true); -var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); -var _helper = __nccwpck_require__(9921); -var _response = __nccwpck_require__(2644); -var _xmlParser = __nccwpck_require__(4040); -function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } -function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } -/* - * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -class Extensions { - constructor(client) { - this.client = client; - } - - /** - * List the objects in the bucket using S3 ListObjects V2 With Metadata - * - * @param bucketName - name of the bucket - * @param prefix - the prefix of the objects that should be listed (optional, default `''`) - * @param recursive - `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`) - * @param startAfter - Specifies the key to start after when listing objects in a bucket. (optional, default `''`) - * @returns stream emitting the objects in the bucket, the object is of the format: - */ - listObjectsV2WithMetadata(bucketName, prefix, recursive, startAfter) { - if (prefix === undefined) { - prefix = ''; - } - if (recursive === undefined) { - recursive = false; - } - if (startAfter === undefined) { - startAfter = ''; - } - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidPrefix)(prefix)) { - throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`); - } - if (!(0, _helper.isString)(prefix)) { - throw new TypeError('prefix should be of type "string"'); - } - if (!(0, _helper.isBoolean)(recursive)) { - throw new TypeError('recursive should be of type "boolean"'); - } - if (!(0, _helper.isString)(startAfter)) { - throw new TypeError('startAfter should be of type "string"'); - } - - // if recursive is false set delimiter to '/' - const delimiter = recursive ? '' : '/'; - return stream.Readable.from(this.listObjectsV2WithMetadataGen(bucketName, prefix, delimiter, startAfter), { - objectMode: true - }); - } - async *listObjectsV2WithMetadataGen(bucketName, prefix, delimiter, startAfter) { - let ended = false; - let continuationToken = ''; - do { - const result = await this.listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, startAfter); - ended = !result.isTruncated; - continuationToken = result.nextContinuationToken; - for (const obj of result.objects) { - yield obj; - } - } while (!ended); - } - async listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, startAfter) { - const queries = []; - - // Call for listing objects v2 API - queries.push(`list-type=2`); - queries.push(`encoding-type=url`); - // escape every value in query string, except maxKeys - queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`); - queries.push(`delimiter=${(0, _helper.uriEscape)(delimiter)}`); - queries.push(`metadata=true`); - if (continuationToken) { - continuationToken = (0, _helper.uriEscape)(continuationToken); - queries.push(`continuation-token=${continuationToken}`); - } - // Set start-after - if (startAfter) { - startAfter = (0, _helper.uriEscape)(startAfter); - queries.push(`start-after=${startAfter}`); - } - queries.push(`max-keys=1000`); - queries.sort(); - let query = ''; - if (queries.length > 0) { - query = `${queries.join('&')}`; - } - const method = 'GET'; - const res = await this.client.makeRequestAsync({ - method, - bucketName, - query - }); - return (0, _xmlParser.parseListObjectsV2WithMetadata)(await (0, _response.readAsString)(res)); - } -} -exports.Extensions = Extensions; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["stream","_interopRequireWildcard","require","errors","_helper","_response","_xmlParser","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","Extensions","constructor","client","listObjectsV2WithMetadata","bucketName","prefix","recursive","startAfter","undefined","isValidBucketName","InvalidBucketNameError","isValidPrefix","InvalidPrefixError","isString","TypeError","isBoolean","delimiter","Readable","from","listObjectsV2WithMetadataGen","objectMode","ended","continuationToken","result","listObjectsV2WithMetadataQuery","isTruncated","nextContinuationToken","objects","queries","push","uriEscape","sort","query","length","join","method","res","makeRequestAsync","parseListObjectsV2WithMetadata","readAsString","exports"],"sources":["extensions.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as stream from 'node:stream'\n\nimport * as errors from '../errors.ts'\nimport type { TypedClient } from './client.ts'\nimport { isBoolean, isString, isValidBucketName, isValidPrefix, uriEscape } from './helper.ts'\nimport { readAsString } from './response.ts'\nimport type { BucketItemWithMetadata, BucketStream } from './type.ts'\nimport { parseListObjectsV2WithMetadata } from './xml-parser.ts'\n\nexport class Extensions {\n  constructor(private readonly client: TypedClient) {}\n\n  /**\n   * List the objects in the bucket using S3 ListObjects V2 With Metadata\n   *\n   * @param bucketName - name of the bucket\n   * @param prefix - the prefix of the objects that should be listed (optional, default `''`)\n   * @param recursive - `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n   * @param startAfter - Specifies the key to start after when listing objects in a bucket. (optional, default `''`)\n   * @returns stream emitting the objects in the bucket, the object is of the format:\n   */\n  public listObjectsV2WithMetadata(\n    bucketName: string,\n    prefix?: string,\n    recursive?: boolean,\n    startAfter?: string,\n  ): BucketStream<BucketItemWithMetadata> {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n\n    // if recursive is false set delimiter to '/'\n    const delimiter = recursive ? '' : '/'\n    return stream.Readable.from(this.listObjectsV2WithMetadataGen(bucketName, prefix, delimiter, startAfter), {\n      objectMode: true,\n    })\n  }\n\n  private async *listObjectsV2WithMetadataGen(\n    bucketName: string,\n    prefix: string,\n    delimiter: string,\n    startAfter: string,\n  ): AsyncIterable<BucketItemWithMetadata> {\n    let ended = false\n    let continuationToken = ''\n    do {\n      const result = await this.listObjectsV2WithMetadataQuery(\n        bucketName,\n        prefix,\n        continuationToken,\n        delimiter,\n        startAfter,\n      )\n      ended = !result.isTruncated\n      continuationToken = result.nextContinuationToken\n      for (const obj of result.objects) {\n        yield obj\n      }\n    } while (!ended)\n  }\n\n  private async listObjectsV2WithMetadataQuery(\n    bucketName: string,\n    prefix: string,\n    continuationToken: string,\n    delimiter: string,\n    startAfter: string,\n  ) {\n    const queries = []\n\n    // Call for listing objects v2 API\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n    queries.push(`metadata=true`)\n\n    if (continuationToken) {\n      continuationToken = uriEscape(continuationToken)\n      queries.push(`continuation-token=${continuationToken}`)\n    }\n    // Set start-after\n    if (startAfter) {\n      startAfter = uriEscape(startAfter)\n      queries.push(`start-after=${startAfter}`)\n    }\n    queries.push(`max-keys=1000`)\n    queries.sort()\n    let query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    const method = 'GET'\n    const res = await this.client.makeRequestAsync({ method, bucketName, query })\n    return parseListObjectsV2WithMetadata(await readAsString(res))\n  }\n}\n"],"mappings":"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"} - -/***/ }), - /***/ 9921: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { @@ -77827,7 +80466,6 @@ exports.probeContentType = probeContentType; exports.readableStream = readableStream; exports.sanitizeETag = sanitizeETag; exports.sanitizeObjectKey = sanitizeObjectKey; -exports.sanitizeSize = sanitizeSize; exports.toArray = toArray; exports.toMd5 = toMd5; exports.toSha256 = toSha256; @@ -77838,7 +80476,7 @@ var stream = _interopRequireWildcard(__nccwpck_require__(2781), true); var _fastXmlParser = __nccwpck_require__(2603); var _ipaddr = __nccwpck_require__(7263); var _lodash = __nccwpck_require__(250); -var mime = _interopRequireWildcard(__nccwpck_require__(3583), true); +var mime = _interopRequireWildcard(__nccwpck_require__(7920), true); var _type = __nccwpck_require__(7293); function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } @@ -78249,9 +80887,6 @@ function sanitizeObjectKey(objectName) { const asStrName = (objectName ? objectName.toString() : '').replace(/\+/g, ' '); return decodeURIComponent(asStrName); } -function sanitizeSize(size) { - return size ? Number.parseInt(size) : undefined; -} const PART_CONSTRAINTS = { // absMinPartSize - absolute minimum part size (5 MiB) ABS_MIN_PART_SIZE: 1024 * 1024 * 5, @@ -78356,7 +80991,7 @@ function parseXml(xml) { } return result; } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["crypto","_interopRequireWildcard","require","stream","_fastXmlParser","_ipaddr","_lodash","mime","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","MetaDataHeaderPrefix","uriEscape","string","split","reduce","acc","elem","buf","Buffer","from","length","char","toString","toUpperCase","uriResourceEscape","replace","getScope","region","date","serviceName","makeDateShort","isAmazonEndpoint","endpoint","isVirtualHostStyle","protocol","bucket","pathStyle","includes","isValidIP","ip","ipaddr","isValid","isValidEndpoint","isValidDomain","host","isString","slice","alphaNumerics","probeContentType","path","contentType","lookup","isValidPort","port","isNumber","isValidBucketName","test","isValidObjectName","objectName","isValidPrefix","prefix","arg","isFunction","isObject","isReadableStream","_read","isBoolean","isEmpty","o","_","isEmptyObject","values","filter","x","undefined","isDefined","isValidDate","Date","isNaN","makeDateLong","s","toISOString","pipesetup","streams","src","dst","on","err","emit","pipe","readableStream","data","Readable","push","insertContentType","metaData","filePath","toLowerCase","prependXAMZMeta","mapKeys","value","isAmzHeader","isSupportedHeader","isStorageClassHeader","temp","startsWith","supported_headers","extractMetadata","headers","pickBy","lower","getVersionId","getSourceVersionId","sanitizeETag","etag","replaceChars","m","toMd5","payload","createHash","update","digest","toSha256","toArray","param","Array","isArray","sanitizeObjectKey","asStrName","decodeURIComponent","sanitizeSize","size","Number","parseInt","PART_CONSTRAINTS","ABS_MIN_PART_SIZE","MIN_PART_SIZE","MAX_PARTS_COUNT","MAX_PART_SIZE","MAX_SINGLE_PUT_OBJECT_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","exports","GENERIC_SSE_HEADER","ENCRYPTION_HEADERS","sseGenericHeader","sseKmsKeyID","getEncryptionHeaders","encConfig","encType","type","ENCRYPTION_TYPES","SSEC","KMS","SSEAlgorithm","KMSMasterKeyID","partsRequired","maxPartSize","requiredPartSize","Math","trunc","calculateEvenSplits","objInfo","reqParts","startIndexParts","endIndexParts","start","Start","divisorValue","reminderValue","nextStart","i","curPartSize","currentStart","currentEnd","startIndex","endIndex","fxp","XMLParser","parseXml","xml","result","parse","Error"],"sources":["helper.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as crypto from 'node:crypto'\nimport * as stream from 'node:stream'\n\nimport { XMLParser } from 'fast-xml-parser'\nimport ipaddr from 'ipaddr.js'\nimport _ from 'lodash'\nimport * as mime from 'mime-types'\n\nimport type { Binary, Encryption, ObjectMetaData, RequestHeaders, ResponseHeader } from './type.ts'\nimport { ENCRYPTION_TYPES } from './type.ts'\n\nconst MetaDataHeaderPrefix = 'x-amz-meta-'\n\n/**\n * All characters in string which are NOT unreserved should be percent encoded.\n * Unreserved characters are : ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\n * Reference https://tools.ietf.org/html/rfc3986#section-2.2\n */\nexport function uriEscape(string: string) {\n  return string.split('').reduce((acc: string, elem: string) => {\n    const buf = Buffer.from(elem)\n    if (buf.length === 1) {\n      // length 1 indicates that elem is not a unicode character.\n      // Check if it is an unreserved characer.\n      if (\n        ('A' <= elem && elem <= 'Z') ||\n        ('a' <= elem && elem <= 'z') ||\n        ('0' <= elem && elem <= '9') ||\n        elem === '_' ||\n        elem === '.' ||\n        elem === '~' ||\n        elem === '-'\n      ) {\n        // Unreserved characer should not be encoded.\n        acc = acc + elem\n        return acc\n      }\n    }\n    // elem needs encoding - i.e elem should be encoded if it's not unreserved\n    // character or if it's a unicode character.\n    for (const char of buf) {\n      acc = acc + '%' + char.toString(16).toUpperCase()\n    }\n    return acc\n  }, '')\n}\n\nexport function uriResourceEscape(string: string) {\n  return uriEscape(string).replace(/%2F/g, '/')\n}\n\nexport function getScope(region: string, date: Date, serviceName = 's3') {\n  return `${makeDateShort(date)}/${region}/${serviceName}/aws4_request`\n}\n\n/**\n * isAmazonEndpoint - true if endpoint is 's3.amazonaws.com' or 's3.cn-north-1.amazonaws.com.cn'\n */\nexport function isAmazonEndpoint(endpoint: string) {\n  return endpoint === 's3.amazonaws.com' || endpoint === 's3.cn-north-1.amazonaws.com.cn'\n}\n\n/**\n * isVirtualHostStyle - verify if bucket name is support with virtual\n * hosts. bucketNames with periods should be always treated as path\n * style if the protocol is 'https:', this is due to SSL wildcard\n * limitation. For all other buckets and Amazon S3 endpoint we will\n * default to virtual host style.\n */\nexport function isVirtualHostStyle(endpoint: string, protocol: string, bucket: string, pathStyle: boolean) {\n  if (protocol === 'https:' && bucket.includes('.')) {\n    return false\n  }\n  return isAmazonEndpoint(endpoint) || !pathStyle\n}\n\nexport function isValidIP(ip: string) {\n  return ipaddr.isValid(ip)\n}\n\n/**\n * @returns if endpoint is valid domain.\n */\nexport function isValidEndpoint(endpoint: string) {\n  return isValidDomain(endpoint) || isValidIP(endpoint)\n}\n\n/**\n * @returns if input host is a valid domain.\n */\nexport function isValidDomain(host: string) {\n  if (!isString(host)) {\n    return false\n  }\n  // See RFC 1035, RFC 3696.\n  if (host.length === 0 || host.length > 255) {\n    return false\n  }\n  // Host cannot start or end with a '-'\n  if (host[0] === '-' || host.slice(-1) === '-') {\n    return false\n  }\n  // Host cannot start or end with a '_'\n  if (host[0] === '_' || host.slice(-1) === '_') {\n    return false\n  }\n  // Host cannot start with a '.'\n  if (host[0] === '.') {\n    return false\n  }\n\n  const alphaNumerics = '`~!@#$%^&*()+={}[]|\\\\\"\\';:><?/'\n  // All non alphanumeric characters are invalid.\n  for (const char of alphaNumerics) {\n    if (host.includes(char)) {\n      return false\n    }\n  }\n  // No need to regexp match, since the list is non-exhaustive.\n  // We let it be valid and fail later.\n  return true\n}\n\n/**\n * Probes contentType using file extensions.\n *\n * @example\n * ```\n * // return 'image/png'\n * probeContentType('file.png')\n * ```\n */\nexport function probeContentType(path: string) {\n  let contentType = mime.lookup(path)\n  if (!contentType) {\n    contentType = 'application/octet-stream'\n  }\n  return contentType\n}\n\n/**\n * is input port valid.\n */\nexport function isValidPort(port: unknown): port is number {\n  // verify if port is a number.\n  if (!isNumber(port)) {\n    return false\n  }\n\n  // port `0` is valid and special case\n  return 0 <= port && port <= 65535\n}\n\nexport function isValidBucketName(bucket: unknown) {\n  if (!isString(bucket)) {\n    return false\n  }\n\n  // bucket length should be less than and no more than 63\n  // characters long.\n  if (bucket.length < 3 || bucket.length > 63) {\n    return false\n  }\n  // bucket with successive periods is invalid.\n  if (bucket.includes('..')) {\n    return false\n  }\n  // bucket cannot have ip address style.\n  if (/[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+/.test(bucket)) {\n    return false\n  }\n  // bucket should begin with alphabet/number and end with alphabet/number,\n  // with alphabet/number/.- in the middle.\n  if (/^[a-z0-9][a-z0-9.-]+[a-z0-9]$/.test(bucket)) {\n    return true\n  }\n  return false\n}\n\n/**\n * check if objectName is a valid object name\n */\nexport function isValidObjectName(objectName: unknown) {\n  if (!isValidPrefix(objectName)) {\n    return false\n  }\n\n  return objectName.length !== 0\n}\n\n/**\n * check if prefix is valid\n */\nexport function isValidPrefix(prefix: unknown): prefix is string {\n  if (!isString(prefix)) {\n    return false\n  }\n  if (prefix.length > 1024) {\n    return false\n  }\n  return true\n}\n\n/**\n * check if typeof arg number\n */\nexport function isNumber(arg: unknown): arg is number {\n  return typeof arg === 'number'\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyFunction = (...args: any[]) => any\n\n/**\n * check if typeof arg function\n */\nexport function isFunction(arg: unknown): arg is AnyFunction {\n  return typeof arg === 'function'\n}\n\n/**\n * check if typeof arg string\n */\nexport function isString(arg: unknown): arg is string {\n  return typeof arg === 'string'\n}\n\n/**\n * check if typeof arg object\n */\nexport function isObject(arg: unknown): arg is object {\n  return typeof arg === 'object' && arg !== null\n}\n\n/**\n * check if object is readable stream\n */\nexport function isReadableStream(arg: unknown): arg is stream.Readable {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  return isObject(arg) && isFunction((arg as stream.Readable)._read)\n}\n\n/**\n * check if arg is boolean\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean'\n}\n\nexport function isEmpty(o: unknown): o is null | undefined {\n  return _.isEmpty(o)\n}\n\nexport function isEmptyObject(o: Record<string, unknown>): boolean {\n  return Object.values(o).filter((x) => x !== undefined).length !== 0\n}\n\nexport function isDefined<T>(o: T): o is Exclude<T, null | undefined> {\n  return o !== null && o !== undefined\n}\n\n/**\n * check if arg is a valid date\n */\nexport function isValidDate(arg: unknown): arg is Date {\n  // @ts-expect-error checknew Date(Math.NaN)\n  return arg instanceof Date && !isNaN(arg)\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDDTHHmmss' + Z\n */\nexport function makeDateLong(date?: Date): string {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 13) + s.slice(14, 16) + s.slice(17, 19) + 'Z'\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDD'\n */\nexport function makeDateShort(date?: Date) {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 10)\n}\n\n/**\n * pipesetup sets up pipe() from left to right os streams array\n * pipesetup will also make sure that error emitted at any of the upstream Stream\n * will be emitted at the last stream. This makes error handling simple\n */\nexport function pipesetup(...streams: [stream.Readable, ...stream.Duplex[], stream.Writable]) {\n  // @ts-expect-error ts can't narrow this\n  return streams.reduce((src: stream.Readable, dst: stream.Writable) => {\n    src.on('error', (err) => dst.emit('error', err))\n    return src.pipe(dst)\n  })\n}\n\n/**\n * return a Readable stream that emits data\n */\nexport function readableStream(data: unknown): stream.Readable {\n  const s = new stream.Readable()\n  s._read = () => {}\n  s.push(data)\n  s.push(null)\n  return s\n}\n\n/**\n * Process metadata to insert appropriate value to `content-type` attribute\n */\nexport function insertContentType(metaData: ObjectMetaData, filePath: string): ObjectMetaData {\n  // check if content-type attribute present in metaData\n  for (const key in metaData) {\n    if (key.toLowerCase() === 'content-type') {\n      return metaData\n    }\n  }\n\n  // if `content-type` attribute is not present in metadata, then infer it from the extension in filePath\n  return {\n    ...metaData,\n    'content-type': probeContentType(filePath),\n  }\n}\n\n/**\n * Function prepends metadata with the appropriate prefix if it is not already on\n */\nexport function prependXAMZMeta(metaData?: ObjectMetaData): RequestHeaders {\n  if (!metaData) {\n    return {}\n  }\n\n  return _.mapKeys(metaData, (value, key) => {\n    if (isAmzHeader(key) || isSupportedHeader(key) || isStorageClassHeader(key)) {\n      return key\n    }\n\n    return MetaDataHeaderPrefix + key\n  })\n}\n\n/**\n * Checks if it is a valid header according to the AmazonS3 API\n */\nexport function isAmzHeader(key: string) {\n  const temp = key.toLowerCase()\n  return (\n    temp.startsWith(MetaDataHeaderPrefix) ||\n    temp === 'x-amz-acl' ||\n    temp.startsWith('x-amz-server-side-encryption-') ||\n    temp === 'x-amz-server-side-encryption'\n  )\n}\n\n/**\n * Checks if it is a supported Header\n */\nexport function isSupportedHeader(key: string) {\n  const supported_headers = [\n    'content-type',\n    'cache-control',\n    'content-encoding',\n    'content-disposition',\n    'content-language',\n    'x-amz-website-redirect-location',\n  ]\n  return supported_headers.includes(key.toLowerCase())\n}\n\n/**\n * Checks if it is a storage header\n */\nexport function isStorageClassHeader(key: string) {\n  return key.toLowerCase() === 'x-amz-storage-class'\n}\n\nexport function extractMetadata(headers: ResponseHeader) {\n  return _.mapKeys(\n    _.pickBy(headers, (value, key) => isSupportedHeader(key) || isStorageClassHeader(key) || isAmzHeader(key)),\n    (value, key) => {\n      const lower = key.toLowerCase()\n      if (lower.startsWith(MetaDataHeaderPrefix)) {\n        return lower.slice(MetaDataHeaderPrefix.length)\n      }\n\n      return key\n    },\n  )\n}\n\nexport function getVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-version-id'] || null\n}\n\nexport function getSourceVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-copy-source-version-id'] || null\n}\n\nexport function sanitizeETag(etag = ''): string {\n  const replaceChars: Record<string, string> = {\n    '\"': '',\n    '&quot;': '',\n    '&#34;': '',\n    '&QUOT;': '',\n    '&#x00022': '',\n  }\n  return etag.replace(/^(\"|&quot;|&#34;)|(\"|&quot;|&#34;)$/g, (m) => replaceChars[m] as string)\n}\n\nexport function toMd5(payload: Binary): string {\n  // use string from browser and buffer from nodejs\n  // browser support is tested only against minio server\n  return crypto.createHash('md5').update(Buffer.from(payload)).digest().toString('base64')\n}\n\nexport function toSha256(payload: Binary): string {\n  return crypto.createHash('sha256').update(payload).digest('hex')\n}\n\n/**\n * toArray returns a single element array with param being the element,\n * if param is just a string, and returns 'param' back if it is an array\n * So, it makes sure param is always an array\n */\nexport function toArray<T = unknown>(param: T | T[]): Array<T> {\n  if (!Array.isArray(param)) {\n    return [param] as T[]\n  }\n  return param\n}\n\nexport function sanitizeObjectKey(objectName: string): string {\n  // + symbol characters are not decoded as spaces in JS. so replace them first and decode to get the correct result.\n  const asStrName = (objectName ? objectName.toString() : '').replace(/\\+/g, ' ')\n  return decodeURIComponent(asStrName)\n}\n\nexport function sanitizeSize(size?: string): number | undefined {\n  return size ? Number.parseInt(size) : undefined\n}\n\nexport const PART_CONSTRAINTS = {\n  // absMinPartSize - absolute minimum part size (5 MiB)\n  ABS_MIN_PART_SIZE: 1024 * 1024 * 5,\n  // MIN_PART_SIZE - minimum part size 16MiB per object after which\n  MIN_PART_SIZE: 1024 * 1024 * 16,\n  // MAX_PARTS_COUNT - maximum number of parts for a single multipart session.\n  MAX_PARTS_COUNT: 10000,\n  // MAX_PART_SIZE - maximum part size 5GiB for a single multipart upload\n  // operation.\n  MAX_PART_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_SINGLE_PUT_OBJECT_SIZE - maximum size 5GiB of object per PUT\n  // operation.\n  MAX_SINGLE_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_MULTIPART_PUT_OBJECT_SIZE - maximum size 5TiB of object for\n  // Multipart operation.\n  MAX_MULTIPART_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 1024 * 5,\n}\n\nconst GENERIC_SSE_HEADER = 'X-Amz-Server-Side-Encryption'\n\nconst ENCRYPTION_HEADERS = {\n  // sseGenericHeader is the AWS SSE header used for SSE-S3 and SSE-KMS.\n  sseGenericHeader: GENERIC_SSE_HEADER,\n  // sseKmsKeyID is the AWS SSE-KMS key id.\n  sseKmsKeyID: GENERIC_SSE_HEADER + '-Aws-Kms-Key-Id',\n} as const\n\n/**\n * Return Encryption headers\n * @param encConfig\n * @returns an object with key value pairs that can be used in headers.\n */\nexport function getEncryptionHeaders(encConfig: Encryption): RequestHeaders {\n  const encType = encConfig.type\n\n  if (!isEmpty(encType)) {\n    if (encType === ENCRYPTION_TYPES.SSEC) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: 'AES256',\n      }\n    } else if (encType === ENCRYPTION_TYPES.KMS) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: encConfig.SSEAlgorithm,\n        [ENCRYPTION_HEADERS.sseKmsKeyID]: encConfig.KMSMasterKeyID,\n      }\n    }\n  }\n\n  return {}\n}\n\nexport function partsRequired(size: number): number {\n  const maxPartSize = PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE / (PART_CONSTRAINTS.MAX_PARTS_COUNT - 1)\n  let requiredPartSize = size / maxPartSize\n  if (size % maxPartSize > 0) {\n    requiredPartSize++\n  }\n  requiredPartSize = Math.trunc(requiredPartSize)\n  return requiredPartSize\n}\n\n/**\n * calculateEvenSplits - computes splits for a source and returns\n * start and end index slices. Splits happen evenly to be sure that no\n * part is less than 5MiB, as that could fail the multipart request if\n * it is not the last part.\n */\nexport function calculateEvenSplits<T extends { Start?: number }>(\n  size: number,\n  objInfo: T,\n): {\n  startIndex: number[]\n  objInfo: T\n  endIndex: number[]\n} | null {\n  if (size === 0) {\n    return null\n  }\n  const reqParts = partsRequired(size)\n  const startIndexParts: number[] = []\n  const endIndexParts: number[] = []\n\n  let start = objInfo.Start\n  if (isEmpty(start) || start === -1) {\n    start = 0\n  }\n  const divisorValue = Math.trunc(size / reqParts)\n\n  const reminderValue = size % reqParts\n\n  let nextStart = start\n\n  for (let i = 0; i < reqParts; i++) {\n    let curPartSize = divisorValue\n    if (i < reminderValue) {\n      curPartSize++\n    }\n\n    const currentStart = nextStart\n    const currentEnd = currentStart + curPartSize - 1\n    nextStart = currentEnd + 1\n\n    startIndexParts.push(currentStart)\n    endIndexParts.push(currentEnd)\n  }\n\n  return { startIndex: startIndexParts, endIndex: endIndexParts, objInfo: objInfo }\n}\n\nconst fxp = new XMLParser()\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function parseXml(xml: string): any {\n  const result = fxp.parse(xml)\n  if (result.Error) {\n    throw result.Error\n  }\n\n  return result\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["crypto","_interopRequireWildcard","require","stream","_fastXmlParser","_ipaddr","_lodash","mime","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","MetaDataHeaderPrefix","uriEscape","string","split","reduce","acc","elem","buf","Buffer","from","length","char","toString","toUpperCase","uriResourceEscape","replace","getScope","region","date","serviceName","makeDateShort","isAmazonEndpoint","endpoint","isVirtualHostStyle","protocol","bucket","pathStyle","includes","isValidIP","ip","ipaddr","isValid","isValidEndpoint","isValidDomain","host","isString","slice","alphaNumerics","probeContentType","path","contentType","lookup","isValidPort","port","isNumber","isValidBucketName","test","isValidObjectName","objectName","isValidPrefix","prefix","arg","isFunction","isObject","isReadableStream","_read","isBoolean","isEmpty","o","_","isEmptyObject","values","filter","x","undefined","isDefined","isValidDate","Date","isNaN","makeDateLong","s","toISOString","pipesetup","streams","src","dst","on","err","emit","pipe","readableStream","data","Readable","push","insertContentType","metaData","filePath","toLowerCase","prependXAMZMeta","mapKeys","value","isAmzHeader","isSupportedHeader","isStorageClassHeader","temp","startsWith","supported_headers","extractMetadata","headers","pickBy","lower","getVersionId","getSourceVersionId","sanitizeETag","etag","replaceChars","m","toMd5","payload","createHash","update","digest","toSha256","toArray","param","Array","isArray","sanitizeObjectKey","asStrName","decodeURIComponent","PART_CONSTRAINTS","ABS_MIN_PART_SIZE","MIN_PART_SIZE","MAX_PARTS_COUNT","MAX_PART_SIZE","MAX_SINGLE_PUT_OBJECT_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","exports","GENERIC_SSE_HEADER","ENCRYPTION_HEADERS","sseGenericHeader","sseKmsKeyID","getEncryptionHeaders","encConfig","encType","type","ENCRYPTION_TYPES","SSEC","KMS","SSEAlgorithm","KMSMasterKeyID","partsRequired","size","maxPartSize","requiredPartSize","Math","trunc","calculateEvenSplits","objInfo","reqParts","startIndexParts","endIndexParts","start","Start","divisorValue","reminderValue","nextStart","i","curPartSize","currentStart","currentEnd","startIndex","endIndex","fxp","XMLParser","parseXml","xml","result","parse","Error"],"sources":["helper.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as crypto from 'node:crypto'\nimport * as stream from 'node:stream'\n\nimport { XMLParser } from 'fast-xml-parser'\nimport ipaddr from 'ipaddr.js'\nimport _ from 'lodash'\nimport * as mime from 'mime-types'\n\nimport type { Binary, Encryption, ObjectMetaData, RequestHeaders, ResponseHeader } from './type.ts'\nimport { ENCRYPTION_TYPES } from './type.ts'\n\nconst MetaDataHeaderPrefix = 'x-amz-meta-'\n\n/**\n * All characters in string which are NOT unreserved should be percent encoded.\n * Unreserved characters are : ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\n * Reference https://tools.ietf.org/html/rfc3986#section-2.2\n */\nexport function uriEscape(string: string) {\n  return string.split('').reduce((acc: string, elem: string) => {\n    const buf = Buffer.from(elem)\n    if (buf.length === 1) {\n      // length 1 indicates that elem is not a unicode character.\n      // Check if it is an unreserved characer.\n      if (\n        ('A' <= elem && elem <= 'Z') ||\n        ('a' <= elem && elem <= 'z') ||\n        ('0' <= elem && elem <= '9') ||\n        elem === '_' ||\n        elem === '.' ||\n        elem === '~' ||\n        elem === '-'\n      ) {\n        // Unreserved characer should not be encoded.\n        acc = acc + elem\n        return acc\n      }\n    }\n    // elem needs encoding - i.e elem should be encoded if it's not unreserved\n    // character or if it's a unicode character.\n    for (const char of buf) {\n      acc = acc + '%' + char.toString(16).toUpperCase()\n    }\n    return acc\n  }, '')\n}\n\nexport function uriResourceEscape(string: string) {\n  return uriEscape(string).replace(/%2F/g, '/')\n}\n\nexport function getScope(region: string, date: Date, serviceName = 's3') {\n  return `${makeDateShort(date)}/${region}/${serviceName}/aws4_request`\n}\n\n/**\n * isAmazonEndpoint - true if endpoint is 's3.amazonaws.com' or 's3.cn-north-1.amazonaws.com.cn'\n */\nexport function isAmazonEndpoint(endpoint: string) {\n  return endpoint === 's3.amazonaws.com' || endpoint === 's3.cn-north-1.amazonaws.com.cn'\n}\n\n/**\n * isVirtualHostStyle - verify if bucket name is support with virtual\n * hosts. bucketNames with periods should be always treated as path\n * style if the protocol is 'https:', this is due to SSL wildcard\n * limitation. For all other buckets and Amazon S3 endpoint we will\n * default to virtual host style.\n */\nexport function isVirtualHostStyle(endpoint: string, protocol: string, bucket: string, pathStyle: boolean) {\n  if (protocol === 'https:' && bucket.includes('.')) {\n    return false\n  }\n  return isAmazonEndpoint(endpoint) || !pathStyle\n}\n\nexport function isValidIP(ip: string) {\n  return ipaddr.isValid(ip)\n}\n\n/**\n * @returns if endpoint is valid domain.\n */\nexport function isValidEndpoint(endpoint: string) {\n  return isValidDomain(endpoint) || isValidIP(endpoint)\n}\n\n/**\n * @returns if input host is a valid domain.\n */\nexport function isValidDomain(host: string) {\n  if (!isString(host)) {\n    return false\n  }\n  // See RFC 1035, RFC 3696.\n  if (host.length === 0 || host.length > 255) {\n    return false\n  }\n  // Host cannot start or end with a '-'\n  if (host[0] === '-' || host.slice(-1) === '-') {\n    return false\n  }\n  // Host cannot start or end with a '_'\n  if (host[0] === '_' || host.slice(-1) === '_') {\n    return false\n  }\n  // Host cannot start with a '.'\n  if (host[0] === '.') {\n    return false\n  }\n\n  const alphaNumerics = '`~!@#$%^&*()+={}[]|\\\\\"\\';:><?/'\n  // All non alphanumeric characters are invalid.\n  for (const char of alphaNumerics) {\n    if (host.includes(char)) {\n      return false\n    }\n  }\n  // No need to regexp match, since the list is non-exhaustive.\n  // We let it be valid and fail later.\n  return true\n}\n\n/**\n * Probes contentType using file extensions.\n *\n * @example\n * ```\n * // return 'image/png'\n * probeContentType('file.png')\n * ```\n */\nexport function probeContentType(path: string) {\n  let contentType = mime.lookup(path)\n  if (!contentType) {\n    contentType = 'application/octet-stream'\n  }\n  return contentType\n}\n\n/**\n * is input port valid.\n */\nexport function isValidPort(port: unknown): port is number {\n  // verify if port is a number.\n  if (!isNumber(port)) {\n    return false\n  }\n\n  // port `0` is valid and special case\n  return 0 <= port && port <= 65535\n}\n\nexport function isValidBucketName(bucket: unknown) {\n  if (!isString(bucket)) {\n    return false\n  }\n\n  // bucket length should be less than and no more than 63\n  // characters long.\n  if (bucket.length < 3 || bucket.length > 63) {\n    return false\n  }\n  // bucket with successive periods is invalid.\n  if (bucket.includes('..')) {\n    return false\n  }\n  // bucket cannot have ip address style.\n  if (/[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+/.test(bucket)) {\n    return false\n  }\n  // bucket should begin with alphabet/number and end with alphabet/number,\n  // with alphabet/number/.- in the middle.\n  if (/^[a-z0-9][a-z0-9.-]+[a-z0-9]$/.test(bucket)) {\n    return true\n  }\n  return false\n}\n\n/**\n * check if objectName is a valid object name\n */\nexport function isValidObjectName(objectName: unknown) {\n  if (!isValidPrefix(objectName)) {\n    return false\n  }\n\n  return objectName.length !== 0\n}\n\n/**\n * check if prefix is valid\n */\nexport function isValidPrefix(prefix: unknown): prefix is string {\n  if (!isString(prefix)) {\n    return false\n  }\n  if (prefix.length > 1024) {\n    return false\n  }\n  return true\n}\n\n/**\n * check if typeof arg number\n */\nexport function isNumber(arg: unknown): arg is number {\n  return typeof arg === 'number'\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyFunction = (...args: any[]) => any\n\n/**\n * check if typeof arg function\n */\nexport function isFunction(arg: unknown): arg is AnyFunction {\n  return typeof arg === 'function'\n}\n\n/**\n * check if typeof arg string\n */\nexport function isString(arg: unknown): arg is string {\n  return typeof arg === 'string'\n}\n\n/**\n * check if typeof arg object\n */\nexport function isObject(arg: unknown): arg is object {\n  return typeof arg === 'object' && arg !== null\n}\n\n/**\n * check if object is readable stream\n */\nexport function isReadableStream(arg: unknown): arg is stream.Readable {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  return isObject(arg) && isFunction((arg as stream.Readable)._read)\n}\n\n/**\n * check if arg is boolean\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean'\n}\n\nexport function isEmpty(o: unknown): o is null | undefined {\n  return _.isEmpty(o)\n}\n\nexport function isEmptyObject(o: Record<string, unknown>): boolean {\n  return Object.values(o).filter((x) => x !== undefined).length !== 0\n}\n\nexport function isDefined<T>(o: T): o is Exclude<T, null | undefined> {\n  return o !== null && o !== undefined\n}\n\n/**\n * check if arg is a valid date\n */\nexport function isValidDate(arg: unknown): arg is Date {\n  // @ts-expect-error checknew Date(Math.NaN)\n  return arg instanceof Date && !isNaN(arg)\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDDTHHmmss' + Z\n */\nexport function makeDateLong(date?: Date): string {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 13) + s.slice(14, 16) + s.slice(17, 19) + 'Z'\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDD'\n */\nexport function makeDateShort(date?: Date) {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 10)\n}\n\n/**\n * pipesetup sets up pipe() from left to right os streams array\n * pipesetup will also make sure that error emitted at any of the upstream Stream\n * will be emitted at the last stream. This makes error handling simple\n */\nexport function pipesetup(...streams: [stream.Readable, ...stream.Duplex[], stream.Writable]) {\n  // @ts-expect-error ts can't narrow this\n  return streams.reduce((src: stream.Readable, dst: stream.Writable) => {\n    src.on('error', (err) => dst.emit('error', err))\n    return src.pipe(dst)\n  })\n}\n\n/**\n * return a Readable stream that emits data\n */\nexport function readableStream(data: unknown): stream.Readable {\n  const s = new stream.Readable()\n  s._read = () => {}\n  s.push(data)\n  s.push(null)\n  return s\n}\n\n/**\n * Process metadata to insert appropriate value to `content-type` attribute\n */\nexport function insertContentType(metaData: ObjectMetaData, filePath: string): ObjectMetaData {\n  // check if content-type attribute present in metaData\n  for (const key in metaData) {\n    if (key.toLowerCase() === 'content-type') {\n      return metaData\n    }\n  }\n\n  // if `content-type` attribute is not present in metadata, then infer it from the extension in filePath\n  return {\n    ...metaData,\n    'content-type': probeContentType(filePath),\n  }\n}\n\n/**\n * Function prepends metadata with the appropriate prefix if it is not already on\n */\nexport function prependXAMZMeta(metaData?: ObjectMetaData): RequestHeaders {\n  if (!metaData) {\n    return {}\n  }\n\n  return _.mapKeys(metaData, (value, key) => {\n    if (isAmzHeader(key) || isSupportedHeader(key) || isStorageClassHeader(key)) {\n      return key\n    }\n\n    return MetaDataHeaderPrefix + key\n  })\n}\n\n/**\n * Checks if it is a valid header according to the AmazonS3 API\n */\nexport function isAmzHeader(key: string) {\n  const temp = key.toLowerCase()\n  return (\n    temp.startsWith(MetaDataHeaderPrefix) ||\n    temp === 'x-amz-acl' ||\n    temp.startsWith('x-amz-server-side-encryption-') ||\n    temp === 'x-amz-server-side-encryption'\n  )\n}\n\n/**\n * Checks if it is a supported Header\n */\nexport function isSupportedHeader(key: string) {\n  const supported_headers = [\n    'content-type',\n    'cache-control',\n    'content-encoding',\n    'content-disposition',\n    'content-language',\n    'x-amz-website-redirect-location',\n  ]\n  return supported_headers.includes(key.toLowerCase())\n}\n\n/**\n * Checks if it is a storage header\n */\nexport function isStorageClassHeader(key: string) {\n  return key.toLowerCase() === 'x-amz-storage-class'\n}\n\nexport function extractMetadata(headers: ResponseHeader) {\n  return _.mapKeys(\n    _.pickBy(headers, (value, key) => isSupportedHeader(key) || isStorageClassHeader(key) || isAmzHeader(key)),\n    (value, key) => {\n      const lower = key.toLowerCase()\n      if (lower.startsWith(MetaDataHeaderPrefix)) {\n        return lower.slice(MetaDataHeaderPrefix.length)\n      }\n\n      return key\n    },\n  )\n}\n\nexport function getVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-version-id'] || null\n}\n\nexport function getSourceVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-copy-source-version-id'] || null\n}\n\nexport function sanitizeETag(etag = ''): string {\n  const replaceChars: Record<string, string> = {\n    '\"': '',\n    '&quot;': '',\n    '&#34;': '',\n    '&QUOT;': '',\n    '&#x00022': '',\n  }\n  return etag.replace(/^(\"|&quot;|&#34;)|(\"|&quot;|&#34;)$/g, (m) => replaceChars[m] as string)\n}\n\nexport function toMd5(payload: Binary): string {\n  // use string from browser and buffer from nodejs\n  // browser support is tested only against minio server\n  return crypto.createHash('md5').update(Buffer.from(payload)).digest().toString('base64')\n}\n\nexport function toSha256(payload: Binary): string {\n  return crypto.createHash('sha256').update(payload).digest('hex')\n}\n\n/**\n * toArray returns a single element array with param being the element,\n * if param is just a string, and returns 'param' back if it is an array\n * So, it makes sure param is always an array\n */\nexport function toArray<T = unknown>(param: T | T[]): Array<T> {\n  if (!Array.isArray(param)) {\n    return [param] as T[]\n  }\n  return param\n}\n\nexport function sanitizeObjectKey(objectName: string): string {\n  // + symbol characters are not decoded as spaces in JS. so replace them first and decode to get the correct result.\n  const asStrName = (objectName ? objectName.toString() : '').replace(/\\+/g, ' ')\n  return decodeURIComponent(asStrName)\n}\n\nexport const PART_CONSTRAINTS = {\n  // absMinPartSize - absolute minimum part size (5 MiB)\n  ABS_MIN_PART_SIZE: 1024 * 1024 * 5,\n  // MIN_PART_SIZE - minimum part size 16MiB per object after which\n  MIN_PART_SIZE: 1024 * 1024 * 16,\n  // MAX_PARTS_COUNT - maximum number of parts for a single multipart session.\n  MAX_PARTS_COUNT: 10000,\n  // MAX_PART_SIZE - maximum part size 5GiB for a single multipart upload\n  // operation.\n  MAX_PART_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_SINGLE_PUT_OBJECT_SIZE - maximum size 5GiB of object per PUT\n  // operation.\n  MAX_SINGLE_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_MULTIPART_PUT_OBJECT_SIZE - maximum size 5TiB of object for\n  // Multipart operation.\n  MAX_MULTIPART_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 1024 * 5,\n}\n\nconst GENERIC_SSE_HEADER = 'X-Amz-Server-Side-Encryption'\n\nconst ENCRYPTION_HEADERS = {\n  // sseGenericHeader is the AWS SSE header used for SSE-S3 and SSE-KMS.\n  sseGenericHeader: GENERIC_SSE_HEADER,\n  // sseKmsKeyID is the AWS SSE-KMS key id.\n  sseKmsKeyID: GENERIC_SSE_HEADER + '-Aws-Kms-Key-Id',\n} as const\n\n/**\n * Return Encryption headers\n * @param encConfig\n * @returns an object with key value pairs that can be used in headers.\n */\nexport function getEncryptionHeaders(encConfig: Encryption): RequestHeaders {\n  const encType = encConfig.type\n\n  if (!isEmpty(encType)) {\n    if (encType === ENCRYPTION_TYPES.SSEC) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: 'AES256',\n      }\n    } else if (encType === ENCRYPTION_TYPES.KMS) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: encConfig.SSEAlgorithm,\n        [ENCRYPTION_HEADERS.sseKmsKeyID]: encConfig.KMSMasterKeyID,\n      }\n    }\n  }\n\n  return {}\n}\n\nexport function partsRequired(size: number): number {\n  const maxPartSize = PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE / (PART_CONSTRAINTS.MAX_PARTS_COUNT - 1)\n  let requiredPartSize = size / maxPartSize\n  if (size % maxPartSize > 0) {\n    requiredPartSize++\n  }\n  requiredPartSize = Math.trunc(requiredPartSize)\n  return requiredPartSize\n}\n\n/**\n * calculateEvenSplits - computes splits for a source and returns\n * start and end index slices. Splits happen evenly to be sure that no\n * part is less than 5MiB, as that could fail the multipart request if\n * it is not the last part.\n */\nexport function calculateEvenSplits<T extends { Start?: number }>(\n  size: number,\n  objInfo: T,\n): {\n  startIndex: number[]\n  objInfo: T\n  endIndex: number[]\n} | null {\n  if (size === 0) {\n    return null\n  }\n  const reqParts = partsRequired(size)\n  const startIndexParts: number[] = []\n  const endIndexParts: number[] = []\n\n  let start = objInfo.Start\n  if (isEmpty(start) || start === -1) {\n    start = 0\n  }\n  const divisorValue = Math.trunc(size / reqParts)\n\n  const reminderValue = size % reqParts\n\n  let nextStart = start\n\n  for (let i = 0; i < reqParts; i++) {\n    let curPartSize = divisorValue\n    if (i < reminderValue) {\n      curPartSize++\n    }\n\n    const currentStart = nextStart\n    const currentEnd = currentStart + curPartSize - 1\n    nextStart = currentEnd + 1\n\n    startIndexParts.push(currentStart)\n    endIndexParts.push(currentEnd)\n  }\n\n  return { startIndex: startIndexParts, endIndex: endIndexParts, objInfo: objInfo }\n}\n\nconst fxp = new XMLParser()\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function parseXml(xml: string): any {\n  const result = fxp.parse(xml)\n  if (result.Error) {\n    throw result.Error\n  }\n\n  return result\n}\n"],"mappings":"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"} /***/ }), @@ -78474,72 +81109,6 @@ exports.PostPolicy = PostPolicy; /***/ }), -/***/ 9093: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.request = request; -var _stream = __nccwpck_require__(2781); -async function request(transport, opt, body = null) { - return new Promise((resolve, reject) => { - const requestObj = transport.request(opt, resp => { - resolve(resp); - }); - if (!body || Buffer.isBuffer(body) || typeof body === 'string') { - requestObj.on('error', e => { - reject(e); - }).end(body); - return; - } - - // pump readable stream - (0, _stream.pipeline)(body, requestObj, err => { - if (err) { - reject(err); - } - }); - }); -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 - -/***/ }), - -/***/ 2644: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.drainResponse = drainResponse; -exports.readAsBuffer = readAsBuffer; -exports.readAsString = readAsString; -async function readAsBuffer(res) { - return new Promise((resolve, reject) => { - const body = []; - res.on('data', chunk => body.push(chunk)).on('error', e => reject(e)).on('end', () => resolve(Buffer.concat(body))); - }); -} -async function readAsString(res) { - const body = await readAsBuffer(res); - return body.toString(); -} -async function drainResponse(res) { - return new Promise((resolve, reject) => { - res.on('data', () => {}).on('error', e => reject(e)).on('end', () => resolve()); - }); -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 - -/***/ }), - /***/ 6314: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { @@ -78636,249 +81205,8 @@ let LEGAL_HOLD_STATUS = /*#__PURE__*/function (LEGAL_HOLD_STATUS) { LEGAL_HOLD_STATUS["DISABLED"] = "OFF"; return LEGAL_HOLD_STATUS; }({}); -/* Replication Config types */ -/* Replication Config types */ exports.LEGAL_HOLD_STATUS = LEGAL_HOLD_STATUS; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 - -/***/ }), - -/***/ 4040: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.parseBucketRegion = parseBucketRegion; -exports.parseError = parseError; -exports.parseInitiateMultipart = parseInitiateMultipart; -exports.parseListBucket = parseListBucket; -exports.parseListObjectsV2WithMetadata = parseListObjectsV2WithMetadata; -exports.parseListParts = parseListParts; -exports.parseReplicationConfig = parseReplicationConfig; -exports.parseResponseError = parseResponseError; -var _fastXmlParser = __nccwpck_require__(2603); -var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); -var _helper = __nccwpck_require__(9921); -var _response = __nccwpck_require__(2644); -function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } -function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } -// parse XML response for bucket region -function parseBucketRegion(xml) { - // return region information - return (0, _helper.parseXml)(xml).LocationConstraint; -} -const fxp = new _fastXmlParser.XMLParser(); - -// Parse XML and return information as Javascript types -// parse error XML response -function parseError(xml, headerInfo) { - let xmlErr = {}; - const xmlObj = fxp.parse(xml); - if (xmlObj.Error) { - xmlErr = xmlObj.Error; - } - const e = new errors.S3Error(); - Object.entries(xmlErr).forEach(([key, value]) => { - e[key.toLowerCase()] = value; - }); - Object.entries(headerInfo).forEach(([key, value]) => { - e[key] = value; - }); - return e; -} - -// Generates an Error object depending on http statusCode and XML body -async function parseResponseError(response) { - const statusCode = response.statusCode; - let code, message; - if (statusCode === 301) { - code = 'MovedPermanently'; - message = 'Moved Permanently'; - } else if (statusCode === 307) { - code = 'TemporaryRedirect'; - message = 'Are you using the correct endpoint URL?'; - } else if (statusCode === 403) { - code = 'AccessDenied'; - message = 'Valid and authorized credentials required'; - } else if (statusCode === 404) { - code = 'NotFound'; - message = 'Not Found'; - } else if (statusCode === 405) { - code = 'MethodNotAllowed'; - message = 'Method Not Allowed'; - } else if (statusCode === 501) { - code = 'MethodNotAllowed'; - message = 'Method Not Allowed'; - } else { - code = 'UnknownError'; - message = `${statusCode}`; - } - const headerInfo = {}; - // A value created by S3 compatible server that uniquely identifies the request. - headerInfo.amzRequestid = response.headers['x-amz-request-id']; - // A special token that helps troubleshoot API replies and issues. - headerInfo.amzId2 = response.headers['x-amz-id-2']; - - // Region where the bucket is located. This header is returned only - // in HEAD bucket and ListObjects response. - headerInfo.amzBucketRegion = response.headers['x-amz-bucket-region']; - const xmlString = await (0, _response.readAsString)(response); - if (xmlString) { - throw parseError(xmlString, headerInfo); - } - - // Message should be instantiated for each S3Errors. - const e = new errors.S3Error(message, { - cause: headerInfo - }); - // S3 Error code. - e.code = code; - Object.entries(headerInfo).forEach(([key, value]) => { - // @ts-expect-error force set error properties - e[key] = value; - }); - throw e; -} - -/** - * parse XML response for list objects v2 with metadata in a bucket - */ -function parseListObjectsV2WithMetadata(xml) { - const result = { - objects: [], - isTruncated: false, - nextContinuationToken: '' - }; - let xmlobj = (0, _helper.parseXml)(xml); - if (!xmlobj.ListBucketResult) { - throw new errors.InvalidXMLError('Missing tag: "ListBucketResult"'); - } - xmlobj = xmlobj.ListBucketResult; - if (xmlobj.IsTruncated) { - result.isTruncated = xmlobj.IsTruncated; - } - if (xmlobj.NextContinuationToken) { - result.nextContinuationToken = xmlobj.NextContinuationToken; - } - if (xmlobj.Contents) { - (0, _helper.toArray)(xmlobj.Contents).forEach(content => { - const name = (0, _helper.sanitizeObjectKey)(content.Key); - const lastModified = new Date(content.LastModified); - const etag = (0, _helper.sanitizeETag)(content.ETag); - const size = content.Size; - let metadata; - if (content.UserMetadata != null) { - metadata = (0, _helper.toArray)(content.UserMetadata)[0]; - } else { - metadata = null; - } - result.objects.push({ - name, - lastModified, - etag, - size, - metadata - }); - }); - } - if (xmlobj.CommonPrefixes) { - (0, _helper.toArray)(xmlobj.CommonPrefixes).forEach(commonPrefix => { - result.objects.push({ - prefix: (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(commonPrefix.Prefix)[0]), - size: 0 - }); - }); - } - return result; -} -// parse XML response for list parts of an in progress multipart upload -function parseListParts(xml) { - let xmlobj = (0, _helper.parseXml)(xml); - const result = { - isTruncated: false, - parts: [], - marker: 0 - }; - if (!xmlobj.ListPartsResult) { - throw new errors.InvalidXMLError('Missing tag: "ListPartsResult"'); - } - xmlobj = xmlobj.ListPartsResult; - if (xmlobj.IsTruncated) { - result.isTruncated = xmlobj.IsTruncated; - } - if (xmlobj.NextPartNumberMarker) { - result.marker = (0, _helper.toArray)(xmlobj.NextPartNumberMarker)[0] || ''; - } - if (xmlobj.Part) { - (0, _helper.toArray)(xmlobj.Part).forEach(p => { - const part = parseInt((0, _helper.toArray)(p.PartNumber)[0], 10); - const lastModified = new Date(p.LastModified); - const etag = p.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, ''); - result.parts.push({ - part, - lastModified, - etag, - size: parseInt(p.Size, 10) - }); - }); - } - return result; -} -function parseListBucket(xml) { - let result = []; - const parsedXmlRes = (0, _helper.parseXml)(xml); - if (!parsedXmlRes.ListAllMyBucketsResult) { - throw new errors.InvalidXMLError('Missing tag: "ListAllMyBucketsResult"'); - } - const { - ListAllMyBucketsResult: { - Buckets = {} - } = {} - } = parsedXmlRes; - if (Buckets.Bucket) { - result = (0, _helper.toArray)(Buckets.Bucket).map((bucket = {}) => { - const { - Name: bucketName, - CreationDate - } = bucket; - const creationDate = new Date(CreationDate); - return { - name: bucketName, - creationDate: creationDate - }; - }); - } - return result; -} -function parseInitiateMultipart(xml) { - let xmlobj = (0, _helper.parseXml)(xml); - if (!xmlobj.InitiateMultipartUploadResult) { - throw new errors.InvalidXMLError('Missing tag: "InitiateMultipartUploadResult"'); - } - xmlobj = xmlobj.InitiateMultipartUploadResult; - if (xmlobj.UploadId) { - return xmlobj.UploadId; - } - throw new errors.InvalidXMLError('Missing tag: "UploadId"'); -} -function parseReplicationConfig(xml) { - const xmlObj = (0, _helper.parseXml)(xml); - const { - Role, - Rule - } = xmlObj.ReplicationConfiguration; - return { - ReplicationConfiguration: { - role: Role, - rules: (0, _helper.toArray)(Rule) - } - }; -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_fastXmlParser","require","errors","_interopRequireWildcard","_helper","_response","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","parseBucketRegion","xml","parseXml","LocationConstraint","fxp","XMLParser","parseError","headerInfo","xmlErr","xmlObj","parse","Error","e","S3Error","entries","forEach","value","toLowerCase","parseResponseError","response","statusCode","code","message","amzRequestid","headers","amzId2","amzBucketRegion","xmlString","readAsString","cause","parseListObjectsV2WithMetadata","result","objects","isTruncated","nextContinuationToken","xmlobj","ListBucketResult","InvalidXMLError","IsTruncated","NextContinuationToken","Contents","toArray","content","name","sanitizeObjectKey","Key","lastModified","Date","LastModified","etag","sanitizeETag","ETag","size","Size","metadata","UserMetadata","push","CommonPrefixes","commonPrefix","prefix","Prefix","parseListParts","parts","marker","ListPartsResult","NextPartNumberMarker","Part","p","part","parseInt","PartNumber","replace","parseListBucket","parsedXmlRes","ListAllMyBucketsResult","Buckets","Bucket","map","bucket","Name","bucketName","CreationDate","creationDate","parseInitiateMultipart","InitiateMultipartUploadResult","UploadId","parseReplicationConfig","Role","Rule","ReplicationConfiguration","role","rules"],"sources":["xml-parser.ts"],"sourcesContent":["import type * as http from 'node:http'\n\nimport { XMLParser } from 'fast-xml-parser'\n\nimport * as errors from '../errors.ts'\nimport { parseXml, sanitizeETag, sanitizeObjectKey, toArray } from './helper.ts'\nimport { readAsString } from './response.ts'\nimport type { BucketItemFromList, BucketItemWithMetadata, ReplicationConfig } from './type.ts'\n\n// parse XML response for bucket region\nexport function parseBucketRegion(xml: string): string {\n  // return region information\n  return parseXml(xml).LocationConstraint\n}\n\nconst fxp = new XMLParser()\n\n// Parse XML and return information as Javascript types\n// parse error XML response\nexport function parseError(xml: string, headerInfo: Record<string, unknown>) {\n  let xmlErr = {}\n  const xmlObj = fxp.parse(xml)\n  if (xmlObj.Error) {\n    xmlErr = xmlObj.Error\n  }\n  const e = new errors.S3Error() as unknown as Record<string, unknown>\n  Object.entries(xmlErr).forEach(([key, value]) => {\n    e[key.toLowerCase()] = value\n  })\n  Object.entries(headerInfo).forEach(([key, value]) => {\n    e[key] = value\n  })\n  return e\n}\n\n// Generates an Error object depending on http statusCode and XML body\nexport async function parseResponseError(response: http.IncomingMessage) {\n  const statusCode = response.statusCode\n  let code: string, message: string\n  if (statusCode === 301) {\n    code = 'MovedPermanently'\n    message = 'Moved Permanently'\n  } else if (statusCode === 307) {\n    code = 'TemporaryRedirect'\n    message = 'Are you using the correct endpoint URL?'\n  } else if (statusCode === 403) {\n    code = 'AccessDenied'\n    message = 'Valid and authorized credentials required'\n  } else if (statusCode === 404) {\n    code = 'NotFound'\n    message = 'Not Found'\n  } else if (statusCode === 405) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else if (statusCode === 501) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else {\n    code = 'UnknownError'\n    message = `${statusCode}`\n  }\n  const headerInfo: Record<string, string | undefined | null> = {}\n  // A value created by S3 compatible server that uniquely identifies the request.\n  headerInfo.amzRequestid = response.headers['x-amz-request-id'] as string | undefined\n  // A special token that helps troubleshoot API replies and issues.\n  headerInfo.amzId2 = response.headers['x-amz-id-2'] as string | undefined\n\n  // Region where the bucket is located. This header is returned only\n  // in HEAD bucket and ListObjects response.\n  headerInfo.amzBucketRegion = response.headers['x-amz-bucket-region'] as string | undefined\n\n  const xmlString = await readAsString(response)\n\n  if (xmlString) {\n    throw parseError(xmlString, headerInfo)\n  }\n\n  // Message should be instantiated for each S3Errors.\n  const e = new errors.S3Error(message, { cause: headerInfo })\n  // S3 Error code.\n  e.code = code\n  Object.entries(headerInfo).forEach(([key, value]) => {\n    // @ts-expect-error force set error properties\n    e[key] = value\n  })\n\n  throw e\n}\n\n/**\n * parse XML response for list objects v2 with metadata in a bucket\n */\nexport function parseListObjectsV2WithMetadata(xml: string) {\n  const result: {\n    objects: Array<BucketItemWithMetadata>\n    isTruncated: boolean\n    nextContinuationToken: string\n  } = {\n    objects: [],\n    isTruncated: false,\n    nextContinuationToken: '',\n  }\n\n  let xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      const name = sanitizeObjectKey(content.Key)\n      const lastModified = new Date(content.LastModified)\n      const etag = sanitizeETag(content.ETag)\n      const size = content.Size\n      let metadata\n      if (content.UserMetadata != null) {\n        metadata = toArray(content.UserMetadata)[0]\n      } else {\n        metadata = null\n      }\n      result.objects.push({ name, lastModified, etag, size, metadata })\n    })\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\nexport type Multipart = {\n  uploads: Array<{\n    key: string\n    uploadId: string\n    initiator: unknown\n    owner: unknown\n    storageClass: unknown\n    initiated: unknown\n  }>\n  prefixes: { prefix: string }[]\n  isTruncated: boolean\n  nextKeyMarker: undefined\n  nextUploadIdMarker: undefined\n}\n\nexport type UploadedPart = {\n  part: number\n  lastModified?: Date\n  etag: string\n  size: number\n}\n\n// parse XML response for list parts of an in progress multipart upload\nexport function parseListParts(xml: string): {\n  isTruncated: boolean\n  marker: number\n  parts: UploadedPart[]\n} {\n  let xmlobj = parseXml(xml)\n  const result: { isTruncated: boolean; marker: number; parts: UploadedPart[] } = {\n    isTruncated: false,\n    parts: [],\n    marker: 0,\n  }\n  if (!xmlobj.ListPartsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListPartsResult\"')\n  }\n  xmlobj = xmlobj.ListPartsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextPartNumberMarker) {\n    result.marker = toArray(xmlobj.NextPartNumberMarker)[0] || ''\n  }\n  if (xmlobj.Part) {\n    toArray(xmlobj.Part).forEach((p) => {\n      const part = parseInt(toArray(p.PartNumber)[0], 10)\n      const lastModified = new Date(p.LastModified)\n      const etag = p.ETag.replace(/^\"/g, '')\n        .replace(/\"$/g, '')\n        .replace(/^&quot;/g, '')\n        .replace(/&quot;$/g, '')\n        .replace(/^&#34;/g, '')\n        .replace(/&#34;$/g, '')\n      result.parts.push({ part, lastModified, etag, size: parseInt(p.Size, 10) })\n    })\n  }\n  return result\n}\n\nexport function parseListBucket(xml: string) {\n  let result: BucketItemFromList[] = []\n  const parsedXmlRes = parseXml(xml)\n\n  if (!parsedXmlRes.ListAllMyBucketsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListAllMyBucketsResult\"')\n  }\n  const { ListAllMyBucketsResult: { Buckets = {} } = {} } = parsedXmlRes\n\n  if (Buckets.Bucket) {\n    result = toArray(Buckets.Bucket).map((bucket = {}) => {\n      const { Name: bucketName, CreationDate } = bucket\n      const creationDate = new Date(CreationDate)\n\n      return { name: bucketName, creationDate: creationDate }\n    })\n  }\n  return result\n}\n\nexport function parseInitiateMultipart(xml: string): string {\n  let xmlobj = parseXml(xml)\n\n  if (!xmlobj.InitiateMultipartUploadResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"InitiateMultipartUploadResult\"')\n  }\n  xmlobj = xmlobj.InitiateMultipartUploadResult\n\n  if (xmlobj.UploadId) {\n    return xmlobj.UploadId\n  }\n  throw new errors.InvalidXMLError('Missing tag: \"UploadId\"')\n}\n\nexport function parseReplicationConfig(xml: string): ReplicationConfig {\n  const xmlObj = parseXml(xml)\n  const { Role, Rule } = xmlObj.ReplicationConfiguration\n  return {\n    ReplicationConfiguration: {\n      role: Role,\n      rules: toArray(Rule),\n    },\n  }\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 /***/ }), @@ -78907,6 +81235,7 @@ var _webEncoding = __nccwpck_require__(1430); var _xml = __nccwpck_require__(7578); var _xml2js = __nccwpck_require__(4659); var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); +var _extensions = __nccwpck_require__(2895); var _helpers = __nccwpck_require__(9455); Object.keys(_helpers).forEach(function (key) { if (key === "default" || key === "__esModule") return; @@ -78914,7 +81243,6 @@ Object.keys(_helpers).forEach(function (key) { if (key in exports && exports[key] === _helpers[key]) return; exports[key] = _helpers[key]; }); -var _callbackify = __nccwpck_require__(3826); var _client = __nccwpck_require__(5586); var _copyConditions = __nccwpck_require__(3250); exports.CopyConditions = _copyConditions.CopyConditions; @@ -79001,6 +81329,263 @@ class Client extends _client.TypedClient { } } + // log the request, response, error + logHTTP(reqOptions, response, err) { + // if no logstreamer available return. + if (!this.logStream) { + return; + } + if (!(0, _helper.isObject)(reqOptions)) { + throw new TypeError('reqOptions should be of type "object"'); + } + if (response && !(0, _helper.isReadableStream)(response)) { + throw new TypeError('response should be of type "Stream"'); + } + if (err && !(err instanceof Error)) { + throw new TypeError('err should be of type "Error"'); + } + var logHeaders = headers => { + _lodash.forEach(headers, (v, k) => { + if (k == 'authorization') { + var redacter = new RegExp('Signature=([0-9a-f]+)'); + v = v.replace(redacter, 'Signature=**REDACTED**'); + } + this.logStream.write(`${k}: ${v}\n`); + }); + this.logStream.write('\n'); + }; + this.logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\n`); + logHeaders(reqOptions.headers); + if (response) { + this.logStream.write(`RESPONSE: ${response.statusCode}\n`); + logHeaders(response.headers); + } + if (err) { + this.logStream.write('ERROR BODY:\n'); + var errJSON = JSON.stringify(err, null, '\t'); + this.logStream.write(`${errJSON}\n`); + } + } + + // Enable tracing + traceOn(stream) { + if (!stream) { + stream = process.stdout; + } + this.logStream = stream; + } + + // Disable tracing + traceOff() { + this.logStream = null; + } + + // makeRequest is the primitive used by the apis for making S3 requests. + // payload can be empty string in case of no payload. + // statusCode is the expected statusCode. If response.statusCode does not match + // we parse the XML error and call the callback with the error message. + // A valid region is passed by the calls - listBuckets, makeBucket and + // getBucketRegion. + makeRequest(options, payload, statusCodes, region, returnResponse, cb) { + if (!(0, _helper.isObject)(options)) { + throw new TypeError('options should be of type "object"'); + } + if (!(0, _helper.isString)(payload) && !(0, _helper.isObject)(payload)) { + // Buffer is of type 'object' + throw new TypeError('payload should be of type "string" or "Buffer"'); + } + statusCodes.forEach(statusCode => { + if (!(0, _helper.isNumber)(statusCode)) { + throw new TypeError('statusCode should be of type "number"'); + } + }); + if (!(0, _helper.isString)(region)) { + throw new TypeError('region should be of type "string"'); + } + if (!(0, _helper.isBoolean)(returnResponse)) { + throw new TypeError('returnResponse should be of type "boolean"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + if (!options.headers) { + options.headers = {}; + } + if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') { + options.headers['content-length'] = payload.length; + } + var sha256sum = ''; + if (this.enableSHA256) { + sha256sum = (0, _helper.toSha256)(payload); + } + var stream = (0, _helper.readableStream)(payload); + this.makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb); + } + + // makeRequestStream will be used directly instead of makeRequest in case the payload + // is available as a stream. for ex. putObject + makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb) { + if (!(0, _helper.isObject)(options)) { + throw new TypeError('options should be of type "object"'); + } + if (!(0, _helper.isReadableStream)(stream)) { + throw new errors.InvalidArgumentError('stream should be a readable Stream'); + } + if (!(0, _helper.isString)(sha256sum)) { + throw new TypeError('sha256sum should be of type "string"'); + } + statusCodes.forEach(statusCode => { + if (!(0, _helper.isNumber)(statusCode)) { + throw new TypeError('statusCode should be of type "number"'); + } + }); + if (!(0, _helper.isString)(region)) { + throw new TypeError('region should be of type "string"'); + } + if (!(0, _helper.isBoolean)(returnResponse)) { + throw new TypeError('returnResponse should be of type "boolean"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + + // sha256sum will be empty for anonymous or https requests + if (!this.enableSHA256 && sha256sum.length !== 0) { + throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`); + } + // sha256sum should be valid for non-anonymous http requests. + if (this.enableSHA256 && sha256sum.length !== 64) { + throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`); + } + var _makeRequest = (e, region) => { + if (e) { + return cb(e); + } + options.region = region; + var reqOptions = this.getRequestOptions(options); + if (!this.anonymous) { + // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation. + if (!this.enableSHA256) { + sha256sum = 'UNSIGNED-PAYLOAD'; + } + let date = new Date(); + reqOptions.headers['x-amz-date'] = (0, _helper.makeDateLong)(date); + reqOptions.headers['x-amz-content-sha256'] = sha256sum; + if (this.sessionToken) { + reqOptions.headers['x-amz-security-token'] = this.sessionToken; + } + this.checkAndRefreshCreds(); + var authorization = (0, _signing.signV4)(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum); + reqOptions.headers.authorization = authorization; + } + var req = this.transport.request(reqOptions, response => { + if (!statusCodes.includes(response.statusCode)) { + // For an incorrect region, S3 server always sends back 400. + // But we will do cache invalidation for all errors so that, + // in future, if AWS S3 decides to send a different status code or + // XML error code we will still work fine. + delete this.regionMap[options.bucketName]; + var errorTransformer = transformers.getErrorTransformer(response); + (0, _helper.pipesetup)(response, errorTransformer).on('error', e => { + this.logHTTP(reqOptions, response, e); + cb(e); + }); + return; + } + this.logHTTP(reqOptions, response); + if (returnResponse) { + return cb(null, response); + } + // We drain the socket so that the connection gets closed. Note that this + // is not expensive as the socket will not have any data. + response.on('data', () => {}); + cb(null); + }); + let pipe = (0, _helper.pipesetup)(stream, req); + pipe.on('error', e => { + this.logHTTP(reqOptions, null, e); + cb(e); + }); + }; + if (region) { + return _makeRequest(null, region); + } + this.getBucketRegion(options.bucketName, _makeRequest); + } + + // gets the region of the bucket + getBucketRegion(bucketName, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('cb should be of type "function"'); + } + + // Region is set with constructor, return the region right here. + if (this.region) { + return cb(null, this.region); + } + if (this.regionMap[bucketName]) { + return cb(null, this.regionMap[bucketName]); + } + var extractRegion = response => { + var transformer = transformers.getBucketRegionTransformer(); + var region = _helpers.DEFAULT_REGION; + (0, _helper.pipesetup)(response, transformer).on('error', cb).on('data', data => { + if (data) { + region = data; + } + }).on('end', () => { + this.regionMap[bucketName] = region; + cb(null, region); + }); + }; + var method = 'GET'; + var query = 'location'; + + // `getBucketLocation` behaves differently in following ways for + // different environments. + // + // - For nodejs env we default to path style requests. + // - For browser env path style requests on buckets yields CORS + // error. To circumvent this problem we make a virtual host + // style request signed with 'us-east-1'. This request fails + // with an error 'AuthorizationHeaderMalformed', additionally + // the error XML also provides Region of the bucket. To validate + // this region is proper we retry the same request with the newly + // obtained region. + var pathStyle = this.pathStyle && typeof window === 'undefined'; + this.makeRequest({ + method, + bucketName, + query, + pathStyle + }, '', [200], _helpers.DEFAULT_REGION, true, (e, response) => { + if (e) { + if (e.name === 'AuthorizationHeaderMalformed') { + var region = e.Region; + if (!region) { + return cb(e); + } + this.makeRequest({ + method, + bucketName, + query + }, '', [200], region, true, (e, response) => { + if (e) { + return cb(e); + } + extractRegion(response); + }); + return; + } + return cb(e); + } + extractRegion(response); + }); + } + // Creates the bucket `bucketName`. // // __Arguments__ @@ -79092,6 +81677,31 @@ class Client extends _client.TypedClient { }, payload, [200], region, false, processWithRetry); } + // List of buckets created. + // + // __Arguments__ + // * `callback(err, buckets)` _function_ - callback function with error as the first argument. `buckets` is an array of bucket information + // + // `buckets` array element: + // * `bucket.name` _string_ : bucket name + // * `bucket.creationDate` _Date_: date when bucket was created + listBuckets(cb) { + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + var method = 'GET'; + this.makeRequest({ + method + }, '', [200], _helpers.DEFAULT_REGION, true, (e, response) => { + if (e) { + return cb(e); + } + var transformer = transformers.getListBucketTransformer(); + var buckets; + (0, _helper.pipesetup)(response, transformer).on('data', result => buckets = result).on('error', e => cb(e)).on('end', () => cb(null, buckets)); + }); + } + // Returns a stream that emits objects that are partially uploaded. // // __Arguments__ @@ -79140,11 +81750,14 @@ class Client extends _client.TypedClient { result.prefixes.forEach(prefix => uploads.push(prefix)); _async.eachSeries(result.uploads, (upload, cb) => { // for each incomplete upload add the sizes of its uploaded parts - this.listParts(bucket, upload.key, upload.uploadId).then(parts => { + this.listParts(bucket, upload.key, upload.uploadId, (err, parts) => { + if (err) { + return cb(err); + } upload.size = parts.reduce((acc, item) => acc + item.size, 0); uploads.push(upload); cb(); - }, cb); + }); }, err => { if (err) { readStream.emit('error', err); @@ -79190,6 +81803,31 @@ class Client extends _client.TypedClient { }); } + // Remove a bucket. + // + // __Arguments__ + // * `bucketName` _string_ : name of the bucket + // * `callback(err)` _function_ : `err` is `null` if the bucket is removed successfully. + removeBucket(bucketName, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + var method = 'DELETE'; + this.makeRequest({ + method, + bucketName + }, '', [204], '', false, e => { + // If the bucket was successfully removed, remove the region map entry. + if (!e) { + delete this.regionMap[bucketName]; + } + cb(e); + }); + } + // Remove the partially uploaded object. // // __Arguments__ @@ -79421,11 +82059,150 @@ class Client extends _client.TypedClient { // Inserts correct `content-type` attribute based on metaData and filePath metaData = (0, _helper.insertContentType)(metaData, filePath); - fs.lstat(filePath, (err, stat) => { - if (err) { - return callback(err); + + // Updates metaData to have the correct prefix if needed + metaData = (0, _helper.prependXAMZMeta)(metaData); + var size; + var partSize; + _async.waterfall([cb => fs.stat(filePath, cb), (stats, cb) => { + size = stats.size; + var stream; + var cbTriggered = false; + var origCb = cb; + cb = function () { + if (cbTriggered) { + return; + } + cbTriggered = true; + if (stream) { + stream.destroy(); + } + return origCb.apply(this, arguments); + }; + if (size > this.maxObjectSize) { + return cb(new Error(`${filePath} size : ${stats.size}, max allowed size : 5TB`)); + } + if (size <= this.partSize) { + // simple PUT request, no multipart + var multipart = false; + var uploader = this.getUploader(bucketName, objectName, metaData, multipart); + var hash = transformers.getHashSummer(this.enableSHA256); + var start = 0; + var end = size - 1; + var autoClose = true; + if (size === 0) { + end = 0; + } + var options = { + start, + end, + autoClose + }; + (0, _helper.pipesetup)(fs.createReadStream(filePath, options), hash).on('data', data => { + var md5sum = data.md5sum; + var sha256sum = data.sha256sum; + stream = fs.createReadStream(filePath, options); + uploader(stream, size, sha256sum, md5sum, (err, objInfo) => { + callback(err, objInfo); + cb(true); + }); + }).on('error', e => cb(e)); + return; } - return this.putObject(bucketName, objectName, fs.createReadStream(filePath), stat.size, metaData, callback); + this.findUploadId(bucketName, objectName, cb); + }, (uploadId, cb) => { + // if there was a previous incomplete upload, fetch all its uploaded parts info + if (uploadId) { + return this.listParts(bucketName, objectName, uploadId, (e, etags) => cb(e, uploadId, etags)); + } + // there was no previous upload, initiate a new one + this.initiateNewMultipartUpload(bucketName, objectName, metaData, (e, uploadId) => cb(e, uploadId, [])); + }, (uploadId, etags, cb) => { + partSize = this.calculatePartSize(size); + var multipart = true; + var uploader = this.getUploader(bucketName, objectName, metaData, multipart); + + // convert array to object to make things easy + var parts = etags.reduce(function (acc, item) { + if (!acc[item.part]) { + acc[item.part] = item; + } + return acc; + }, {}); + var partsDone = []; + var partNumber = 1; + var uploadedSize = 0; + _async.whilst(cb => { + cb(null, uploadedSize < size); + }, cb => { + var stream; + var cbTriggered = false; + var origCb = cb; + cb = function () { + if (cbTriggered) { + return; + } + cbTriggered = true; + if (stream) { + stream.destroy(); + } + return origCb.apply(this, arguments); + }; + var part = parts[partNumber]; + var hash = transformers.getHashSummer(this.enableSHA256); + var length = partSize; + if (length > size - uploadedSize) { + length = size - uploadedSize; + } + var start = uploadedSize; + var end = uploadedSize + length - 1; + var autoClose = true; + var options = { + autoClose, + start, + end + }; + // verify md5sum of each part + (0, _helper.pipesetup)(fs.createReadStream(filePath, options), hash).on('data', data => { + var md5sumHex = Buffer.from(data.md5sum, 'base64').toString('hex'); + if (part && md5sumHex === part.etag) { + // md5 matches, chunk already uploaded + partsDone.push({ + part: partNumber, + etag: part.etag + }); + partNumber++; + uploadedSize += length; + return cb(); + } + // part is not uploaded yet, or md5 mismatch + stream = fs.createReadStream(filePath, options); + uploader(uploadId, partNumber, stream, length, data.sha256sum, data.md5sum, (e, objInfo) => { + if (e) { + return cb(e); + } + partsDone.push({ + part: partNumber, + etag: objInfo.etag + }); + partNumber++; + uploadedSize += length; + return cb(); + }); + }).on('error', e => cb(e)); + }, e => { + if (e) { + return cb(e); + } + cb(null, partsDone, uploadId); + }); + }, + // all parts uploaded, complete the multipart upload + (etags, uploadId, cb) => this.completeMultipartUpload(bucketName, objectName, uploadId, etags, cb)], (err, ...rest) => { + if (err === true) { + return; + } + callback(err, ...rest); }); } @@ -79925,6 +82702,112 @@ class Client extends _client.TypedClient { return readStream; } + // Stat information of the object. + // + // __Arguments__ + // * `bucketName` _string_: name of the bucket + // * `objectName` _string_: name of the object + // * `statOpts` _object_ : Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional). + // * `callback(err, stat)` _function_: `err` is not `null` in case of error, `stat` contains the object information: + // * `stat.size` _number_: size of the object + // * `stat.etag` _string_: etag of the object + // * `stat.metaData` _string_: MetaData of the object + // * `stat.lastModified` _Date_: modified time stamp + // * `stat.versionId` _string_: version id of the object if available + statObject(bucketName, objectName, statOpts = {}, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + // backward compatibility + if ((0, _helper.isFunction)(statOpts)) { + cb = statOpts; + statOpts = {}; + } + if (!(0, _helper.isObject)(statOpts)) { + throw new errors.InvalidArgumentError('statOpts should be of type "object"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + var query = querystring.stringify(statOpts); + var method = 'HEAD'; + this.makeRequest({ + method, + bucketName, + objectName, + query + }, '', [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + + // We drain the socket so that the connection gets closed. Note that this + // is not expensive as the socket will not have any data. + response.on('data', () => {}); + const result = { + size: +response.headers['content-length'], + metaData: (0, _helper.extractMetadata)(response.headers), + lastModified: new Date(response.headers['last-modified']), + versionId: (0, _helper.getVersionId)(response.headers), + etag: (0, _helper.sanitizeETag)(response.headers.etag) + }; + cb(null, result); + }); + } + + // Remove the specified object. + // + // __Arguments__ + // * `bucketName` _string_: name of the bucket + // * `objectName` _string_: name of the object + // * `removeOpts` _object_: Version of the object in the form `{versionId:'my-uuid', governanceBypass:true|false, forceDelete:true|false}`. Default is `{}`. (optional) + // * `callback(err)` _function_: callback function is called with non `null` value in case of error + removeObject(bucketName, objectName, removeOpts = {}, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + // backward compatibility + if ((0, _helper.isFunction)(removeOpts)) { + cb = removeOpts; + removeOpts = {}; + } + if (!(0, _helper.isObject)(removeOpts)) { + throw new errors.InvalidArgumentError('removeOpts should be of type "object"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + const method = 'DELETE'; + const queryParams = {}; + if (removeOpts.versionId) { + queryParams.versionId = `${removeOpts.versionId}`; + } + const headers = {}; + if (removeOpts.governanceBypass) { + headers['X-Amz-Bypass-Governance-Retention'] = true; + } + if (removeOpts.forceDelete) { + headers['x-minio-force-delete'] = true; + } + const query = querystring.stringify(queryParams); + let requestOptions = { + method, + bucketName, + objectName, + headers + }; + if (query) { + requestOptions['query'] = query; + } + this.makeRequest(requestOptions, '', [200, 204], '', false, cb); + } + // Remove all the objects residing in the objectsList. // // __Arguments__ @@ -79986,7 +82869,7 @@ class Client extends _client.TypedClient { headless: true }); let payload = builder.buildObject(deleteObjects); - payload = Buffer.from(encoder.encode(payload)); + payload = encoder.encode(payload); const headers = {}; headers['Content-MD5'] = (0, _helper.toMd5)(payload); let removeObjectsResult; @@ -80242,6 +83125,37 @@ class Client extends _client.TypedClient { }); } + // Calls implemented below are related to multipart. + + // Initiate a new multipart upload. + initiateNewMultipartUpload(bucketName, objectName, metaData, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + if (!(0, _helper.isObject)(metaData)) { + throw new errors.InvalidObjectNameError('contentType should be of type "object"'); + } + var method = 'POST'; + let headers = Object.assign({}, metaData); + var query = 'uploads'; + this.makeRequest({ + method, + bucketName, + objectName, + query, + headers + }, '', [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + var transformer = transformers.getInitiateMultipartTransformer(); + (0, _helper.pipesetup)(response, transformer).on('error', e => cb(e)).on('data', uploadId => cb(null, uploadId)); + }); + } + // Complete the multipart upload. After all the parts are uploaded issuing // this call will aggregate the parts on the server into a single object. completeMultipartUpload(bucketName, objectName, uploadId, etags, cb) { @@ -80304,6 +83218,78 @@ class Client extends _client.TypedClient { }); } + // Get part-info of all parts of an incomplete upload specified by uploadId. + listParts(bucketName, objectName, uploadId, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + if (!(0, _helper.isString)(uploadId)) { + throw new TypeError('uploadId should be of type "string"'); + } + if (!uploadId) { + throw new errors.InvalidArgumentError('uploadId cannot be empty'); + } + var parts = []; + var listNext = marker => { + this.listPartsQuery(bucketName, objectName, uploadId, marker, (e, result) => { + if (e) { + cb(e); + return; + } + parts = parts.concat(result.parts); + if (result.isTruncated) { + listNext(result.marker); + return; + } + cb(null, parts); + }); + }; + listNext(0); + } + + // Called by listParts to fetch a batch of part-info + listPartsQuery(bucketName, objectName, uploadId, marker, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + if (!(0, _helper.isString)(uploadId)) { + throw new TypeError('uploadId should be of type "string"'); + } + if (!(0, _helper.isNumber)(marker)) { + throw new TypeError('marker should be of type "number"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + if (!uploadId) { + throw new errors.InvalidArgumentError('uploadId cannot be empty'); + } + var query = ''; + if (marker && marker !== 0) { + query += `part-number-marker=${marker}&`; + } + query += `uploadId=${(0, _helper.uriEscape)(uploadId)}`; + var method = 'GET'; + this.makeRequest({ + method, + bucketName, + objectName, + query + }, '', [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + var transformer = transformers.getListPartsTransformer(); + (0, _helper.pipesetup)(response, transformer).on('error', e => cb(e)).on('data', data => cb(null, data)); + }); + } + // Called by listIncompleteUploads to fetch a batch of incomplete uploads. listIncompleteUploadsQuery(bucketName, prefix, keyMarker, uploadIdMarker, delimiter) { if (!(0, _helper.isValidBucketName)(bucketName)) { @@ -80389,6 +83375,97 @@ class Client extends _client.TypedClient { listNext('', ''); } + // Returns a function that can be used for uploading objects. + // If multipart === true, it returns function that is used to upload + // a part of the multipart. + getUploader(bucketName, objectName, metaData, multipart) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + if (!(0, _helper.isBoolean)(multipart)) { + throw new TypeError('multipart should be of type "boolean"'); + } + if (!(0, _helper.isObject)(metaData)) { + throw new TypeError('metadata should be of type "object"'); + } + var validate = (stream, length, sha256sum, md5sum, cb) => { + if (!(0, _helper.isReadableStream)(stream)) { + throw new TypeError('stream should be of type "Stream"'); + } + if (!(0, _helper.isNumber)(length)) { + throw new TypeError('length should be of type "number"'); + } + if (!(0, _helper.isString)(sha256sum)) { + throw new TypeError('sha256sum should be of type "string"'); + } + if (!(0, _helper.isString)(md5sum)) { + throw new TypeError('md5sum should be of type "string"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + }; + var simpleUploader = (...args) => { + validate(...args); + var query = ''; + upload(query, ...args); + }; + var multipartUploader = (uploadId, partNumber, ...rest) => { + if (!(0, _helper.isString)(uploadId)) { + throw new TypeError('uploadId should be of type "string"'); + } + if (!(0, _helper.isNumber)(partNumber)) { + throw new TypeError('partNumber should be of type "number"'); + } + if (!uploadId) { + throw new errors.InvalidArgumentError('Empty uploadId'); + } + if (!partNumber) { + throw new errors.InvalidArgumentError('partNumber cannot be 0'); + } + validate(...rest); + var query = `partNumber=${partNumber}&uploadId=${(0, _helper.uriEscape)(uploadId)}`; + upload(query, ...rest); + }; + var upload = (query, stream, length, sha256sum, md5sum, cb) => { + var method = 'PUT'; + let headers = { + 'Content-Length': length + }; + if (!multipart) { + headers = Object.assign({}, metaData, headers); + } + if (!this.enableSHA256) { + headers['Content-MD5'] = md5sum; + } + this.makeRequestStream({ + method, + bucketName, + objectName, + query, + headers + }, stream, sha256sum, [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + const result = { + etag: (0, _helper.sanitizeETag)(response.headers.etag), + versionId: (0, _helper.getVersionId)(response.headers) + }; + // Ignore the 'data' event so that the stream closes. (nodejs stream requirement) + response.on('data', () => {}); + cb(null, result); + }); + }; + if (multipart) { + return multipartUploader; + } + return simpleUploader; + } + // Remove all the notification configurations in the S3 provider setBucketNotification(bucketName, config, cb) { if (!(0, _helper.isValidBucketName)(bucketName)) { @@ -80560,7 +83637,7 @@ class Client extends _client.TypedClient { } }); let payload = builder.buildObject(taggingConfig); - payload = Buffer.from(encoder.encode(payload)); + payload = encoder.encode(payload); headers['Content-MD5'] = (0, _helper.toMd5)(payload); const requestOptions = { method, @@ -80724,9 +83801,6 @@ class Client extends _client.TypedClient { * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful. */ getBucketTagging(bucketName, cb) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`); - } const method = 'GET'; const query = 'tagging'; const requestOptions = { @@ -80809,7 +83883,7 @@ class Client extends _client.TypedClient { } }); let payload = builder.buildObject(policyConfig); - payload = Buffer.from(encoder.encode(payload)); + payload = encoder.encode(payload); const requestOptions = { method, bucketName, @@ -81138,6 +84212,86 @@ class Client extends _client.TypedClient { query }, '', [204], '', false, cb); } + setBucketReplication(bucketName, replicationConfig = {}, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isObject)(replicationConfig)) { + throw new errors.InvalidArgumentError('replicationConfig should be of type "object"'); + } else { + if (_lodash.isEmpty(replicationConfig.role)) { + throw new errors.InvalidArgumentError('Role cannot be empty'); + } else if (replicationConfig.role && !(0, _helper.isString)(replicationConfig.role)) { + throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role); + } + if (_lodash.isEmpty(replicationConfig.rules)) { + throw new errors.InvalidArgumentError('Minimum one replication rule must be specified'); + } + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + const method = 'PUT'; + let query = 'replication'; + const headers = {}; + const replicationParamsConfig = { + ReplicationConfiguration: { + Role: replicationConfig.role, + Rule: replicationConfig.rules + } + }; + const builder = new _xml2js.Builder({ + renderOpts: { + pretty: false + }, + headless: true + }); + let payload = builder.buildObject(replicationParamsConfig); + headers['Content-MD5'] = (0, _helper.toMd5)(payload); + this.makeRequest({ + method, + bucketName, + query, + headers + }, payload, [200], '', false, cb); + } + getBucketReplication(bucketName, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isFunction)(cb)) { + throw new errors.InvalidArgumentError('callback should be of type "function"'); + } + const method = 'GET'; + const query = 'replication'; + this.makeRequest({ + method, + bucketName, + query + }, '', [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + let replicationConfig = Buffer.from(''); + (0, _helper.pipesetup)(response, transformers.replicationConfigTransformer()).on('data', data => { + replicationConfig = data; + }).on('error', cb).on('end', () => { + cb(null, replicationConfig); + }); + }); + } + removeBucketReplication(bucketName, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + const method = 'DELETE'; + const query = 'replication'; + this.makeRequest({ + method, + bucketName, + query + }, '', [200, 204], '', false, cb); + } getObjectLegalHold(bucketName, objectName, getOpts = {}, cb) { if (!(0, _helper.isValidBucketName)(bucketName)) { throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); @@ -81238,6 +84392,25 @@ class Client extends _client.TypedClient { }, payload, [200], '', false, cb); } + /** + * Internal Method to abort a multipart upload request in case of any errors. + * @param bucketName __string__ Bucket Name + * @param objectName __string__ Object Name + * @param uploadId __string__ id of a multipart upload to cancel during compose object sequence. + * @param cb __function__ callback function + */ + abortMultipartUpload(bucketName, objectName, uploadId, cb) { + const method = 'DELETE'; + let query = `uploadId=${uploadId}`; + const requestOptions = { + method, + bucketName, + objectName: objectName, + query + }; + this.makeRequest(requestOptions, '', [204], '', false, cb); + } + /** * Internal method to upload a part during compose object. * @param partConfig __object__ contains the following. @@ -81403,8 +84576,7 @@ class Client extends _client.TypedClient { const uploadList = getUploadPartConfigList(uploadId); _async.map(uploadList, me.uploadPartCopy.bind(me), (err, res) => { if (err) { - this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId).then(() => cb(), err => cb(err)); - return; + return this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, cb); } const partsDone = res.map(partCopy => ({ etag: partCopy.etag, @@ -81414,10 +84586,11 @@ class Client extends _client.TypedClient { }); }; const newUploadHeaders = destObjConfig.getHeaders(); - me.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders).then(uploadId => { + me.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders, (err, uploadId) => { + if (err) { + return cb(err, null); + } performUploadParts(uploadId); - }, err => { - cb(err, null); }); }).catch(error => { cb(error, null); @@ -81504,18 +84677,28 @@ class Client extends _client.TypedClient { }); }); } + get extensions() { + if (!this.clientExtensions) { + this.clientExtensions = new _extensions.extensions(this); + } + return this.clientExtensions; + } } // Promisify various public-facing APIs on the Client module. exports.Client = Client; Client.prototype.makeBucket = (0, _promisify.promisify)(Client.prototype.makeBucket); +Client.prototype.listBuckets = (0, _promisify.promisify)(Client.prototype.listBuckets); Client.prototype.bucketExists = (0, _promisify.promisify)(Client.prototype.bucketExists); +Client.prototype.removeBucket = (0, _promisify.promisify)(Client.prototype.removeBucket); Client.prototype.getObject = (0, _promisify.promisify)(Client.prototype.getObject); Client.prototype.getPartialObject = (0, _promisify.promisify)(Client.prototype.getPartialObject); Client.prototype.fGetObject = (0, _promisify.promisify)(Client.prototype.fGetObject); Client.prototype.putObject = (0, _promisify.promisify)(Client.prototype.putObject); Client.prototype.fPutObject = (0, _promisify.promisify)(Client.prototype.fPutObject); Client.prototype.copyObject = (0, _promisify.promisify)(Client.prototype.copyObject); +Client.prototype.statObject = (0, _promisify.promisify)(Client.prototype.statObject); +Client.prototype.removeObject = (0, _promisify.promisify)(Client.prototype.removeObject); Client.prototype.removeObjects = (0, _promisify.promisify)(Client.prototype.removeObjects); Client.prototype.presignedUrl = (0, _promisify.promisify)(Client.prototype.presignedUrl); Client.prototype.presignedGetObject = (0, _promisify.promisify)(Client.prototype.presignedGetObject); @@ -81545,20 +84728,14 @@ Client.prototype.getObjectRetention = (0, _promisify.promisify)(Client.prototype Client.prototype.setBucketEncryption = (0, _promisify.promisify)(Client.prototype.setBucketEncryption); Client.prototype.getBucketEncryption = (0, _promisify.promisify)(Client.prototype.getBucketEncryption); Client.prototype.removeBucketEncryption = (0, _promisify.promisify)(Client.prototype.removeBucketEncryption); +Client.prototype.setBucketReplication = (0, _promisify.promisify)(Client.prototype.setBucketReplication); +Client.prototype.getBucketReplication = (0, _promisify.promisify)(Client.prototype.getBucketReplication); +Client.prototype.removeBucketReplication = (0, _promisify.promisify)(Client.prototype.removeBucketReplication); Client.prototype.setObjectLegalHold = (0, _promisify.promisify)(Client.prototype.setObjectLegalHold); Client.prototype.getObjectLegalHold = (0, _promisify.promisify)(Client.prototype.getObjectLegalHold); Client.prototype.composeObject = (0, _promisify.promisify)(Client.prototype.composeObject); Client.prototype.selectObjectContent = (0, _promisify.promisify)(Client.prototype.selectObjectContent); - -// refactored API use promise internally -Client.prototype.removeObject = (0, _callbackify.callbackify)(Client.prototype.removeObject); -Client.prototype.statObject = (0, _callbackify.callbackify)(Client.prototype.statObject); -Client.prototype.removeBucket = (0, _callbackify.callbackify)(Client.prototype.removeBucket); -Client.prototype.listBuckets = (0, _callbackify.callbackify)(Client.prototype.listBuckets); -Client.prototype.removeBucketReplication = (0, _callbackify.callbackify)(Client.prototype.removeBucketReplication); -Client.prototype.setBucketReplication = (0, _callbackify.callbackify)(Client.prototype.setBucketReplication); -Client.prototype.getBucketReplication = (0, _callbackify.callbackify)(Client.prototype.getBucketReplication); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","_interopRequireWildcard","require","path","Stream","_async","_blockStream","_lodash","querystring","_webEncoding","_xml","_xml2js","errors","_helpers","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","_callbackify","_client","_copyConditions","CopyConditions","_helper","_postPolicy","PostPolicy","_type","_notification","_objectUploader","_promisify","_signing","transformers","_xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","defineProperty","getOwnPropertyDescriptor","desc","set","Client","TypedClient","setAppInfo","appName","appVersion","isString","TypeError","trim","InvalidArgumentError","userAgent","calculatePartSize","size","isNumber","maxObjectSize","overRidePartSize","partSize","makeBucket","bucketName","region","makeOpts","cb","isValidBucketName","InvalidBucketNameError","isObject","isFunction","payload","DEFAULT_REGION","createBucketConfiguration","push","_attr","xmlns","LocationConstraint","payloadObject","CreateBucketConfiguration","Xml","method","headers","ObjectLocking","processWithRetry","err","code","makeRequest","listIncompleteUploads","bucket","prefix","recursive","undefined","isValidPrefix","InvalidPrefixError","isBoolean","delimiter","keyMarker","uploadIdMarker","uploads","ended","readStream","Readable","objectMode","_read","length","shift","listIncompleteUploadsQuery","on","e","emit","result","prefixes","async","eachSeries","upload","listParts","uploadId","then","parts","reduce","acc","item","isTruncated","nextKeyMarker","nextUploadIdMarker","bucketExists","removeIncompleteUpload","objectName","IsValidBucketNameError","isValidObjectName","InvalidObjectNameError","removeUploadId","during","findUploadId","query","fGetObject","filePath","getOpts","partFile","partFileStream","objStat","rename","waterfall","statObject","mkdir","dirname","etag","stat","stats","offset","createWriteStream","flags","getPartialObject","downloadStream","pipesetup","Error","getObject","range","expectedStatusCodes","stringify","fPutObject","metaData","callback","insertContentType","lstat","putObject","createReadStream","stream","prependXAMZMeta","Buffer","readableStream","isReadableStream","chunker","BlockStream2","zeroPadding","uploader","ObjectUploader","copyObjectV1","arg1","arg2","arg3","arg4","arg5","srcObject","conditions","uriResourceEscape","modified","unmodified","matchETag","matchEtagExcept","matchETagExcept","response","transformer","getCopyObjectTransformer","data","copyObjectV2","sourceConfig","destConfig","CopySourceOptions","CopyDestinationOptions","validate","assign","getHeaders","Bucket","resHeaders","copyObjResponse","Key","LastModified","MetaData","extractMetadata","VersionId","getVersionId","SourceVersionId","getSourceVersionId","Etag","sanitizeETag","Size","copyObject","allArgs","arguments","listObjectsQuery","marker","listQueryOpts","Delimiter","MaxKeys","IncludeVersion","queries","uriEscape","sort","join","getListObjectsTransformer","listObjects","listOpts","objects","nextMarker","versionIdMarker","listObjectsV2Query","continuationToken","maxKeys","startAfter","getListObjectsV2Transformer","listObjectsV2","nextContinuationToken","removeObjects","objectsList","Array","isArray","maxEntries","entry","list","listOfList","encoder","TextEncoder","batchResults","batchCb","value","name","versionId","deleteObjects","Delete","Quiet","builder","xml2js","Builder","headless","buildObject","from","encode","toMd5","removeObjectsResult","removeObjectsTransformer","_","flatten","getBucketPolicy","policy","getConcater","toString","setBucketPolicy","InvalidBucketPolicyError","presignedUrl","expires","reqParams","requestDate","anonymous","AnonymousRequestError","Date","isValidDate","getBucketRegion","url","reqOptions","getRequestOptions","checkAndRefreshCreds","presignSignatureV4","accessKey","secretKey","sessionToken","pe","presignedGetObject","respHeaders","validRespHeaders","header","presignedPutObject","newPostPolicy","presignedPostPolicy","postPolicy","formData","date","dateStr","makeDateLong","expiration","setSeconds","setExpires","getScope","policyBase64","JSON","signature","postPresignSignatureV4","opts","portStr","port","urlStr","protocol","host","postURL","completeMultipartUpload","etags","element","Part","PartNumber","part","ETag","CompleteMultipartUpload","getCompleteMultipartTransformer","errCode","S3Error","errMessage","completeMultipartResult","maxUploads","unshift","getListMultipartTransformer","latestUpload","listNext","initiated","getTime","setBucketNotification","config","rootName","renderOpts","pretty","removeAllBucketNotification","NotificationConfig","getBucketNotification","getBucketNotificationTransformer","bucketNotification","listenBucketNotification","suffix","events","listener","NotificationPoller","start","getBucketVersioning","versionConfig","bucketVersioningTransformer","setBucketVersioning","setTagging","taggingParams","tags","putOpts","tagsList","entries","Value","taggingConfig","Tagging","TagSet","Tag","requestOptions","setBucketTagging","setObjectTagging","removeTagging","removeOpts","removeBucketTagging","removeObjectTagging","getBucketTagging","getTagsTransformer","getObjectTagging","applyBucketLifecycle","policyConfig","removeBucketLifecycle","setBucketLifecycle","lifeCycleConfig","isEmpty","getBucketLifecycle","lifecycleTransformer","lifecycleConfig","setObjectLockConfig","lockConfigOpts","retentionModes","RETENTION_MODES","COMPLIANCE","GOVERNANCE","validUnits","RETENTION_VALIDITY_UNITS","DAYS","YEARS","mode","includes","unit","validity","ObjectLockEnabled","configKeys","difference","Rule","DefaultRetention","Mode","Days","Years","getObjectLockConfig","objectLockConfig","objectLockTransformer","putObjectRetention","retentionOpts","governanceBypass","retainUntilDate","params","RetainUntilDate","getObjectRetention","retentionConfig","objectRetentionTransformer","setBucketEncryption","encryptionConfig","encryptionObj","ApplyServerSideEncryptionByDefault","SSEAlgorithm","getBucketEncryption","bucketEncConfig","bucketEncryptionTransformer","removeBucketEncryption","getObjectLegalHold","legalHoldConfig","objectLegalHoldTransformer","setObjectLegalHold","setOpts","defaultOpts","status","LEGAL_HOLD_STATUS","ENABLED","DISABLED","Status","uploadPartCopy","partConfig","uploadID","partNumber","partCopyResult","uploadPartTransformer","uploadPartCopyRes","composeObject","destObjConfig","sourceObjList","me","sourceFilesLength","PART_CONSTRAINTS","MAX_PARTS_COUNT","i","getStatOptions","srcConfig","statOpts","VersionID","srcObjectSizes","totalSize","totalParts","sourceObjStats","map","srcItem","Promise","all","srcObjectInfos","validatedStats","resItemStat","index","srcCopySize","MatchRange","srcStart","Start","srcEnd","End","ABS_MIN_PART_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","partsRequired","MAX_PART_SIZE","MatchETag","splitPartSizeList","idx","calSize","calculateEvenSplits","getUploadPartConfigList","uploadPartConfigList","splitSize","splitIndex","startIndex","startIdx","endIndex","endIdx","objInfo","objConfig","partIndex","totalUploads","splitStart","upldCtrIdx","splitEnd","sourceObj","uploadPartConfig","performUploadParts","uploadList","bind","res","abortMultipartUpload","partsDone","partCopy","newUploadHeaders","initiateNewMultipartUpload","catch","error","selectObjectContent","selectOpts","expression","inputSerialization","outputSerialization","Expression","ExpressionType","expressionType","InputSerialization","OutputSerialization","requestProgress","RequestProgress","scanRange","ScanRange","selectResult","selectObjectContentTransformer","parseSelectObjectContentResponse","promisify","removeObject","callbackify","removeBucket","listBuckets","removeBucketReplication","setBucketReplication","getBucketReplication"],"sources":["minio.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport * as Stream from 'node:stream'\n\nimport async from 'async'\nimport BlockStream2 from 'block-stream2'\nimport _ from 'lodash'\nimport * as querystring from 'query-string'\nimport { TextEncoder } from 'web-encoding'\nimport Xml from 'xml'\nimport xml2js from 'xml2js'\n\nimport * as errors from './errors.ts'\nimport { CopyDestinationOptions, CopySourceOptions, DEFAULT_REGION } from './helpers.ts'\nimport { callbackify } from './internal/callbackify.js'\nimport { TypedClient } from './internal/client.ts'\nimport { CopyConditions } from './internal/copy-conditions.ts'\nimport {\n  calculateEvenSplits,\n  extractMetadata,\n  getScope,\n  getSourceVersionId,\n  getVersionId,\n  insertContentType,\n  isBoolean,\n  isFunction,\n  isNumber,\n  isObject,\n  isReadableStream,\n  isString,\n  isValidBucketName,\n  isValidDate,\n  isValidObjectName,\n  isValidPrefix,\n  makeDateLong,\n  PART_CONSTRAINTS,\n  partsRequired,\n  pipesetup,\n  prependXAMZMeta,\n  readableStream,\n  sanitizeETag,\n  toMd5,\n  uriEscape,\n  uriResourceEscape,\n} from './internal/helper.ts'\nimport { PostPolicy } from './internal/post-policy.ts'\nimport { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './internal/type.ts'\nimport { NotificationConfig, NotificationPoller } from './notification.js'\nimport { ObjectUploader } from './object-uploader.js'\nimport { promisify } from './promisify.js'\nimport { postPresignSignatureV4, presignSignatureV4 } from './signing.ts'\nimport * as transformers from './transformers.js'\nimport { parseSelectObjectContentResponse } from './xml-parsers.js'\n\nexport * from './helpers.ts'\nexport * from './notification.js'\nexport { CopyConditions, PostPolicy }\n\nexport class Client extends TypedClient {\n  // Set application specific information.\n  //\n  // Generates User-Agent in the following style.\n  //\n  //       MinIO (OS; ARCH) LIB/VER APP/VER\n  //\n  // __Arguments__\n  // * `appName` _string_ - Application name.\n  // * `appVersion` _string_ - Application version.\n  setAppInfo(appName, appVersion) {\n    if (!isString(appName)) {\n      throw new TypeError(`Invalid appName: ${appName}`)\n    }\n    if (appName.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appName cannot be empty.')\n    }\n    if (!isString(appVersion)) {\n      throw new TypeError(`Invalid appVersion: ${appVersion}`)\n    }\n    if (appVersion.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appVersion cannot be empty.')\n    }\n    this.userAgent = `${this.userAgent} ${appName}/${appVersion}`\n  }\n\n  // Calculate part size given the object size. Part size will be atleast this.partSize\n  calculatePartSize(size) {\n    if (!isNumber(size)) {\n      throw new TypeError('size should be of type \"number\"')\n    }\n    if (size > this.maxObjectSize) {\n      throw new TypeError(`size should not be more than ${this.maxObjectSize}`)\n    }\n    if (this.overRidePartSize) {\n      return this.partSize\n    }\n    var partSize = this.partSize\n    for (;;) {\n      // while(true) {...} throws linting error.\n      // If partSize is big enough to accomodate the object size, then use it.\n      if (partSize * 10000 > size) {\n        return partSize\n      }\n      // Try part sizes as 64MB, 80MB, 96MB etc.\n      partSize += 16 * 1024 * 1024\n    }\n  }\n\n  // Creates the bucket `bucketName`.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ - Name of the bucket\n  // * `region` _string_ - region valid values are _us-west-1_, _us-west-2_,  _eu-west-1_, _eu-central-1_, _ap-southeast-1_, _ap-northeast-1_, _ap-southeast-2_, _sa-east-1_.\n  // * `makeOpts` _object_ - Options to create a bucket. e.g {ObjectLocking:true} (Optional)\n  // * `callback(err)` _function_ - callback function with `err` as the error argument. `err` is null if the bucket is successfully created.\n  makeBucket(bucketName, region, makeOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    // Backward Compatibility\n    if (isObject(region)) {\n      cb = makeOpts\n      makeOpts = region\n      region = ''\n    }\n    if (isFunction(region)) {\n      cb = region\n      region = ''\n      makeOpts = {}\n    }\n    if (isFunction(makeOpts)) {\n      cb = makeOpts\n      makeOpts = {}\n    }\n\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!isObject(makeOpts)) {\n      throw new TypeError('makeOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var payload = ''\n\n    // Region already set in constructor, validate if\n    // caller requested bucket location is same.\n    if (region && this.region) {\n      if (region !== this.region) {\n        throw new errors.InvalidArgumentError(`Configured region ${this.region}, requested ${region}`)\n      }\n    }\n    // sending makeBucket request with XML containing 'us-east-1' fails. For\n    // default region server expects the request without body\n    if (region && region !== DEFAULT_REGION) {\n      var createBucketConfiguration = []\n      createBucketConfiguration.push({\n        _attr: {\n          xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/',\n        },\n      })\n      createBucketConfiguration.push({\n        LocationConstraint: region,\n      })\n      var payloadObject = {\n        CreateBucketConfiguration: createBucketConfiguration,\n      }\n      payload = Xml(payloadObject)\n    }\n    var method = 'PUT'\n    var headers = {}\n\n    if (makeOpts.ObjectLocking) {\n      headers['x-amz-bucket-object-lock-enabled'] = true\n    }\n\n    if (!region) {\n      region = DEFAULT_REGION\n    }\n\n    const processWithRetry = (err) => {\n      if (err && (region === '' || region === DEFAULT_REGION)) {\n        if (err.code === 'AuthorizationHeaderMalformed' && err.region !== '') {\n          // Retry with region returned as part of error\n          this.makeRequest({ method, bucketName, headers }, payload, [200], err.region, false, cb)\n        } else {\n          return cb && cb(err)\n        }\n      }\n      return cb && cb(err)\n    }\n    this.makeRequest({ method, bucketName, headers }, payload, [200], region, false, processWithRetry)\n  }\n\n  // Returns a stream that emits objects that are partially uploaded.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: prefix of the object names that are partially uploaded (optional, default `''`)\n  // * `recursive` _bool_: directory style listing when false, recursive listing when true (optional, default `false`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_ : emits objects of the format:\n  //   * `object.key` _string_: name of the object\n  //   * `object.uploadId` _string_: upload ID of the object\n  //   * `object.size` _Integer_: size of the partially uploaded object\n  listIncompleteUploads(bucket, prefix, recursive) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucket)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    var delimiter = recursive ? '' : '/'\n    var keyMarker = ''\n    var uploadIdMarker = ''\n    var uploads = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one upload info per _read()\n      if (uploads.length) {\n        return readStream.push(uploads.shift())\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      this.listIncompleteUploadsQuery(bucket, prefix, keyMarker, uploadIdMarker, delimiter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          result.prefixes.forEach((prefix) => uploads.push(prefix))\n          async.eachSeries(\n            result.uploads,\n            (upload, cb) => {\n              // for each incomplete upload add the sizes of its uploaded parts\n              this.listParts(bucket, upload.key, upload.uploadId).then((parts) => {\n                upload.size = parts.reduce((acc, item) => acc + item.size, 0)\n                uploads.push(upload)\n                cb()\n              }, cb)\n            },\n            (err) => {\n              if (err) {\n                readStream.emit('error', err)\n                return\n              }\n              if (result.isTruncated) {\n                keyMarker = result.nextKeyMarker\n                uploadIdMarker = result.nextUploadIdMarker\n              } else {\n                ended = true\n              }\n              readStream._read()\n            },\n          )\n        })\n    }\n    return readStream\n  }\n\n  // To check if a bucket already exists.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ : name of the bucket\n  // * `callback(err)` _function_ : `err` is `null` if the bucket exists\n  bucketExists(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'HEAD'\n    this.makeRequest({ method, bucketName }, '', [200], '', false, (err) => {\n      if (err) {\n        if (err.code == 'NoSuchBucket' || err.code == 'NotFound') {\n          return cb(null, false)\n        }\n        return cb(err)\n      }\n      cb(null, true)\n    })\n  }\n\n  // Remove the partially uploaded object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `callback(err)` _function_: callback function is called with non `null` value in case of error\n  removeIncompleteUpload(bucketName, objectName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.IsValidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var removeUploadId\n    async.during(\n      (cb) => {\n        this.findUploadId(bucketName, objectName, (e, uploadId) => {\n          if (e) {\n            return cb(e)\n          }\n          removeUploadId = uploadId\n          cb(null, uploadId)\n        })\n      },\n      (cb) => {\n        var method = 'DELETE'\n        var query = `uploadId=${removeUploadId}`\n        this.makeRequest({ method, bucketName, objectName, query }, '', [204], '', false, (e) => cb(e))\n      },\n      cb,\n    )\n  }\n\n  // Callback is called with `error` in case of error or `null` in case of success\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `filePath` _string_: path to which the object data will be written to\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err)` _function_: callback is called with `err` in case of error.\n  fGetObject(bucketName, objectName, filePath, getOpts = {}, cb) {\n    // Input validation.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    // Internal data.\n    var partFile\n    var partFileStream\n    var objStat\n\n    // Rename wrapper.\n    var rename = (err) => {\n      if (err) {\n        return cb(err)\n      }\n      fs.rename(partFile, filePath, cb)\n    }\n\n    async.waterfall(\n      [\n        (cb) => this.statObject(bucketName, objectName, getOpts, cb),\n        (result, cb) => {\n          objStat = result\n          // Create any missing top level directories.\n          fs.mkdir(path.dirname(filePath), { recursive: true }, (err) => cb(err))\n        },\n        (cb) => {\n          partFile = `${filePath}.${objStat.etag}.part.minio`\n          fs.stat(partFile, (e, stats) => {\n            var offset = 0\n            if (e) {\n              partFileStream = fs.createWriteStream(partFile, { flags: 'w' })\n            } else {\n              if (objStat.size === stats.size) {\n                return rename()\n              }\n              offset = stats.size\n              partFileStream = fs.createWriteStream(partFile, { flags: 'a' })\n            }\n            this.getPartialObject(bucketName, objectName, offset, 0, getOpts, cb)\n          })\n        },\n        (downloadStream, cb) => {\n          pipesetup(downloadStream, partFileStream)\n            .on('error', (e) => cb(e))\n            .on('finish', cb)\n        },\n        (cb) => fs.stat(partFile, cb),\n        (stats, cb) => {\n          if (stats.size === objStat.size) {\n            return cb()\n          }\n          cb(new Error('Size mismatch between downloaded file and the object'))\n        },\n      ],\n      rename,\n    )\n  }\n\n  // Callback is called with readable stream of the object content.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err, stream)` _function_: callback is called with `err` in case of error. `stream` is the object content stream\n  getObject(bucketName, objectName, getOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    this.getPartialObject(bucketName, objectName, 0, 0, getOpts, cb)\n  }\n\n  // Callback is called with readable stream of the partial object content.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `offset` _number_: offset of the object from where the stream will start\n  // * `length` _number_: length of the object that will be read in the stream (optional, if not specified we read the rest of the file from the offset)\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err, stream)` _function_: callback is called with `err` in case of error. `stream` is the object content stream\n  getPartialObject(bucketName, objectName, offset, length, getOpts = {}, cb) {\n    if (isFunction(length)) {\n      cb = length\n      length = 0\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isNumber(offset)) {\n      throw new TypeError('offset should be of type \"number\"')\n    }\n    if (!isNumber(length)) {\n      throw new TypeError('length should be of type \"number\"')\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var range = ''\n    if (offset || length) {\n      if (offset) {\n        range = `bytes=${+offset}-`\n      } else {\n        range = 'bytes=0-'\n        offset = 0\n      }\n      if (length) {\n        range += `${+length + offset - 1}`\n      }\n    }\n\n    var headers = {}\n    if (range !== '') {\n      headers.range = range\n    }\n\n    var expectedStatusCodes = [200]\n    if (range) {\n      expectedStatusCodes.push(206)\n    }\n    var method = 'GET'\n\n    var query = querystring.stringify(getOpts)\n    this.makeRequest({ method, bucketName, objectName, headers, query }, '', expectedStatusCodes, '', true, cb)\n  }\n\n  // Uploads the object using contents from a file\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `filePath` _string_: file path of the file to be uploaded\n  // * `metaData` _Javascript Object_: metaData assosciated with the object\n  // * `callback(err, objInfo)` _function_: non null `err` indicates error, `objInfo` _object_ which contains versionId and etag.\n  fPutObject(bucketName, objectName, filePath, metaData, callback) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    if (isFunction(metaData)) {\n      callback = metaData\n      metaData = {} // Set metaData empty if no metaData provided.\n    }\n    if (!isObject(metaData)) {\n      throw new TypeError('metaData should be of type \"object\"')\n    }\n\n    // Inserts correct `content-type` attribute based on metaData and filePath\n    metaData = insertContentType(metaData, filePath)\n\n    fs.lstat(filePath, (err, stat) => {\n      if (err) {\n        return callback(err)\n      }\n      return this.putObject(bucketName, objectName, fs.createReadStream(filePath), stat.size, metaData, callback)\n    })\n  }\n\n  // Uploads the object.\n  //\n  // Uploading a stream\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `stream` _Stream_: Readable stream\n  // * `size` _number_: size of the object (optional)\n  // * `callback(err, etag)` _function_: non null `err` indicates error, `etag` _string_ is the etag of the object uploaded.\n  //\n  // Uploading \"Buffer\" or \"string\"\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `string or Buffer` _string_ or _Buffer_: string or buffer\n  // * `callback(err, objInfo)` _function_: `err` is `null` in case of success and `info` will have the following object details:\n  //   * `etag` _string_: etag of the object\n  //   * `versionId` _string_: versionId of the object\n  putObject(bucketName, objectName, stream, size, metaData, callback) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    // We'll need to shift arguments to the left because of size and metaData.\n    if (isFunction(size)) {\n      callback = size\n      metaData = {}\n    } else if (isFunction(metaData)) {\n      callback = metaData\n      metaData = {}\n    }\n\n    // We'll need to shift arguments to the left because of metaData\n    // and size being optional.\n    if (isObject(size)) {\n      metaData = size\n    }\n\n    // Ensures Metadata has appropriate prefix for A3 API\n    metaData = prependXAMZMeta(metaData)\n    if (typeof stream === 'string' || stream instanceof Buffer) {\n      // Adapts the non-stream interface into a stream.\n      size = stream.length\n      stream = readableStream(stream)\n    } else if (!isReadableStream(stream)) {\n      throw new TypeError('third argument should be of type \"stream.Readable\" or \"Buffer\" or \"string\"')\n    }\n\n    if (!isFunction(callback)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    if (isNumber(size) && size < 0) {\n      throw new errors.InvalidArgumentError(`size cannot be negative, given size: ${size}`)\n    }\n\n    // Get the part size and forward that to the BlockStream. Default to the\n    // largest block size possible if necessary.\n    if (!isNumber(size)) {\n      size = this.maxObjectSize\n    }\n\n    size = this.calculatePartSize(size)\n\n    // s3 requires that all non-end chunks be at least `this.partSize`,\n    // so we chunk the stream until we hit either that size or the end before\n    // we flush it to s3.\n    let chunker = new BlockStream2({ size, zeroPadding: false })\n\n    // This is a Writable stream that can be written to in order to upload\n    // to the specified bucket and object automatically.\n    let uploader = new ObjectUploader(this, bucketName, objectName, size, metaData, callback)\n    // stream => chunker => uploader\n    pipesetup(stream, chunker, uploader)\n  }\n\n  // Copy the object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `srcObject` _string_: path of the source object to be copied\n  // * `conditions` _CopyConditions_: copy conditions that needs to be satisfied (optional, default `null`)\n  // * `callback(err, {etag, lastModified})` _function_: non null `err` indicates error, `etag` _string_ and `listModifed` _Date_ are respectively the etag and the last modified date of the newly copied object\n  copyObjectV1(arg1, arg2, arg3, arg4, arg5) {\n    var bucketName = arg1\n    var objectName = arg2\n    var srcObject = arg3\n    var conditions, cb\n    if (typeof arg4 == 'function' && arg5 === undefined) {\n      conditions = null\n      cb = arg4\n    } else {\n      conditions = arg4\n      cb = arg5\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(srcObject)) {\n      throw new TypeError('srcObject should be of type \"string\"')\n    }\n    if (srcObject === '') {\n      throw new errors.InvalidPrefixError(`Empty source prefix`)\n    }\n\n    if (conditions !== null && !(conditions instanceof CopyConditions)) {\n      throw new TypeError('conditions should be of type \"CopyConditions\"')\n    }\n\n    var headers = {}\n    headers['x-amz-copy-source'] = uriResourceEscape(srcObject)\n\n    if (conditions !== null) {\n      if (conditions.modified !== '') {\n        headers['x-amz-copy-source-if-modified-since'] = conditions.modified\n      }\n      if (conditions.unmodified !== '') {\n        headers['x-amz-copy-source-if-unmodified-since'] = conditions.unmodified\n      }\n      if (conditions.matchETag !== '') {\n        headers['x-amz-copy-source-if-match'] = conditions.matchETag\n      }\n      if (conditions.matchEtagExcept !== '') {\n        headers['x-amz-copy-source-if-none-match'] = conditions.matchETagExcept\n      }\n    }\n\n    var method = 'PUT'\n    this.makeRequest({ method, bucketName, objectName, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getCopyObjectTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => cb(null, data))\n    })\n  }\n\n  /**\n   * Internal Method to perform copy of an object.\n   * @param sourceConfig __object__   instance of CopySourceOptions @link ./helpers/CopySourceOptions\n   * @param destConfig  __object__   instance of CopyDestinationOptions @link ./helpers/CopyDestinationOptions\n   * @param cb __function__ called with null if there is an error\n   * @returns Promise if no callack is passed.\n   */\n  copyObjectV2(sourceConfig, destConfig, cb) {\n    if (!(sourceConfig instanceof CopySourceOptions)) {\n      throw new errors.InvalidArgumentError('sourceConfig should of type CopySourceOptions ')\n    }\n    if (!(destConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n    if (!destConfig.validate()) {\n      return false\n    }\n    if (!destConfig.validate()) {\n      return false\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const headers = Object.assign({}, sourceConfig.getHeaders(), destConfig.getHeaders())\n\n    const bucketName = destConfig.Bucket\n    const objectName = destConfig.Object\n\n    const method = 'PUT'\n    this.makeRequest({ method, bucketName, objectName, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      const transformer = transformers.getCopyObjectTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => {\n          const resHeaders = response.headers\n\n          const copyObjResponse = {\n            Bucket: destConfig.Bucket,\n            Key: destConfig.Object,\n            LastModified: data.LastModified,\n            MetaData: extractMetadata(resHeaders),\n            VersionId: getVersionId(resHeaders),\n            SourceVersionId: getSourceVersionId(resHeaders),\n            Etag: sanitizeETag(resHeaders.etag),\n            Size: +resHeaders['content-length'],\n          }\n\n          return cb(null, copyObjResponse)\n        })\n    })\n  }\n\n  // Backward compatibility for Copy Object API.\n  copyObject(...allArgs) {\n    if (allArgs[0] instanceof CopySourceOptions && allArgs[1] instanceof CopyDestinationOptions) {\n      return this.copyObjectV2(...arguments)\n    }\n    return this.copyObjectV1(...arguments)\n  }\n\n  // list a batch of objects\n  listObjectsQuery(bucketName, prefix, marker, listQueryOpts = {}) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(marker)) {\n      throw new TypeError('marker should be of type \"string\"')\n    }\n    let { Delimiter, MaxKeys, IncludeVersion } = listQueryOpts\n\n    if (!isObject(listQueryOpts)) {\n      throw new TypeError('listQueryOpts should be of type \"object\"')\n    }\n\n    if (!isString(Delimiter)) {\n      throw new TypeError('Delimiter should be of type \"string\"')\n    }\n    if (!isNumber(MaxKeys)) {\n      throw new TypeError('MaxKeys should be of type \"number\"')\n    }\n\n    const queries = []\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(Delimiter)}`)\n    queries.push(`encoding-type=url`)\n\n    if (IncludeVersion) {\n      queries.push(`versions`)\n    }\n\n    if (marker) {\n      marker = uriEscape(marker)\n      if (IncludeVersion) {\n        queries.push(`key-marker=${marker}`)\n      } else {\n        queries.push(`marker=${marker}`)\n      }\n    }\n\n    // no need to escape maxKeys\n    if (MaxKeys) {\n      if (MaxKeys >= 1000) {\n        MaxKeys = 1000\n      }\n      queries.push(`max-keys=${MaxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n\n    var method = 'GET'\n    var transformer = transformers.getListObjectsTransformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // List the objects in the bucket.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `listOpts _object_: query params to list object with below keys\n  // *    listOpts.MaxKeys _int_ maximum number of keys to return\n  // *    listOpts.IncludeVersion  _bool_ true|false to include versions.\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  // * `obj.name` _string_: name of the object\n  // * `obj.prefix` _string_: name of the object prefix\n  // * `obj.size` _number_: size of the object\n  // * `obj.etag` _string_: etag of the object\n  // * `obj.lastModified` _Date_: modified time stamp\n  // * `obj.isDeleteMarker` _boolean_: true if it is a delete marker\n  // * `obj.versionId` _string_: versionId of the object\n  listObjects(bucketName, prefix, recursive, listOpts = {}) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isObject(listOpts)) {\n      throw new TypeError('listOpts should be of type \"object\"')\n    }\n    var marker = ''\n    const listQueryOpts = {\n      Delimiter: recursive ? '' : '/', // if recursive is false set delimiter to '/'\n      MaxKeys: 1000,\n      IncludeVersion: listOpts.IncludeVersion,\n    }\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsQuery(bucketName, prefix, marker, listQueryOpts)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            marker = result.nextMarker || result.versionIdMarker\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // listObjectsV2Query - (List Objects V2) - List some or all (up to 1000) of the objects in a bucket.\n  //\n  // You can use the request parameters as selection criteria to return a subset of the objects in a bucket.\n  // request parameters :-\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: Limits the response to keys that begin with the specified prefix.\n  // * `continuation-token` _string_: Used to continue iterating over a set of objects.\n  // * `delimiter` _string_: A delimiter is a character you use to group keys.\n  // * `max-keys` _number_: Sets the maximum number of keys returned in the response body.\n  // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket.\n  listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(continuationToken)) {\n      throw new TypeError('continuationToken should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    if (!isNumber(maxKeys)) {\n      throw new TypeError('maxKeys should be of type \"number\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    var queries = []\n\n    // Call for listing objects v2 API\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (continuationToken) {\n      continuationToken = uriEscape(continuationToken)\n      queries.push(`continuation-token=${continuationToken}`)\n    }\n    // Set start-after\n    if (startAfter) {\n      startAfter = uriEscape(startAfter)\n      queries.push(`start-after=${startAfter}`)\n    }\n    // no need to escape maxKeys\n    if (maxKeys) {\n      if (maxKeys >= 1000) {\n        maxKeys = 1000\n      }\n      queries.push(`max-keys=${maxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListObjectsV2Transformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // List the objects in the bucket using S3 ListObjects V2\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  //   * `obj.name` _string_: name of the object\n  //   * `obj.prefix` _string_: name of the object prefix\n  //   * `obj.size` _number_: size of the object\n  //   * `obj.etag` _string_: etag of the object\n  //   * `obj.lastModified` _Date_: modified time stamp\n  listObjectsV2(bucketName, prefix, recursive, startAfter) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    // if recursive is false set delimiter to '/'\n    var delimiter = recursive ? '' : '/'\n    var continuationToken = ''\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, 1000, startAfter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            continuationToken = result.nextContinuationToken\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // Remove all the objects residing in the objectsList.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectsList` _array_: array of objects of one of the following:\n  // *         List of Object names as array of strings which are object keys:  ['objectname1','objectname2']\n  // *         List of Object name and versionId as an object:  [{name:\"objectname\",versionId:\"my-version-id\"}]\n\n  removeObjects(bucketName, objectsList, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Array.isArray(objectsList)) {\n      throw new errors.InvalidArgumentError('objectsList should be a list')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const maxEntries = 1000\n    const query = 'delete'\n    const method = 'POST'\n\n    let result = objectsList.reduce(\n      (result, entry) => {\n        result.list.push(entry)\n        if (result.list.length === maxEntries) {\n          result.listOfList.push(result.list)\n          result.list = []\n        }\n        return result\n      },\n      { listOfList: [], list: [] },\n    )\n\n    if (result.list.length > 0) {\n      result.listOfList.push(result.list)\n    }\n\n    const encoder = new TextEncoder()\n    const batchResults = []\n\n    async.eachSeries(\n      result.listOfList,\n      (list, batchCb) => {\n        var objects = []\n        list.forEach(function (value) {\n          if (isObject(value)) {\n            objects.push({ Key: value.name, VersionId: value.versionId })\n          } else {\n            objects.push({ Key: value })\n          }\n        })\n        let deleteObjects = { Delete: { Quiet: true, Object: objects } }\n        const builder = new xml2js.Builder({ headless: true })\n        let payload = builder.buildObject(deleteObjects)\n        payload = Buffer.from(encoder.encode(payload))\n        const headers = {}\n\n        headers['Content-MD5'] = toMd5(payload)\n\n        let removeObjectsResult\n        this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', true, (e, response) => {\n          if (e) {\n            return batchCb(e)\n          }\n          pipesetup(response, transformers.removeObjectsTransformer())\n            .on('data', (data) => {\n              removeObjectsResult = data\n            })\n            .on('error', (e) => {\n              return batchCb(e, null)\n            })\n            .on('end', () => {\n              batchResults.push(removeObjectsResult)\n              return batchCb(null, removeObjectsResult)\n            })\n        })\n      },\n      () => {\n        cb(null, _.flatten(batchResults))\n      },\n    )\n  }\n\n  // Get the policy on a bucket or an object prefix.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `callback(err, policy)` _function_: callback function\n  getBucketPolicy(bucketName, cb) {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let method = 'GET'\n    let query = 'policy'\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let policy = Buffer.from('')\n      pipesetup(response, transformers.getConcater())\n        .on('data', (data) => (policy = data))\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, policy.toString())\n        })\n    })\n  }\n\n  // Set the policy on a bucket or an object prefix.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `bucketPolicy` _string_: bucket policy (JSON stringify'ed)\n  // * `callback(err)` _function_: callback function\n  setBucketPolicy(bucketName, policy, cb) {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(policy)) {\n      throw new errors.InvalidBucketPolicyError(`Invalid bucket policy: ${policy} - must be \"string\"`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let method = 'DELETE'\n    let query = 'policy'\n\n    if (policy) {\n      method = 'PUT'\n    }\n\n    this.makeRequest({ method, bucketName, query }, policy, [204], '', false, cb)\n  }\n\n  // Generate a generic presigned URL which can be\n  // used for HTTP methods GET, PUT, HEAD and DELETE\n  //\n  // __Arguments__\n  // * `method` _string_: name of the HTTP method\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  // * `reqParams` _object_: request parameters (optional) e.g {versionId:\"10fa9946-3f64-4137-a58f-888065c0732e\"}\n  // * `requestDate` _Date_: A date object, the url will be issued at (optional)\n  presignedUrl(method, bucketName, objectName, expires, reqParams, requestDate, cb) {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned ' + method + ' url cannot be generated for anonymous requests')\n    }\n    if (isFunction(requestDate)) {\n      cb = requestDate\n      requestDate = new Date()\n    }\n    if (isFunction(reqParams)) {\n      cb = reqParams\n      reqParams = {}\n      requestDate = new Date()\n    }\n    if (isFunction(expires)) {\n      cb = expires\n      reqParams = {}\n      expires = 24 * 60 * 60 * 7 // 7 days in seconds\n      requestDate = new Date()\n    }\n    if (!isNumber(expires)) {\n      throw new TypeError('expires should be of type \"number\"')\n    }\n    if (!isObject(reqParams)) {\n      throw new TypeError('reqParams should be of type \"object\"')\n    }\n    if (!isValidDate(requestDate)) {\n      throw new TypeError('requestDate should be of type \"Date\" and valid')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var query = querystring.stringify(reqParams)\n    this.getBucketRegion(bucketName, (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      // This statement is added to ensure that we send error through\n      // callback on presign failure.\n      var url\n      var reqOptions = this.getRequestOptions({ method, region, bucketName, objectName, query })\n\n      this.checkAndRefreshCreds()\n      try {\n        url = presignSignatureV4(\n          reqOptions,\n          this.accessKey,\n          this.secretKey,\n          this.sessionToken,\n          region,\n          requestDate,\n          expires,\n        )\n      } catch (pe) {\n        return cb(pe)\n      }\n      cb(null, url)\n    })\n  }\n\n  // Generate a presigned URL for GET\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  // * `respHeaders` _object_: response headers to override or request params for query (optional) e.g {versionId:\"10fa9946-3f64-4137-a58f-888065c0732e\"}\n  // * `requestDate` _Date_: A date object, the url will be issued at (optional)\n  presignedGetObject(bucketName, objectName, expires, respHeaders, requestDate, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (isFunction(respHeaders)) {\n      cb = respHeaders\n      respHeaders = {}\n      requestDate = new Date()\n    }\n\n    var validRespHeaders = [\n      'response-content-type',\n      'response-content-language',\n      'response-expires',\n      'response-cache-control',\n      'response-content-disposition',\n      'response-content-encoding',\n    ]\n    validRespHeaders.forEach((header) => {\n      if (respHeaders !== undefined && respHeaders[header] !== undefined && !isString(respHeaders[header])) {\n        throw new TypeError(`response header ${header} should be of type \"string\"`)\n      }\n    })\n    return this.presignedUrl('GET', bucketName, objectName, expires, respHeaders, requestDate, cb)\n  }\n\n  // Generate a presigned URL for PUT. Using this URL, the browser can upload to S3 only with the specified object name.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  presignedPutObject(bucketName, objectName, expires, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    return this.presignedUrl('PUT', bucketName, objectName, expires, cb)\n  }\n\n  // return PostPolicy object\n  newPostPolicy() {\n    return new PostPolicy()\n  }\n\n  // presignedPostPolicy can be used in situations where we want more control on the upload than what\n  // presignedPutObject() provides. i.e Using presignedPostPolicy we will be able to put policy restrictions\n  // on the object's `name` `bucket` `expiry` `Content-Type` `Content-Disposition` `metaData`\n  presignedPostPolicy(postPolicy, cb) {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned POST policy cannot be generated for anonymous requests')\n    }\n    if (!isObject(postPolicy)) {\n      throw new TypeError('postPolicy should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n    this.getBucketRegion(postPolicy.formData.bucket, (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      var date = new Date()\n      var dateStr = makeDateLong(date)\n\n      this.checkAndRefreshCreds()\n\n      if (!postPolicy.policy.expiration) {\n        // 'expiration' is mandatory field for S3.\n        // Set default expiration date of 7 days.\n        var expires = new Date()\n        expires.setSeconds(24 * 60 * 60 * 7)\n        postPolicy.setExpires(expires)\n      }\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-date', dateStr])\n      postPolicy.formData['x-amz-date'] = dateStr\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-algorithm', 'AWS4-HMAC-SHA256'])\n      postPolicy.formData['x-amz-algorithm'] = 'AWS4-HMAC-SHA256'\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-credential', this.accessKey + '/' + getScope(region, date)])\n      postPolicy.formData['x-amz-credential'] = this.accessKey + '/' + getScope(region, date)\n\n      if (this.sessionToken) {\n        postPolicy.policy.conditions.push(['eq', '$x-amz-security-token', this.sessionToken])\n        postPolicy.formData['x-amz-security-token'] = this.sessionToken\n      }\n\n      var policyBase64 = Buffer.from(JSON.stringify(postPolicy.policy)).toString('base64')\n\n      postPolicy.formData.policy = policyBase64\n\n      var signature = postPresignSignatureV4(region, date, this.secretKey, policyBase64)\n\n      postPolicy.formData['x-amz-signature'] = signature\n      var opts = {}\n      opts.region = region\n      opts.bucketName = postPolicy.formData.bucket\n      var reqOptions = this.getRequestOptions(opts)\n      var portStr = this.port == 80 || this.port === 443 ? '' : `:${this.port.toString()}`\n      var urlStr = `${reqOptions.protocol}//${reqOptions.host}${portStr}${reqOptions.path}`\n      cb(null, { postURL: urlStr, formData: postPolicy.formData })\n    })\n  }\n\n  // Complete the multipart upload. After all the parts are uploaded issuing\n  // this call will aggregate the parts on the server into a single object.\n  completeMultipartUpload(bucketName, objectName, uploadId, etags, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isObject(etags)) {\n      throw new TypeError('etags should be of type \"Array\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    var method = 'POST'\n    var query = `uploadId=${uriEscape(uploadId)}`\n\n    var parts = []\n\n    etags.forEach((element) => {\n      parts.push({\n        Part: [\n          {\n            PartNumber: element.part,\n          },\n          {\n            ETag: element.etag,\n          },\n        ],\n      })\n    })\n\n    var payloadObject = { CompleteMultipartUpload: parts }\n    var payload = Xml(payloadObject)\n\n    this.makeRequest({ method, bucketName, objectName, query }, payload, [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getCompleteMultipartTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (result) => {\n          if (result.errCode) {\n            // Multipart Complete API returns an error XML after a 200 http status\n            cb(new errors.S3Error(result.errMessage))\n          } else {\n            const completeMultipartResult = {\n              etag: result.etag,\n              versionId: getVersionId(response.headers),\n            }\n            cb(null, completeMultipartResult)\n          }\n        })\n    })\n  }\n\n  // Called by listIncompleteUploads to fetch a batch of incomplete uploads.\n  listIncompleteUploadsQuery(bucketName, prefix, keyMarker, uploadIdMarker, delimiter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(keyMarker)) {\n      throw new TypeError('keyMarker should be of type \"string\"')\n    }\n    if (!isString(uploadIdMarker)) {\n      throw new TypeError('uploadIdMarker should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    var queries = []\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (keyMarker) {\n      keyMarker = uriEscape(keyMarker)\n      queries.push(`key-marker=${keyMarker}`)\n    }\n    if (uploadIdMarker) {\n      queries.push(`upload-id-marker=${uploadIdMarker}`)\n    }\n\n    var maxUploads = 1000\n    queries.push(`max-uploads=${maxUploads}`)\n    queries.sort()\n    queries.unshift('uploads')\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListMultipartTransformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // Find uploadId of an incomplete upload.\n  findUploadId(bucketName, objectName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n    var latestUpload\n    var listNext = (keyMarker, uploadIdMarker) => {\n      this.listIncompleteUploadsQuery(bucketName, objectName, keyMarker, uploadIdMarker, '')\n        .on('error', (e) => cb(e))\n        .on('data', (result) => {\n          result.uploads.forEach((upload) => {\n            if (upload.key === objectName) {\n              if (!latestUpload || upload.initiated.getTime() > latestUpload.initiated.getTime()) {\n                latestUpload = upload\n                return\n              }\n            }\n          })\n          if (result.isTruncated) {\n            listNext(result.nextKeyMarker, result.nextUploadIdMarker)\n            return\n          }\n          if (latestUpload) {\n            return cb(null, latestUpload.uploadId)\n          }\n          cb(null, undefined)\n        })\n    }\n    listNext('', '')\n  }\n\n  // Remove all the notification configurations in the S3 provider\n  setBucketNotification(bucketName, config, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(config)) {\n      throw new TypeError('notification config should be of type \"Object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'PUT'\n    var query = 'notification'\n    var builder = new xml2js.Builder({\n      rootName: 'NotificationConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    var payload = builder.buildObject(config)\n    this.makeRequest({ method, bucketName, query }, payload, [200], '', false, cb)\n  }\n\n  removeAllBucketNotification(bucketName, cb) {\n    this.setBucketNotification(bucketName, new NotificationConfig(), cb)\n  }\n\n  // Return the list of notification configurations stored\n  // in the S3 provider\n  getBucketNotification(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    var query = 'notification'\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getBucketNotificationTransformer()\n      var bucketNotification\n      pipesetup(response, transformer)\n        .on('data', (result) => (bucketNotification = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, bucketNotification))\n    })\n  }\n\n  // Listens for bucket notifications. Returns an EventEmitter.\n  listenBucketNotification(bucketName, prefix, suffix, events) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix must be of type string')\n    }\n    if (!isString(suffix)) {\n      throw new TypeError('suffix must be of type string')\n    }\n    if (!Array.isArray(events)) {\n      throw new TypeError('events must be of type Array')\n    }\n    let listener = new NotificationPoller(this, bucketName, prefix, suffix, events)\n    listener.start()\n\n    return listener\n  }\n\n  getBucketVersioning(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    var query = 'versioning'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let versionConfig = Buffer.from('')\n      pipesetup(response, transformers.bucketVersioningTransformer())\n        .on('data', (data) => {\n          versionConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, versionConfig)\n        })\n    })\n  }\n\n  setBucketVersioning(bucketName, versionConfig, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Object.keys(versionConfig).length) {\n      throw new errors.InvalidArgumentError('versionConfig should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var method = 'PUT'\n    var query = 'versioning'\n    var builder = new xml2js.Builder({\n      rootName: 'VersioningConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    var payload = builder.buildObject(versionConfig)\n\n    this.makeRequest({ method, bucketName, query }, payload, [200], '', false, cb)\n  }\n\n  /** To set Tags on a bucket or object based on the params\n   *  __Arguments__\n   * taggingParams _object_ Which contains the following properties\n   *  bucketName _string_,\n   *  objectName _string_ (Optional),\n   *  tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   *  putOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   *  cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setTagging(taggingParams) {\n    const { bucketName, objectName, tags, putOpts = {}, cb } = taggingParams\n    const method = 'PUT'\n    let query = 'tagging'\n\n    if (putOpts && putOpts.versionId) {\n      query = `${query}&versionId=${putOpts.versionId}`\n    }\n    const tagsList = []\n    for (const [key, value] of Object.entries(tags)) {\n      tagsList.push({ Key: key, Value: value })\n    }\n    const taggingConfig = {\n      Tagging: {\n        TagSet: {\n          Tag: tagsList,\n        },\n      },\n    }\n    const encoder = new TextEncoder()\n    const headers = {}\n    const builder = new xml2js.Builder({ headless: true, renderOpts: { pretty: false } })\n    let payload = builder.buildObject(taggingConfig)\n    payload = Buffer.from(encoder.encode(payload))\n    headers['Content-MD5'] = toMd5(payload)\n    const requestOptions = { method, bucketName, query, headers }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest(requestOptions, payload, [200], '', false, cb)\n  }\n\n  /** Set Tags on a Bucket\n   * __Arguments__\n   * bucketName _string_\n   * tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setBucketTagging(bucketName, tags, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('maximum tags allowed is 10\"')\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    return this.setTagging({ bucketName, tags, cb })\n  }\n\n  /** Set Tags on an Object\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_\n   *  * tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   *  putOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setObjectTagging(bucketName, objectName, tags, putOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n\n    if (isFunction(putOpts)) {\n      cb = putOpts\n      putOpts = {}\n    }\n\n    if (!isObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('Maximum tags allowed is 10\"')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    return this.setTagging({ bucketName, objectName, tags, putOpts, cb })\n  }\n\n  /** Remove Tags on an Bucket/Object based on params\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_ (optional)\n   * removeOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeTagging({ bucketName, objectName, removeOpts, cb }) {\n    const method = 'DELETE'\n    let query = 'tagging'\n\n    if (removeOpts && Object.keys(removeOpts).length && removeOpts.versionId) {\n      query = `${query}&versionId=${removeOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, objectName, query }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    this.makeRequest(requestOptions, '', [200, 204], '', true, cb)\n  }\n\n  /** Remove Tags associated with a bucket\n   *  __Arguments__\n   * bucketName _string_\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeBucketTagging(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    return this.removeTagging({ bucketName, cb })\n  }\n\n  /** Remove tags associated with an object\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_\n   * removeOpts _object_ (Optional) e.g. {VersionID:\"my-object-version-id\"}\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeObjectTagging(bucketName, objectName, removeOpts, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (isFunction(removeOpts)) {\n      cb = removeOpts\n      removeOpts = {}\n    }\n    if (removeOpts && Object.keys(removeOpts).length && !isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    return this.removeTagging({ bucketName, objectName, removeOpts, cb })\n  }\n\n  /** Get Tags associated with a Bucket\n   *  __Arguments__\n   * bucketName _string_\n   * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  getBucketTagging(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n\n    const method = 'GET'\n    const query = 'tagging'\n    const requestOptions = { method, bucketName, query }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      var transformer = transformers.getTagsTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let tagsList\n      pipesetup(response, transformer)\n        .on('data', (result) => (tagsList = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, tagsList))\n    })\n  }\n\n  /** Get the tags associated with a bucket OR an object\n   * bucketName _string_\n   * objectName _string_ (Optional)\n   * getOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"}\n   * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  getObjectTagging(bucketName, objectName, getOpts = {}, cb = () => false) {\n    const method = 'GET'\n    let query = 'tagging'\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n    if (!isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('getOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    if (getOpts && getOpts.versionId) {\n      query = `${query}&versionId=${getOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, query }\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      const transformer = transformers.getTagsTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let tagsList\n      pipesetup(response, transformer)\n        .on('data', (result) => (tagsList = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, tagsList))\n    })\n  }\n\n  /**\n   * Apply lifecycle configuration on a bucket.\n   * bucketName _string_\n   * policyConfig _object_ a valid policy configuration object.\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  applyBucketLifecycle(bucketName, policyConfig, cb) {\n    const method = 'PUT'\n    const query = 'lifecycle'\n\n    const encoder = new TextEncoder()\n    const headers = {}\n    const builder = new xml2js.Builder({\n      rootName: 'LifecycleConfiguration',\n      headless: true,\n      renderOpts: { pretty: false },\n    })\n    let payload = builder.buildObject(policyConfig)\n    payload = Buffer.from(encoder.encode(payload))\n    const requestOptions = { method, bucketName, query, headers }\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest(requestOptions, payload, [200], '', false, cb)\n  }\n\n  /** Remove lifecycle configuration of a bucket.\n   * bucketName _string_\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeBucketLifecycle(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'lifecycle'\n    this.makeRequest({ method, bucketName, query }, '', [204], '', false, cb)\n  }\n\n  /** Set/Override lifecycle configuration on a bucket. if the configuration is empty, it removes the configuration.\n   * bucketName _string_\n   * lifeCycleConfig _object_ one of the following values: (null or '') to remove the lifecycle configuration. or a valid lifecycle configuration\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setBucketLifecycle(bucketName, lifeCycleConfig = null, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (_.isEmpty(lifeCycleConfig)) {\n      this.removeBucketLifecycle(bucketName, cb)\n    } else {\n      this.applyBucketLifecycle(bucketName, lifeCycleConfig, cb)\n    }\n  }\n\n  /** Get lifecycle configuration on a bucket.\n   * bucketName _string_\n   * `cb(config)` _function_ - callback function with lifecycle configuration as the error argument.\n   */\n  getBucketLifecycle(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'lifecycle'\n    const requestOptions = { method, bucketName, query }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      const transformer = transformers.lifecycleTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let lifecycleConfig\n      pipesetup(response, transformer)\n        .on('data', (result) => (lifecycleConfig = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, lifecycleConfig))\n    })\n  }\n\n  setObjectLockConfig(bucketName, lockConfigOpts = {}, cb) {\n    const retentionModes = [RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE]\n    const validUnits = [RETENTION_VALIDITY_UNITS.DAYS, RETENTION_VALIDITY_UNITS.YEARS]\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (lockConfigOpts.mode && !retentionModes.includes(lockConfigOpts.mode)) {\n      throw new TypeError(`lockConfigOpts.mode should be one of ${retentionModes}`)\n    }\n    if (lockConfigOpts.unit && !validUnits.includes(lockConfigOpts.unit)) {\n      throw new TypeError(`lockConfigOpts.unit should be one of ${validUnits}`)\n    }\n    if (lockConfigOpts.validity && !isNumber(lockConfigOpts.validity)) {\n      throw new TypeError(`lockConfigOpts.validity should be a number`)\n    }\n\n    const method = 'PUT'\n    const query = 'object-lock'\n\n    let config = {\n      ObjectLockEnabled: 'Enabled',\n    }\n    const configKeys = Object.keys(lockConfigOpts)\n    // Check if keys are present and all keys are present.\n    if (configKeys.length > 0) {\n      if (_.difference(configKeys, ['unit', 'mode', 'validity']).length !== 0) {\n        throw new TypeError(\n          `lockConfigOpts.mode,lockConfigOpts.unit,lockConfigOpts.validity all the properties should be specified.`,\n        )\n      } else {\n        config.Rule = {\n          DefaultRetention: {},\n        }\n        if (lockConfigOpts.mode) {\n          config.Rule.DefaultRetention.Mode = lockConfigOpts.mode\n        }\n        if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.DAYS) {\n          config.Rule.DefaultRetention.Days = lockConfigOpts.validity\n        } else if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.YEARS) {\n          config.Rule.DefaultRetention.Years = lockConfigOpts.validity\n        }\n      }\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'ObjectLockConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getObjectLockConfig(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'object-lock'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let objectLockConfig = Buffer.from('')\n      pipesetup(response, transformers.objectLockTransformer())\n        .on('data', (data) => {\n          objectLockConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, objectLockConfig)\n        })\n    })\n  }\n\n  putObjectRetention(bucketName, objectName, retentionOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(retentionOpts)) {\n      throw new errors.InvalidArgumentError('retentionOpts should be of type \"object\"')\n    } else {\n      if (retentionOpts.governanceBypass && !isBoolean(retentionOpts.governanceBypass)) {\n        throw new errors.InvalidArgumentError('Invalid value for governanceBypass', retentionOpts.governanceBypass)\n      }\n      if (\n        retentionOpts.mode &&\n        ![RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE].includes(retentionOpts.mode)\n      ) {\n        throw new errors.InvalidArgumentError('Invalid object retention mode ', retentionOpts.mode)\n      }\n      if (retentionOpts.retainUntilDate && !isString(retentionOpts.retainUntilDate)) {\n        throw new errors.InvalidArgumentError('Invalid value for retainUntilDate', retentionOpts.retainUntilDate)\n      }\n      if (retentionOpts.versionId && !isString(retentionOpts.versionId)) {\n        throw new errors.InvalidArgumentError('Invalid value for versionId', retentionOpts.versionId)\n      }\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'PUT'\n    let query = 'retention'\n\n    const headers = {}\n    if (retentionOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'Retention', renderOpts: { pretty: false }, headless: true })\n    const params = {}\n\n    if (retentionOpts.mode) {\n      params.Mode = retentionOpts.mode\n    }\n    if (retentionOpts.retainUntilDate) {\n      params.RetainUntilDate = retentionOpts.retainUntilDate\n    }\n    if (retentionOpts.versionId) {\n      query += `&versionId=${retentionOpts.versionId}`\n    }\n\n    let payload = builder.buildObject(params)\n\n    headers['Content-MD5'] = toMd5(payload)\n    this.makeRequest({ method, bucketName, objectName, query, headers }, payload, [200, 204], '', false, cb)\n  }\n\n  getObjectRetention(bucketName, objectName, getOpts, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"object\"')\n    } else if (getOpts.versionId && !isString(getOpts.versionId)) {\n      throw new errors.InvalidArgumentError('VersionID should be of type \"string\"')\n    }\n    if (cb && !isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    let query = 'retention'\n    if (getOpts.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let retentionConfig = Buffer.from('')\n      pipesetup(response, transformers.objectRetentionTransformer())\n        .on('data', (data) => {\n          retentionConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, retentionConfig)\n        })\n    })\n  }\n\n  setBucketEncryption(bucketName, encryptionConfig, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (isFunction(encryptionConfig)) {\n      cb = encryptionConfig\n      encryptionConfig = null\n    }\n\n    if (!_.isEmpty(encryptionConfig) && encryptionConfig.Rule.length > 1) {\n      throw new errors.InvalidArgumentError('Invalid Rule length. Only one rule is allowed.: ' + encryptionConfig.Rule)\n    }\n    if (cb && !isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let encryptionObj = encryptionConfig\n    if (_.isEmpty(encryptionConfig)) {\n      encryptionObj = {\n        // Default MinIO Server Supported Rule\n        Rule: [\n          {\n            ApplyServerSideEncryptionByDefault: {\n              SSEAlgorithm: 'AES256',\n            },\n          },\n        ],\n      }\n    }\n\n    let method = 'PUT'\n    let query = 'encryption'\n    let builder = new xml2js.Builder({\n      rootName: 'ServerSideEncryptionConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    let payload = builder.buildObject(encryptionObj)\n\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getBucketEncryption(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'encryption'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let bucketEncConfig = Buffer.from('')\n      pipesetup(response, transformers.bucketEncryptionTransformer())\n        .on('data', (data) => {\n          bucketEncConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, bucketEncConfig)\n        })\n    })\n  }\n  removeBucketEncryption(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'DELETE'\n    const query = 'encryption'\n\n    this.makeRequest({ method, bucketName, query }, '', [204], '', false, cb)\n  }\n\n  getObjectLegalHold(bucketName, objectName, getOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isObject(getOpts)) {\n      throw new TypeError('getOpts should be of type \"Object\"')\n    } else if (Object.keys(getOpts).length > 0 && getOpts.versionId && !isString(getOpts.versionId)) {\n      throw new TypeError('versionId should be of type string.:', getOpts.versionId)\n    }\n\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    const method = 'GET'\n    let query = 'legal-hold'\n\n    if (getOpts.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let legalHoldConfig = Buffer.from('')\n      pipesetup(response, transformers.objectLegalHoldTransformer())\n        .on('data', (data) => {\n          legalHoldConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, legalHoldConfig)\n        })\n    })\n  }\n\n  setObjectLegalHold(bucketName, objectName, setOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    const defaultOpts = {\n      status: LEGAL_HOLD_STATUS.ENABLED,\n    }\n    if (isFunction(setOpts)) {\n      cb = setOpts\n      setOpts = defaultOpts\n    }\n\n    if (!isObject(setOpts)) {\n      throw new TypeError('setOpts should be of type \"Object\"')\n    } else {\n      if (![LEGAL_HOLD_STATUS.ENABLED, LEGAL_HOLD_STATUS.DISABLED].includes(setOpts.status)) {\n        throw new TypeError('Invalid status: ' + setOpts.status)\n      }\n      if (setOpts.versionId && !setOpts.versionId.length) {\n        throw new TypeError('versionId should be of type string.:' + setOpts.versionId)\n      }\n    }\n\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    if (_.isEmpty(setOpts)) {\n      setOpts = {\n        defaultOpts,\n      }\n    }\n\n    const method = 'PUT'\n    let query = 'legal-hold'\n\n    if (setOpts.versionId) {\n      query += `&versionId=${setOpts.versionId}`\n    }\n\n    let config = {\n      Status: setOpts.status,\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'LegalHold', renderOpts: { pretty: false }, headless: true })\n    const payload = builder.buildObject(config)\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, objectName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  /**\n   * Internal method to upload a part during compose object.\n   * @param partConfig __object__ contains the following.\n   *    bucketName __string__\n   *    objectName __string__\n   *    uploadID __string__\n   *    partNumber __number__\n   *    headers __object__\n   * @param cb called with null incase of error.\n   */\n  uploadPartCopy(partConfig, cb) {\n    const { bucketName, objectName, uploadID, partNumber, headers } = partConfig\n\n    const method = 'PUT'\n    let query = `uploadId=${uploadID}&partNumber=${partNumber}`\n    const requestOptions = { method, bucketName, objectName: objectName, query, headers }\n    return this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      let partCopyResult = Buffer.from('')\n      if (e) {\n        return cb(e)\n      }\n      pipesetup(response, transformers.uploadPartTransformer())\n        .on('data', (data) => {\n          partCopyResult = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          let uploadPartCopyRes = {\n            etag: sanitizeETag(partCopyResult.ETag),\n            key: objectName,\n            part: partNumber,\n          }\n\n          cb(null, uploadPartCopyRes)\n        })\n    })\n  }\n\n  composeObject(destObjConfig = {}, sourceObjList = [], cb) {\n    const me = this // many async flows. so store the ref.\n    const sourceFilesLength = sourceObjList.length\n\n    if (!Array.isArray(sourceObjList)) {\n      throw new errors.InvalidArgumentError('sourceConfig should an array of CopySourceOptions ')\n    }\n    if (!(destObjConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n\n    if (sourceFilesLength < 1 || sourceFilesLength > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n      throw new errors.InvalidArgumentError(\n        `\"There must be as least one and up to ${PART_CONSTRAINTS.MAX_PARTS_COUNT} source objects.`,\n      )\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    for (let i = 0; i < sourceFilesLength; i++) {\n      if (!sourceObjList[i].validate()) {\n        return false\n      }\n    }\n\n    if (!destObjConfig.validate()) {\n      return false\n    }\n\n    const getStatOptions = (srcConfig) => {\n      let statOpts = {}\n      if (!_.isEmpty(srcConfig.VersionID)) {\n        statOpts = {\n          versionId: srcConfig.VersionID,\n        }\n      }\n      return statOpts\n    }\n    const srcObjectSizes = []\n    let totalSize = 0\n    let totalParts = 0\n\n    const sourceObjStats = sourceObjList.map((srcItem) =>\n      me.statObject(srcItem.Bucket, srcItem.Object, getStatOptions(srcItem)),\n    )\n\n    return Promise.all(sourceObjStats)\n      .then((srcObjectInfos) => {\n        const validatedStats = srcObjectInfos.map((resItemStat, index) => {\n          const srcConfig = sourceObjList[index]\n\n          let srcCopySize = resItemStat.size\n          // Check if a segment is specified, and if so, is the\n          // segment within object bounds?\n          if (srcConfig.MatchRange) {\n            // Since range is specified,\n            //    0 <= src.srcStart <= src.srcEnd\n            // so only invalid case to check is:\n            const srcStart = srcConfig.Start\n            const srcEnd = srcConfig.End\n            if (srcEnd >= srcCopySize || srcStart < 0) {\n              throw new errors.InvalidArgumentError(\n                `CopySrcOptions ${index} has invalid segment-to-copy [${srcStart}, ${srcEnd}] (size is ${srcCopySize})`,\n              )\n            }\n            srcCopySize = srcEnd - srcStart + 1\n          }\n\n          // Only the last source may be less than `absMinPartSize`\n          if (srcCopySize < PART_CONSTRAINTS.ABS_MIN_PART_SIZE && index < sourceFilesLength - 1) {\n            throw new errors.InvalidArgumentError(\n              `CopySrcOptions ${index} is too small (${srcCopySize}) and it is not the last part.`,\n            )\n          }\n\n          // Is data to copy too large?\n          totalSize += srcCopySize\n          if (totalSize > PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE) {\n            throw new errors.InvalidArgumentError(`Cannot compose an object of size ${totalSize} (> 5TiB)`)\n          }\n\n          // record source size\n          srcObjectSizes[index] = srcCopySize\n\n          // calculate parts needed for current source\n          totalParts += partsRequired(srcCopySize)\n          // Do we need more parts than we are allowed?\n          if (totalParts > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n            throw new errors.InvalidArgumentError(\n              `Your proposed compose object requires more than ${PART_CONSTRAINTS.MAX_PARTS_COUNT} parts`,\n            )\n          }\n\n          return resItemStat\n        })\n\n        if ((totalParts === 1 && totalSize <= PART_CONSTRAINTS.MAX_PART_SIZE) || totalSize === 0) {\n          return this.copyObject(sourceObjList[0], destObjConfig, cb) // use copyObjectV2\n        }\n\n        // preserve etag to avoid modification of object while copying.\n        for (let i = 0; i < sourceFilesLength; i++) {\n          sourceObjList[i].MatchETag = validatedStats[i].etag\n        }\n\n        const splitPartSizeList = validatedStats.map((resItemStat, idx) => {\n          const calSize = calculateEvenSplits(srcObjectSizes[idx], sourceObjList[idx])\n          return calSize\n        })\n\n        function getUploadPartConfigList(uploadId) {\n          const uploadPartConfigList = []\n\n          splitPartSizeList.forEach((splitSize, splitIndex) => {\n            const { startIndex: startIdx, endIndex: endIdx, objInfo: objConfig } = splitSize\n\n            let partIndex = splitIndex + 1 // part index starts from 1.\n            const totalUploads = Array.from(startIdx)\n\n            const headers = sourceObjList[splitIndex].getHeaders()\n\n            totalUploads.forEach((splitStart, upldCtrIdx) => {\n              let splitEnd = endIdx[upldCtrIdx]\n\n              const sourceObj = `${objConfig.Bucket}/${objConfig.Object}`\n              headers['x-amz-copy-source'] = `${sourceObj}`\n              headers['x-amz-copy-source-range'] = `bytes=${splitStart}-${splitEnd}`\n\n              const uploadPartConfig = {\n                bucketName: destObjConfig.Bucket,\n                objectName: destObjConfig.Object,\n                uploadID: uploadId,\n                partNumber: partIndex,\n                headers: headers,\n                sourceObj: sourceObj,\n              }\n\n              uploadPartConfigList.push(uploadPartConfig)\n            })\n          })\n\n          return uploadPartConfigList\n        }\n\n        const performUploadParts = (uploadId) => {\n          const uploadList = getUploadPartConfigList(uploadId)\n\n          async.map(uploadList, me.uploadPartCopy.bind(me), (err, res) => {\n            if (err) {\n              this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId).then(\n                () => cb(),\n                (err) => cb(err),\n              )\n              return\n            }\n            const partsDone = res.map((partCopy) => ({ etag: partCopy.etag, part: partCopy.part }))\n            return me.completeMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, partsDone, cb)\n          })\n        }\n\n        const newUploadHeaders = destObjConfig.getHeaders()\n\n        me.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders).then(\n          (uploadId) => {\n            performUploadParts(uploadId)\n          },\n          (err) => {\n            cb(err, null)\n          },\n        )\n      })\n      .catch((error) => {\n        cb(error, null)\n      })\n  }\n  selectObjectContent(bucketName, objectName, selectOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!_.isEmpty(selectOpts)) {\n      if (!isString(selectOpts.expression)) {\n        throw new TypeError('sqlExpression should be of type \"string\"')\n      }\n      if (!_.isEmpty(selectOpts.inputSerialization)) {\n        if (!isObject(selectOpts.inputSerialization)) {\n          throw new TypeError('inputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('inputSerialization is required')\n      }\n      if (!_.isEmpty(selectOpts.outputSerialization)) {\n        if (!isObject(selectOpts.outputSerialization)) {\n          throw new TypeError('outputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('outputSerialization is required')\n      }\n    } else {\n      throw new TypeError('valid select configuration is required')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'POST'\n    let query = `select`\n    query += '&select-type=2'\n\n    const config = [\n      {\n        Expression: selectOpts.expression,\n      },\n      {\n        ExpressionType: selectOpts.expressionType || 'SQL',\n      },\n      {\n        InputSerialization: [selectOpts.inputSerialization],\n      },\n      {\n        OutputSerialization: [selectOpts.outputSerialization],\n      },\n    ]\n\n    // Optional\n    if (selectOpts.requestProgress) {\n      config.push({ RequestProgress: selectOpts.requestProgress })\n    }\n    // Optional\n    if (selectOpts.scanRange) {\n      config.push({ ScanRange: selectOpts.scanRange })\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'SelectObjectContentRequest',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    this.makeRequest({ method, bucketName, objectName, query }, payload, [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let selectResult\n      pipesetup(response, transformers.selectObjectContentTransformer())\n        .on('data', (data) => {\n          selectResult = parseSelectObjectContentResponse(data)\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, selectResult)\n        })\n    })\n  }\n}\n\n// Promisify various public-facing APIs on the Client module.\nClient.prototype.makeBucket = promisify(Client.prototype.makeBucket)\nClient.prototype.bucketExists = promisify(Client.prototype.bucketExists)\n\nClient.prototype.getObject = promisify(Client.prototype.getObject)\nClient.prototype.getPartialObject = promisify(Client.prototype.getPartialObject)\nClient.prototype.fGetObject = promisify(Client.prototype.fGetObject)\nClient.prototype.putObject = promisify(Client.prototype.putObject)\nClient.prototype.fPutObject = promisify(Client.prototype.fPutObject)\nClient.prototype.copyObject = promisify(Client.prototype.copyObject)\nClient.prototype.removeObjects = promisify(Client.prototype.removeObjects)\n\nClient.prototype.presignedUrl = promisify(Client.prototype.presignedUrl)\nClient.prototype.presignedGetObject = promisify(Client.prototype.presignedGetObject)\nClient.prototype.presignedPutObject = promisify(Client.prototype.presignedPutObject)\nClient.prototype.presignedPostPolicy = promisify(Client.prototype.presignedPostPolicy)\nClient.prototype.getBucketNotification = promisify(Client.prototype.getBucketNotification)\nClient.prototype.setBucketNotification = promisify(Client.prototype.setBucketNotification)\nClient.prototype.removeAllBucketNotification = promisify(Client.prototype.removeAllBucketNotification)\nClient.prototype.getBucketPolicy = promisify(Client.prototype.getBucketPolicy)\nClient.prototype.setBucketPolicy = promisify(Client.prototype.setBucketPolicy)\nClient.prototype.removeIncompleteUpload = promisify(Client.prototype.removeIncompleteUpload)\nClient.prototype.getBucketVersioning = promisify(Client.prototype.getBucketVersioning)\nClient.prototype.setBucketVersioning = promisify(Client.prototype.setBucketVersioning)\nClient.prototype.setBucketTagging = promisify(Client.prototype.setBucketTagging)\nClient.prototype.removeBucketTagging = promisify(Client.prototype.removeBucketTagging)\nClient.prototype.getBucketTagging = promisify(Client.prototype.getBucketTagging)\nClient.prototype.setObjectTagging = promisify(Client.prototype.setObjectTagging)\nClient.prototype.removeObjectTagging = promisify(Client.prototype.removeObjectTagging)\nClient.prototype.getObjectTagging = promisify(Client.prototype.getObjectTagging)\nClient.prototype.setBucketLifecycle = promisify(Client.prototype.setBucketLifecycle)\nClient.prototype.getBucketLifecycle = promisify(Client.prototype.getBucketLifecycle)\nClient.prototype.removeBucketLifecycle = promisify(Client.prototype.removeBucketLifecycle)\nClient.prototype.setObjectLockConfig = promisify(Client.prototype.setObjectLockConfig)\nClient.prototype.getObjectLockConfig = promisify(Client.prototype.getObjectLockConfig)\nClient.prototype.putObjectRetention = promisify(Client.prototype.putObjectRetention)\nClient.prototype.getObjectRetention = promisify(Client.prototype.getObjectRetention)\nClient.prototype.setBucketEncryption = promisify(Client.prototype.setBucketEncryption)\nClient.prototype.getBucketEncryption = promisify(Client.prototype.getBucketEncryption)\nClient.prototype.removeBucketEncryption = promisify(Client.prototype.removeBucketEncryption)\nClient.prototype.setObjectLegalHold = promisify(Client.prototype.setObjectLegalHold)\nClient.prototype.getObjectLegalHold = promisify(Client.prototype.getObjectLegalHold)\nClient.prototype.composeObject = promisify(Client.prototype.composeObject)\nClient.prototype.selectObjectContent = promisify(Client.prototype.selectObjectContent)\n\n// refactored API use promise internally\nClient.prototype.removeObject = callbackify(Client.prototype.removeObject)\nClient.prototype.statObject = callbackify(Client.prototype.statObject)\nClient.prototype.removeBucket = callbackify(Client.prototype.removeBucket)\nClient.prototype.listBuckets = callbackify(Client.prototype.listBuckets)\nClient.prototype.removeBucketReplication = callbackify(Client.prototype.removeBucketReplication)\nClient.prototype.setBucketReplication = callbackify(Client.prototype.setBucketReplication)\nClient.prototype.getBucketReplication = callbackify(Client.prototype.getBucketReplication)\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","_interopRequireWildcard","require","path","Stream","_async","_blockStream","_lodash","querystring","_webEncoding","_xml","_xml2js","errors","_extensions","_helpers","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","_client","_copyConditions","CopyConditions","_helper","_postPolicy","PostPolicy","_type","_notification","_objectUploader","_promisify","_signing","transformers","_xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","defineProperty","getOwnPropertyDescriptor","desc","set","Client","TypedClient","setAppInfo","appName","appVersion","isString","TypeError","trim","InvalidArgumentError","userAgent","calculatePartSize","size","isNumber","maxObjectSize","overRidePartSize","partSize","logHTTP","reqOptions","response","err","logStream","isObject","isReadableStream","Error","logHeaders","headers","_","v","k","redacter","RegExp","replace","write","method","statusCode","errJSON","JSON","stringify","traceOn","stream","process","stdout","traceOff","makeRequest","options","payload","statusCodes","region","returnResponse","cb","isBoolean","isFunction","length","sha256sum","enableSHA256","toSha256","readableStream","makeRequestStream","_makeRequest","e","getRequestOptions","anonymous","date","Date","makeDateLong","sessionToken","checkAndRefreshCreds","authorization","signV4","accessKey","secretKey","req","transport","request","includes","regionMap","bucketName","errorTransformer","getErrorTransformer","pipesetup","on","pipe","getBucketRegion","isValidBucketName","InvalidBucketNameError","extractRegion","transformer","getBucketRegionTransformer","DEFAULT_REGION","data","query","pathStyle","window","name","Region","makeBucket","makeOpts","createBucketConfiguration","push","_attr","xmlns","LocationConstraint","payloadObject","CreateBucketConfiguration","Xml","ObjectLocking","processWithRetry","code","listBuckets","getListBucketTransformer","buckets","result","listIncompleteUploads","bucket","prefix","recursive","undefined","isValidPrefix","InvalidPrefixError","delimiter","keyMarker","uploadIdMarker","uploads","ended","readStream","Readable","objectMode","_read","shift","listIncompleteUploadsQuery","emit","prefixes","async","eachSeries","upload","listParts","uploadId","parts","reduce","acc","item","isTruncated","nextKeyMarker","nextUploadIdMarker","bucketExists","removeBucket","removeIncompleteUpload","objectName","IsValidBucketNameError","isValidObjectName","InvalidObjectNameError","removeUploadId","during","findUploadId","fGetObject","filePath","getOpts","partFile","partFileStream","objStat","rename","waterfall","statObject","mkdir","dirname","etag","stat","stats","offset","createWriteStream","flags","getPartialObject","downloadStream","getObject","range","expectedStatusCodes","fPutObject","metaData","callback","insertContentType","prependXAMZMeta","cbTriggered","origCb","destroy","apply","arguments","multipart","uploader","getUploader","hash","getHashSummer","start","end","autoClose","createReadStream","md5sum","objInfo","etags","initiateNewMultipartUpload","part","partsDone","partNumber","uploadedSize","whilst","md5sumHex","Buffer","from","toString","completeMultipartUpload","rest","putObject","chunker","BlockStream2","zeroPadding","ObjectUploader","copyObjectV1","arg1","arg2","arg3","arg4","arg5","srcObject","conditions","uriResourceEscape","modified","unmodified","matchETag","matchEtagExcept","matchETagExcept","getCopyObjectTransformer","copyObjectV2","sourceConfig","destConfig","CopySourceOptions","CopyDestinationOptions","validate","assign","getHeaders","Bucket","resHeaders","copyObjResponse","Key","LastModified","MetaData","extractMetadata","VersionId","getVersionId","SourceVersionId","getSourceVersionId","Etag","sanitizeETag","Size","copyObject","allArgs","listObjectsQuery","marker","listQueryOpts","Delimiter","MaxKeys","IncludeVersion","queries","uriEscape","sort","join","getListObjectsTransformer","listObjects","listOpts","objects","nextMarker","versionIdMarker","listObjectsV2Query","continuationToken","maxKeys","startAfter","getListObjectsV2Transformer","listObjectsV2","nextContinuationToken","statOpts","lastModified","versionId","removeObject","removeOpts","queryParams","governanceBypass","forceDelete","requestOptions","removeObjects","objectsList","Array","isArray","maxEntries","entry","list","listOfList","encoder","TextEncoder","batchResults","batchCb","value","deleteObjects","Delete","Quiet","builder","xml2js","Builder","headless","buildObject","encode","toMd5","removeObjectsResult","removeObjectsTransformer","flatten","getBucketPolicy","policy","getConcater","setBucketPolicy","InvalidBucketPolicyError","presignedUrl","expires","reqParams","requestDate","AnonymousRequestError","isValidDate","url","presignSignatureV4","pe","presignedGetObject","respHeaders","validRespHeaders","header","presignedPutObject","newPostPolicy","presignedPostPolicy","postPolicy","formData","dateStr","expiration","setSeconds","setExpires","getScope","policyBase64","signature","postPresignSignatureV4","opts","portStr","port","urlStr","protocol","host","postURL","getInitiateMultipartTransformer","element","Part","PartNumber","ETag","CompleteMultipartUpload","getCompleteMultipartTransformer","errCode","S3Error","errMessage","completeMultipartResult","listNext","listPartsQuery","concat","getListPartsTransformer","maxUploads","unshift","getListMultipartTransformer","latestUpload","initiated","getTime","simpleUploader","args","multipartUploader","setBucketNotification","config","rootName","renderOpts","pretty","removeAllBucketNotification","NotificationConfig","getBucketNotification","getBucketNotificationTransformer","bucketNotification","listenBucketNotification","suffix","events","listener","NotificationPoller","getBucketVersioning","versionConfig","bucketVersioningTransformer","setBucketVersioning","setTagging","taggingParams","tags","putOpts","tagsList","entries","Value","taggingConfig","Tagging","TagSet","Tag","setBucketTagging","setObjectTagging","removeTagging","removeBucketTagging","removeObjectTagging","getBucketTagging","getTagsTransformer","getObjectTagging","applyBucketLifecycle","policyConfig","removeBucketLifecycle","setBucketLifecycle","lifeCycleConfig","isEmpty","getBucketLifecycle","lifecycleTransformer","lifecycleConfig","setObjectLockConfig","lockConfigOpts","retentionModes","RETENTION_MODES","COMPLIANCE","GOVERNANCE","validUnits","RETENTION_VALIDITY_UNITS","DAYS","YEARS","mode","unit","validity","ObjectLockEnabled","configKeys","difference","Rule","DefaultRetention","Mode","Days","Years","getObjectLockConfig","objectLockConfig","objectLockTransformer","putObjectRetention","retentionOpts","retainUntilDate","params","RetainUntilDate","getObjectRetention","retentionConfig","objectRetentionTransformer","setBucketEncryption","encryptionConfig","encryptionObj","ApplyServerSideEncryptionByDefault","SSEAlgorithm","getBucketEncryption","bucketEncConfig","bucketEncryptionTransformer","removeBucketEncryption","setBucketReplication","replicationConfig","role","rules","replicationParamsConfig","ReplicationConfiguration","Role","getBucketReplication","replicationConfigTransformer","removeBucketReplication","getObjectLegalHold","legalHoldConfig","objectLegalHoldTransformer","setObjectLegalHold","setOpts","defaultOpts","status","LEGAL_HOLD_STATUS","ENABLED","DISABLED","Status","abortMultipartUpload","uploadPartCopy","partConfig","uploadID","partCopyResult","uploadPartTransformer","uploadPartCopyRes","composeObject","destObjConfig","sourceObjList","me","sourceFilesLength","PART_CONSTRAINTS","MAX_PARTS_COUNT","i","getStatOptions","srcConfig","VersionID","srcObjectSizes","totalSize","totalParts","sourceObjStats","map","srcItem","Promise","all","then","srcObjectInfos","validatedStats","resItemStat","index","srcCopySize","MatchRange","srcStart","Start","srcEnd","End","ABS_MIN_PART_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","partsRequired","MAX_PART_SIZE","MatchETag","splitPartSizeList","idx","calSize","calculateEvenSplits","getUploadPartConfigList","uploadPartConfigList","splitSize","splitIndex","startIndex","startIdx","endIndex","endIdx","objConfig","partIndex","totalUploads","splitStart","upldCtrIdx","splitEnd","sourceObj","uploadPartConfig","performUploadParts","uploadList","bind","res","partCopy","newUploadHeaders","catch","error","selectObjectContent","selectOpts","expression","inputSerialization","outputSerialization","Expression","ExpressionType","expressionType","InputSerialization","OutputSerialization","requestProgress","RequestProgress","scanRange","ScanRange","selectResult","selectObjectContentTransformer","parseSelectObjectContentResponse","extensions","clientExtensions","promisify"],"sources":["minio.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport * as Stream from 'node:stream'\n\nimport async from 'async'\nimport BlockStream2 from 'block-stream2'\nimport _ from 'lodash'\nimport * as querystring from 'query-string'\nimport { TextEncoder } from 'web-encoding'\nimport Xml from 'xml'\nimport xml2js from 'xml2js'\n\nimport * as errors from './errors.ts'\nimport { extensions } from './extensions.js'\nimport { CopyDestinationOptions, CopySourceOptions, DEFAULT_REGION } from './helpers.ts'\nimport { TypedClient } from './internal/client.ts'\nimport { CopyConditions } from './internal/copy-conditions.ts'\nimport {\n  calculateEvenSplits,\n  extractMetadata,\n  getScope,\n  getSourceVersionId,\n  getVersionId,\n  insertContentType,\n  isBoolean,\n  isFunction,\n  isNumber,\n  isObject,\n  isReadableStream,\n  isString,\n  isValidBucketName,\n  isValidDate,\n  isValidObjectName,\n  isValidPrefix,\n  makeDateLong,\n  PART_CONSTRAINTS,\n  partsRequired,\n  pipesetup,\n  prependXAMZMeta,\n  readableStream,\n  sanitizeETag,\n  toMd5,\n  toSha256,\n  uriEscape,\n  uriResourceEscape,\n} from './internal/helper.ts'\nimport { PostPolicy } from './internal/post-policy.ts'\nimport { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './internal/type.ts'\nimport { NotificationConfig, NotificationPoller } from './notification.js'\nimport { ObjectUploader } from './object-uploader.js'\nimport { promisify } from './promisify.js'\nimport { postPresignSignatureV4, presignSignatureV4, signV4 } from './signing.ts'\nimport * as transformers from './transformers.js'\nimport { parseSelectObjectContentResponse } from './xml-parsers.js'\n\nexport * from './helpers.ts'\nexport * from './notification.js'\nexport { CopyConditions, PostPolicy }\n\nexport class Client extends TypedClient {\n  // Set application specific information.\n  //\n  // Generates User-Agent in the following style.\n  //\n  //       MinIO (OS; ARCH) LIB/VER APP/VER\n  //\n  // __Arguments__\n  // * `appName` _string_ - Application name.\n  // * `appVersion` _string_ - Application version.\n  setAppInfo(appName, appVersion) {\n    if (!isString(appName)) {\n      throw new TypeError(`Invalid appName: ${appName}`)\n    }\n    if (appName.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appName cannot be empty.')\n    }\n    if (!isString(appVersion)) {\n      throw new TypeError(`Invalid appVersion: ${appVersion}`)\n    }\n    if (appVersion.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appVersion cannot be empty.')\n    }\n    this.userAgent = `${this.userAgent} ${appName}/${appVersion}`\n  }\n\n  // Calculate part size given the object size. Part size will be atleast this.partSize\n  calculatePartSize(size) {\n    if (!isNumber(size)) {\n      throw new TypeError('size should be of type \"number\"')\n    }\n    if (size > this.maxObjectSize) {\n      throw new TypeError(`size should not be more than ${this.maxObjectSize}`)\n    }\n    if (this.overRidePartSize) {\n      return this.partSize\n    }\n    var partSize = this.partSize\n    for (;;) {\n      // while(true) {...} throws linting error.\n      // If partSize is big enough to accomodate the object size, then use it.\n      if (partSize * 10000 > size) {\n        return partSize\n      }\n      // Try part sizes as 64MB, 80MB, 96MB etc.\n      partSize += 16 * 1024 * 1024\n    }\n  }\n\n  // log the request, response, error\n  logHTTP(reqOptions, response, err) {\n    // if no logstreamer available return.\n    if (!this.logStream) {\n      return\n    }\n    if (!isObject(reqOptions)) {\n      throw new TypeError('reqOptions should be of type \"object\"')\n    }\n    if (response && !isReadableStream(response)) {\n      throw new TypeError('response should be of type \"Stream\"')\n    }\n    if (err && !(err instanceof Error)) {\n      throw new TypeError('err should be of type \"Error\"')\n    }\n    var logHeaders = (headers) => {\n      _.forEach(headers, (v, k) => {\n        if (k == 'authorization') {\n          var redacter = new RegExp('Signature=([0-9a-f]+)')\n          v = v.replace(redacter, 'Signature=**REDACTED**')\n        }\n        this.logStream.write(`${k}: ${v}\\n`)\n      })\n      this.logStream.write('\\n')\n    }\n    this.logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\\n`)\n    logHeaders(reqOptions.headers)\n    if (response) {\n      this.logStream.write(`RESPONSE: ${response.statusCode}\\n`)\n      logHeaders(response.headers)\n    }\n    if (err) {\n      this.logStream.write('ERROR BODY:\\n')\n      var errJSON = JSON.stringify(err, null, '\\t')\n      this.logStream.write(`${errJSON}\\n`)\n    }\n  }\n\n  // Enable tracing\n  traceOn(stream) {\n    if (!stream) {\n      stream = process.stdout\n    }\n    this.logStream = stream\n  }\n\n  // Disable tracing\n  traceOff() {\n    this.logStream = null\n  }\n\n  // makeRequest is the primitive used by the apis for making S3 requests.\n  // payload can be empty string in case of no payload.\n  // statusCode is the expected statusCode. If response.statusCode does not match\n  // we parse the XML error and call the callback with the error message.\n  // A valid region is passed by the calls - listBuckets, makeBucket and\n  // getBucketRegion.\n  makeRequest(options, payload, statusCodes, region, returnResponse, cb) {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!isString(payload) && !isObject(payload)) {\n      // Buffer is of type 'object'\n      throw new TypeError('payload should be of type \"string\" or \"Buffer\"')\n    }\n    statusCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!isBoolean(returnResponse)) {\n      throw new TypeError('returnResponse should be of type \"boolean\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    if (!options.headers) {\n      options.headers = {}\n    }\n    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') {\n      options.headers['content-length'] = payload.length\n    }\n    var sha256sum = ''\n    if (this.enableSHA256) {\n      sha256sum = toSha256(payload)\n    }\n    var stream = readableStream(payload)\n    this.makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb)\n  }\n\n  // makeRequestStream will be used directly instead of makeRequest in case the payload\n  // is available as a stream. for ex. putObject\n  makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb) {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!isReadableStream(stream)) {\n      throw new errors.InvalidArgumentError('stream should be a readable Stream')\n    }\n    if (!isString(sha256sum)) {\n      throw new TypeError('sha256sum should be of type \"string\"')\n    }\n    statusCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!isBoolean(returnResponse)) {\n      throw new TypeError('returnResponse should be of type \"boolean\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    // sha256sum will be empty for anonymous or https requests\n    if (!this.enableSHA256 && sha256sum.length !== 0) {\n      throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`)\n    }\n    // sha256sum should be valid for non-anonymous http requests.\n    if (this.enableSHA256 && sha256sum.length !== 64) {\n      throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`)\n    }\n\n    var _makeRequest = (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      options.region = region\n      var reqOptions = this.getRequestOptions(options)\n      if (!this.anonymous) {\n        // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation.\n        if (!this.enableSHA256) {\n          sha256sum = 'UNSIGNED-PAYLOAD'\n        }\n\n        let date = new Date()\n\n        reqOptions.headers['x-amz-date'] = makeDateLong(date)\n        reqOptions.headers['x-amz-content-sha256'] = sha256sum\n        if (this.sessionToken) {\n          reqOptions.headers['x-amz-security-token'] = this.sessionToken\n        }\n\n        this.checkAndRefreshCreds()\n        var authorization = signV4(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum)\n        reqOptions.headers.authorization = authorization\n      }\n      var req = this.transport.request(reqOptions, (response) => {\n        if (!statusCodes.includes(response.statusCode)) {\n          // For an incorrect region, S3 server always sends back 400.\n          // But we will do cache invalidation for all errors so that,\n          // in future, if AWS S3 decides to send a different status code or\n          // XML error code we will still work fine.\n          delete this.regionMap[options.bucketName]\n          var errorTransformer = transformers.getErrorTransformer(response)\n          pipesetup(response, errorTransformer).on('error', (e) => {\n            this.logHTTP(reqOptions, response, e)\n            cb(e)\n          })\n          return\n        }\n        this.logHTTP(reqOptions, response)\n        if (returnResponse) {\n          return cb(null, response)\n        }\n        // We drain the socket so that the connection gets closed. Note that this\n        // is not expensive as the socket will not have any data.\n        response.on('data', () => {})\n        cb(null)\n      })\n      let pipe = pipesetup(stream, req)\n      pipe.on('error', (e) => {\n        this.logHTTP(reqOptions, null, e)\n        cb(e)\n      })\n    }\n    if (region) {\n      return _makeRequest(null, region)\n    }\n    this.getBucketRegion(options.bucketName, _makeRequest)\n  }\n\n  // gets the region of the bucket\n  getBucketRegion(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n\n    // Region is set with constructor, return the region right here.\n    if (this.region) {\n      return cb(null, this.region)\n    }\n\n    if (this.regionMap[bucketName]) {\n      return cb(null, this.regionMap[bucketName])\n    }\n    var extractRegion = (response) => {\n      var transformer = transformers.getBucketRegionTransformer()\n      var region = DEFAULT_REGION\n      pipesetup(response, transformer)\n        .on('error', cb)\n        .on('data', (data) => {\n          if (data) {\n            region = data\n          }\n        })\n        .on('end', () => {\n          this.regionMap[bucketName] = region\n          cb(null, region)\n        })\n    }\n\n    var method = 'GET'\n    var query = 'location'\n\n    // `getBucketLocation` behaves differently in following ways for\n    // different environments.\n    //\n    // - For nodejs env we default to path style requests.\n    // - For browser env path style requests on buckets yields CORS\n    //   error. To circumvent this problem we make a virtual host\n    //   style request signed with 'us-east-1'. This request fails\n    //   with an error 'AuthorizationHeaderMalformed', additionally\n    //   the error XML also provides Region of the bucket. To validate\n    //   this region is proper we retry the same request with the newly\n    //   obtained region.\n    var pathStyle = this.pathStyle && typeof window === 'undefined'\n\n    this.makeRequest({ method, bucketName, query, pathStyle }, '', [200], DEFAULT_REGION, true, (e, response) => {\n      if (e) {\n        if (e.name === 'AuthorizationHeaderMalformed') {\n          var region = e.Region\n          if (!region) {\n            return cb(e)\n          }\n          this.makeRequest({ method, bucketName, query }, '', [200], region, true, (e, response) => {\n            if (e) {\n              return cb(e)\n            }\n            extractRegion(response)\n          })\n          return\n        }\n        return cb(e)\n      }\n      extractRegion(response)\n    })\n  }\n\n  // Creates the bucket `bucketName`.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ - Name of the bucket\n  // * `region` _string_ - region valid values are _us-west-1_, _us-west-2_,  _eu-west-1_, _eu-central-1_, _ap-southeast-1_, _ap-northeast-1_, _ap-southeast-2_, _sa-east-1_.\n  // * `makeOpts` _object_ - Options to create a bucket. e.g {ObjectLocking:true} (Optional)\n  // * `callback(err)` _function_ - callback function with `err` as the error argument. `err` is null if the bucket is successfully created.\n  makeBucket(bucketName, region, makeOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    // Backward Compatibility\n    if (isObject(region)) {\n      cb = makeOpts\n      makeOpts = region\n      region = ''\n    }\n    if (isFunction(region)) {\n      cb = region\n      region = ''\n      makeOpts = {}\n    }\n    if (isFunction(makeOpts)) {\n      cb = makeOpts\n      makeOpts = {}\n    }\n\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!isObject(makeOpts)) {\n      throw new TypeError('makeOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var payload = ''\n\n    // Region already set in constructor, validate if\n    // caller requested bucket location is same.\n    if (region && this.region) {\n      if (region !== this.region) {\n        throw new errors.InvalidArgumentError(`Configured region ${this.region}, requested ${region}`)\n      }\n    }\n    // sending makeBucket request with XML containing 'us-east-1' fails. For\n    // default region server expects the request without body\n    if (region && region !== DEFAULT_REGION) {\n      var createBucketConfiguration = []\n      createBucketConfiguration.push({\n        _attr: {\n          xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/',\n        },\n      })\n      createBucketConfiguration.push({\n        LocationConstraint: region,\n      })\n      var payloadObject = {\n        CreateBucketConfiguration: createBucketConfiguration,\n      }\n      payload = Xml(payloadObject)\n    }\n    var method = 'PUT'\n    var headers = {}\n\n    if (makeOpts.ObjectLocking) {\n      headers['x-amz-bucket-object-lock-enabled'] = true\n    }\n\n    if (!region) {\n      region = DEFAULT_REGION\n    }\n\n    const processWithRetry = (err) => {\n      if (err && (region === '' || region === DEFAULT_REGION)) {\n        if (err.code === 'AuthorizationHeaderMalformed' && err.region !== '') {\n          // Retry with region returned as part of error\n          this.makeRequest({ method, bucketName, headers }, payload, [200], err.region, false, cb)\n        } else {\n          return cb && cb(err)\n        }\n      }\n      return cb && cb(err)\n    }\n    this.makeRequest({ method, bucketName, headers }, payload, [200], region, false, processWithRetry)\n  }\n\n  // List of buckets created.\n  //\n  // __Arguments__\n  // * `callback(err, buckets)` _function_ - callback function with error as the first argument. `buckets` is an array of bucket information\n  //\n  // `buckets` array element:\n  // * `bucket.name` _string_ : bucket name\n  // * `bucket.creationDate` _Date_: date when bucket was created\n  listBuckets(cb) {\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    this.makeRequest({ method }, '', [200], DEFAULT_REGION, true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getListBucketTransformer()\n      var buckets\n      pipesetup(response, transformer)\n        .on('data', (result) => (buckets = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, buckets))\n    })\n  }\n\n  // Returns a stream that emits objects that are partially uploaded.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: prefix of the object names that are partially uploaded (optional, default `''`)\n  // * `recursive` _bool_: directory style listing when false, recursive listing when true (optional, default `false`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_ : emits objects of the format:\n  //   * `object.key` _string_: name of the object\n  //   * `object.uploadId` _string_: upload ID of the object\n  //   * `object.size` _Integer_: size of the partially uploaded object\n  listIncompleteUploads(bucket, prefix, recursive) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucket)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    var delimiter = recursive ? '' : '/'\n    var keyMarker = ''\n    var uploadIdMarker = ''\n    var uploads = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one upload info per _read()\n      if (uploads.length) {\n        return readStream.push(uploads.shift())\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      this.listIncompleteUploadsQuery(bucket, prefix, keyMarker, uploadIdMarker, delimiter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          result.prefixes.forEach((prefix) => uploads.push(prefix))\n          async.eachSeries(\n            result.uploads,\n            (upload, cb) => {\n              // for each incomplete upload add the sizes of its uploaded parts\n              this.listParts(bucket, upload.key, upload.uploadId, (err, parts) => {\n                if (err) {\n                  return cb(err)\n                }\n                upload.size = parts.reduce((acc, item) => acc + item.size, 0)\n                uploads.push(upload)\n                cb()\n              })\n            },\n            (err) => {\n              if (err) {\n                readStream.emit('error', err)\n                return\n              }\n              if (result.isTruncated) {\n                keyMarker = result.nextKeyMarker\n                uploadIdMarker = result.nextUploadIdMarker\n              } else {\n                ended = true\n              }\n              readStream._read()\n            },\n          )\n        })\n    }\n    return readStream\n  }\n\n  // To check if a bucket already exists.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ : name of the bucket\n  // * `callback(err)` _function_ : `err` is `null` if the bucket exists\n  bucketExists(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'HEAD'\n    this.makeRequest({ method, bucketName }, '', [200], '', false, (err) => {\n      if (err) {\n        if (err.code == 'NoSuchBucket' || err.code == 'NotFound') {\n          return cb(null, false)\n        }\n        return cb(err)\n      }\n      cb(null, true)\n    })\n  }\n\n  // Remove a bucket.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ : name of the bucket\n  // * `callback(err)` _function_ : `err` is `null` if the bucket is removed successfully.\n  removeBucket(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'DELETE'\n    this.makeRequest({ method, bucketName }, '', [204], '', false, (e) => {\n      // If the bucket was successfully removed, remove the region map entry.\n      if (!e) {\n        delete this.regionMap[bucketName]\n      }\n      cb(e)\n    })\n  }\n\n  // Remove the partially uploaded object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `callback(err)` _function_: callback function is called with non `null` value in case of error\n  removeIncompleteUpload(bucketName, objectName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.IsValidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var removeUploadId\n    async.during(\n      (cb) => {\n        this.findUploadId(bucketName, objectName, (e, uploadId) => {\n          if (e) {\n            return cb(e)\n          }\n          removeUploadId = uploadId\n          cb(null, uploadId)\n        })\n      },\n      (cb) => {\n        var method = 'DELETE'\n        var query = `uploadId=${removeUploadId}`\n        this.makeRequest({ method, bucketName, objectName, query }, '', [204], '', false, (e) => cb(e))\n      },\n      cb,\n    )\n  }\n\n  // Callback is called with `error` in case of error or `null` in case of success\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `filePath` _string_: path to which the object data will be written to\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err)` _function_: callback is called with `err` in case of error.\n  fGetObject(bucketName, objectName, filePath, getOpts = {}, cb) {\n    // Input validation.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    // Internal data.\n    var partFile\n    var partFileStream\n    var objStat\n\n    // Rename wrapper.\n    var rename = (err) => {\n      if (err) {\n        return cb(err)\n      }\n      fs.rename(partFile, filePath, cb)\n    }\n\n    async.waterfall(\n      [\n        (cb) => this.statObject(bucketName, objectName, getOpts, cb),\n        (result, cb) => {\n          objStat = result\n          // Create any missing top level directories.\n          fs.mkdir(path.dirname(filePath), { recursive: true }, (err) => cb(err))\n        },\n        (cb) => {\n          partFile = `${filePath}.${objStat.etag}.part.minio`\n          fs.stat(partFile, (e, stats) => {\n            var offset = 0\n            if (e) {\n              partFileStream = fs.createWriteStream(partFile, { flags: 'w' })\n            } else {\n              if (objStat.size === stats.size) {\n                return rename()\n              }\n              offset = stats.size\n              partFileStream = fs.createWriteStream(partFile, { flags: 'a' })\n            }\n            this.getPartialObject(bucketName, objectName, offset, 0, getOpts, cb)\n          })\n        },\n        (downloadStream, cb) => {\n          pipesetup(downloadStream, partFileStream)\n            .on('error', (e) => cb(e))\n            .on('finish', cb)\n        },\n        (cb) => fs.stat(partFile, cb),\n        (stats, cb) => {\n          if (stats.size === objStat.size) {\n            return cb()\n          }\n          cb(new Error('Size mismatch between downloaded file and the object'))\n        },\n      ],\n      rename,\n    )\n  }\n\n  // Callback is called with readable stream of the object content.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err, stream)` _function_: callback is called with `err` in case of error. `stream` is the object content stream\n  getObject(bucketName, objectName, getOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    this.getPartialObject(bucketName, objectName, 0, 0, getOpts, cb)\n  }\n\n  // Callback is called with readable stream of the partial object content.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `offset` _number_: offset of the object from where the stream will start\n  // * `length` _number_: length of the object that will be read in the stream (optional, if not specified we read the rest of the file from the offset)\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err, stream)` _function_: callback is called with `err` in case of error. `stream` is the object content stream\n  getPartialObject(bucketName, objectName, offset, length, getOpts = {}, cb) {\n    if (isFunction(length)) {\n      cb = length\n      length = 0\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isNumber(offset)) {\n      throw new TypeError('offset should be of type \"number\"')\n    }\n    if (!isNumber(length)) {\n      throw new TypeError('length should be of type \"number\"')\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var range = ''\n    if (offset || length) {\n      if (offset) {\n        range = `bytes=${+offset}-`\n      } else {\n        range = 'bytes=0-'\n        offset = 0\n      }\n      if (length) {\n        range += `${+length + offset - 1}`\n      }\n    }\n\n    var headers = {}\n    if (range !== '') {\n      headers.range = range\n    }\n\n    var expectedStatusCodes = [200]\n    if (range) {\n      expectedStatusCodes.push(206)\n    }\n    var method = 'GET'\n\n    var query = querystring.stringify(getOpts)\n    this.makeRequest({ method, bucketName, objectName, headers, query }, '', expectedStatusCodes, '', true, cb)\n  }\n\n  // Uploads the object using contents from a file\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `filePath` _string_: file path of the file to be uploaded\n  // * `metaData` _Javascript Object_: metaData assosciated with the object\n  // * `callback(err, objInfo)` _function_: non null `err` indicates error, `objInfo` _object_ which contains versionId and etag.\n  fPutObject(bucketName, objectName, filePath, metaData, callback) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    if (isFunction(metaData)) {\n      callback = metaData\n      metaData = {} // Set metaData empty if no metaData provided.\n    }\n    if (!isObject(metaData)) {\n      throw new TypeError('metaData should be of type \"object\"')\n    }\n\n    // Inserts correct `content-type` attribute based on metaData and filePath\n    metaData = insertContentType(metaData, filePath)\n\n    // Updates metaData to have the correct prefix if needed\n    metaData = prependXAMZMeta(metaData)\n    var size\n    var partSize\n\n    async.waterfall(\n      [\n        (cb) => fs.stat(filePath, cb),\n        (stats, cb) => {\n          size = stats.size\n          var stream\n          var cbTriggered = false\n          var origCb = cb\n          cb = function () {\n            if (cbTriggered) {\n              return\n            }\n            cbTriggered = true\n            if (stream) {\n              stream.destroy()\n            }\n            return origCb.apply(this, arguments)\n          }\n          if (size > this.maxObjectSize) {\n            return cb(new Error(`${filePath} size : ${stats.size}, max allowed size : 5TB`))\n          }\n          if (size <= this.partSize) {\n            // simple PUT request, no multipart\n            var multipart = false\n            var uploader = this.getUploader(bucketName, objectName, metaData, multipart)\n            var hash = transformers.getHashSummer(this.enableSHA256)\n            var start = 0\n            var end = size - 1\n            var autoClose = true\n            if (size === 0) {\n              end = 0\n            }\n            var options = { start, end, autoClose }\n            pipesetup(fs.createReadStream(filePath, options), hash)\n              .on('data', (data) => {\n                var md5sum = data.md5sum\n                var sha256sum = data.sha256sum\n                stream = fs.createReadStream(filePath, options)\n                uploader(stream, size, sha256sum, md5sum, (err, objInfo) => {\n                  callback(err, objInfo)\n                  cb(true)\n                })\n              })\n              .on('error', (e) => cb(e))\n            return\n          }\n          this.findUploadId(bucketName, objectName, cb)\n        },\n        (uploadId, cb) => {\n          // if there was a previous incomplete upload, fetch all its uploaded parts info\n          if (uploadId) {\n            return this.listParts(bucketName, objectName, uploadId, (e, etags) => cb(e, uploadId, etags))\n          }\n          // there was no previous upload, initiate a new one\n          this.initiateNewMultipartUpload(bucketName, objectName, metaData, (e, uploadId) => cb(e, uploadId, []))\n        },\n        (uploadId, etags, cb) => {\n          partSize = this.calculatePartSize(size)\n          var multipart = true\n          var uploader = this.getUploader(bucketName, objectName, metaData, multipart)\n\n          // convert array to object to make things easy\n          var parts = etags.reduce(function (acc, item) {\n            if (!acc[item.part]) {\n              acc[item.part] = item\n            }\n            return acc\n          }, {})\n          var partsDone = []\n          var partNumber = 1\n          var uploadedSize = 0\n          async.whilst(\n            (cb) => {\n              cb(null, uploadedSize < size)\n            },\n            (cb) => {\n              var stream\n              var cbTriggered = false\n              var origCb = cb\n              cb = function () {\n                if (cbTriggered) {\n                  return\n                }\n                cbTriggered = true\n                if (stream) {\n                  stream.destroy()\n                }\n                return origCb.apply(this, arguments)\n              }\n              var part = parts[partNumber]\n              var hash = transformers.getHashSummer(this.enableSHA256)\n              var length = partSize\n              if (length > size - uploadedSize) {\n                length = size - uploadedSize\n              }\n              var start = uploadedSize\n              var end = uploadedSize + length - 1\n              var autoClose = true\n              var options = { autoClose, start, end }\n              // verify md5sum of each part\n              pipesetup(fs.createReadStream(filePath, options), hash)\n                .on('data', (data) => {\n                  var md5sumHex = Buffer.from(data.md5sum, 'base64').toString('hex')\n                  if (part && md5sumHex === part.etag) {\n                    // md5 matches, chunk already uploaded\n                    partsDone.push({ part: partNumber, etag: part.etag })\n                    partNumber++\n                    uploadedSize += length\n                    return cb()\n                  }\n                  // part is not uploaded yet, or md5 mismatch\n                  stream = fs.createReadStream(filePath, options)\n                  uploader(uploadId, partNumber, stream, length, data.sha256sum, data.md5sum, (e, objInfo) => {\n                    if (e) {\n                      return cb(e)\n                    }\n                    partsDone.push({ part: partNumber, etag: objInfo.etag })\n                    partNumber++\n                    uploadedSize += length\n                    return cb()\n                  })\n                })\n                .on('error', (e) => cb(e))\n            },\n            (e) => {\n              if (e) {\n                return cb(e)\n              }\n              cb(null, partsDone, uploadId)\n            },\n          )\n        },\n        // all parts uploaded, complete the multipart upload\n        (etags, uploadId, cb) => this.completeMultipartUpload(bucketName, objectName, uploadId, etags, cb),\n      ],\n      (err, ...rest) => {\n        if (err === true) {\n          return\n        }\n        callback(err, ...rest)\n      },\n    )\n  }\n\n  // Uploads the object.\n  //\n  // Uploading a stream\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `stream` _Stream_: Readable stream\n  // * `size` _number_: size of the object (optional)\n  // * `callback(err, etag)` _function_: non null `err` indicates error, `etag` _string_ is the etag of the object uploaded.\n  //\n  // Uploading \"Buffer\" or \"string\"\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `string or Buffer` _string_ or _Buffer_: string or buffer\n  // * `callback(err, objInfo)` _function_: `err` is `null` in case of success and `info` will have the following object details:\n  //   * `etag` _string_: etag of the object\n  //   * `versionId` _string_: versionId of the object\n  putObject(bucketName, objectName, stream, size, metaData, callback) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    // We'll need to shift arguments to the left because of size and metaData.\n    if (isFunction(size)) {\n      callback = size\n      metaData = {}\n    } else if (isFunction(metaData)) {\n      callback = metaData\n      metaData = {}\n    }\n\n    // We'll need to shift arguments to the left because of metaData\n    // and size being optional.\n    if (isObject(size)) {\n      metaData = size\n    }\n\n    // Ensures Metadata has appropriate prefix for A3 API\n    metaData = prependXAMZMeta(metaData)\n    if (typeof stream === 'string' || stream instanceof Buffer) {\n      // Adapts the non-stream interface into a stream.\n      size = stream.length\n      stream = readableStream(stream)\n    } else if (!isReadableStream(stream)) {\n      throw new TypeError('third argument should be of type \"stream.Readable\" or \"Buffer\" or \"string\"')\n    }\n\n    if (!isFunction(callback)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    if (isNumber(size) && size < 0) {\n      throw new errors.InvalidArgumentError(`size cannot be negative, given size: ${size}`)\n    }\n\n    // Get the part size and forward that to the BlockStream. Default to the\n    // largest block size possible if necessary.\n    if (!isNumber(size)) {\n      size = this.maxObjectSize\n    }\n\n    size = this.calculatePartSize(size)\n\n    // s3 requires that all non-end chunks be at least `this.partSize`,\n    // so we chunk the stream until we hit either that size or the end before\n    // we flush it to s3.\n    let chunker = new BlockStream2({ size, zeroPadding: false })\n\n    // This is a Writable stream that can be written to in order to upload\n    // to the specified bucket and object automatically.\n    let uploader = new ObjectUploader(this, bucketName, objectName, size, metaData, callback)\n    // stream => chunker => uploader\n    pipesetup(stream, chunker, uploader)\n  }\n\n  // Copy the object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `srcObject` _string_: path of the source object to be copied\n  // * `conditions` _CopyConditions_: copy conditions that needs to be satisfied (optional, default `null`)\n  // * `callback(err, {etag, lastModified})` _function_: non null `err` indicates error, `etag` _string_ and `listModifed` _Date_ are respectively the etag and the last modified date of the newly copied object\n  copyObjectV1(arg1, arg2, arg3, arg4, arg5) {\n    var bucketName = arg1\n    var objectName = arg2\n    var srcObject = arg3\n    var conditions, cb\n    if (typeof arg4 == 'function' && arg5 === undefined) {\n      conditions = null\n      cb = arg4\n    } else {\n      conditions = arg4\n      cb = arg5\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(srcObject)) {\n      throw new TypeError('srcObject should be of type \"string\"')\n    }\n    if (srcObject === '') {\n      throw new errors.InvalidPrefixError(`Empty source prefix`)\n    }\n\n    if (conditions !== null && !(conditions instanceof CopyConditions)) {\n      throw new TypeError('conditions should be of type \"CopyConditions\"')\n    }\n\n    var headers = {}\n    headers['x-amz-copy-source'] = uriResourceEscape(srcObject)\n\n    if (conditions !== null) {\n      if (conditions.modified !== '') {\n        headers['x-amz-copy-source-if-modified-since'] = conditions.modified\n      }\n      if (conditions.unmodified !== '') {\n        headers['x-amz-copy-source-if-unmodified-since'] = conditions.unmodified\n      }\n      if (conditions.matchETag !== '') {\n        headers['x-amz-copy-source-if-match'] = conditions.matchETag\n      }\n      if (conditions.matchEtagExcept !== '') {\n        headers['x-amz-copy-source-if-none-match'] = conditions.matchETagExcept\n      }\n    }\n\n    var method = 'PUT'\n    this.makeRequest({ method, bucketName, objectName, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getCopyObjectTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => cb(null, data))\n    })\n  }\n\n  /**\n   * Internal Method to perform copy of an object.\n   * @param sourceConfig __object__   instance of CopySourceOptions @link ./helpers/CopySourceOptions\n   * @param destConfig  __object__   instance of CopyDestinationOptions @link ./helpers/CopyDestinationOptions\n   * @param cb __function__ called with null if there is an error\n   * @returns Promise if no callack is passed.\n   */\n  copyObjectV2(sourceConfig, destConfig, cb) {\n    if (!(sourceConfig instanceof CopySourceOptions)) {\n      throw new errors.InvalidArgumentError('sourceConfig should of type CopySourceOptions ')\n    }\n    if (!(destConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n    if (!destConfig.validate()) {\n      return false\n    }\n    if (!destConfig.validate()) {\n      return false\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const headers = Object.assign({}, sourceConfig.getHeaders(), destConfig.getHeaders())\n\n    const bucketName = destConfig.Bucket\n    const objectName = destConfig.Object\n\n    const method = 'PUT'\n    this.makeRequest({ method, bucketName, objectName, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      const transformer = transformers.getCopyObjectTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => {\n          const resHeaders = response.headers\n\n          const copyObjResponse = {\n            Bucket: destConfig.Bucket,\n            Key: destConfig.Object,\n            LastModified: data.LastModified,\n            MetaData: extractMetadata(resHeaders),\n            VersionId: getVersionId(resHeaders),\n            SourceVersionId: getSourceVersionId(resHeaders),\n            Etag: sanitizeETag(resHeaders.etag),\n            Size: +resHeaders['content-length'],\n          }\n\n          return cb(null, copyObjResponse)\n        })\n    })\n  }\n\n  // Backward compatibility for Copy Object API.\n  copyObject(...allArgs) {\n    if (allArgs[0] instanceof CopySourceOptions && allArgs[1] instanceof CopyDestinationOptions) {\n      return this.copyObjectV2(...arguments)\n    }\n    return this.copyObjectV1(...arguments)\n  }\n\n  // list a batch of objects\n  listObjectsQuery(bucketName, prefix, marker, listQueryOpts = {}) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(marker)) {\n      throw new TypeError('marker should be of type \"string\"')\n    }\n    let { Delimiter, MaxKeys, IncludeVersion } = listQueryOpts\n\n    if (!isObject(listQueryOpts)) {\n      throw new TypeError('listQueryOpts should be of type \"object\"')\n    }\n\n    if (!isString(Delimiter)) {\n      throw new TypeError('Delimiter should be of type \"string\"')\n    }\n    if (!isNumber(MaxKeys)) {\n      throw new TypeError('MaxKeys should be of type \"number\"')\n    }\n\n    const queries = []\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(Delimiter)}`)\n    queries.push(`encoding-type=url`)\n\n    if (IncludeVersion) {\n      queries.push(`versions`)\n    }\n\n    if (marker) {\n      marker = uriEscape(marker)\n      if (IncludeVersion) {\n        queries.push(`key-marker=${marker}`)\n      } else {\n        queries.push(`marker=${marker}`)\n      }\n    }\n\n    // no need to escape maxKeys\n    if (MaxKeys) {\n      if (MaxKeys >= 1000) {\n        MaxKeys = 1000\n      }\n      queries.push(`max-keys=${MaxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n\n    var method = 'GET'\n    var transformer = transformers.getListObjectsTransformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // List the objects in the bucket.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `listOpts _object_: query params to list object with below keys\n  // *    listOpts.MaxKeys _int_ maximum number of keys to return\n  // *    listOpts.IncludeVersion  _bool_ true|false to include versions.\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  // * `obj.name` _string_: name of the object\n  // * `obj.prefix` _string_: name of the object prefix\n  // * `obj.size` _number_: size of the object\n  // * `obj.etag` _string_: etag of the object\n  // * `obj.lastModified` _Date_: modified time stamp\n  // * `obj.isDeleteMarker` _boolean_: true if it is a delete marker\n  // * `obj.versionId` _string_: versionId of the object\n  listObjects(bucketName, prefix, recursive, listOpts = {}) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isObject(listOpts)) {\n      throw new TypeError('listOpts should be of type \"object\"')\n    }\n    var marker = ''\n    const listQueryOpts = {\n      Delimiter: recursive ? '' : '/', // if recursive is false set delimiter to '/'\n      MaxKeys: 1000,\n      IncludeVersion: listOpts.IncludeVersion,\n    }\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsQuery(bucketName, prefix, marker, listQueryOpts)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            marker = result.nextMarker || result.versionIdMarker\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // listObjectsV2Query - (List Objects V2) - List some or all (up to 1000) of the objects in a bucket.\n  //\n  // You can use the request parameters as selection criteria to return a subset of the objects in a bucket.\n  // request parameters :-\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: Limits the response to keys that begin with the specified prefix.\n  // * `continuation-token` _string_: Used to continue iterating over a set of objects.\n  // * `delimiter` _string_: A delimiter is a character you use to group keys.\n  // * `max-keys` _number_: Sets the maximum number of keys returned in the response body.\n  // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket.\n  listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(continuationToken)) {\n      throw new TypeError('continuationToken should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    if (!isNumber(maxKeys)) {\n      throw new TypeError('maxKeys should be of type \"number\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    var queries = []\n\n    // Call for listing objects v2 API\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (continuationToken) {\n      continuationToken = uriEscape(continuationToken)\n      queries.push(`continuation-token=${continuationToken}`)\n    }\n    // Set start-after\n    if (startAfter) {\n      startAfter = uriEscape(startAfter)\n      queries.push(`start-after=${startAfter}`)\n    }\n    // no need to escape maxKeys\n    if (maxKeys) {\n      if (maxKeys >= 1000) {\n        maxKeys = 1000\n      }\n      queries.push(`max-keys=${maxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListObjectsV2Transformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // List the objects in the bucket using S3 ListObjects V2\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  //   * `obj.name` _string_: name of the object\n  //   * `obj.prefix` _string_: name of the object prefix\n  //   * `obj.size` _number_: size of the object\n  //   * `obj.etag` _string_: etag of the object\n  //   * `obj.lastModified` _Date_: modified time stamp\n  listObjectsV2(bucketName, prefix, recursive, startAfter) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    // if recursive is false set delimiter to '/'\n    var delimiter = recursive ? '' : '/'\n    var continuationToken = ''\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, 1000, startAfter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            continuationToken = result.nextContinuationToken\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // Stat information of the object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `statOpts`  _object_ : Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional).\n  // * `callback(err, stat)` _function_: `err` is not `null` in case of error, `stat` contains the object information:\n  //   * `stat.size` _number_: size of the object\n  //   * `stat.etag` _string_: etag of the object\n  //   * `stat.metaData` _string_: MetaData of the object\n  //   * `stat.lastModified` _Date_: modified time stamp\n  //   * `stat.versionId` _string_: version id of the object if available\n  statObject(bucketName, objectName, statOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    // backward compatibility\n    if (isFunction(statOpts)) {\n      cb = statOpts\n      statOpts = {}\n    }\n\n    if (!isObject(statOpts)) {\n      throw new errors.InvalidArgumentError('statOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var query = querystring.stringify(statOpts)\n    var method = 'HEAD'\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      // We drain the socket so that the connection gets closed. Note that this\n      // is not expensive as the socket will not have any data.\n      response.on('data', () => {})\n\n      const result = {\n        size: +response.headers['content-length'],\n        metaData: extractMetadata(response.headers),\n        lastModified: new Date(response.headers['last-modified']),\n        versionId: getVersionId(response.headers),\n        etag: sanitizeETag(response.headers.etag),\n      }\n\n      cb(null, result)\n    })\n  }\n\n  // Remove the specified object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `removeOpts` _object_: Version of the object in the form `{versionId:'my-uuid', governanceBypass:true|false, forceDelete:true|false}`. Default is `{}`. (optional)\n  // * `callback(err)` _function_: callback function is called with non `null` value in case of error\n  removeObject(bucketName, objectName, removeOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    // backward compatibility\n    if (isFunction(removeOpts)) {\n      cb = removeOpts\n      removeOpts = {}\n    }\n\n    if (!isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    const method = 'DELETE'\n    const queryParams = {}\n\n    if (removeOpts.versionId) {\n      queryParams.versionId = `${removeOpts.versionId}`\n    }\n    const headers = {}\n    if (removeOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n    if (removeOpts.forceDelete) {\n      headers['x-minio-force-delete'] = true\n    }\n\n    const query = querystring.stringify(queryParams)\n\n    let requestOptions = { method, bucketName, objectName, headers }\n    if (query) {\n      requestOptions['query'] = query\n    }\n\n    this.makeRequest(requestOptions, '', [200, 204], '', false, cb)\n  }\n\n  // Remove all the objects residing in the objectsList.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectsList` _array_: array of objects of one of the following:\n  // *         List of Object names as array of strings which are object keys:  ['objectname1','objectname2']\n  // *         List of Object name and versionId as an object:  [{name:\"objectname\",versionId:\"my-version-id\"}]\n\n  removeObjects(bucketName, objectsList, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Array.isArray(objectsList)) {\n      throw new errors.InvalidArgumentError('objectsList should be a list')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const maxEntries = 1000\n    const query = 'delete'\n    const method = 'POST'\n\n    let result = objectsList.reduce(\n      (result, entry) => {\n        result.list.push(entry)\n        if (result.list.length === maxEntries) {\n          result.listOfList.push(result.list)\n          result.list = []\n        }\n        return result\n      },\n      { listOfList: [], list: [] },\n    )\n\n    if (result.list.length > 0) {\n      result.listOfList.push(result.list)\n    }\n\n    const encoder = new TextEncoder()\n    const batchResults = []\n\n    async.eachSeries(\n      result.listOfList,\n      (list, batchCb) => {\n        var objects = []\n        list.forEach(function (value) {\n          if (isObject(value)) {\n            objects.push({ Key: value.name, VersionId: value.versionId })\n          } else {\n            objects.push({ Key: value })\n          }\n        })\n        let deleteObjects = { Delete: { Quiet: true, Object: objects } }\n        const builder = new xml2js.Builder({ headless: true })\n        let payload = builder.buildObject(deleteObjects)\n        payload = encoder.encode(payload)\n        const headers = {}\n\n        headers['Content-MD5'] = toMd5(payload)\n\n        let removeObjectsResult\n        this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', true, (e, response) => {\n          if (e) {\n            return batchCb(e)\n          }\n          pipesetup(response, transformers.removeObjectsTransformer())\n            .on('data', (data) => {\n              removeObjectsResult = data\n            })\n            .on('error', (e) => {\n              return batchCb(e, null)\n            })\n            .on('end', () => {\n              batchResults.push(removeObjectsResult)\n              return batchCb(null, removeObjectsResult)\n            })\n        })\n      },\n      () => {\n        cb(null, _.flatten(batchResults))\n      },\n    )\n  }\n\n  // Get the policy on a bucket or an object prefix.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `callback(err, policy)` _function_: callback function\n  getBucketPolicy(bucketName, cb) {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let method = 'GET'\n    let query = 'policy'\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let policy = Buffer.from('')\n      pipesetup(response, transformers.getConcater())\n        .on('data', (data) => (policy = data))\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, policy.toString())\n        })\n    })\n  }\n\n  // Set the policy on a bucket or an object prefix.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `bucketPolicy` _string_: bucket policy (JSON stringify'ed)\n  // * `callback(err)` _function_: callback function\n  setBucketPolicy(bucketName, policy, cb) {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(policy)) {\n      throw new errors.InvalidBucketPolicyError(`Invalid bucket policy: ${policy} - must be \"string\"`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let method = 'DELETE'\n    let query = 'policy'\n\n    if (policy) {\n      method = 'PUT'\n    }\n\n    this.makeRequest({ method, bucketName, query }, policy, [204], '', false, cb)\n  }\n\n  // Generate a generic presigned URL which can be\n  // used for HTTP methods GET, PUT, HEAD and DELETE\n  //\n  // __Arguments__\n  // * `method` _string_: name of the HTTP method\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  // * `reqParams` _object_: request parameters (optional) e.g {versionId:\"10fa9946-3f64-4137-a58f-888065c0732e\"}\n  // * `requestDate` _Date_: A date object, the url will be issued at (optional)\n  presignedUrl(method, bucketName, objectName, expires, reqParams, requestDate, cb) {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned ' + method + ' url cannot be generated for anonymous requests')\n    }\n    if (isFunction(requestDate)) {\n      cb = requestDate\n      requestDate = new Date()\n    }\n    if (isFunction(reqParams)) {\n      cb = reqParams\n      reqParams = {}\n      requestDate = new Date()\n    }\n    if (isFunction(expires)) {\n      cb = expires\n      reqParams = {}\n      expires = 24 * 60 * 60 * 7 // 7 days in seconds\n      requestDate = new Date()\n    }\n    if (!isNumber(expires)) {\n      throw new TypeError('expires should be of type \"number\"')\n    }\n    if (!isObject(reqParams)) {\n      throw new TypeError('reqParams should be of type \"object\"')\n    }\n    if (!isValidDate(requestDate)) {\n      throw new TypeError('requestDate should be of type \"Date\" and valid')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var query = querystring.stringify(reqParams)\n    this.getBucketRegion(bucketName, (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      // This statement is added to ensure that we send error through\n      // callback on presign failure.\n      var url\n      var reqOptions = this.getRequestOptions({ method, region, bucketName, objectName, query })\n\n      this.checkAndRefreshCreds()\n      try {\n        url = presignSignatureV4(\n          reqOptions,\n          this.accessKey,\n          this.secretKey,\n          this.sessionToken,\n          region,\n          requestDate,\n          expires,\n        )\n      } catch (pe) {\n        return cb(pe)\n      }\n      cb(null, url)\n    })\n  }\n\n  // Generate a presigned URL for GET\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  // * `respHeaders` _object_: response headers to override or request params for query (optional) e.g {versionId:\"10fa9946-3f64-4137-a58f-888065c0732e\"}\n  // * `requestDate` _Date_: A date object, the url will be issued at (optional)\n  presignedGetObject(bucketName, objectName, expires, respHeaders, requestDate, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (isFunction(respHeaders)) {\n      cb = respHeaders\n      respHeaders = {}\n      requestDate = new Date()\n    }\n\n    var validRespHeaders = [\n      'response-content-type',\n      'response-content-language',\n      'response-expires',\n      'response-cache-control',\n      'response-content-disposition',\n      'response-content-encoding',\n    ]\n    validRespHeaders.forEach((header) => {\n      if (respHeaders !== undefined && respHeaders[header] !== undefined && !isString(respHeaders[header])) {\n        throw new TypeError(`response header ${header} should be of type \"string\"`)\n      }\n    })\n    return this.presignedUrl('GET', bucketName, objectName, expires, respHeaders, requestDate, cb)\n  }\n\n  // Generate a presigned URL for PUT. Using this URL, the browser can upload to S3 only with the specified object name.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  presignedPutObject(bucketName, objectName, expires, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    return this.presignedUrl('PUT', bucketName, objectName, expires, cb)\n  }\n\n  // return PostPolicy object\n  newPostPolicy() {\n    return new PostPolicy()\n  }\n\n  // presignedPostPolicy can be used in situations where we want more control on the upload than what\n  // presignedPutObject() provides. i.e Using presignedPostPolicy we will be able to put policy restrictions\n  // on the object's `name` `bucket` `expiry` `Content-Type` `Content-Disposition` `metaData`\n  presignedPostPolicy(postPolicy, cb) {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned POST policy cannot be generated for anonymous requests')\n    }\n    if (!isObject(postPolicy)) {\n      throw new TypeError('postPolicy should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n    this.getBucketRegion(postPolicy.formData.bucket, (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      var date = new Date()\n      var dateStr = makeDateLong(date)\n\n      this.checkAndRefreshCreds()\n\n      if (!postPolicy.policy.expiration) {\n        // 'expiration' is mandatory field for S3.\n        // Set default expiration date of 7 days.\n        var expires = new Date()\n        expires.setSeconds(24 * 60 * 60 * 7)\n        postPolicy.setExpires(expires)\n      }\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-date', dateStr])\n      postPolicy.formData['x-amz-date'] = dateStr\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-algorithm', 'AWS4-HMAC-SHA256'])\n      postPolicy.formData['x-amz-algorithm'] = 'AWS4-HMAC-SHA256'\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-credential', this.accessKey + '/' + getScope(region, date)])\n      postPolicy.formData['x-amz-credential'] = this.accessKey + '/' + getScope(region, date)\n\n      if (this.sessionToken) {\n        postPolicy.policy.conditions.push(['eq', '$x-amz-security-token', this.sessionToken])\n        postPolicy.formData['x-amz-security-token'] = this.sessionToken\n      }\n\n      var policyBase64 = Buffer.from(JSON.stringify(postPolicy.policy)).toString('base64')\n\n      postPolicy.formData.policy = policyBase64\n\n      var signature = postPresignSignatureV4(region, date, this.secretKey, policyBase64)\n\n      postPolicy.formData['x-amz-signature'] = signature\n      var opts = {}\n      opts.region = region\n      opts.bucketName = postPolicy.formData.bucket\n      var reqOptions = this.getRequestOptions(opts)\n      var portStr = this.port == 80 || this.port === 443 ? '' : `:${this.port.toString()}`\n      var urlStr = `${reqOptions.protocol}//${reqOptions.host}${portStr}${reqOptions.path}`\n      cb(null, { postURL: urlStr, formData: postPolicy.formData })\n    })\n  }\n\n  // Calls implemented below are related to multipart.\n\n  // Initiate a new multipart upload.\n  initiateNewMultipartUpload(bucketName, objectName, metaData, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(metaData)) {\n      throw new errors.InvalidObjectNameError('contentType should be of type \"object\"')\n    }\n    var method = 'POST'\n    let headers = Object.assign({}, metaData)\n    var query = 'uploads'\n    this.makeRequest({ method, bucketName, objectName, query, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getInitiateMultipartTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (uploadId) => cb(null, uploadId))\n    })\n  }\n\n  // Complete the multipart upload. After all the parts are uploaded issuing\n  // this call will aggregate the parts on the server into a single object.\n  completeMultipartUpload(bucketName, objectName, uploadId, etags, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isObject(etags)) {\n      throw new TypeError('etags should be of type \"Array\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    var method = 'POST'\n    var query = `uploadId=${uriEscape(uploadId)}`\n\n    var parts = []\n\n    etags.forEach((element) => {\n      parts.push({\n        Part: [\n          {\n            PartNumber: element.part,\n          },\n          {\n            ETag: element.etag,\n          },\n        ],\n      })\n    })\n\n    var payloadObject = { CompleteMultipartUpload: parts }\n    var payload = Xml(payloadObject)\n\n    this.makeRequest({ method, bucketName, objectName, query }, payload, [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getCompleteMultipartTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (result) => {\n          if (result.errCode) {\n            // Multipart Complete API returns an error XML after a 200 http status\n            cb(new errors.S3Error(result.errMessage))\n          } else {\n            const completeMultipartResult = {\n              etag: result.etag,\n              versionId: getVersionId(response.headers),\n            }\n            cb(null, completeMultipartResult)\n          }\n        })\n    })\n  }\n\n  // Get part-info of all parts of an incomplete upload specified by uploadId.\n  listParts(bucketName, objectName, uploadId, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n    var parts = []\n    var listNext = (marker) => {\n      this.listPartsQuery(bucketName, objectName, uploadId, marker, (e, result) => {\n        if (e) {\n          cb(e)\n          return\n        }\n        parts = parts.concat(result.parts)\n        if (result.isTruncated) {\n          listNext(result.marker)\n          return\n        }\n        cb(null, parts)\n      })\n    }\n    listNext(0)\n  }\n\n  // Called by listParts to fetch a batch of part-info\n  listPartsQuery(bucketName, objectName, uploadId, marker, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isNumber(marker)) {\n      throw new TypeError('marker should be of type \"number\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n    var query = ''\n    if (marker && marker !== 0) {\n      query += `part-number-marker=${marker}&`\n    }\n    query += `uploadId=${uriEscape(uploadId)}`\n\n    var method = 'GET'\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getListPartsTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => cb(null, data))\n    })\n  }\n\n  // Called by listIncompleteUploads to fetch a batch of incomplete uploads.\n  listIncompleteUploadsQuery(bucketName, prefix, keyMarker, uploadIdMarker, delimiter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(keyMarker)) {\n      throw new TypeError('keyMarker should be of type \"string\"')\n    }\n    if (!isString(uploadIdMarker)) {\n      throw new TypeError('uploadIdMarker should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    var queries = []\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (keyMarker) {\n      keyMarker = uriEscape(keyMarker)\n      queries.push(`key-marker=${keyMarker}`)\n    }\n    if (uploadIdMarker) {\n      queries.push(`upload-id-marker=${uploadIdMarker}`)\n    }\n\n    var maxUploads = 1000\n    queries.push(`max-uploads=${maxUploads}`)\n    queries.sort()\n    queries.unshift('uploads')\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListMultipartTransformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // Find uploadId of an incomplete upload.\n  findUploadId(bucketName, objectName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n    var latestUpload\n    var listNext = (keyMarker, uploadIdMarker) => {\n      this.listIncompleteUploadsQuery(bucketName, objectName, keyMarker, uploadIdMarker, '')\n        .on('error', (e) => cb(e))\n        .on('data', (result) => {\n          result.uploads.forEach((upload) => {\n            if (upload.key === objectName) {\n              if (!latestUpload || upload.initiated.getTime() > latestUpload.initiated.getTime()) {\n                latestUpload = upload\n                return\n              }\n            }\n          })\n          if (result.isTruncated) {\n            listNext(result.nextKeyMarker, result.nextUploadIdMarker)\n            return\n          }\n          if (latestUpload) {\n            return cb(null, latestUpload.uploadId)\n          }\n          cb(null, undefined)\n        })\n    }\n    listNext('', '')\n  }\n\n  // Returns a function that can be used for uploading objects.\n  // If multipart === true, it returns function that is used to upload\n  // a part of the multipart.\n  getUploader(bucketName, objectName, metaData, multipart) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isBoolean(multipart)) {\n      throw new TypeError('multipart should be of type \"boolean\"')\n    }\n    if (!isObject(metaData)) {\n      throw new TypeError('metadata should be of type \"object\"')\n    }\n\n    var validate = (stream, length, sha256sum, md5sum, cb) => {\n      if (!isReadableStream(stream)) {\n        throw new TypeError('stream should be of type \"Stream\"')\n      }\n      if (!isNumber(length)) {\n        throw new TypeError('length should be of type \"number\"')\n      }\n      if (!isString(sha256sum)) {\n        throw new TypeError('sha256sum should be of type \"string\"')\n      }\n      if (!isString(md5sum)) {\n        throw new TypeError('md5sum should be of type \"string\"')\n      }\n      if (!isFunction(cb)) {\n        throw new TypeError('callback should be of type \"function\"')\n      }\n    }\n    var simpleUploader = (...args) => {\n      validate(...args)\n      var query = ''\n      upload(query, ...args)\n    }\n    var multipartUploader = (uploadId, partNumber, ...rest) => {\n      if (!isString(uploadId)) {\n        throw new TypeError('uploadId should be of type \"string\"')\n      }\n      if (!isNumber(partNumber)) {\n        throw new TypeError('partNumber should be of type \"number\"')\n      }\n      if (!uploadId) {\n        throw new errors.InvalidArgumentError('Empty uploadId')\n      }\n      if (!partNumber) {\n        throw new errors.InvalidArgumentError('partNumber cannot be 0')\n      }\n      validate(...rest)\n      var query = `partNumber=${partNumber}&uploadId=${uriEscape(uploadId)}`\n      upload(query, ...rest)\n    }\n    var upload = (query, stream, length, sha256sum, md5sum, cb) => {\n      var method = 'PUT'\n      let headers = { 'Content-Length': length }\n\n      if (!multipart) {\n        headers = Object.assign({}, metaData, headers)\n      }\n\n      if (!this.enableSHA256) {\n        headers['Content-MD5'] = md5sum\n      }\n      this.makeRequestStream(\n        { method, bucketName, objectName, query, headers },\n        stream,\n        sha256sum,\n        [200],\n        '',\n        true,\n        (e, response) => {\n          if (e) {\n            return cb(e)\n          }\n          const result = {\n            etag: sanitizeETag(response.headers.etag),\n            versionId: getVersionId(response.headers),\n          }\n          // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n          response.on('data', () => {})\n          cb(null, result)\n        },\n      )\n    }\n    if (multipart) {\n      return multipartUploader\n    }\n    return simpleUploader\n  }\n\n  // Remove all the notification configurations in the S3 provider\n  setBucketNotification(bucketName, config, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(config)) {\n      throw new TypeError('notification config should be of type \"Object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'PUT'\n    var query = 'notification'\n    var builder = new xml2js.Builder({\n      rootName: 'NotificationConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    var payload = builder.buildObject(config)\n    this.makeRequest({ method, bucketName, query }, payload, [200], '', false, cb)\n  }\n\n  removeAllBucketNotification(bucketName, cb) {\n    this.setBucketNotification(bucketName, new NotificationConfig(), cb)\n  }\n\n  // Return the list of notification configurations stored\n  // in the S3 provider\n  getBucketNotification(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    var query = 'notification'\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getBucketNotificationTransformer()\n      var bucketNotification\n      pipesetup(response, transformer)\n        .on('data', (result) => (bucketNotification = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, bucketNotification))\n    })\n  }\n\n  // Listens for bucket notifications. Returns an EventEmitter.\n  listenBucketNotification(bucketName, prefix, suffix, events) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix must be of type string')\n    }\n    if (!isString(suffix)) {\n      throw new TypeError('suffix must be of type string')\n    }\n    if (!Array.isArray(events)) {\n      throw new TypeError('events must be of type Array')\n    }\n    let listener = new NotificationPoller(this, bucketName, prefix, suffix, events)\n    listener.start()\n\n    return listener\n  }\n\n  getBucketVersioning(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    var query = 'versioning'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let versionConfig = Buffer.from('')\n      pipesetup(response, transformers.bucketVersioningTransformer())\n        .on('data', (data) => {\n          versionConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, versionConfig)\n        })\n    })\n  }\n\n  setBucketVersioning(bucketName, versionConfig, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Object.keys(versionConfig).length) {\n      throw new errors.InvalidArgumentError('versionConfig should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var method = 'PUT'\n    var query = 'versioning'\n    var builder = new xml2js.Builder({\n      rootName: 'VersioningConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    var payload = builder.buildObject(versionConfig)\n\n    this.makeRequest({ method, bucketName, query }, payload, [200], '', false, cb)\n  }\n\n  /** To set Tags on a bucket or object based on the params\n   *  __Arguments__\n   * taggingParams _object_ Which contains the following properties\n   *  bucketName _string_,\n   *  objectName _string_ (Optional),\n   *  tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   *  putOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   *  cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setTagging(taggingParams) {\n    const { bucketName, objectName, tags, putOpts = {}, cb } = taggingParams\n    const method = 'PUT'\n    let query = 'tagging'\n\n    if (putOpts && putOpts.versionId) {\n      query = `${query}&versionId=${putOpts.versionId}`\n    }\n    const tagsList = []\n    for (const [key, value] of Object.entries(tags)) {\n      tagsList.push({ Key: key, Value: value })\n    }\n    const taggingConfig = {\n      Tagging: {\n        TagSet: {\n          Tag: tagsList,\n        },\n      },\n    }\n    const encoder = new TextEncoder()\n    const headers = {}\n    const builder = new xml2js.Builder({ headless: true, renderOpts: { pretty: false } })\n    let payload = builder.buildObject(taggingConfig)\n    payload = encoder.encode(payload)\n    headers['Content-MD5'] = toMd5(payload)\n    const requestOptions = { method, bucketName, query, headers }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest(requestOptions, payload, [200], '', false, cb)\n  }\n\n  /** Set Tags on a Bucket\n   * __Arguments__\n   * bucketName _string_\n   * tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setBucketTagging(bucketName, tags, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('maximum tags allowed is 10\"')\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    return this.setTagging({ bucketName, tags, cb })\n  }\n\n  /** Set Tags on an Object\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_\n   *  * tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   *  putOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setObjectTagging(bucketName, objectName, tags, putOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n\n    if (isFunction(putOpts)) {\n      cb = putOpts\n      putOpts = {}\n    }\n\n    if (!isObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('Maximum tags allowed is 10\"')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    return this.setTagging({ bucketName, objectName, tags, putOpts, cb })\n  }\n\n  /** Remove Tags on an Bucket/Object based on params\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_ (optional)\n   * removeOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeTagging({ bucketName, objectName, removeOpts, cb }) {\n    const method = 'DELETE'\n    let query = 'tagging'\n\n    if (removeOpts && Object.keys(removeOpts).length && removeOpts.versionId) {\n      query = `${query}&versionId=${removeOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, objectName, query }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    this.makeRequest(requestOptions, '', [200, 204], '', true, cb)\n  }\n\n  /** Remove Tags associated with a bucket\n   *  __Arguments__\n   * bucketName _string_\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeBucketTagging(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    return this.removeTagging({ bucketName, cb })\n  }\n\n  /** Remove tags associated with an object\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_\n   * removeOpts _object_ (Optional) e.g. {VersionID:\"my-object-version-id\"}\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeObjectTagging(bucketName, objectName, removeOpts, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (isFunction(removeOpts)) {\n      cb = removeOpts\n      removeOpts = {}\n    }\n    if (removeOpts && Object.keys(removeOpts).length && !isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    return this.removeTagging({ bucketName, objectName, removeOpts, cb })\n  }\n\n  /** Get Tags associated with a Bucket\n   *  __Arguments__\n   * bucketName _string_\n   * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  getBucketTagging(bucketName, cb) {\n    const method = 'GET'\n    const query = 'tagging'\n    const requestOptions = { method, bucketName, query }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      var transformer = transformers.getTagsTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let tagsList\n      pipesetup(response, transformer)\n        .on('data', (result) => (tagsList = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, tagsList))\n    })\n  }\n\n  /** Get the tags associated with a bucket OR an object\n   * bucketName _string_\n   * objectName _string_ (Optional)\n   * getOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"}\n   * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  getObjectTagging(bucketName, objectName, getOpts = {}, cb = () => false) {\n    const method = 'GET'\n    let query = 'tagging'\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n    if (!isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('getOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    if (getOpts && getOpts.versionId) {\n      query = `${query}&versionId=${getOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, query }\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      const transformer = transformers.getTagsTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let tagsList\n      pipesetup(response, transformer)\n        .on('data', (result) => (tagsList = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, tagsList))\n    })\n  }\n\n  /**\n   * Apply lifecycle configuration on a bucket.\n   * bucketName _string_\n   * policyConfig _object_ a valid policy configuration object.\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  applyBucketLifecycle(bucketName, policyConfig, cb) {\n    const method = 'PUT'\n    const query = 'lifecycle'\n\n    const encoder = new TextEncoder()\n    const headers = {}\n    const builder = new xml2js.Builder({\n      rootName: 'LifecycleConfiguration',\n      headless: true,\n      renderOpts: { pretty: false },\n    })\n    let payload = builder.buildObject(policyConfig)\n    payload = encoder.encode(payload)\n    const requestOptions = { method, bucketName, query, headers }\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest(requestOptions, payload, [200], '', false, cb)\n  }\n\n  /** Remove lifecycle configuration of a bucket.\n   * bucketName _string_\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeBucketLifecycle(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'lifecycle'\n    this.makeRequest({ method, bucketName, query }, '', [204], '', false, cb)\n  }\n\n  /** Set/Override lifecycle configuration on a bucket. if the configuration is empty, it removes the configuration.\n   * bucketName _string_\n   * lifeCycleConfig _object_ one of the following values: (null or '') to remove the lifecycle configuration. or a valid lifecycle configuration\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setBucketLifecycle(bucketName, lifeCycleConfig = null, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (_.isEmpty(lifeCycleConfig)) {\n      this.removeBucketLifecycle(bucketName, cb)\n    } else {\n      this.applyBucketLifecycle(bucketName, lifeCycleConfig, cb)\n    }\n  }\n\n  /** Get lifecycle configuration on a bucket.\n   * bucketName _string_\n   * `cb(config)` _function_ - callback function with lifecycle configuration as the error argument.\n   */\n  getBucketLifecycle(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'lifecycle'\n    const requestOptions = { method, bucketName, query }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      const transformer = transformers.lifecycleTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let lifecycleConfig\n      pipesetup(response, transformer)\n        .on('data', (result) => (lifecycleConfig = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, lifecycleConfig))\n    })\n  }\n\n  setObjectLockConfig(bucketName, lockConfigOpts = {}, cb) {\n    const retentionModes = [RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE]\n    const validUnits = [RETENTION_VALIDITY_UNITS.DAYS, RETENTION_VALIDITY_UNITS.YEARS]\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (lockConfigOpts.mode && !retentionModes.includes(lockConfigOpts.mode)) {\n      throw new TypeError(`lockConfigOpts.mode should be one of ${retentionModes}`)\n    }\n    if (lockConfigOpts.unit && !validUnits.includes(lockConfigOpts.unit)) {\n      throw new TypeError(`lockConfigOpts.unit should be one of ${validUnits}`)\n    }\n    if (lockConfigOpts.validity && !isNumber(lockConfigOpts.validity)) {\n      throw new TypeError(`lockConfigOpts.validity should be a number`)\n    }\n\n    const method = 'PUT'\n    const query = 'object-lock'\n\n    let config = {\n      ObjectLockEnabled: 'Enabled',\n    }\n    const configKeys = Object.keys(lockConfigOpts)\n    // Check if keys are present and all keys are present.\n    if (configKeys.length > 0) {\n      if (_.difference(configKeys, ['unit', 'mode', 'validity']).length !== 0) {\n        throw new TypeError(\n          `lockConfigOpts.mode,lockConfigOpts.unit,lockConfigOpts.validity all the properties should be specified.`,\n        )\n      } else {\n        config.Rule = {\n          DefaultRetention: {},\n        }\n        if (lockConfigOpts.mode) {\n          config.Rule.DefaultRetention.Mode = lockConfigOpts.mode\n        }\n        if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.DAYS) {\n          config.Rule.DefaultRetention.Days = lockConfigOpts.validity\n        } else if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.YEARS) {\n          config.Rule.DefaultRetention.Years = lockConfigOpts.validity\n        }\n      }\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'ObjectLockConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getObjectLockConfig(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'object-lock'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let objectLockConfig = Buffer.from('')\n      pipesetup(response, transformers.objectLockTransformer())\n        .on('data', (data) => {\n          objectLockConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, objectLockConfig)\n        })\n    })\n  }\n\n  putObjectRetention(bucketName, objectName, retentionOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(retentionOpts)) {\n      throw new errors.InvalidArgumentError('retentionOpts should be of type \"object\"')\n    } else {\n      if (retentionOpts.governanceBypass && !isBoolean(retentionOpts.governanceBypass)) {\n        throw new errors.InvalidArgumentError('Invalid value for governanceBypass', retentionOpts.governanceBypass)\n      }\n      if (\n        retentionOpts.mode &&\n        ![RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE].includes(retentionOpts.mode)\n      ) {\n        throw new errors.InvalidArgumentError('Invalid object retention mode ', retentionOpts.mode)\n      }\n      if (retentionOpts.retainUntilDate && !isString(retentionOpts.retainUntilDate)) {\n        throw new errors.InvalidArgumentError('Invalid value for retainUntilDate', retentionOpts.retainUntilDate)\n      }\n      if (retentionOpts.versionId && !isString(retentionOpts.versionId)) {\n        throw new errors.InvalidArgumentError('Invalid value for versionId', retentionOpts.versionId)\n      }\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'PUT'\n    let query = 'retention'\n\n    const headers = {}\n    if (retentionOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'Retention', renderOpts: { pretty: false }, headless: true })\n    const params = {}\n\n    if (retentionOpts.mode) {\n      params.Mode = retentionOpts.mode\n    }\n    if (retentionOpts.retainUntilDate) {\n      params.RetainUntilDate = retentionOpts.retainUntilDate\n    }\n    if (retentionOpts.versionId) {\n      query += `&versionId=${retentionOpts.versionId}`\n    }\n\n    let payload = builder.buildObject(params)\n\n    headers['Content-MD5'] = toMd5(payload)\n    this.makeRequest({ method, bucketName, objectName, query, headers }, payload, [200, 204], '', false, cb)\n  }\n\n  getObjectRetention(bucketName, objectName, getOpts, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"object\"')\n    } else if (getOpts.versionId && !isString(getOpts.versionId)) {\n      throw new errors.InvalidArgumentError('VersionID should be of type \"string\"')\n    }\n    if (cb && !isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    let query = 'retention'\n    if (getOpts.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let retentionConfig = Buffer.from('')\n      pipesetup(response, transformers.objectRetentionTransformer())\n        .on('data', (data) => {\n          retentionConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, retentionConfig)\n        })\n    })\n  }\n\n  setBucketEncryption(bucketName, encryptionConfig, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (isFunction(encryptionConfig)) {\n      cb = encryptionConfig\n      encryptionConfig = null\n    }\n\n    if (!_.isEmpty(encryptionConfig) && encryptionConfig.Rule.length > 1) {\n      throw new errors.InvalidArgumentError('Invalid Rule length. Only one rule is allowed.: ' + encryptionConfig.Rule)\n    }\n    if (cb && !isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let encryptionObj = encryptionConfig\n    if (_.isEmpty(encryptionConfig)) {\n      encryptionObj = {\n        // Default MinIO Server Supported Rule\n        Rule: [\n          {\n            ApplyServerSideEncryptionByDefault: {\n              SSEAlgorithm: 'AES256',\n            },\n          },\n        ],\n      }\n    }\n\n    let method = 'PUT'\n    let query = 'encryption'\n    let builder = new xml2js.Builder({\n      rootName: 'ServerSideEncryptionConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    let payload = builder.buildObject(encryptionObj)\n\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getBucketEncryption(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'encryption'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let bucketEncConfig = Buffer.from('')\n      pipesetup(response, transformers.bucketEncryptionTransformer())\n        .on('data', (data) => {\n          bucketEncConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, bucketEncConfig)\n        })\n    })\n  }\n  removeBucketEncryption(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'DELETE'\n    const query = 'encryption'\n\n    this.makeRequest({ method, bucketName, query }, '', [204], '', false, cb)\n  }\n\n  setBucketReplication(bucketName, replicationConfig = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(replicationConfig)) {\n      throw new errors.InvalidArgumentError('replicationConfig should be of type \"object\"')\n    } else {\n      if (_.isEmpty(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Role cannot be empty')\n      } else if (replicationConfig.role && !isString(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role)\n      }\n      if (_.isEmpty(replicationConfig.rules)) {\n        throw new errors.InvalidArgumentError('Minimum one replication rule must be specified')\n      }\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'PUT'\n    let query = 'replication'\n    const headers = {}\n\n    const replicationParamsConfig = {\n      ReplicationConfiguration: {\n        Role: replicationConfig.role,\n        Rule: replicationConfig.rules,\n      },\n    }\n\n    const builder = new xml2js.Builder({ renderOpts: { pretty: false }, headless: true })\n\n    let payload = builder.buildObject(replicationParamsConfig)\n\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getBucketReplication(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'replication'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let replicationConfig = Buffer.from('')\n      pipesetup(response, transformers.replicationConfigTransformer())\n        .on('data', (data) => {\n          replicationConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, replicationConfig)\n        })\n    })\n  }\n\n  removeBucketReplication(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'replication'\n    this.makeRequest({ method, bucketName, query }, '', [200, 204], '', false, cb)\n  }\n\n  getObjectLegalHold(bucketName, objectName, getOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isObject(getOpts)) {\n      throw new TypeError('getOpts should be of type \"Object\"')\n    } else if (Object.keys(getOpts).length > 0 && getOpts.versionId && !isString(getOpts.versionId)) {\n      throw new TypeError('versionId should be of type string.:', getOpts.versionId)\n    }\n\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    const method = 'GET'\n    let query = 'legal-hold'\n\n    if (getOpts.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let legalHoldConfig = Buffer.from('')\n      pipesetup(response, transformers.objectLegalHoldTransformer())\n        .on('data', (data) => {\n          legalHoldConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, legalHoldConfig)\n        })\n    })\n  }\n\n  setObjectLegalHold(bucketName, objectName, setOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    const defaultOpts = {\n      status: LEGAL_HOLD_STATUS.ENABLED,\n    }\n    if (isFunction(setOpts)) {\n      cb = setOpts\n      setOpts = defaultOpts\n    }\n\n    if (!isObject(setOpts)) {\n      throw new TypeError('setOpts should be of type \"Object\"')\n    } else {\n      if (![LEGAL_HOLD_STATUS.ENABLED, LEGAL_HOLD_STATUS.DISABLED].includes(setOpts.status)) {\n        throw new TypeError('Invalid status: ' + setOpts.status)\n      }\n      if (setOpts.versionId && !setOpts.versionId.length) {\n        throw new TypeError('versionId should be of type string.:' + setOpts.versionId)\n      }\n    }\n\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    if (_.isEmpty(setOpts)) {\n      setOpts = {\n        defaultOpts,\n      }\n    }\n\n    const method = 'PUT'\n    let query = 'legal-hold'\n\n    if (setOpts.versionId) {\n      query += `&versionId=${setOpts.versionId}`\n    }\n\n    let config = {\n      Status: setOpts.status,\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'LegalHold', renderOpts: { pretty: false }, headless: true })\n    const payload = builder.buildObject(config)\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, objectName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  /**\n   * Internal Method to abort a multipart upload request in case of any errors.\n   * @param bucketName __string__ Bucket Name\n   * @param objectName __string__ Object Name\n   * @param uploadId __string__ id of a multipart upload to cancel during compose object sequence.\n   * @param cb __function__ callback function\n   */\n  abortMultipartUpload(bucketName, objectName, uploadId, cb) {\n    const method = 'DELETE'\n    let query = `uploadId=${uploadId}`\n\n    const requestOptions = { method, bucketName, objectName: objectName, query }\n    this.makeRequest(requestOptions, '', [204], '', false, cb)\n  }\n\n  /**\n   * Internal method to upload a part during compose object.\n   * @param partConfig __object__ contains the following.\n   *    bucketName __string__\n   *    objectName __string__\n   *    uploadID __string__\n   *    partNumber __number__\n   *    headers __object__\n   * @param cb called with null incase of error.\n   */\n  uploadPartCopy(partConfig, cb) {\n    const { bucketName, objectName, uploadID, partNumber, headers } = partConfig\n\n    const method = 'PUT'\n    let query = `uploadId=${uploadID}&partNumber=${partNumber}`\n    const requestOptions = { method, bucketName, objectName: objectName, query, headers }\n    return this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      let partCopyResult = Buffer.from('')\n      if (e) {\n        return cb(e)\n      }\n      pipesetup(response, transformers.uploadPartTransformer())\n        .on('data', (data) => {\n          partCopyResult = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          let uploadPartCopyRes = {\n            etag: sanitizeETag(partCopyResult.ETag),\n            key: objectName,\n            part: partNumber,\n          }\n\n          cb(null, uploadPartCopyRes)\n        })\n    })\n  }\n\n  composeObject(destObjConfig = {}, sourceObjList = [], cb) {\n    const me = this // many async flows. so store the ref.\n    const sourceFilesLength = sourceObjList.length\n\n    if (!Array.isArray(sourceObjList)) {\n      throw new errors.InvalidArgumentError('sourceConfig should an array of CopySourceOptions ')\n    }\n    if (!(destObjConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n\n    if (sourceFilesLength < 1 || sourceFilesLength > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n      throw new errors.InvalidArgumentError(\n        `\"There must be as least one and up to ${PART_CONSTRAINTS.MAX_PARTS_COUNT} source objects.`,\n      )\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    for (let i = 0; i < sourceFilesLength; i++) {\n      if (!sourceObjList[i].validate()) {\n        return false\n      }\n    }\n\n    if (!destObjConfig.validate()) {\n      return false\n    }\n\n    const getStatOptions = (srcConfig) => {\n      let statOpts = {}\n      if (!_.isEmpty(srcConfig.VersionID)) {\n        statOpts = {\n          versionId: srcConfig.VersionID,\n        }\n      }\n      return statOpts\n    }\n    const srcObjectSizes = []\n    let totalSize = 0\n    let totalParts = 0\n\n    const sourceObjStats = sourceObjList.map((srcItem) =>\n      me.statObject(srcItem.Bucket, srcItem.Object, getStatOptions(srcItem)),\n    )\n\n    return Promise.all(sourceObjStats)\n      .then((srcObjectInfos) => {\n        const validatedStats = srcObjectInfos.map((resItemStat, index) => {\n          const srcConfig = sourceObjList[index]\n\n          let srcCopySize = resItemStat.size\n          // Check if a segment is specified, and if so, is the\n          // segment within object bounds?\n          if (srcConfig.MatchRange) {\n            // Since range is specified,\n            //    0 <= src.srcStart <= src.srcEnd\n            // so only invalid case to check is:\n            const srcStart = srcConfig.Start\n            const srcEnd = srcConfig.End\n            if (srcEnd >= srcCopySize || srcStart < 0) {\n              throw new errors.InvalidArgumentError(\n                `CopySrcOptions ${index} has invalid segment-to-copy [${srcStart}, ${srcEnd}] (size is ${srcCopySize})`,\n              )\n            }\n            srcCopySize = srcEnd - srcStart + 1\n          }\n\n          // Only the last source may be less than `absMinPartSize`\n          if (srcCopySize < PART_CONSTRAINTS.ABS_MIN_PART_SIZE && index < sourceFilesLength - 1) {\n            throw new errors.InvalidArgumentError(\n              `CopySrcOptions ${index} is too small (${srcCopySize}) and it is not the last part.`,\n            )\n          }\n\n          // Is data to copy too large?\n          totalSize += srcCopySize\n          if (totalSize > PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE) {\n            throw new errors.InvalidArgumentError(`Cannot compose an object of size ${totalSize} (> 5TiB)`)\n          }\n\n          // record source size\n          srcObjectSizes[index] = srcCopySize\n\n          // calculate parts needed for current source\n          totalParts += partsRequired(srcCopySize)\n          // Do we need more parts than we are allowed?\n          if (totalParts > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n            throw new errors.InvalidArgumentError(\n              `Your proposed compose object requires more than ${PART_CONSTRAINTS.MAX_PARTS_COUNT} parts`,\n            )\n          }\n\n          return resItemStat\n        })\n\n        if ((totalParts === 1 && totalSize <= PART_CONSTRAINTS.MAX_PART_SIZE) || totalSize === 0) {\n          return this.copyObject(sourceObjList[0], destObjConfig, cb) // use copyObjectV2\n        }\n\n        // preserve etag to avoid modification of object while copying.\n        for (let i = 0; i < sourceFilesLength; i++) {\n          sourceObjList[i].MatchETag = validatedStats[i].etag\n        }\n\n        const splitPartSizeList = validatedStats.map((resItemStat, idx) => {\n          const calSize = calculateEvenSplits(srcObjectSizes[idx], sourceObjList[idx])\n          return calSize\n        })\n\n        function getUploadPartConfigList(uploadId) {\n          const uploadPartConfigList = []\n\n          splitPartSizeList.forEach((splitSize, splitIndex) => {\n            const { startIndex: startIdx, endIndex: endIdx, objInfo: objConfig } = splitSize\n\n            let partIndex = splitIndex + 1 // part index starts from 1.\n            const totalUploads = Array.from(startIdx)\n\n            const headers = sourceObjList[splitIndex].getHeaders()\n\n            totalUploads.forEach((splitStart, upldCtrIdx) => {\n              let splitEnd = endIdx[upldCtrIdx]\n\n              const sourceObj = `${objConfig.Bucket}/${objConfig.Object}`\n              headers['x-amz-copy-source'] = `${sourceObj}`\n              headers['x-amz-copy-source-range'] = `bytes=${splitStart}-${splitEnd}`\n\n              const uploadPartConfig = {\n                bucketName: destObjConfig.Bucket,\n                objectName: destObjConfig.Object,\n                uploadID: uploadId,\n                partNumber: partIndex,\n                headers: headers,\n                sourceObj: sourceObj,\n              }\n\n              uploadPartConfigList.push(uploadPartConfig)\n            })\n          })\n\n          return uploadPartConfigList\n        }\n\n        const performUploadParts = (uploadId) => {\n          const uploadList = getUploadPartConfigList(uploadId)\n\n          async.map(uploadList, me.uploadPartCopy.bind(me), (err, res) => {\n            if (err) {\n              return this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, cb)\n            }\n            const partsDone = res.map((partCopy) => ({ etag: partCopy.etag, part: partCopy.part }))\n            return me.completeMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, partsDone, cb)\n          })\n        }\n\n        const newUploadHeaders = destObjConfig.getHeaders()\n\n        me.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders, (err, uploadId) => {\n          if (err) {\n            return cb(err, null)\n          }\n          performUploadParts(uploadId)\n        })\n      })\n      .catch((error) => {\n        cb(error, null)\n      })\n  }\n  selectObjectContent(bucketName, objectName, selectOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!_.isEmpty(selectOpts)) {\n      if (!isString(selectOpts.expression)) {\n        throw new TypeError('sqlExpression should be of type \"string\"')\n      }\n      if (!_.isEmpty(selectOpts.inputSerialization)) {\n        if (!isObject(selectOpts.inputSerialization)) {\n          throw new TypeError('inputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('inputSerialization is required')\n      }\n      if (!_.isEmpty(selectOpts.outputSerialization)) {\n        if (!isObject(selectOpts.outputSerialization)) {\n          throw new TypeError('outputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('outputSerialization is required')\n      }\n    } else {\n      throw new TypeError('valid select configuration is required')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'POST'\n    let query = `select`\n    query += '&select-type=2'\n\n    const config = [\n      {\n        Expression: selectOpts.expression,\n      },\n      {\n        ExpressionType: selectOpts.expressionType || 'SQL',\n      },\n      {\n        InputSerialization: [selectOpts.inputSerialization],\n      },\n      {\n        OutputSerialization: [selectOpts.outputSerialization],\n      },\n    ]\n\n    // Optional\n    if (selectOpts.requestProgress) {\n      config.push({ RequestProgress: selectOpts.requestProgress })\n    }\n    // Optional\n    if (selectOpts.scanRange) {\n      config.push({ ScanRange: selectOpts.scanRange })\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'SelectObjectContentRequest',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    this.makeRequest({ method, bucketName, objectName, query }, payload, [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let selectResult\n      pipesetup(response, transformers.selectObjectContentTransformer())\n        .on('data', (data) => {\n          selectResult = parseSelectObjectContentResponse(data)\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, selectResult)\n        })\n    })\n  }\n\n  get extensions() {\n    if (!this.clientExtensions) {\n      this.clientExtensions = new extensions(this)\n    }\n    return this.clientExtensions\n  }\n}\n\n// Promisify various public-facing APIs on the Client module.\nClient.prototype.makeBucket = promisify(Client.prototype.makeBucket)\nClient.prototype.listBuckets = promisify(Client.prototype.listBuckets)\nClient.prototype.bucketExists = promisify(Client.prototype.bucketExists)\nClient.prototype.removeBucket = promisify(Client.prototype.removeBucket)\n\nClient.prototype.getObject = promisify(Client.prototype.getObject)\nClient.prototype.getPartialObject = promisify(Client.prototype.getPartialObject)\nClient.prototype.fGetObject = promisify(Client.prototype.fGetObject)\nClient.prototype.putObject = promisify(Client.prototype.putObject)\nClient.prototype.fPutObject = promisify(Client.prototype.fPutObject)\nClient.prototype.copyObject = promisify(Client.prototype.copyObject)\nClient.prototype.statObject = promisify(Client.prototype.statObject)\nClient.prototype.removeObject = promisify(Client.prototype.removeObject)\nClient.prototype.removeObjects = promisify(Client.prototype.removeObjects)\n\nClient.prototype.presignedUrl = promisify(Client.prototype.presignedUrl)\nClient.prototype.presignedGetObject = promisify(Client.prototype.presignedGetObject)\nClient.prototype.presignedPutObject = promisify(Client.prototype.presignedPutObject)\nClient.prototype.presignedPostPolicy = promisify(Client.prototype.presignedPostPolicy)\nClient.prototype.getBucketNotification = promisify(Client.prototype.getBucketNotification)\nClient.prototype.setBucketNotification = promisify(Client.prototype.setBucketNotification)\nClient.prototype.removeAllBucketNotification = promisify(Client.prototype.removeAllBucketNotification)\nClient.prototype.getBucketPolicy = promisify(Client.prototype.getBucketPolicy)\nClient.prototype.setBucketPolicy = promisify(Client.prototype.setBucketPolicy)\nClient.prototype.removeIncompleteUpload = promisify(Client.prototype.removeIncompleteUpload)\nClient.prototype.getBucketVersioning = promisify(Client.prototype.getBucketVersioning)\nClient.prototype.setBucketVersioning = promisify(Client.prototype.setBucketVersioning)\nClient.prototype.setBucketTagging = promisify(Client.prototype.setBucketTagging)\nClient.prototype.removeBucketTagging = promisify(Client.prototype.removeBucketTagging)\nClient.prototype.getBucketTagging = promisify(Client.prototype.getBucketTagging)\nClient.prototype.setObjectTagging = promisify(Client.prototype.setObjectTagging)\nClient.prototype.removeObjectTagging = promisify(Client.prototype.removeObjectTagging)\nClient.prototype.getObjectTagging = promisify(Client.prototype.getObjectTagging)\nClient.prototype.setBucketLifecycle = promisify(Client.prototype.setBucketLifecycle)\nClient.prototype.getBucketLifecycle = promisify(Client.prototype.getBucketLifecycle)\nClient.prototype.removeBucketLifecycle = promisify(Client.prototype.removeBucketLifecycle)\nClient.prototype.setObjectLockConfig = promisify(Client.prototype.setObjectLockConfig)\nClient.prototype.getObjectLockConfig = promisify(Client.prototype.getObjectLockConfig)\nClient.prototype.putObjectRetention = promisify(Client.prototype.putObjectRetention)\nClient.prototype.getObjectRetention = promisify(Client.prototype.getObjectRetention)\nClient.prototype.setBucketEncryption = promisify(Client.prototype.setBucketEncryption)\nClient.prototype.getBucketEncryption = promisify(Client.prototype.getBucketEncryption)\nClient.prototype.removeBucketEncryption = promisify(Client.prototype.removeBucketEncryption)\nClient.prototype.setBucketReplication = promisify(Client.prototype.setBucketReplication)\nClient.prototype.getBucketReplication = promisify(Client.prototype.getBucketReplication)\nClient.prototype.removeBucketReplication = promisify(Client.prototype.removeBucketReplication)\nClient.prototype.setObjectLegalHold = promisify(Client.prototype.setObjectLegalHold)\nClient.prototype.getObjectLegalHold = promisify(Client.prototype.getObjectLegalHold)\nClient.prototype.composeObject = promisify(Client.prototype.composeObject)\nClient.prototype.selectObjectContent = promisify(Client.prototype.selectObjectContent)\n"],"mappings":"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"} /***/ }), @@ -81931,18 +85108,25 @@ class ObjectUploader extends _stream.Transform { // If no upload ID exists, initiate a new one. if (!id) { - this.client.initiateNewMultipartUpload(this.bucketName, this.objectName, this.metaData).then(id => { + this.client.initiateNewMultipartUpload(this.bucketName, this.objectName, this.metaData, (err, id) => { + if (err) { + return callback(err); + } this.id = id; // We are now ready to accept new chunks — this will flush the buffered chunk. this.emit('ready'); - }, err => callback(err)); + }); return; } this.id = id; // Retrieve the pre-uploaded parts, if we need to resume the upload. - this.client.listParts(this.bucketName, this.objectName, id).then(etags => { + this.client.listParts(this.bucketName, this.objectName, id, (err, etags) => { + if (err) { + return this.emit('error', err); + } + // It is possible for no parts to be already uploaded. if (!etags) { etags = []; @@ -81956,8 +85140,6 @@ class ObjectUploader extends _stream.Transform { return prev; }, {}); this.emit('ready'); - }, err => { - return this.emit('error', err); }); }); return; @@ -82083,7 +85265,7 @@ class ObjectUploader extends _stream.Transform { exports.ObjectUploader = ObjectUploader; var _default = ObjectUploader; exports["default"] = _default; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Crypto","_interopRequireWildcard","require","_stream","querystring","_helper","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","ObjectUploader","Transform","constructor","client","bucketName","objectName","partSize","metaData","callback","emptyStream","partNumber","oldParts","etags","id","on","err","_transform","chunk","encoding","method","headers","length","md5digest","enableSHA256","createHash","update","digest","toString","options","assign","query","makeRequest","response","result","etag","sanitizeETag","versionId","getVersionId","process","nextTick","once","findUploadId","emit","initiateNewMultipartUpload","then","listParts","reduce","prev","item","part","oldPart","push","stringify","uploadId","replace","_flush","completeMultipartUpload","exports","_default"],"sources":["object-uploader.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Crypto from 'node:crypto'\nimport { Transform } from 'node:stream'\n\nimport * as querystring from 'query-string'\n\nimport { getVersionId, sanitizeETag } from './internal/helper.ts'\n\n// We extend Transform because Writable does not implement ._flush().\nexport class ObjectUploader extends Transform {\n  constructor(client, bucketName, objectName, partSize, metaData, callback) {\n    super()\n    this.emptyStream = true\n    this.client = client\n    this.bucketName = bucketName\n    this.objectName = objectName\n    // The size of each multipart, chunked by BlockStream2.\n    this.partSize = partSize\n    // This is the metadata for the object.\n    this.metaData = metaData\n\n    // Call like: callback(error, {etag, versionId}).\n    this.callback = callback\n\n    // We need to keep track of what number chunk/part we're on. This increments\n    // each time _write() is called. Starts with 1, not 0.\n    this.partNumber = 1\n\n    // A list of the previously uploaded chunks, for resuming a file upload. This\n    // will be null if we aren't resuming an upload.\n    this.oldParts = null\n\n    // Keep track of the etags for aggregating the chunks together later. Each\n    // etag represents a single chunk of the file.\n    this.etags = []\n\n    // This is for the multipart upload request — if null, we're either not initiated\n    // yet or we're flushing in one packet.\n    this.id = null\n\n    // Handle errors.\n    this.on('error', (err) => {\n      callback(err)\n    })\n  }\n\n  _transform(chunk, encoding, callback) {\n    this.emptyStream = false\n    let method = 'PUT'\n    let headers = { 'Content-Length': chunk.length }\n    let md5digest = ''\n\n    // Calculate and set Content-MD5 header if SHA256 is not set.\n    // This will happen only when there is a secure connection to the s3 server.\n    if (!this.client.enableSHA256) {\n      md5digest = Crypto.createHash('md5').update(chunk).digest()\n      headers['Content-MD5'] = md5digest.toString('base64')\n    }\n    // We can flush the object in one packet if it fits in one chunk. This is true\n    // if the chunk size is smaller than the part size, signifying the end of the\n    // stream.\n    if (this.partNumber == 1 && chunk.length < this.partSize) {\n      // PUT the chunk in a single request — use an empty query.\n      let options = {\n        method,\n        // Set user metadata as this is not a multipart upload\n        headers: Object.assign({}, this.metaData, headers),\n        query: '',\n        bucketName: this.bucketName,\n        objectName: this.objectName,\n      }\n\n      this.client.makeRequest(options, chunk, [200], '', true, (err, response) => {\n        if (err) {\n          return callback(err)\n        }\n        let result = {\n          etag: sanitizeETag(response.headers.etag),\n          versionId: getVersionId(response.headers),\n        }\n        // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n        response.on('data', () => {})\n\n        // Give the etag back, we're done!\n\n        process.nextTick(() => {\n          this.callback(null, result)\n        })\n\n        // Because we're sure the stream has ended, allow it to flush and end.\n        callback()\n      })\n\n      return\n    }\n\n    // If we aren't flushing in one packet, we need to initiate the multipart upload,\n    // if it hasn't already been done. The write will be buffered until the upload has been\n    // initiated.\n    if (this.id === null) {\n      this.once('ready', () => {\n        this._transform(chunk, encoding, callback)\n      })\n\n      // Check for an incomplete previous upload.\n      this.client.findUploadId(this.bucketName, this.objectName, (err, id) => {\n        if (err) {\n          return this.emit('error', err)\n        }\n\n        // If no upload ID exists, initiate a new one.\n        if (!id) {\n          this.client.initiateNewMultipartUpload(this.bucketName, this.objectName, this.metaData).then(\n            (id) => {\n              this.id = id\n\n              // We are now ready to accept new chunks — this will flush the buffered chunk.\n              this.emit('ready')\n            },\n            (err) => callback(err),\n          )\n\n          return\n        }\n\n        this.id = id\n\n        // Retrieve the pre-uploaded parts, if we need to resume the upload.\n        this.client.listParts(this.bucketName, this.objectName, id).then(\n          (etags) => {\n            // It is possible for no parts to be already uploaded.\n            if (!etags) {\n              etags = []\n            }\n\n            // oldParts will become an object, allowing oldParts[partNumber].etag\n            this.oldParts = etags.reduce(function (prev, item) {\n              if (!prev[item.part]) {\n                prev[item.part] = item\n              }\n              return prev\n            }, {})\n\n            this.emit('ready')\n          },\n          (err) => {\n            return this.emit('error', err)\n          },\n        )\n      })\n\n      return\n    }\n\n    // Continue uploading various parts if we have initiated multipart upload.\n    let partNumber = this.partNumber++\n\n    // Check to see if we've already uploaded this chunk. If the hash sums match,\n    // we can skip to the next chunk.\n    if (this.oldParts) {\n      let oldPart = this.oldParts[partNumber]\n\n      // Calulcate the md5 hash, if it has not already been calculated.\n      if (!md5digest) {\n        md5digest = Crypto.createHash('md5').update(chunk).digest()\n      }\n\n      if (oldPart && md5digest.toString('hex') === oldPart.etag) {\n        // The md5 matches, the chunk has already been uploaded.\n        this.etags.push({ part: partNumber, etag: oldPart.etag })\n\n        callback()\n        return\n      }\n    }\n\n    // Write the chunk with an uploader.\n    let query = querystring.stringify({\n      partNumber: partNumber,\n      uploadId: this.id,\n    })\n\n    let options = {\n      method,\n      query,\n      headers,\n      bucketName: this.bucketName,\n      objectName: this.objectName,\n    }\n\n    this.client.makeRequest(options, chunk, [200], '', true, (err, response) => {\n      if (err) {\n        return callback(err)\n      }\n\n      // In order to aggregate the parts together, we need to collect the etags.\n      let etag = response.headers.etag\n      if (etag) {\n        etag = etag.replace(/^\"/, '').replace(/\"$/, '')\n      }\n\n      this.etags.push({ part: partNumber, etag })\n\n      // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n      response.on('data', () => {})\n\n      // We're ready for the next chunk.\n      callback()\n    })\n  }\n\n  _flush(callback) {\n    if (this.emptyStream) {\n      let method = 'PUT'\n      let headers = Object.assign({}, this.metaData, { 'Content-Length': 0 })\n      let options = {\n        method,\n        headers,\n        query: '',\n        bucketName: this.bucketName,\n        objectName: this.objectName,\n      }\n\n      this.client.makeRequest(options, '', [200], '', true, (err, response) => {\n        if (err) {\n          return callback(err)\n        }\n\n        let result = {\n          etag: sanitizeETag(response.headers.etag),\n          versionId: getVersionId(response.headers),\n        }\n\n        // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n        response.on('data', () => {})\n\n        // Give the etag back, we're done!\n        process.nextTick(() => {\n          this.callback(null, result)\n        })\n\n        // Because we're sure the stream has ended, allow it to flush and end.\n        callback()\n      })\n\n      return\n    }\n    // If it has been uploaded in a single packet, we don't have to do anything.\n    if (this.id === null) {\n      return\n    }\n\n    // This is called when all of the chunks uploaded successfully, thus\n    // completing the multipart upload.\n    this.client.completeMultipartUpload(this.bucketName, this.objectName, this.id, this.etags, (err, etag) => {\n      if (err) {\n        return callback(err)\n      }\n\n      // Call our callback on the next tick to allow the streams infrastructure\n      // to finish what its doing before we continue.\n      process.nextTick(() => {\n        this.callback(null, etag)\n      })\n\n      callback()\n    })\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default ObjectUploader\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Crypto","_interopRequireWildcard","require","_stream","querystring","_helper","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","ObjectUploader","Transform","constructor","client","bucketName","objectName","partSize","metaData","callback","emptyStream","partNumber","oldParts","etags","id","on","err","_transform","chunk","encoding","method","headers","length","md5digest","enableSHA256","createHash","update","digest","toString","options","assign","query","makeRequest","response","result","etag","sanitizeETag","versionId","getVersionId","process","nextTick","once","findUploadId","emit","initiateNewMultipartUpload","listParts","reduce","prev","item","part","oldPart","push","stringify","uploadId","replace","_flush","completeMultipartUpload","exports","_default"],"sources":["object-uploader.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Crypto from 'node:crypto'\nimport { Transform } from 'node:stream'\n\nimport * as querystring from 'query-string'\n\nimport { getVersionId, sanitizeETag } from './internal/helper.ts'\n\n// We extend Transform because Writable does not implement ._flush().\nexport class ObjectUploader extends Transform {\n  constructor(client, bucketName, objectName, partSize, metaData, callback) {\n    super()\n    this.emptyStream = true\n    this.client = client\n    this.bucketName = bucketName\n    this.objectName = objectName\n    // The size of each multipart, chunked by BlockStream2.\n    this.partSize = partSize\n    // This is the metadata for the object.\n    this.metaData = metaData\n\n    // Call like: callback(error, {etag, versionId}).\n    this.callback = callback\n\n    // We need to keep track of what number chunk/part we're on. This increments\n    // each time _write() is called. Starts with 1, not 0.\n    this.partNumber = 1\n\n    // A list of the previously uploaded chunks, for resuming a file upload. This\n    // will be null if we aren't resuming an upload.\n    this.oldParts = null\n\n    // Keep track of the etags for aggregating the chunks together later. Each\n    // etag represents a single chunk of the file.\n    this.etags = []\n\n    // This is for the multipart upload request — if null, we're either not initiated\n    // yet or we're flushing in one packet.\n    this.id = null\n\n    // Handle errors.\n    this.on('error', (err) => {\n      callback(err)\n    })\n  }\n\n  _transform(chunk, encoding, callback) {\n    this.emptyStream = false\n    let method = 'PUT'\n    let headers = { 'Content-Length': chunk.length }\n    let md5digest = ''\n\n    // Calculate and set Content-MD5 header if SHA256 is not set.\n    // This will happen only when there is a secure connection to the s3 server.\n    if (!this.client.enableSHA256) {\n      md5digest = Crypto.createHash('md5').update(chunk).digest()\n      headers['Content-MD5'] = md5digest.toString('base64')\n    }\n    // We can flush the object in one packet if it fits in one chunk. This is true\n    // if the chunk size is smaller than the part size, signifying the end of the\n    // stream.\n    if (this.partNumber == 1 && chunk.length < this.partSize) {\n      // PUT the chunk in a single request — use an empty query.\n      let options = {\n        method,\n        // Set user metadata as this is not a multipart upload\n        headers: Object.assign({}, this.metaData, headers),\n        query: '',\n        bucketName: this.bucketName,\n        objectName: this.objectName,\n      }\n\n      this.client.makeRequest(options, chunk, [200], '', true, (err, response) => {\n        if (err) {\n          return callback(err)\n        }\n        let result = {\n          etag: sanitizeETag(response.headers.etag),\n          versionId: getVersionId(response.headers),\n        }\n        // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n        response.on('data', () => {})\n\n        // Give the etag back, we're done!\n\n        process.nextTick(() => {\n          this.callback(null, result)\n        })\n\n        // Because we're sure the stream has ended, allow it to flush and end.\n        callback()\n      })\n\n      return\n    }\n\n    // If we aren't flushing in one packet, we need to initiate the multipart upload,\n    // if it hasn't already been done. The write will be buffered until the upload has been\n    // initiated.\n    if (this.id === null) {\n      this.once('ready', () => {\n        this._transform(chunk, encoding, callback)\n      })\n\n      // Check for an incomplete previous upload.\n      this.client.findUploadId(this.bucketName, this.objectName, (err, id) => {\n        if (err) {\n          return this.emit('error', err)\n        }\n\n        // If no upload ID exists, initiate a new one.\n        if (!id) {\n          this.client.initiateNewMultipartUpload(this.bucketName, this.objectName, this.metaData, (err, id) => {\n            if (err) {\n              return callback(err)\n            }\n\n            this.id = id\n\n            // We are now ready to accept new chunks — this will flush the buffered chunk.\n            this.emit('ready')\n          })\n\n          return\n        }\n\n        this.id = id\n\n        // Retrieve the pre-uploaded parts, if we need to resume the upload.\n        this.client.listParts(this.bucketName, this.objectName, id, (err, etags) => {\n          if (err) {\n            return this.emit('error', err)\n          }\n\n          // It is possible for no parts to be already uploaded.\n          if (!etags) {\n            etags = []\n          }\n\n          // oldParts will become an object, allowing oldParts[partNumber].etag\n          this.oldParts = etags.reduce(function (prev, item) {\n            if (!prev[item.part]) {\n              prev[item.part] = item\n            }\n            return prev\n          }, {})\n\n          this.emit('ready')\n        })\n      })\n\n      return\n    }\n\n    // Continue uploading various parts if we have initiated multipart upload.\n    let partNumber = this.partNumber++\n\n    // Check to see if we've already uploaded this chunk. If the hash sums match,\n    // we can skip to the next chunk.\n    if (this.oldParts) {\n      let oldPart = this.oldParts[partNumber]\n\n      // Calulcate the md5 hash, if it has not already been calculated.\n      if (!md5digest) {\n        md5digest = Crypto.createHash('md5').update(chunk).digest()\n      }\n\n      if (oldPart && md5digest.toString('hex') === oldPart.etag) {\n        // The md5 matches, the chunk has already been uploaded.\n        this.etags.push({ part: partNumber, etag: oldPart.etag })\n\n        callback()\n        return\n      }\n    }\n\n    // Write the chunk with an uploader.\n    let query = querystring.stringify({\n      partNumber: partNumber,\n      uploadId: this.id,\n    })\n\n    let options = {\n      method,\n      query,\n      headers,\n      bucketName: this.bucketName,\n      objectName: this.objectName,\n    }\n\n    this.client.makeRequest(options, chunk, [200], '', true, (err, response) => {\n      if (err) {\n        return callback(err)\n      }\n\n      // In order to aggregate the parts together, we need to collect the etags.\n      let etag = response.headers.etag\n      if (etag) {\n        etag = etag.replace(/^\"/, '').replace(/\"$/, '')\n      }\n\n      this.etags.push({ part: partNumber, etag })\n\n      // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n      response.on('data', () => {})\n\n      // We're ready for the next chunk.\n      callback()\n    })\n  }\n\n  _flush(callback) {\n    if (this.emptyStream) {\n      let method = 'PUT'\n      let headers = Object.assign({}, this.metaData, { 'Content-Length': 0 })\n      let options = {\n        method,\n        headers,\n        query: '',\n        bucketName: this.bucketName,\n        objectName: this.objectName,\n      }\n\n      this.client.makeRequest(options, '', [200], '', true, (err, response) => {\n        if (err) {\n          return callback(err)\n        }\n\n        let result = {\n          etag: sanitizeETag(response.headers.etag),\n          versionId: getVersionId(response.headers),\n        }\n\n        // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n        response.on('data', () => {})\n\n        // Give the etag back, we're done!\n        process.nextTick(() => {\n          this.callback(null, result)\n        })\n\n        // Because we're sure the stream has ended, allow it to flush and end.\n        callback()\n      })\n\n      return\n    }\n    // If it has been uploaded in a single packet, we don't have to do anything.\n    if (this.id === null) {\n      return\n    }\n\n    // This is called when all of the chunks uploaded successfully, thus\n    // completing the multipart upload.\n    this.client.completeMultipartUpload(this.bucketName, this.objectName, this.id, this.etags, (err, etag) => {\n      if (err) {\n        return callback(err)\n      }\n\n      // Call our callback on the next tick to allow the streams infrastructure\n      // to finish what its doing before we continue.\n      process.nextTick(() => {\n        this.callback(null, etag)\n      })\n\n      callback()\n    })\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default ObjectUploader\n"],"mappings":"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"} /***/ }), @@ -82417,14 +85599,19 @@ Object.defineProperty(exports, "__esModule", ({ exports.bucketEncryptionTransformer = bucketEncryptionTransformer; exports.bucketVersioningTransformer = bucketVersioningTransformer; exports.getBucketNotificationTransformer = getBucketNotificationTransformer; +exports.getBucketRegionTransformer = getBucketRegionTransformer; exports.getCompleteMultipartTransformer = getCompleteMultipartTransformer; exports.getConcater = getConcater; exports.getCopyObjectTransformer = getCopyObjectTransformer; +exports.getErrorTransformer = getErrorTransformer; exports.getHashSummer = getHashSummer; +exports.getInitiateMultipartTransformer = getInitiateMultipartTransformer; +exports.getListBucketTransformer = getListBucketTransformer; exports.getListMultipartTransformer = getListMultipartTransformer; exports.getListObjectsTransformer = getListObjectsTransformer; exports.getListObjectsV2Transformer = getListObjectsV2Transformer; exports.getListObjectsV2WithMetadataTransformer = getListObjectsV2WithMetadataTransformer; +exports.getListPartsTransformer = getListPartsTransformer; exports.getNotificationTransformer = getNotificationTransformer; exports.getTagsTransformer = getTagsTransformer; exports.lifecycleTransformer = lifecycleTransformer; @@ -82432,11 +85619,14 @@ exports.objectLegalHoldTransformer = objectLegalHoldTransformer; exports.objectLockTransformer = objectLockTransformer; exports.objectRetentionTransformer = objectRetentionTransformer; exports.removeObjectsTransformer = removeObjectsTransformer; +exports.replicationConfigTransformer = replicationConfigTransformer; exports.selectObjectContentTransformer = selectObjectContentTransformer; exports.uploadPartTransformer = uploadPartTransformer; var Crypto = _interopRequireWildcard(__nccwpck_require__(6113), true); var _jsonStream = __nccwpck_require__(1676); +var _lodash = __nccwpck_require__(250); var _through = __nccwpck_require__(8180); +var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); var _helper = __nccwpck_require__(9921); var xmlParsers = _interopRequireWildcard(__nccwpck_require__(714), true); function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } @@ -82493,6 +85683,65 @@ function getConcater(parser, emitError) { }); } +// Generates an Error object depending on http statusCode and XML body +function getErrorTransformer(response) { + var statusCode = response.statusCode; + var code, message; + if (statusCode === 301) { + code = 'MovedPermanently'; + message = 'Moved Permanently'; + } else if (statusCode === 307) { + code = 'TemporaryRedirect'; + message = 'Are you using the correct endpoint URL?'; + } else if (statusCode === 403) { + code = 'AccessDenied'; + message = 'Valid and authorized credentials required'; + } else if (statusCode === 404) { + code = 'NotFound'; + message = 'Not Found'; + } else if (statusCode === 405) { + code = 'MethodNotAllowed'; + message = 'Method Not Allowed'; + } else if (statusCode === 501) { + code = 'MethodNotAllowed'; + message = 'Method Not Allowed'; + } else { + code = 'UnknownError'; + message = `${statusCode}`; + } + var headerInfo = {}; + // A value created by S3 compatible server that uniquely identifies + // the request. + headerInfo.amzRequestid = response.headersSent ? response.getHeader('x-amz-request-id') : null; + // A special token that helps troubleshoot API replies and issues. + headerInfo.amzId2 = response.headersSent ? response.getHeader('x-amz-id-2') : null; + // Region where the bucket is located. This header is returned only + // in HEAD bucket and ListObjects response. + headerInfo.amzBucketRegion = response.headersSent ? response.getHeader('x-amz-bucket-region') : null; + return getConcater(xmlString => { + let getError = () => { + // Message should be instantiated for each S3Errors. + var e = new errors.S3Error(message); + // S3 Error code. + e.code = code; + _lodash.each(headerInfo, (value, key) => { + e[key] = value; + }); + return e; + }; + if (!xmlString) { + return getError(); + } + let e; + try { + e = xmlParsers.parseError(xmlString, headerInfo); + } catch (ex) { + return getError(); + } + return e; + }, true); +} + // A through stream that calculates md5sum and sha256sum function getHashSummer(enableSHA256) { var md5 = Crypto.createHash('md5'); @@ -82530,11 +85779,26 @@ function getCopyObjectTransformer() { return getConcater(xmlParsers.parseCopyObject); } +// Parses listBuckets response. +function getListBucketTransformer() { + return getConcater(xmlParsers.parseListBucket); +} + // Parses listMultipartUploads response. function getListMultipartTransformer() { return getConcater(xmlParsers.parseListMultipart); } +// Parses listParts response. +function getListPartsTransformer() { + return getConcater(xmlParsers.parseListParts); +} + +// Parses initMultipartUpload response. +function getInitiateMultipartTransformer() { + return getConcater(xmlParsers.parseInitiateMultipart); +} + // Parses listObjects response. function getListObjectsTransformer() { return getConcater(xmlParsers.parseListObjects); @@ -82555,6 +85819,11 @@ function getCompleteMultipartTransformer() { return getConcater(xmlParsers.parseCompleteMultipart); } +// Parses getBucketLocation response. +function getBucketRegionTransformer() { + return getConcater(xmlParsers.parseBucketRegion); +} + // Parses GET/SET BucketNotification response function getBucketNotificationTransformer() { return getConcater(xmlParsers.parseBucketNotification); @@ -82583,6 +85852,9 @@ function objectRetentionTransformer() { function bucketEncryptionTransformer() { return getConcater(xmlParsers.parseBucketEncryptionConfig); } +function replicationConfigTransformer() { + return getConcater(xmlParsers.parseReplicationConfig); +} function objectLegalHoldTransformer() { return getConcater(xmlParsers.parseObjectLegalHoldConfig); } @@ -82595,7 +85867,7 @@ function selectObjectContentTransformer() { function removeObjectsTransformer() { return getConcater(xmlParsers.removeObjectsParser); } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Crypto","_interopRequireWildcard","require","_jsonStream","_through","_helper","xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","getConcater","parser","emitError","objectMode","bufs","isFunction","TypeError","Through2","chunk","enc","cb","push","Buffer","concat","toString","length","getHashSummer","enableSHA256","md5","createHash","sha256","update","md5sum","sha256sum","digest","hashData","getCopyObjectTransformer","parseCopyObject","getListMultipartTransformer","parseListMultipart","getListObjectsTransformer","parseListObjects","getListObjectsV2Transformer","parseListObjectsV2","getListObjectsV2WithMetadataTransformer","parseListObjectsV2WithMetadata","getCompleteMultipartTransformer","parseCompleteMultipart","getBucketNotificationTransformer","parseBucketNotification","getNotificationTransformer","JSONParser","bucketVersioningTransformer","parseBucketVersioningConfig","getTagsTransformer","parseTagging","lifecycleTransformer","parseLifecycleConfig","objectLockTransformer","parseObjectLockConfig","objectRetentionTransformer","parseObjectRetentionConfig","bucketEncryptionTransformer","parseBucketEncryptionConfig","objectLegalHoldTransformer","parseObjectLegalHoldConfig","uploadPartTransformer","uploadPartParser","selectObjectContentTransformer","removeObjectsTransformer","removeObjectsParser"],"sources":["transformers.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015, 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Crypto from 'node:crypto'\n\nimport JSONParser from 'json-stream'\nimport Through2 from 'through2'\n\nimport { isFunction } from './internal/helper.ts'\nimport * as xmlParsers from './xml-parsers.js'\n\n// getConcater returns a stream that concatenates the input and emits\n// the concatenated output when 'end' has reached. If an optional\n// parser function is passed upon reaching the 'end' of the stream,\n// `parser(concatenated_data)` will be emitted.\nexport function getConcater(parser, emitError) {\n  var objectMode = false\n  var bufs = []\n\n  if (parser && !isFunction(parser)) {\n    throw new TypeError('parser should be of type \"function\"')\n  }\n\n  if (parser) {\n    objectMode = true\n  }\n\n  return Through2(\n    { objectMode },\n    function (chunk, enc, cb) {\n      bufs.push(chunk)\n      cb()\n    },\n    function (cb) {\n      if (emitError) {\n        cb(parser(Buffer.concat(bufs).toString()))\n        // cb(e) would mean we have to emit 'end' by explicitly calling this.push(null)\n        this.push(null)\n        return\n      }\n      if (bufs.length) {\n        if (parser) {\n          this.push(parser(Buffer.concat(bufs).toString()))\n        } else {\n          this.push(Buffer.concat(bufs))\n        }\n      }\n      cb()\n    },\n  )\n}\n\n// A through stream that calculates md5sum and sha256sum\nexport function getHashSummer(enableSHA256) {\n  var md5 = Crypto.createHash('md5')\n  var sha256 = Crypto.createHash('sha256')\n\n  return Through2.obj(\n    function (chunk, enc, cb) {\n      if (enableSHA256) {\n        sha256.update(chunk)\n      } else {\n        md5.update(chunk)\n      }\n      cb()\n    },\n    function (cb) {\n      var md5sum = ''\n      var sha256sum = ''\n      if (enableSHA256) {\n        sha256sum = sha256.digest('hex')\n      } else {\n        md5sum = md5.digest('base64')\n      }\n      var hashData = { md5sum, sha256sum }\n      this.push(hashData)\n      this.push(null)\n      cb()\n    },\n  )\n}\n\n// Following functions return a stream object that parses XML\n// and emits suitable Javascript objects.\n\n// Parses CopyObject response.\nexport function getCopyObjectTransformer() {\n  return getConcater(xmlParsers.parseCopyObject)\n}\n\n// Parses listMultipartUploads response.\nexport function getListMultipartTransformer() {\n  return getConcater(xmlParsers.parseListMultipart)\n}\n\n// Parses listObjects response.\nexport function getListObjectsTransformer() {\n  return getConcater(xmlParsers.parseListObjects)\n}\n\n// Parses listObjects response.\nexport function getListObjectsV2Transformer() {\n  return getConcater(xmlParsers.parseListObjectsV2)\n}\n\n// Parses listObjects with metadata response.\nexport function getListObjectsV2WithMetadataTransformer() {\n  return getConcater(xmlParsers.parseListObjectsV2WithMetadata)\n}\n\n// Parses completeMultipartUpload response.\nexport function getCompleteMultipartTransformer() {\n  return getConcater(xmlParsers.parseCompleteMultipart)\n}\n\n// Parses GET/SET BucketNotification response\nexport function getBucketNotificationTransformer() {\n  return getConcater(xmlParsers.parseBucketNotification)\n}\n\n// Parses a notification.\nexport function getNotificationTransformer() {\n  // This will parse and return each object.\n  return new JSONParser()\n}\n\nexport function bucketVersioningTransformer() {\n  return getConcater(xmlParsers.parseBucketVersioningConfig)\n}\n\nexport function getTagsTransformer() {\n  return getConcater(xmlParsers.parseTagging)\n}\n\nexport function lifecycleTransformer() {\n  return getConcater(xmlParsers.parseLifecycleConfig)\n}\n\nexport function objectLockTransformer() {\n  return getConcater(xmlParsers.parseObjectLockConfig)\n}\n\nexport function objectRetentionTransformer() {\n  return getConcater(xmlParsers.parseObjectRetentionConfig)\n}\nexport function bucketEncryptionTransformer() {\n  return getConcater(xmlParsers.parseBucketEncryptionConfig)\n}\n\nexport function objectLegalHoldTransformer() {\n  return getConcater(xmlParsers.parseObjectLegalHoldConfig)\n}\n\nexport function uploadPartTransformer() {\n  return getConcater(xmlParsers.uploadPartParser)\n}\nexport function selectObjectContentTransformer() {\n  return getConcater()\n}\n\nexport function removeObjectsTransformer() {\n  return getConcater(xmlParsers.removeObjectsParser)\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Crypto","_interopRequireWildcard","require","_jsonStream","_lodash","_through","errors","_helper","xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","getConcater","parser","emitError","objectMode","bufs","isFunction","TypeError","Through2","chunk","enc","cb","push","Buffer","concat","toString","length","getErrorTransformer","response","statusCode","code","message","headerInfo","amzRequestid","headersSent","getHeader","amzId2","amzBucketRegion","xmlString","getError","e","S3Error","_","each","value","parseError","ex","getHashSummer","enableSHA256","md5","createHash","sha256","update","md5sum","sha256sum","digest","hashData","getCopyObjectTransformer","parseCopyObject","getListBucketTransformer","parseListBucket","getListMultipartTransformer","parseListMultipart","getListPartsTransformer","parseListParts","getInitiateMultipartTransformer","parseInitiateMultipart","getListObjectsTransformer","parseListObjects","getListObjectsV2Transformer","parseListObjectsV2","getListObjectsV2WithMetadataTransformer","parseListObjectsV2WithMetadata","getCompleteMultipartTransformer","parseCompleteMultipart","getBucketRegionTransformer","parseBucketRegion","getBucketNotificationTransformer","parseBucketNotification","getNotificationTransformer","JSONParser","bucketVersioningTransformer","parseBucketVersioningConfig","getTagsTransformer","parseTagging","lifecycleTransformer","parseLifecycleConfig","objectLockTransformer","parseObjectLockConfig","objectRetentionTransformer","parseObjectRetentionConfig","bucketEncryptionTransformer","parseBucketEncryptionConfig","replicationConfigTransformer","parseReplicationConfig","objectLegalHoldTransformer","parseObjectLegalHoldConfig","uploadPartTransformer","uploadPartParser","selectObjectContentTransformer","removeObjectsTransformer","removeObjectsParser"],"sources":["transformers.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015, 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Crypto from 'node:crypto'\n\nimport JSONParser from 'json-stream'\nimport _ from 'lodash'\nimport Through2 from 'through2'\n\nimport * as errors from './errors.ts'\nimport { isFunction } from './internal/helper.ts'\nimport * as xmlParsers from './xml-parsers.js'\n\n// getConcater returns a stream that concatenates the input and emits\n// the concatenated output when 'end' has reached. If an optional\n// parser function is passed upon reaching the 'end' of the stream,\n// `parser(concatenated_data)` will be emitted.\nexport function getConcater(parser, emitError) {\n  var objectMode = false\n  var bufs = []\n\n  if (parser && !isFunction(parser)) {\n    throw new TypeError('parser should be of type \"function\"')\n  }\n\n  if (parser) {\n    objectMode = true\n  }\n\n  return Through2(\n    { objectMode },\n    function (chunk, enc, cb) {\n      bufs.push(chunk)\n      cb()\n    },\n    function (cb) {\n      if (emitError) {\n        cb(parser(Buffer.concat(bufs).toString()))\n        // cb(e) would mean we have to emit 'end' by explicitly calling this.push(null)\n        this.push(null)\n        return\n      }\n      if (bufs.length) {\n        if (parser) {\n          this.push(parser(Buffer.concat(bufs).toString()))\n        } else {\n          this.push(Buffer.concat(bufs))\n        }\n      }\n      cb()\n    },\n  )\n}\n\n// Generates an Error object depending on http statusCode and XML body\nexport function getErrorTransformer(response) {\n  var statusCode = response.statusCode\n  var code, message\n  if (statusCode === 301) {\n    code = 'MovedPermanently'\n    message = 'Moved Permanently'\n  } else if (statusCode === 307) {\n    code = 'TemporaryRedirect'\n    message = 'Are you using the correct endpoint URL?'\n  } else if (statusCode === 403) {\n    code = 'AccessDenied'\n    message = 'Valid and authorized credentials required'\n  } else if (statusCode === 404) {\n    code = 'NotFound'\n    message = 'Not Found'\n  } else if (statusCode === 405) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else if (statusCode === 501) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else {\n    code = 'UnknownError'\n    message = `${statusCode}`\n  }\n\n  var headerInfo = {}\n  // A value created by S3 compatible server that uniquely identifies\n  // the request.\n  headerInfo.amzRequestid = response.headersSent ? response.getHeader('x-amz-request-id') : null\n  // A special token that helps troubleshoot API replies and issues.\n  headerInfo.amzId2 = response.headersSent ? response.getHeader('x-amz-id-2') : null\n  // Region where the bucket is located. This header is returned only\n  // in HEAD bucket and ListObjects response.\n  headerInfo.amzBucketRegion = response.headersSent ? response.getHeader('x-amz-bucket-region') : null\n\n  return getConcater((xmlString) => {\n    let getError = () => {\n      // Message should be instantiated for each S3Errors.\n      var e = new errors.S3Error(message)\n      // S3 Error code.\n      e.code = code\n      _.each(headerInfo, (value, key) => {\n        e[key] = value\n      })\n      return e\n    }\n    if (!xmlString) {\n      return getError()\n    }\n    let e\n    try {\n      e = xmlParsers.parseError(xmlString, headerInfo)\n    } catch (ex) {\n      return getError()\n    }\n    return e\n  }, true)\n}\n\n// A through stream that calculates md5sum and sha256sum\nexport function getHashSummer(enableSHA256) {\n  var md5 = Crypto.createHash('md5')\n  var sha256 = Crypto.createHash('sha256')\n\n  return Through2.obj(\n    function (chunk, enc, cb) {\n      if (enableSHA256) {\n        sha256.update(chunk)\n      } else {\n        md5.update(chunk)\n      }\n      cb()\n    },\n    function (cb) {\n      var md5sum = ''\n      var sha256sum = ''\n      if (enableSHA256) {\n        sha256sum = sha256.digest('hex')\n      } else {\n        md5sum = md5.digest('base64')\n      }\n      var hashData = { md5sum, sha256sum }\n      this.push(hashData)\n      this.push(null)\n      cb()\n    },\n  )\n}\n\n// Following functions return a stream object that parses XML\n// and emits suitable Javascript objects.\n\n// Parses CopyObject response.\nexport function getCopyObjectTransformer() {\n  return getConcater(xmlParsers.parseCopyObject)\n}\n\n// Parses listBuckets response.\nexport function getListBucketTransformer() {\n  return getConcater(xmlParsers.parseListBucket)\n}\n\n// Parses listMultipartUploads response.\nexport function getListMultipartTransformer() {\n  return getConcater(xmlParsers.parseListMultipart)\n}\n\n// Parses listParts response.\nexport function getListPartsTransformer() {\n  return getConcater(xmlParsers.parseListParts)\n}\n\n// Parses initMultipartUpload response.\nexport function getInitiateMultipartTransformer() {\n  return getConcater(xmlParsers.parseInitiateMultipart)\n}\n\n// Parses listObjects response.\nexport function getListObjectsTransformer() {\n  return getConcater(xmlParsers.parseListObjects)\n}\n\n// Parses listObjects response.\nexport function getListObjectsV2Transformer() {\n  return getConcater(xmlParsers.parseListObjectsV2)\n}\n\n// Parses listObjects with metadata response.\nexport function getListObjectsV2WithMetadataTransformer() {\n  return getConcater(xmlParsers.parseListObjectsV2WithMetadata)\n}\n\n// Parses completeMultipartUpload response.\nexport function getCompleteMultipartTransformer() {\n  return getConcater(xmlParsers.parseCompleteMultipart)\n}\n\n// Parses getBucketLocation response.\nexport function getBucketRegionTransformer() {\n  return getConcater(xmlParsers.parseBucketRegion)\n}\n\n// Parses GET/SET BucketNotification response\nexport function getBucketNotificationTransformer() {\n  return getConcater(xmlParsers.parseBucketNotification)\n}\n\n// Parses a notification.\nexport function getNotificationTransformer() {\n  // This will parse and return each object.\n  return new JSONParser()\n}\n\nexport function bucketVersioningTransformer() {\n  return getConcater(xmlParsers.parseBucketVersioningConfig)\n}\n\nexport function getTagsTransformer() {\n  return getConcater(xmlParsers.parseTagging)\n}\n\nexport function lifecycleTransformer() {\n  return getConcater(xmlParsers.parseLifecycleConfig)\n}\n\nexport function objectLockTransformer() {\n  return getConcater(xmlParsers.parseObjectLockConfig)\n}\n\nexport function objectRetentionTransformer() {\n  return getConcater(xmlParsers.parseObjectRetentionConfig)\n}\nexport function bucketEncryptionTransformer() {\n  return getConcater(xmlParsers.parseBucketEncryptionConfig)\n}\n\nexport function replicationConfigTransformer() {\n  return getConcater(xmlParsers.parseReplicationConfig)\n}\n\nexport function objectLegalHoldTransformer() {\n  return getConcater(xmlParsers.parseObjectLegalHoldConfig)\n}\n\nexport function uploadPartTransformer() {\n  return getConcater(xmlParsers.uploadPartParser)\n}\nexport function selectObjectContentTransformer() {\n  return getConcater()\n}\n\nexport function removeObjectsTransformer() {\n  return getConcater(xmlParsers.removeObjectsParser)\n}\n"],"mappings":"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"} /***/ }), @@ -82610,23 +85882,30 @@ Object.defineProperty(exports, "__esModule", ({ })); exports.parseBucketEncryptionConfig = parseBucketEncryptionConfig; exports.parseBucketNotification = parseBucketNotification; +exports.parseBucketRegion = parseBucketRegion; exports.parseBucketVersioningConfig = parseBucketVersioningConfig; exports.parseCompleteMultipart = parseCompleteMultipart; exports.parseCopyObject = parseCopyObject; +exports.parseError = parseError; +exports.parseInitiateMultipart = parseInitiateMultipart; exports.parseLifecycleConfig = parseLifecycleConfig; +exports.parseListBucket = parseListBucket; exports.parseListMultipart = parseListMultipart; exports.parseListObjects = parseListObjects; exports.parseListObjectsV2 = parseListObjectsV2; exports.parseListObjectsV2WithMetadata = parseListObjectsV2WithMetadata; +exports.parseListParts = parseListParts; exports.parseObjectLegalHoldConfig = parseObjectLegalHoldConfig; exports.parseObjectLockConfig = parseObjectLockConfig; exports.parseObjectRetentionConfig = parseObjectRetentionConfig; +exports.parseReplicationConfig = parseReplicationConfig; exports.parseSelectObjectContentResponse = parseSelectObjectContentResponse; exports.parseTagging = parseTagging; exports.removeObjectsParser = removeObjectsParser; exports.uploadPartParser = uploadPartParser; var _bufferCrc = __nccwpck_require__(4024); var _fastXmlParser = __nccwpck_require__(2603); +var _lodash = __nccwpck_require__(250); var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); var _helpers = __nccwpck_require__(9455); var _helper = __nccwpck_require__(9921); @@ -82649,11 +85928,25 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && * limitations under the License. */ -const fxpWithoutNumParser = new _fastXmlParser.XMLParser({ - numberParseOptions: { - skipLike: /./ +// Parse XML and return information as Javascript types +const fxp = new _fastXmlParser.XMLParser(); + +// parse error XML response +function parseError(xml, headerInfo) { + var xmlErr = {}; + var xmlObj = fxp.parse(xml); + if (xmlObj.Error) { + xmlErr = xmlObj.Error; } -}); + var e = new errors.S3Error(); + _lodash.each(xmlErr, (value, key) => { + e[key.toLowerCase()] = value; + }); + _lodash.each(headerInfo, (value, key) => { + e[key] = value; + }); + return e; +} // parse XML response for copy object function parseCopyObject(xml) { @@ -82694,7 +85987,7 @@ function parseListMultipart(xml) { result.nextKeyMarker = xmlobj.NextKeyMarker; } if (xmlobj.NextUploadIdMarker) { - result.nextUploadIdMarker = xmlobj.nextUploadIdMarker || ''; + result.nextUploadIdMarker = xmlobj.nextUploadIdMarker; } if (xmlobj.CommonPrefixes) { (0, _helper.toArray)(xmlobj.CommonPrefixes).forEach(prefix => { @@ -82731,6 +86024,27 @@ function parseListMultipart(xml) { } // parse XML response to list all the owned buckets +function parseListBucket(xml) { + var result = []; + var xmlobj = (0, _helper.parseXml)(xml); + if (!xmlobj.ListAllMyBucketsResult) { + throw new errors.InvalidXMLError('Missing tag: "ListAllMyBucketsResult"'); + } + xmlobj = xmlobj.ListAllMyBucketsResult; + if (xmlobj.Buckets) { + if (xmlobj.Buckets.Bucket) { + (0, _helper.toArray)(xmlobj.Buckets.Bucket).forEach(bucket => { + var name = bucket.Name; + var creationDate = new Date(bucket.CreationDate); + result.push({ + name, + creationDate + }); + }); + } + } + return result; +} // parse XML response for bucket notification function parseBucketNotification(xml) { @@ -82821,6 +86135,58 @@ function parseBucketNotification(xml) { return result; } +// parse XML response for bucket region +function parseBucketRegion(xml) { + // return region information + return (0, _helper.parseXml)(xml).LocationConstraint; +} + +// parse XML response for list parts of an in progress multipart upload +function parseListParts(xml) { + var xmlobj = (0, _helper.parseXml)(xml); + var result = { + isTruncated: false, + parts: [], + marker: undefined + }; + if (!xmlobj.ListPartsResult) { + throw new errors.InvalidXMLError('Missing tag: "ListPartsResult"'); + } + xmlobj = xmlobj.ListPartsResult; + if (xmlobj.IsTruncated) { + result.isTruncated = xmlobj.IsTruncated; + } + if (xmlobj.NextPartNumberMarker) { + result.marker = +(0, _helper.toArray)(xmlobj.NextPartNumberMarker)[0]; + } + if (xmlobj.Part) { + (0, _helper.toArray)(xmlobj.Part).forEach(p => { + var part = +(0, _helper.toArray)(p.PartNumber)[0]; + var lastModified = new Date(p.LastModified); + var etag = p.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, ''); + result.parts.push({ + part, + lastModified, + etag + }); + }); + } + return result; +} + +// parse XML response when a new multipart upload is initiated +function parseInitiateMultipart(xml) { + var xmlobj = (0, _helper.parseXml)(xml); + if (!xmlobj.InitiateMultipartUploadResult) { + throw new errors.InvalidXMLError('Missing tag: "InitiateMultipartUploadResult"'); + } + xmlobj = xmlobj.InitiateMultipartUploadResult; + if (xmlobj.UploadId) { + return xmlobj.UploadId; + } + throw new errors.InvalidXMLError('Missing tag: "UploadId"'); +} + // parse XML response when a multipart upload is completed function parseCompleteMultipart(xml) { var xmlobj = (0, _helper.parseXml)(xml).CompleteMultipartUploadResult; @@ -82861,12 +86227,11 @@ const formatObjInfo = (content, opts = {}) => { const name = (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(Key)[0]); const lastModified = new Date((0, _helper.toArray)(LastModified)[0]); const etag = (0, _helper.sanitizeETag)((0, _helper.toArray)(ETag)[0]); - const size = (0, _helper.sanitizeSize)(Size); return { name, lastModified, etag, - size, + size: Size, versionId: VersionId, isLatest: IsLatest, isDeleteMarker: opts.IsDeleteMarker ? opts.IsDeleteMarker : false @@ -82881,7 +86246,7 @@ function parseListObjects(xml) { }; let isTruncated = false; let nextMarker, nextVersionKeyMarker; - const xmlobj = fxpWithoutNumParser.parse(xml); + const xmlobj = (0, _helper.parseXml)(xml); const parseCommonPrefixesEntity = responseEntity => { if (responseEntity) { (0, _helper.toArray)(responseEntity).forEach(commonPrefix => { @@ -82903,7 +86268,7 @@ function parseListObjects(xml) { const name = (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(content.Key)[0]); const lastModified = new Date((0, _helper.toArray)(content.LastModified)[0]); const etag = (0, _helper.sanitizeETag)((0, _helper.toArray)(content.ETag)[0]); - const size = (0, _helper.sanitizeSize)(content.Size); + const size = content.Size; result.objects.push({ name, lastModified, @@ -83097,6 +86462,16 @@ function parseBucketEncryptionConfig(xml) { let encConfig = (0, _helper.parseXml)(xml); return encConfig; } +function parseReplicationConfig(xml) { + const xmlObj = (0, _helper.parseXml)(xml); + const replicationConfig = { + ReplicationConfiguration: { + role: xmlObj.ReplicationConfiguration.Role, + rules: (0, _helper.toArray)(xmlObj.ReplicationConfiguration.Rule) + } + }; + return replicationConfig; +} function parseObjectLegalHoldConfig(xml) { const xmlObj = (0, _helper.parseXml)(xml); return xmlObj.LegalHold; @@ -83246,7 +86621,222 @@ function parseSelectObjectContentResponse(res) { } // messageType End } // Top Level Stream End } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_bufferCrc","require","_fastXmlParser","errors","_interopRequireWildcard","_helpers","_helper","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","fxpWithoutNumParser","XMLParser","numberParseOptions","skipLike","parseCopyObject","xml","result","etag","lastModified","xmlobj","parseXml","CopyObjectResult","InvalidXMLError","ETag","replace","LastModified","Date","parseListMultipart","uploads","prefixes","isTruncated","ListMultipartUploadsResult","IsTruncated","NextKeyMarker","nextKeyMarker","NextUploadIdMarker","nextUploadIdMarker","CommonPrefixes","toArray","forEach","prefix","push","sanitizeObjectKey","Prefix","Upload","upload","Key","uploadId","UploadId","initiator","id","Initiator","ID","displayName","DisplayName","owner","Owner","storageClass","StorageClass","initiated","Initiated","parseBucketNotification","TopicConfiguration","QueueConfiguration","CloudFunctionConfiguration","genEvents","events","s3event","genFilterRules","filters","S3Key","FilterRule","rule","Name","Value","NotificationConfiguration","config","Id","Topic","Event","Filter","Queue","CloudFunction","parseCompleteMultipart","CompleteMultipartUploadResult","Location","location","bucket","Bucket","Code","Message","errCode","errMessage","formatObjInfo","content","opts","Size","VersionId","IsLatest","isObject","name","sanitizeETag","size","sanitizeSize","versionId","isLatest","isDeleteMarker","IsDeleteMarker","parseListObjects","objects","nextMarker","nextVersionKeyMarker","parse","parseCommonPrefixesEntity","responseEntity","commonPrefix","listBucketResult","ListBucketResult","listVersionsResult","ListVersionsResult","Contents","NextMarker","Version","DeleteMarker","NextVersionIdMarker","versionIdMarker","parseListObjectsV2","NextContinuationToken","nextContinuationToken","parseListObjectsV2WithMetadata","metadata","UserMetadata","parseBucketVersioningConfig","xmlObj","VersioningConfiguration","parseTagging","Tagging","TagSet","Tag","tagResult","parseLifecycleConfig","LifecycleConfiguration","parseObjectLockConfig","lockConfigResult","ObjectLockConfiguration","objectLockEnabled","ObjectLockEnabled","retentionResp","Rule","DefaultRetention","mode","Mode","isUnitYears","Years","validity","unit","RETENTION_VALIDITY_UNITS","YEARS","Days","DAYS","parseObjectRetentionConfig","retentionConfig","Retention","retainUntilDate","RetainUntilDate","parseBucketEncryptionConfig","encConfig","parseObjectLegalHoldConfig","LegalHold","uploadPartParser","respEl","CopyPartResult","removeObjectsParser","DeleteResult","Error","parseSelectObjectContentResponse","res","extractHeaderType","stream","headerNameLen","Buffer","from","read","readUInt8","headerNameWithSeparator","toString","splitBySeparator","split","headerName","length","extractHeaderValue","bodyLen","readUInt16BE","bodyName","selectResults","SelectResults","responseStream","readableStream","_readableState","msgCrcAccumulator","totalByteLengthBuffer","crc32","headerBytesBuffer","calculatedPreludeCrc","readInt32BE","preludeCrcBuffer","totalMsgLength","headerLength","preludeCrcByteValue","headers","headerBytes","headerReaderStream","headerTypeName","payloadStream","payLoadLength","payLoadBuffer","messageCrcByteValue","calculatedCrc","messageType","errorMessage","contentType","eventType","setResponse","readData","setRecords","progressData","setProgress","statsData","setStats","warningMessage","console","warn"],"sources":["xml-parsers.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport crc32 from 'buffer-crc32'\nimport { XMLParser } from 'fast-xml-parser'\n\nimport * as errors from './errors.ts'\nimport { SelectResults } from './helpers.ts'\nimport {\n  isObject,\n  parseXml,\n  readableStream,\n  sanitizeETag,\n  sanitizeObjectKey,\n  sanitizeSize,\n  toArray,\n} from './internal/helper.ts'\nimport { RETENTION_VALIDITY_UNITS } from './internal/type.ts'\n\nconst fxpWithoutNumParser = new XMLParser({\n  numberParseOptions: {\n    skipLike: /./,\n  },\n})\n\n// parse XML response for copy object\nexport function parseCopyObject(xml) {\n  var result = {\n    etag: '',\n    lastModified: '',\n  }\n\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.CopyObjectResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"CopyObjectResult\"')\n  }\n  xmlobj = xmlobj.CopyObjectResult\n  if (xmlobj.ETag) {\n    result.etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n  }\n  if (xmlobj.LastModified) {\n    result.lastModified = new Date(xmlobj.LastModified)\n  }\n\n  return result\n}\n\n// parse XML response for listing in-progress multipart uploads\nexport function parseListMultipart(xml) {\n  var result = {\n    uploads: [],\n    prefixes: [],\n    isTruncated: false,\n  }\n\n  var xmlobj = parseXml(xml)\n\n  if (!xmlobj.ListMultipartUploadsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListMultipartUploadsResult\"')\n  }\n  xmlobj = xmlobj.ListMultipartUploadsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextKeyMarker) {\n    result.nextKeyMarker = xmlobj.NextKeyMarker\n  }\n  if (xmlobj.NextUploadIdMarker) {\n    result.nextUploadIdMarker = xmlobj.nextUploadIdMarker || ''\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((prefix) => {\n      result.prefixes.push({ prefix: sanitizeObjectKey(toArray(prefix.Prefix)[0]) })\n    })\n  }\n\n  if (xmlobj.Upload) {\n    toArray(xmlobj.Upload).forEach((upload) => {\n      var key = upload.Key\n      var uploadId = upload.UploadId\n      var initiator = { id: upload.Initiator.ID, displayName: upload.Initiator.DisplayName }\n      var owner = { id: upload.Owner.ID, displayName: upload.Owner.DisplayName }\n      var storageClass = upload.StorageClass\n      var initiated = new Date(upload.Initiated)\n      result.uploads.push({ key, uploadId, initiator, owner, storageClass, initiated })\n    })\n  }\n  return result\n}\n\n// parse XML response to list all the owned buckets\n\n// parse XML response for bucket notification\nexport function parseBucketNotification(xml) {\n  var result = {\n    TopicConfiguration: [],\n    QueueConfiguration: [],\n    CloudFunctionConfiguration: [],\n  }\n  // Parse the events list\n  var genEvents = function (events) {\n    var result = []\n    if (events) {\n      toArray(events).forEach((s3event) => {\n        result.push(s3event)\n      })\n    }\n    return result\n  }\n  // Parse all filter rules\n  var genFilterRules = function (filters) {\n    var result = []\n    if (filters) {\n      filters = toArray(filters)\n      if (filters[0].S3Key) {\n        filters[0].S3Key = toArray(filters[0].S3Key)\n        if (filters[0].S3Key[0].FilterRule) {\n          toArray(filters[0].S3Key[0].FilterRule).forEach((rule) => {\n            var Name = toArray(rule.Name)[0]\n            var Value = toArray(rule.Value)[0]\n            result.push({ Name, Value })\n          })\n        }\n      }\n    }\n    return result\n  }\n\n  var xmlobj = parseXml(xml)\n  xmlobj = xmlobj.NotificationConfiguration\n\n  // Parse all topic configurations in the xml\n  if (xmlobj.TopicConfiguration) {\n    toArray(xmlobj.TopicConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var Topic = toArray(config.Topic)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.TopicConfiguration.push({ Id, Topic, Event, Filter })\n    })\n  }\n  // Parse all topic configurations in the xml\n  if (xmlobj.QueueConfiguration) {\n    toArray(xmlobj.QueueConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var Queue = toArray(config.Queue)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.QueueConfiguration.push({ Id, Queue, Event, Filter })\n    })\n  }\n  // Parse all QueueConfiguration arrays\n  if (xmlobj.CloudFunctionConfiguration) {\n    toArray(xmlobj.CloudFunctionConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var CloudFunction = toArray(config.CloudFunction)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.CloudFunctionConfiguration.push({ Id, CloudFunction, Event, Filter })\n    })\n  }\n\n  return result\n}\n\n// parse XML response when a multipart upload is completed\nexport function parseCompleteMultipart(xml) {\n  var xmlobj = parseXml(xml).CompleteMultipartUploadResult\n  if (xmlobj.Location) {\n    var location = toArray(xmlobj.Location)[0]\n    var bucket = toArray(xmlobj.Bucket)[0]\n    var key = xmlobj.Key\n    var etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n\n    return { location, bucket, key, etag }\n  }\n  // Complete Multipart can return XML Error after a 200 OK response\n  if (xmlobj.Code && xmlobj.Message) {\n    var errCode = toArray(xmlobj.Code)[0]\n    var errMessage = toArray(xmlobj.Message)[0]\n    return { errCode, errMessage }\n  }\n}\n\nconst formatObjInfo = (content, opts = {}) => {\n  let { Key, LastModified, ETag, Size, VersionId, IsLatest } = content\n\n  if (!isObject(opts)) {\n    opts = {}\n  }\n\n  const name = sanitizeObjectKey(toArray(Key)[0])\n  const lastModified = new Date(toArray(LastModified)[0])\n  const etag = sanitizeETag(toArray(ETag)[0])\n  const size = sanitizeSize(Size)\n\n  return {\n    name,\n    lastModified,\n    etag,\n    size,\n    versionId: VersionId,\n    isLatest: IsLatest,\n    isDeleteMarker: opts.IsDeleteMarker ? opts.IsDeleteMarker : false,\n  }\n}\n\n// parse XML response for list objects in a bucket\nexport function parseListObjects(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  let isTruncated = false\n  let nextMarker, nextVersionKeyMarker\n  const xmlobj = fxpWithoutNumParser.parse(xml)\n\n  const parseCommonPrefixesEntity = (responseEntity) => {\n    if (responseEntity) {\n      toArray(responseEntity).forEach((commonPrefix) => {\n        result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n      })\n    }\n  }\n\n  const listBucketResult = xmlobj.ListBucketResult\n  const listVersionsResult = xmlobj.ListVersionsResult\n\n  if (listBucketResult) {\n    if (listBucketResult.IsTruncated) {\n      isTruncated = listBucketResult.IsTruncated\n    }\n    if (listBucketResult.Contents) {\n      toArray(listBucketResult.Contents).forEach((content) => {\n        const name = sanitizeObjectKey(toArray(content.Key)[0])\n        const lastModified = new Date(toArray(content.LastModified)[0])\n        const etag = sanitizeETag(toArray(content.ETag)[0])\n        const size = sanitizeSize(content.Size)\n        result.objects.push({ name, lastModified, etag, size })\n      })\n    }\n\n    if (listBucketResult.NextMarker) {\n      nextMarker = listBucketResult.NextMarker\n    }\n    parseCommonPrefixesEntity(listBucketResult.CommonPrefixes)\n  }\n\n  if (listVersionsResult) {\n    if (listVersionsResult.IsTruncated) {\n      isTruncated = listVersionsResult.IsTruncated\n    }\n\n    if (listVersionsResult.Version) {\n      toArray(listVersionsResult.Version).forEach((content) => {\n        result.objects.push(formatObjInfo(content))\n      })\n    }\n    if (listVersionsResult.DeleteMarker) {\n      toArray(listVersionsResult.DeleteMarker).forEach((content) => {\n        result.objects.push(formatObjInfo(content, { IsDeleteMarker: true }))\n      })\n    }\n\n    if (listVersionsResult.NextKeyMarker) {\n      nextVersionKeyMarker = listVersionsResult.NextKeyMarker\n    }\n    if (listVersionsResult.NextVersionIdMarker) {\n      result.versionIdMarker = listVersionsResult.NextVersionIdMarker\n    }\n    parseCommonPrefixesEntity(listVersionsResult.CommonPrefixes)\n  }\n\n  result.isTruncated = isTruncated\n  if (isTruncated) {\n    result.nextMarker = nextVersionKeyMarker || nextMarker\n  }\n  return result\n}\n\n// parse XML response for list objects v2 in a bucket\nexport function parseListObjectsV2(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      var name = sanitizeObjectKey(toArray(content.Key)[0])\n      var lastModified = new Date(content.LastModified)\n      var etag = sanitizeETag(content.ETag)\n      var size = content.Size\n      result.objects.push({ name, lastModified, etag, size })\n    })\n  }\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\n// parse XML response for list objects v2 with metadata in a bucket\nexport function parseListObjectsV2WithMetadata(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      var name = sanitizeObjectKey(content.Key)\n      var lastModified = new Date(content.LastModified)\n      var etag = sanitizeETag(content.ETag)\n      var size = content.Size\n      var metadata\n      if (content.UserMetadata != null) {\n        metadata = toArray(content.UserMetadata)[0]\n      } else {\n        metadata = null\n      }\n      result.objects.push({ name, lastModified, etag, size, metadata })\n    })\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\nexport function parseBucketVersioningConfig(xml) {\n  var xmlObj = parseXml(xml)\n  return xmlObj.VersioningConfiguration\n}\n\nexport function parseTagging(xml) {\n  const xmlObj = parseXml(xml)\n  let result = []\n  if (xmlObj.Tagging && xmlObj.Tagging.TagSet && xmlObj.Tagging.TagSet.Tag) {\n    const tagResult = xmlObj.Tagging.TagSet.Tag\n    // if it is a single tag convert into an array so that the return value is always an array.\n    if (isObject(tagResult)) {\n      result.push(tagResult)\n    } else {\n      result = tagResult\n    }\n  }\n  return result\n}\n\nexport function parseLifecycleConfig(xml) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LifecycleConfiguration\n}\n\nexport function parseObjectLockConfig(xml) {\n  const xmlObj = parseXml(xml)\n  let lockConfigResult = {}\n  if (xmlObj.ObjectLockConfiguration) {\n    lockConfigResult = {\n      objectLockEnabled: xmlObj.ObjectLockConfiguration.ObjectLockEnabled,\n    }\n    let retentionResp\n    if (\n      xmlObj.ObjectLockConfiguration &&\n      xmlObj.ObjectLockConfiguration.Rule &&\n      xmlObj.ObjectLockConfiguration.Rule.DefaultRetention\n    ) {\n      retentionResp = xmlObj.ObjectLockConfiguration.Rule.DefaultRetention || {}\n      lockConfigResult.mode = retentionResp.Mode\n    }\n    if (retentionResp) {\n      const isUnitYears = retentionResp.Years\n      if (isUnitYears) {\n        lockConfigResult.validity = isUnitYears\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.YEARS\n      } else {\n        lockConfigResult.validity = retentionResp.Days\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.DAYS\n      }\n    }\n    return lockConfigResult\n  }\n}\n\nexport function parseObjectRetentionConfig(xml) {\n  const xmlObj = parseXml(xml)\n  const retentionConfig = xmlObj.Retention\n\n  return {\n    mode: retentionConfig.Mode,\n    retainUntilDate: retentionConfig.RetainUntilDate,\n  }\n}\n\nexport function parseBucketEncryptionConfig(xml) {\n  let encConfig = parseXml(xml)\n  return encConfig\n}\n\nexport function parseObjectLegalHoldConfig(xml) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LegalHold\n}\n\nexport function uploadPartParser(xml) {\n  const xmlObj = parseXml(xml)\n  const respEl = xmlObj.CopyPartResult\n  return respEl\n}\n\nexport function removeObjectsParser(xml) {\n  const xmlObj = parseXml(xml)\n  if (xmlObj.DeleteResult && xmlObj.DeleteResult.Error) {\n    // return errors as array always. as the response is object in case of single object passed in removeObjects\n    return toArray(xmlObj.DeleteResult.Error)\n  }\n  return []\n}\n\nexport function parseSelectObjectContentResponse(res) {\n  // extractHeaderType extracts the first half of the header message, the header type.\n  function extractHeaderType(stream) {\n    const headerNameLen = Buffer.from(stream.read(1)).readUInt8()\n    const headerNameWithSeparator = Buffer.from(stream.read(headerNameLen)).toString()\n    const splitBySeparator = (headerNameWithSeparator || '').split(':')\n    const headerName = splitBySeparator.length >= 1 ? splitBySeparator[1] : ''\n    return headerName\n  }\n\n  function extractHeaderValue(stream) {\n    const bodyLen = Buffer.from(stream.read(2)).readUInt16BE()\n    const bodyName = Buffer.from(stream.read(bodyLen)).toString()\n    return bodyName\n  }\n\n  const selectResults = new SelectResults({}) // will be returned\n\n  const responseStream = readableStream(res) // convert byte array to a readable responseStream\n  while (responseStream._readableState.length) {\n    // Top level responseStream read tracker.\n    let msgCrcAccumulator // accumulate from start of the message till the message crc start.\n\n    const totalByteLengthBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(totalByteLengthBuffer)\n\n    const headerBytesBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(headerBytesBuffer, msgCrcAccumulator)\n\n    const calculatedPreludeCrc = msgCrcAccumulator.readInt32BE() // use it to check if any CRC mismatch in header itself.\n\n    const preludeCrcBuffer = Buffer.from(responseStream.read(4)) // read 4 bytes    i.e 4+4 =8 + 4 = 12 ( prelude + prelude crc)\n    msgCrcAccumulator = crc32(preludeCrcBuffer, msgCrcAccumulator)\n\n    const totalMsgLength = totalByteLengthBuffer.readInt32BE()\n    const headerLength = headerBytesBuffer.readInt32BE()\n    const preludeCrcByteValue = preludeCrcBuffer.readInt32BE()\n\n    if (preludeCrcByteValue !== calculatedPreludeCrc) {\n      // Handle Header CRC mismatch Error\n      throw new Error(\n        `Header Checksum Mismatch, Prelude CRC of ${preludeCrcByteValue} does not equal expected CRC of ${calculatedPreludeCrc}`,\n      )\n    }\n\n    const headers = {}\n    if (headerLength > 0) {\n      const headerBytes = Buffer.from(responseStream.read(headerLength))\n      msgCrcAccumulator = crc32(headerBytes, msgCrcAccumulator)\n      const headerReaderStream = readableStream(headerBytes)\n      while (headerReaderStream._readableState.length) {\n        let headerTypeName = extractHeaderType(headerReaderStream)\n        headerReaderStream.read(1) // just read and ignore it.\n        headers[headerTypeName] = extractHeaderValue(headerReaderStream)\n      }\n    }\n\n    let payloadStream\n    const payLoadLength = totalMsgLength - headerLength - 16\n    if (payLoadLength > 0) {\n      const payLoadBuffer = Buffer.from(responseStream.read(payLoadLength))\n      msgCrcAccumulator = crc32(payLoadBuffer, msgCrcAccumulator)\n      // read the checksum early and detect any mismatch so we can avoid unnecessary further processing.\n      const messageCrcByteValue = Buffer.from(responseStream.read(4)).readInt32BE()\n      const calculatedCrc = msgCrcAccumulator.readInt32BE()\n      // Handle message CRC Error\n      if (messageCrcByteValue !== calculatedCrc) {\n        throw new Error(\n          `Message Checksum Mismatch, Message CRC of ${messageCrcByteValue} does not equal expected CRC of ${calculatedCrc}`,\n        )\n      }\n      payloadStream = readableStream(payLoadBuffer)\n    }\n\n    const messageType = headers['message-type']\n\n    switch (messageType) {\n      case 'error': {\n        const errorMessage = headers['error-code'] + ':\"' + headers['error-message'] + '\"'\n        throw new Error(errorMessage)\n      }\n      case 'event': {\n        const contentType = headers['content-type']\n        const eventType = headers['event-type']\n\n        switch (eventType) {\n          case 'End': {\n            selectResults.setResponse(res)\n            return selectResults\n          }\n\n          case 'Records': {\n            const readData = payloadStream.read(payLoadLength)\n            selectResults.setRecords(readData)\n            break\n          }\n\n          case 'Progress':\n            {\n              switch (contentType) {\n                case 'text/xml': {\n                  const progressData = payloadStream.read(payLoadLength)\n                  selectResults.setProgress(progressData.toString())\n                  break\n                }\n                default: {\n                  const errorMessage = `Unexpected content-type ${contentType} sent for event-type Progress`\n                  throw new Error(errorMessage)\n                }\n              }\n            }\n            break\n          case 'Stats':\n            {\n              switch (contentType) {\n                case 'text/xml': {\n                  const statsData = payloadStream.read(payLoadLength)\n                  selectResults.setStats(statsData.toString())\n                  break\n                }\n                default: {\n                  const errorMessage = `Unexpected content-type ${contentType} sent for event-type Stats`\n                  throw new Error(errorMessage)\n                }\n              }\n            }\n            break\n          default: {\n            // Continuation message: Not sure if it is supported. did not find a reference or any message in response.\n            // It does not have a payload.\n            const warningMessage = `Un implemented event detected  ${messageType}.`\n            // eslint-disable-next-line no-console\n            console.warn(warningMessage)\n          }\n        } // eventType End\n      } // Event End\n    } // messageType End\n  } // Top Level Stream End\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_bufferCrc","require","_fastXmlParser","_lodash","errors","_interopRequireWildcard","_helpers","_helper","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","fxp","XMLParser","parseError","xml","headerInfo","xmlErr","xmlObj","parse","Error","e","S3Error","_","each","value","toLowerCase","parseCopyObject","result","etag","lastModified","xmlobj","parseXml","CopyObjectResult","InvalidXMLError","ETag","replace","LastModified","Date","parseListMultipart","uploads","prefixes","isTruncated","ListMultipartUploadsResult","IsTruncated","NextKeyMarker","nextKeyMarker","NextUploadIdMarker","nextUploadIdMarker","CommonPrefixes","toArray","forEach","prefix","push","sanitizeObjectKey","Prefix","Upload","upload","Key","uploadId","UploadId","initiator","id","Initiator","ID","displayName","DisplayName","owner","Owner","storageClass","StorageClass","initiated","Initiated","parseListBucket","ListAllMyBucketsResult","Buckets","Bucket","bucket","name","Name","creationDate","CreationDate","parseBucketNotification","TopicConfiguration","QueueConfiguration","CloudFunctionConfiguration","genEvents","events","s3event","genFilterRules","filters","S3Key","FilterRule","rule","Value","NotificationConfiguration","config","Id","Topic","Event","Filter","Queue","CloudFunction","parseBucketRegion","LocationConstraint","parseListParts","parts","marker","undefined","ListPartsResult","NextPartNumberMarker","Part","p","part","PartNumber","parseInitiateMultipart","InitiateMultipartUploadResult","parseCompleteMultipart","CompleteMultipartUploadResult","Location","location","Code","Message","errCode","errMessage","formatObjInfo","content","opts","Size","VersionId","IsLatest","isObject","sanitizeETag","size","versionId","isLatest","isDeleteMarker","IsDeleteMarker","parseListObjects","objects","nextMarker","nextVersionKeyMarker","parseCommonPrefixesEntity","responseEntity","commonPrefix","listBucketResult","ListBucketResult","listVersionsResult","ListVersionsResult","Contents","NextMarker","Version","DeleteMarker","NextVersionIdMarker","versionIdMarker","parseListObjectsV2","NextContinuationToken","nextContinuationToken","parseListObjectsV2WithMetadata","metadata","UserMetadata","parseBucketVersioningConfig","VersioningConfiguration","parseTagging","Tagging","TagSet","Tag","tagResult","parseLifecycleConfig","LifecycleConfiguration","parseObjectLockConfig","lockConfigResult","ObjectLockConfiguration","objectLockEnabled","ObjectLockEnabled","retentionResp","Rule","DefaultRetention","mode","Mode","isUnitYears","Years","validity","unit","RETENTION_VALIDITY_UNITS","YEARS","Days","DAYS","parseObjectRetentionConfig","retentionConfig","Retention","retainUntilDate","RetainUntilDate","parseBucketEncryptionConfig","encConfig","parseReplicationConfig","replicationConfig","ReplicationConfiguration","role","Role","rules","parseObjectLegalHoldConfig","LegalHold","uploadPartParser","respEl","CopyPartResult","removeObjectsParser","DeleteResult","parseSelectObjectContentResponse","res","extractHeaderType","stream","headerNameLen","Buffer","from","read","readUInt8","headerNameWithSeparator","toString","splitBySeparator","split","headerName","length","extractHeaderValue","bodyLen","readUInt16BE","bodyName","selectResults","SelectResults","responseStream","readableStream","_readableState","msgCrcAccumulator","totalByteLengthBuffer","crc32","headerBytesBuffer","calculatedPreludeCrc","readInt32BE","preludeCrcBuffer","totalMsgLength","headerLength","preludeCrcByteValue","headers","headerBytes","headerReaderStream","headerTypeName","payloadStream","payLoadLength","payLoadBuffer","messageCrcByteValue","calculatedCrc","messageType","errorMessage","contentType","eventType","setResponse","readData","setRecords","progressData","setProgress","statsData","setStats","warningMessage","console","warn"],"sources":["xml-parsers.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport crc32 from 'buffer-crc32'\nimport { XMLParser } from 'fast-xml-parser'\nimport _ from 'lodash'\n\nimport * as errors from './errors.ts'\nimport { SelectResults } from './helpers.ts'\nimport { isObject, parseXml, readableStream, sanitizeETag, sanitizeObjectKey, toArray } from './internal/helper.ts'\nimport { RETENTION_VALIDITY_UNITS } from './internal/type.ts'\n\n// Parse XML and return information as Javascript types\nconst fxp = new XMLParser()\n\n// parse error XML response\nexport function parseError(xml, headerInfo) {\n  var xmlErr = {}\n  var xmlObj = fxp.parse(xml)\n  if (xmlObj.Error) {\n    xmlErr = xmlObj.Error\n  }\n\n  var e = new errors.S3Error()\n  _.each(xmlErr, (value, key) => {\n    e[key.toLowerCase()] = value\n  })\n\n  _.each(headerInfo, (value, key) => {\n    e[key] = value\n  })\n  return e\n}\n\n// parse XML response for copy object\nexport function parseCopyObject(xml) {\n  var result = {\n    etag: '',\n    lastModified: '',\n  }\n\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.CopyObjectResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"CopyObjectResult\"')\n  }\n  xmlobj = xmlobj.CopyObjectResult\n  if (xmlobj.ETag) {\n    result.etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n  }\n  if (xmlobj.LastModified) {\n    result.lastModified = new Date(xmlobj.LastModified)\n  }\n\n  return result\n}\n\n// parse XML response for listing in-progress multipart uploads\nexport function parseListMultipart(xml) {\n  var result = {\n    uploads: [],\n    prefixes: [],\n    isTruncated: false,\n  }\n\n  var xmlobj = parseXml(xml)\n\n  if (!xmlobj.ListMultipartUploadsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListMultipartUploadsResult\"')\n  }\n  xmlobj = xmlobj.ListMultipartUploadsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextKeyMarker) {\n    result.nextKeyMarker = xmlobj.NextKeyMarker\n  }\n  if (xmlobj.NextUploadIdMarker) {\n    result.nextUploadIdMarker = xmlobj.nextUploadIdMarker\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((prefix) => {\n      result.prefixes.push({ prefix: sanitizeObjectKey(toArray(prefix.Prefix)[0]) })\n    })\n  }\n\n  if (xmlobj.Upload) {\n    toArray(xmlobj.Upload).forEach((upload) => {\n      var key = upload.Key\n      var uploadId = upload.UploadId\n      var initiator = { id: upload.Initiator.ID, displayName: upload.Initiator.DisplayName }\n      var owner = { id: upload.Owner.ID, displayName: upload.Owner.DisplayName }\n      var storageClass = upload.StorageClass\n      var initiated = new Date(upload.Initiated)\n      result.uploads.push({ key, uploadId, initiator, owner, storageClass, initiated })\n    })\n  }\n  return result\n}\n\n// parse XML response to list all the owned buckets\nexport function parseListBucket(xml) {\n  var result = []\n  var xmlobj = parseXml(xml)\n\n  if (!xmlobj.ListAllMyBucketsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListAllMyBucketsResult\"')\n  }\n  xmlobj = xmlobj.ListAllMyBucketsResult\n\n  if (xmlobj.Buckets) {\n    if (xmlobj.Buckets.Bucket) {\n      toArray(xmlobj.Buckets.Bucket).forEach((bucket) => {\n        var name = bucket.Name\n        var creationDate = new Date(bucket.CreationDate)\n        result.push({ name, creationDate })\n      })\n    }\n  }\n  return result\n}\n\n// parse XML response for bucket notification\nexport function parseBucketNotification(xml) {\n  var result = {\n    TopicConfiguration: [],\n    QueueConfiguration: [],\n    CloudFunctionConfiguration: [],\n  }\n  // Parse the events list\n  var genEvents = function (events) {\n    var result = []\n    if (events) {\n      toArray(events).forEach((s3event) => {\n        result.push(s3event)\n      })\n    }\n    return result\n  }\n  // Parse all filter rules\n  var genFilterRules = function (filters) {\n    var result = []\n    if (filters) {\n      filters = toArray(filters)\n      if (filters[0].S3Key) {\n        filters[0].S3Key = toArray(filters[0].S3Key)\n        if (filters[0].S3Key[0].FilterRule) {\n          toArray(filters[0].S3Key[0].FilterRule).forEach((rule) => {\n            var Name = toArray(rule.Name)[0]\n            var Value = toArray(rule.Value)[0]\n            result.push({ Name, Value })\n          })\n        }\n      }\n    }\n    return result\n  }\n\n  var xmlobj = parseXml(xml)\n  xmlobj = xmlobj.NotificationConfiguration\n\n  // Parse all topic configurations in the xml\n  if (xmlobj.TopicConfiguration) {\n    toArray(xmlobj.TopicConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var Topic = toArray(config.Topic)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.TopicConfiguration.push({ Id, Topic, Event, Filter })\n    })\n  }\n  // Parse all topic configurations in the xml\n  if (xmlobj.QueueConfiguration) {\n    toArray(xmlobj.QueueConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var Queue = toArray(config.Queue)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.QueueConfiguration.push({ Id, Queue, Event, Filter })\n    })\n  }\n  // Parse all QueueConfiguration arrays\n  if (xmlobj.CloudFunctionConfiguration) {\n    toArray(xmlobj.CloudFunctionConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var CloudFunction = toArray(config.CloudFunction)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.CloudFunctionConfiguration.push({ Id, CloudFunction, Event, Filter })\n    })\n  }\n\n  return result\n}\n\n// parse XML response for bucket region\nexport function parseBucketRegion(xml) {\n  // return region information\n  return parseXml(xml).LocationConstraint\n}\n\n// parse XML response for list parts of an in progress multipart upload\nexport function parseListParts(xml) {\n  var xmlobj = parseXml(xml)\n  var result = {\n    isTruncated: false,\n    parts: [],\n    marker: undefined,\n  }\n  if (!xmlobj.ListPartsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListPartsResult\"')\n  }\n  xmlobj = xmlobj.ListPartsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextPartNumberMarker) {\n    result.marker = +toArray(xmlobj.NextPartNumberMarker)[0]\n  }\n  if (xmlobj.Part) {\n    toArray(xmlobj.Part).forEach((p) => {\n      var part = +toArray(p.PartNumber)[0]\n      var lastModified = new Date(p.LastModified)\n      var etag = p.ETag.replace(/^\"/g, '')\n        .replace(/\"$/g, '')\n        .replace(/^&quot;/g, '')\n        .replace(/&quot;$/g, '')\n        .replace(/^&#34;/g, '')\n        .replace(/&#34;$/g, '')\n      result.parts.push({ part, lastModified, etag })\n    })\n  }\n  return result\n}\n\n// parse XML response when a new multipart upload is initiated\nexport function parseInitiateMultipart(xml) {\n  var xmlobj = parseXml(xml)\n\n  if (!xmlobj.InitiateMultipartUploadResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"InitiateMultipartUploadResult\"')\n  }\n  xmlobj = xmlobj.InitiateMultipartUploadResult\n\n  if (xmlobj.UploadId) {\n    return xmlobj.UploadId\n  }\n  throw new errors.InvalidXMLError('Missing tag: \"UploadId\"')\n}\n\n// parse XML response when a multipart upload is completed\nexport function parseCompleteMultipart(xml) {\n  var xmlobj = parseXml(xml).CompleteMultipartUploadResult\n  if (xmlobj.Location) {\n    var location = toArray(xmlobj.Location)[0]\n    var bucket = toArray(xmlobj.Bucket)[0]\n    var key = xmlobj.Key\n    var etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n\n    return { location, bucket, key, etag }\n  }\n  // Complete Multipart can return XML Error after a 200 OK response\n  if (xmlobj.Code && xmlobj.Message) {\n    var errCode = toArray(xmlobj.Code)[0]\n    var errMessage = toArray(xmlobj.Message)[0]\n    return { errCode, errMessage }\n  }\n}\n\nconst formatObjInfo = (content, opts = {}) => {\n  let { Key, LastModified, ETag, Size, VersionId, IsLatest } = content\n\n  if (!isObject(opts)) {\n    opts = {}\n  }\n\n  const name = sanitizeObjectKey(toArray(Key)[0])\n  const lastModified = new Date(toArray(LastModified)[0])\n  const etag = sanitizeETag(toArray(ETag)[0])\n\n  return {\n    name,\n    lastModified,\n    etag,\n    size: Size,\n    versionId: VersionId,\n    isLatest: IsLatest,\n    isDeleteMarker: opts.IsDeleteMarker ? opts.IsDeleteMarker : false,\n  }\n}\n\n// parse XML response for list objects in a bucket\nexport function parseListObjects(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  let isTruncated = false\n  let nextMarker, nextVersionKeyMarker\n  const xmlobj = parseXml(xml)\n\n  const parseCommonPrefixesEntity = (responseEntity) => {\n    if (responseEntity) {\n      toArray(responseEntity).forEach((commonPrefix) => {\n        result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n      })\n    }\n  }\n\n  const listBucketResult = xmlobj.ListBucketResult\n  const listVersionsResult = xmlobj.ListVersionsResult\n\n  if (listBucketResult) {\n    if (listBucketResult.IsTruncated) {\n      isTruncated = listBucketResult.IsTruncated\n    }\n    if (listBucketResult.Contents) {\n      toArray(listBucketResult.Contents).forEach((content) => {\n        const name = sanitizeObjectKey(toArray(content.Key)[0])\n        const lastModified = new Date(toArray(content.LastModified)[0])\n        const etag = sanitizeETag(toArray(content.ETag)[0])\n        const size = content.Size\n        result.objects.push({ name, lastModified, etag, size })\n      })\n    }\n\n    if (listBucketResult.NextMarker) {\n      nextMarker = listBucketResult.NextMarker\n    }\n    parseCommonPrefixesEntity(listBucketResult.CommonPrefixes)\n  }\n\n  if (listVersionsResult) {\n    if (listVersionsResult.IsTruncated) {\n      isTruncated = listVersionsResult.IsTruncated\n    }\n\n    if (listVersionsResult.Version) {\n      toArray(listVersionsResult.Version).forEach((content) => {\n        result.objects.push(formatObjInfo(content))\n      })\n    }\n    if (listVersionsResult.DeleteMarker) {\n      toArray(listVersionsResult.DeleteMarker).forEach((content) => {\n        result.objects.push(formatObjInfo(content, { IsDeleteMarker: true }))\n      })\n    }\n\n    if (listVersionsResult.NextKeyMarker) {\n      nextVersionKeyMarker = listVersionsResult.NextKeyMarker\n    }\n    if (listVersionsResult.NextVersionIdMarker) {\n      result.versionIdMarker = listVersionsResult.NextVersionIdMarker\n    }\n    parseCommonPrefixesEntity(listVersionsResult.CommonPrefixes)\n  }\n\n  result.isTruncated = isTruncated\n  if (isTruncated) {\n    result.nextMarker = nextVersionKeyMarker || nextMarker\n  }\n  return result\n}\n\n// parse XML response for list objects v2 in a bucket\nexport function parseListObjectsV2(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      var name = sanitizeObjectKey(toArray(content.Key)[0])\n      var lastModified = new Date(content.LastModified)\n      var etag = sanitizeETag(content.ETag)\n      var size = content.Size\n      result.objects.push({ name, lastModified, etag, size })\n    })\n  }\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\n// parse XML response for list objects v2 with metadata in a bucket\nexport function parseListObjectsV2WithMetadata(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      var name = sanitizeObjectKey(content.Key)\n      var lastModified = new Date(content.LastModified)\n      var etag = sanitizeETag(content.ETag)\n      var size = content.Size\n      var metadata\n      if (content.UserMetadata != null) {\n        metadata = toArray(content.UserMetadata)[0]\n      } else {\n        metadata = null\n      }\n      result.objects.push({ name, lastModified, etag, size, metadata })\n    })\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\nexport function parseBucketVersioningConfig(xml) {\n  var xmlObj = parseXml(xml)\n  return xmlObj.VersioningConfiguration\n}\n\nexport function parseTagging(xml) {\n  const xmlObj = parseXml(xml)\n  let result = []\n  if (xmlObj.Tagging && xmlObj.Tagging.TagSet && xmlObj.Tagging.TagSet.Tag) {\n    const tagResult = xmlObj.Tagging.TagSet.Tag\n    // if it is a single tag convert into an array so that the return value is always an array.\n    if (isObject(tagResult)) {\n      result.push(tagResult)\n    } else {\n      result = tagResult\n    }\n  }\n  return result\n}\n\nexport function parseLifecycleConfig(xml) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LifecycleConfiguration\n}\n\nexport function parseObjectLockConfig(xml) {\n  const xmlObj = parseXml(xml)\n  let lockConfigResult = {}\n  if (xmlObj.ObjectLockConfiguration) {\n    lockConfigResult = {\n      objectLockEnabled: xmlObj.ObjectLockConfiguration.ObjectLockEnabled,\n    }\n    let retentionResp\n    if (\n      xmlObj.ObjectLockConfiguration &&\n      xmlObj.ObjectLockConfiguration.Rule &&\n      xmlObj.ObjectLockConfiguration.Rule.DefaultRetention\n    ) {\n      retentionResp = xmlObj.ObjectLockConfiguration.Rule.DefaultRetention || {}\n      lockConfigResult.mode = retentionResp.Mode\n    }\n    if (retentionResp) {\n      const isUnitYears = retentionResp.Years\n      if (isUnitYears) {\n        lockConfigResult.validity = isUnitYears\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.YEARS\n      } else {\n        lockConfigResult.validity = retentionResp.Days\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.DAYS\n      }\n    }\n    return lockConfigResult\n  }\n}\n\nexport function parseObjectRetentionConfig(xml) {\n  const xmlObj = parseXml(xml)\n  const retentionConfig = xmlObj.Retention\n\n  return {\n    mode: retentionConfig.Mode,\n    retainUntilDate: retentionConfig.RetainUntilDate,\n  }\n}\n\nexport function parseBucketEncryptionConfig(xml) {\n  let encConfig = parseXml(xml)\n  return encConfig\n}\nexport function parseReplicationConfig(xml) {\n  const xmlObj = parseXml(xml)\n  const replicationConfig = {\n    ReplicationConfiguration: {\n      role: xmlObj.ReplicationConfiguration.Role,\n      rules: toArray(xmlObj.ReplicationConfiguration.Rule),\n    },\n  }\n  return replicationConfig\n}\n\nexport function parseObjectLegalHoldConfig(xml) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LegalHold\n}\n\nexport function uploadPartParser(xml) {\n  const xmlObj = parseXml(xml)\n  const respEl = xmlObj.CopyPartResult\n  return respEl\n}\n\nexport function removeObjectsParser(xml) {\n  const xmlObj = parseXml(xml)\n  if (xmlObj.DeleteResult && xmlObj.DeleteResult.Error) {\n    // return errors as array always. as the response is object in case of single object passed in removeObjects\n    return toArray(xmlObj.DeleteResult.Error)\n  }\n  return []\n}\n\nexport function parseSelectObjectContentResponse(res) {\n  // extractHeaderType extracts the first half of the header message, the header type.\n  function extractHeaderType(stream) {\n    const headerNameLen = Buffer.from(stream.read(1)).readUInt8()\n    const headerNameWithSeparator = Buffer.from(stream.read(headerNameLen)).toString()\n    const splitBySeparator = (headerNameWithSeparator || '').split(':')\n    const headerName = splitBySeparator.length >= 1 ? splitBySeparator[1] : ''\n    return headerName\n  }\n\n  function extractHeaderValue(stream) {\n    const bodyLen = Buffer.from(stream.read(2)).readUInt16BE()\n    const bodyName = Buffer.from(stream.read(bodyLen)).toString()\n    return bodyName\n  }\n\n  const selectResults = new SelectResults({}) // will be returned\n\n  const responseStream = readableStream(res) // convert byte array to a readable responseStream\n  while (responseStream._readableState.length) {\n    // Top level responseStream read tracker.\n    let msgCrcAccumulator // accumulate from start of the message till the message crc start.\n\n    const totalByteLengthBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(totalByteLengthBuffer)\n\n    const headerBytesBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(headerBytesBuffer, msgCrcAccumulator)\n\n    const calculatedPreludeCrc = msgCrcAccumulator.readInt32BE() // use it to check if any CRC mismatch in header itself.\n\n    const preludeCrcBuffer = Buffer.from(responseStream.read(4)) // read 4 bytes    i.e 4+4 =8 + 4 = 12 ( prelude + prelude crc)\n    msgCrcAccumulator = crc32(preludeCrcBuffer, msgCrcAccumulator)\n\n    const totalMsgLength = totalByteLengthBuffer.readInt32BE()\n    const headerLength = headerBytesBuffer.readInt32BE()\n    const preludeCrcByteValue = preludeCrcBuffer.readInt32BE()\n\n    if (preludeCrcByteValue !== calculatedPreludeCrc) {\n      // Handle Header CRC mismatch Error\n      throw new Error(\n        `Header Checksum Mismatch, Prelude CRC of ${preludeCrcByteValue} does not equal expected CRC of ${calculatedPreludeCrc}`,\n      )\n    }\n\n    const headers = {}\n    if (headerLength > 0) {\n      const headerBytes = Buffer.from(responseStream.read(headerLength))\n      msgCrcAccumulator = crc32(headerBytes, msgCrcAccumulator)\n      const headerReaderStream = readableStream(headerBytes)\n      while (headerReaderStream._readableState.length) {\n        let headerTypeName = extractHeaderType(headerReaderStream)\n        headerReaderStream.read(1) // just read and ignore it.\n        headers[headerTypeName] = extractHeaderValue(headerReaderStream)\n      }\n    }\n\n    let payloadStream\n    const payLoadLength = totalMsgLength - headerLength - 16\n    if (payLoadLength > 0) {\n      const payLoadBuffer = Buffer.from(responseStream.read(payLoadLength))\n      msgCrcAccumulator = crc32(payLoadBuffer, msgCrcAccumulator)\n      // read the checksum early and detect any mismatch so we can avoid unnecessary further processing.\n      const messageCrcByteValue = Buffer.from(responseStream.read(4)).readInt32BE()\n      const calculatedCrc = msgCrcAccumulator.readInt32BE()\n      // Handle message CRC Error\n      if (messageCrcByteValue !== calculatedCrc) {\n        throw new Error(\n          `Message Checksum Mismatch, Message CRC of ${messageCrcByteValue} does not equal expected CRC of ${calculatedCrc}`,\n        )\n      }\n      payloadStream = readableStream(payLoadBuffer)\n    }\n\n    const messageType = headers['message-type']\n\n    switch (messageType) {\n      case 'error': {\n        const errorMessage = headers['error-code'] + ':\"' + headers['error-message'] + '\"'\n        throw new Error(errorMessage)\n      }\n      case 'event': {\n        const contentType = headers['content-type']\n        const eventType = headers['event-type']\n\n        switch (eventType) {\n          case 'End': {\n            selectResults.setResponse(res)\n            return selectResults\n          }\n\n          case 'Records': {\n            const readData = payloadStream.read(payLoadLength)\n            selectResults.setRecords(readData)\n            break\n          }\n\n          case 'Progress':\n            {\n              switch (contentType) {\n                case 'text/xml': {\n                  const progressData = payloadStream.read(payLoadLength)\n                  selectResults.setProgress(progressData.toString())\n                  break\n                }\n                default: {\n                  const errorMessage = `Unexpected content-type ${contentType} sent for event-type Progress`\n                  throw new Error(errorMessage)\n                }\n              }\n            }\n            break\n          case 'Stats':\n            {\n              switch (contentType) {\n                case 'text/xml': {\n                  const statsData = payloadStream.read(payLoadLength)\n                  selectResults.setStats(statsData.toString())\n                  break\n                }\n                default: {\n                  const errorMessage = `Unexpected content-type ${contentType} sent for event-type Stats`\n                  throw new Error(errorMessage)\n                }\n              }\n            }\n            break\n          default: {\n            // Continuation message: Not sure if it is supported. did not find a reference or any message in response.\n            // It does not have a payload.\n            const warningMessage = `Un implemented event detected  ${messageType}.`\n            // eslint-disable-next-line no-console\n            console.warn(warningMessage)\n          }\n        } // eventType End\n      } // Event End\n    } // messageType End\n  } // Top Level Stream End\n}\n"],"mappings":"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"} + +/***/ }), + +/***/ 7962: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +/*! + * mime-db + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2015-2022 Douglas Christopher Wilson + * MIT Licensed + */ + +/** + * Module exports. + */ + +module.exports = __nccwpck_require__(2639) + + +/***/ }), + +/***/ 7920: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; +/*! + * mime-types + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + */ + + + +/** + * Module dependencies. + * @private + */ + +var db = __nccwpck_require__(7962) +var extname = (__nccwpck_require__(1017).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 + } + }) +} + /***/ }), @@ -88743,60 +92333,48 @@ module.exports.q = codes; // 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. -/**/ + +/**/ var objectKeys = Object.keys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - module.exports = Duplex; - var Readable = __nccwpck_require__(1433); - var Writable = __nccwpck_require__(2094); - __nccwpck_require__(4124)(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 @@ -88823,20 +92401,20 @@ Object.defineProperty(Duplex.prototype, 'writableLength', { get: function get() { return this._writableState.length; } -}); // the no-half-open enforcer +}); +// 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. + 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 @@ -88846,7 +92424,6 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { if (this._readableState === undefined || this._writableState === undefined) { return false; } - return this._readableState.destroyed && this._writableState.destroyed; }, set: function set(value) { @@ -88854,10 +92431,10 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { // has not been initialized yet if (this._readableState === undefined || this._writableState === undefined) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // backward compatibility, the user is explicitly + // managing destroyed this._readableState.destroyed = value; this._writableState.destroyed = value; } @@ -88889,22 +92466,20 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { // 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; +module.exports = PassThrough; var Transform = __nccwpck_require__(4415); - __nccwpck_require__(4124)(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); }; @@ -88937,47 +92512,38 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { // USE OR OTHER DEALINGS IN THE SOFTWARE. + module.exports = Readable; -/**/ +/**/ var Duplex; /**/ Readable.ReadableState = ReadableState; -/**/ +/**/ var EE = (__nccwpck_require__(2361).EventEmitter); - var EElistenerCount = function EElistenerCount(emitter, type) { return emitter.listeners(type).length; }; /**/ /**/ - - var Stream = __nccwpck_require__(2387); /**/ - var Buffer = (__nccwpck_require__(4300).Buffer); - -var OurUint8Array = global.Uint8Array || function () {}; - +var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } - function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } -/**/ - +/**/ var debugUtil = __nccwpck_require__(3837); - var debug; - if (debugUtil && debugUtil.debuglog) { debug = debugUtil.debuglog('stream'); } else { @@ -88985,60 +92551,57 @@ if (debugUtil && debugUtil.debuglog) { } /**/ - var BufferList = __nccwpck_require__(2746); - var destroyImpl = __nccwpck_require__(7049); - var _require = __nccwpck_require__(9948), - getHighWaterMark = _require.getHighWaterMark; - + getHighWaterMark = _require.getHighWaterMark; var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q), - 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. - + 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; - __nccwpck_require__(4124)(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 + 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 || __nccwpck_require__(1359); - options = options || {}; // Duplex streams are both readable and writable, but share + 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; - if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to + // 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 + 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); - this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the + // 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; @@ -89046,61 +92609,66 @@ function ReadableState(options, stream, isDuplex) { 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 + 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; - this.sync = true; // whenever we return null, then we set a flag to say + // 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.paused = true; - this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish') + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; - this.autoDestroy = !!options.autoDestroy; // has it been destroyed + // Should .destroy() be called after 'end' (and potentially 'finish') + this.autoDestroy = !!options.autoDestroy; - this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string + // 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'; - 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 + // 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 = (__nccwpck_require__(4841)/* .StringDecoder */ .s); this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } - function Readable(options) { Duplex = Duplex || __nccwpck_require__(1359); - 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 + 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._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 @@ -89110,7 +92678,6 @@ Object.defineProperty(Readable.prototype, 'destroyed', { if (this._readableState === undefined) { return false; } - return this._readableState.destroyed; }, set: function set(value) { @@ -89118,69 +92685,60 @@ Object.defineProperty(Readable.prototype, 'destroyed', { // has not been initialized yet if (!this._readableState) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // 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. +}; + +// 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() - +}; +// 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) { @@ -89189,7 +92747,6 @@ function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { 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); @@ -89201,14 +92758,13 @@ function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { state.reading = false; maybeReadMore(stream, state); } - } // We can push more data if we are below the highWaterMark. + } + + // 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; @@ -89219,50 +92775,42 @@ function addChunk(stream, state, chunk, addToFront) { 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. - +}; +// backwards compatibility. Readable.prototype.setEncoding = function (enc) { if (!StringDecoder) StringDecoder = (__nccwpck_require__(4841)/* .StringDecoder */ .s); 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: + 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 - +}; +// 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. @@ -89278,55 +92826,54 @@ function computeNewHighWaterMark(n) { n |= n >>> 16; n++; } - return n; -} // This function is designed to be inlinable, so please take care when making -// changes to the function body. - +} +// 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 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 (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. - +} +// 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 + 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); - n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up. - + // 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 + } + + // 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 @@ -89347,40 +92894,37 @@ Readable.prototype.read = function (n) { // '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. - + // 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 + 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. - + } + // 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 - + 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, + 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; @@ -89388,34 +92932,28 @@ Readable.prototype.read = function (n) { 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 (!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() @@ -89424,61 +92962,56 @@ function onEofChunk(stream, state) { } 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 +} + +// 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 + } + + // 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, +} + +// 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. // @@ -89507,49 +93040,42 @@ function maybeReadMore_(stream, state) { var len = state.length; debug('maybeReadMore read 0'); stream.read(0); - if (len === state.length) // didn't get any data, stop spinning. + if (len === state.length) + // didn't get any data, stop spinning. break; } - state.readingMore = false; -} // abstract method. to be overridden in specific implementation classes. +} + +// 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; @@ -89557,23 +93083,21 @@ Readable.prototype.pipe = function (dest, pipeOpts) { } } } - function onend() { debug('onend'); dest.end(); - } // when the dest drains, it reduces the awaitDrain counter + } + + // 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 - + debug('cleanup'); + // cleanup event handlers once the pipe is broken dest.removeListener('close', onclose); dest.removeListener('finish', onfinish); dest.removeListener('drain', ondrain); @@ -89582,22 +93106,20 @@ Readable.prototype.pipe = function (dest, pipeOpts) { 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 + 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 @@ -89607,87 +93129,84 @@ Readable.prototype.pipe = function (dest, pipeOpts) { 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. - + } + // 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. + // 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. + // 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 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. + 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. + } + // slow case. multiple pipe destinations. if (!dest) { // remove all. @@ -89696,17 +93215,13 @@ Readable.prototype.unpipe = function (dest) { state.pipes = null; state.pipesCount = 0; state.flowing = false; - - for (var i = 0; i < len; i++) { - dests[i].emit('unpipe', this, { - hasUnpiped: false - }); - } - + for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, { + hasUnpiped: false + }); return this; - } // try to find the right one. - + } + // try to find the right one. var index = indexOf(state.pipes, dest); if (index === -1) return this; state.pipes.splice(index, 1); @@ -89714,19 +93229,19 @@ Readable.prototype.unpipe = function (dest) { 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 - +}; +// 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 + 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) { @@ -89734,7 +93249,6 @@ Readable.prototype.on = function (ev, fn) { state.flowing = false; state.emittedReadable = false; debug('on readable', state.length, state.reading); - if (state.length) { emitReadable(this); } else if (!state.reading) { @@ -89742,15 +93256,11 @@ Readable.prototype.on = function (ev, fn) { } } } - 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 @@ -89760,13 +93270,10 @@ Readable.prototype.removeListener = function (ev, fn) { // 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 @@ -89776,121 +93283,103 @@ Readable.prototype.removeAllListeners = function (ev) { // 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 + 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. - +} +// 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 + 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); +} - while (state.flowing && stream.read() !== null) { - ; - } -} // wrap an old-style stream as the async data source. +// 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.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. + }); + // 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) { @@ -89899,37 +93388,32 @@ Readable.prototype.wrap = function (stream) { }; }(i); } - } // proxy certain important events. - + } + // 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. - + } + // 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 = __nccwpck_require__(3306); } - return createReadableStreamAsyncIterator(this); }; } - Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -89961,8 +93445,9 @@ Object.defineProperty(Readable.prototype, 'readableFlowing', { this._readableState.flowing = state; } } -}); // exposed for testing purposes only. +}); +// exposed for testing purposes only. Readable._fromList = fromList; Object.defineProperty(Readable.prototype, 'readableLength', { // making it explicit this property is not enumerable @@ -89972,11 +93457,12 @@ Object.defineProperty(Readable.prototype, 'readableLength', { get: function get() { return this._readableState.length; } -}); // Pluck off n bytes from an array of buffers. +}); + +// 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; @@ -89991,52 +93477,44 @@ function fromList(n, state) { } 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. + 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 = __nccwpck_require__(9082); } - 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; } @@ -90066,6 +93544,7 @@ function indexOf(xs, x) { // 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 @@ -90109,40 +93588,34 @@ function indexOf(xs, x) { // the results of the previous transformed chunk were consumed. -module.exports = Transform; +module.exports = Transform; var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q), - 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; - + 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 = __nccwpck_require__(1359); - __nccwpck_require__(4124)(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` + 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); @@ -90153,26 +93626,25 @@ function Transform(options) { 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 + // 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. - + } + // 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); @@ -90181,11 +93653,12 @@ function prefinish() { 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! +}; + +// This is the part where you do stuff! // override this function in implementation classes. // 'chunk' is an input chunk. // @@ -90195,33 +93668,27 @@ Transform.prototype.push = function (chunk, encoding) { // 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. +}; + +// 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 @@ -90229,20 +93696,20 @@ Transform.prototype._read = function (n) { 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 (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); @@ -90274,29 +93741,29 @@ function done(stream, er, data) { // 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; -/* */ +/* */ 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 - +} +// 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); }; @@ -90304,155 +93771,159 @@ function CorkedRequest(state) { /* */ /**/ - - var Duplex; /**/ Writable.WritableState = WritableState; -/**/ +/**/ var internalUtil = { deprecate: __nccwpck_require__(7127) }; /**/ /**/ - var Stream = __nccwpck_require__(2387); /**/ - var Buffer = (__nccwpck_require__(4300).Buffer); - -var OurUint8Array = global.Uint8Array || function () {}; - +var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } - function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } - var destroyImpl = __nccwpck_require__(7049); - var _require = __nccwpck_require__(9948), - getHighWaterMark = _require.getHighWaterMark; - + getHighWaterMark = _require.getHighWaterMark; var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q), - 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; - + 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; - __nccwpck_require__(4124)(Writable, Stream); - function nop() {} - function WritableState(options, stream, isDuplex) { Duplex = Duplex || __nccwpck_require__(1359); - options = options || {}; // Duplex streams are both readable and writable, but share + 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; - if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream + // 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 + 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); - 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 + // if _final has been called + this.finalCalled = false; - this.ended = false; // when 'finish' is emitted + // drain event flag. + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; - this.finished = false; // has it been destroyed + // has it been destroyed + this.destroyed = false; - this.destroyed = false; // should we decode strings into buffers before passing to _write? + // 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 + 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'; - this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement + // 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; - this.length = 0; // a flag to see when we're in the middle of a write. + // a flag to see when we're in the middle of a write. + this.writing = false; - this.writing = false; // when true all writes will be buffered until .uncork() call + // when true all writes will be buffered until .uncork() call + this.corked = 0; - this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately, + // 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; - this.sync = true; // a flag to know if we're processing previously buffered items, which + // 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; - this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb) - + // 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. + // 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.lastBufferedRequest = null; + + // number of pending user-supplied write callbacks // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; - this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs + // emit prefinish if the only thing we're waiting for is _write cbs // This is relevant for synchronous Transform streams + this.prefinished = false; - this.prefinished = false; // True if the error was already emitted and should not be thrown again + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; - this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true. + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; - this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end') + // Should .destroy() be called after 'finish' (and potentially 'end') + this.autoDestroy = !!options.autoDestroy; - this.autoDestroy = !!options.autoDestroy; // count buffered requests + // count buffered requests + this.bufferedRequestCount = 0; - this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always + // 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', { @@ -90461,12 +93932,11 @@ WritableState.prototype.getBuffer = function 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. - +})(); +// 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, { @@ -90481,81 +93951,73 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot return object instanceof this; }; } - function Writable(options) { - Duplex = Duplex || __nccwpck_require__(1359); // Writable ctor is applied to Duplexes, too. + Duplex = Duplex || __nccwpck_require__(1359); + + // 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._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. - +} +// 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 - + 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 +} + +// 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)) { @@ -90564,20 +94026,16 @@ Writable.prototype.write = function (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(); @@ -90585,7 +94043,6 @@ Writable.prototype.setDefaultEncoding = function setDefaultEncoding(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 @@ -90595,15 +94052,12 @@ Object.defineProperty(Writable.prototype, 'writableBuffer', { 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 @@ -90612,27 +94066,25 @@ Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { get: function get() { return this._writableState.highWaterMark; } -}); // if we're already writing something, then just put this +}); + +// 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. - + 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 = { @@ -90642,21 +94094,17 @@ function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { 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; @@ -90665,16 +94113,14 @@ function doWrite(stream, state, writev, len, chunk, encoding, cb) { 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 + 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); @@ -90683,20 +94129,18 @@ function onwriteError(stream, state, sync, er, cb) { // it is async cb(er); stream._writableState.errorEmitted = true; - errorOrDestroy(stream, er); // this can emit finish, but finish must + 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; @@ -90706,11 +94150,9 @@ function onwrite(stream, er) { 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 { @@ -90718,29 +94160,27 @@ function onwrite(stream, er) { } } } - 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 +} + +// 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 - +} +// 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; @@ -90749,28 +94189,25 @@ function clearBuffer(stream, state) { 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 + 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 @@ -90781,32 +94218,26 @@ function clearBuffer(stream, state) { 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 + 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; @@ -90815,19 +94246,18 @@ Writable.prototype.end = function (chunk, encoding, cb) { cb = encoding; encoding = null; } + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks - + // .end() fully uncorks if (state.corked) { state.corked = 1; this.uncork(); - } // ignore unnecessary end() calls. - + } + // 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 @@ -90837,25 +94267,20 @@ Object.defineProperty(Writable.prototype, 'writableLength', { 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) { @@ -90868,59 +94293,47 @@ function prefinish(stream, state) { } } } - 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. - + } + // 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 @@ -90930,7 +94343,6 @@ Object.defineProperty(Writable.prototype, 'destroyed', { if (this._writableState === undefined) { return false; } - return this._writableState.destroyed; }, set: function set(value) { @@ -90938,16 +94350,15 @@ Object.defineProperty(Writable.prototype, 'destroyed', { // has not been initialized yet if (!this._writableState) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // 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); }; @@ -90961,11 +94372,10 @@ Writable.prototype._destroy = function (err, cb) { 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; } - +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var finished = __nccwpck_require__(6080); - var kLastResolve = Symbol('lastResolve'); var kLastReject = Symbol('lastReject'); var kError = Symbol('error'); @@ -90973,22 +94383,19 @@ 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 + 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; @@ -90997,13 +94404,11 @@ function readAndResolve(iter) { } } } - 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 () { @@ -91011,33 +94416,26 @@ function wrapForNext(lastPromise, iter) { 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 @@ -91052,29 +94450,25 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro } }); }); - } // if we have multiple next() calls + } + + // 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; } @@ -91082,7 +94476,6 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro 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 @@ -91092,15 +94485,12 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro 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 @@ -91119,7 +94509,6 @@ var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterat }), _defineProperty(_Object$create, kHandlePromise, { value: function value(resolve, reject) { var data = iterator[kStream].read(); - if (data) { iterator[kLastPromise] = null; iterator[kLastResolve] = null; @@ -91135,35 +94524,30 @@ var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterat 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 + 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; /***/ }), @@ -91174,41 +94558,29 @@ module.exports = createReadableStreamAsyncIterator; "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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); 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; } - +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, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var _require = __nccwpck_require__(4300), - Buffer = _require.Buffer; - + Buffer = _require.Buffer; var _require2 = __nccwpck_require__(3837), - inspect = _require2.inspect; - + 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 () { +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) { @@ -91252,11 +94624,7 @@ function () { if (this.length === 0) return ''; var p = this.head; var ret = '' + p.data; - - while (p = p.next) { - ret += s + p.data; - } - + while (p = p.next) ret += s + p.data; return ret; } }, { @@ -91266,21 +94634,19 @@ function () { 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. + } + // 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); @@ -91292,15 +94658,15 @@ function () { // 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. + } + // Consumes a specified amount of characters from the buffered data. }, { key: "_getString", value: function _getString(n) { @@ -91308,13 +94674,11 @@ function () { 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; @@ -91323,17 +94687,15 @@ function () { 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. + } + // Consumes a specified amount of bytes from the buffered data. }, { key: "_getBuffer", value: function _getBuffer(n) { @@ -91342,13 +94704,11 @@ function () { 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; @@ -91357,21 +94717,19 @@ function () { 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. + } + // Make sure the linked list only shows the minimal necessary information. }, { key: custom, value: function value(_, options) { - return inspect(this, _objectSpread({}, options, { + return inspect(this, _objectSpread(_objectSpread({}, options), {}, { // Only inspect one level. depth: 0, // It should not recurse. @@ -91379,7 +94737,6 @@ function () { })); } }]); - return BufferList; }(); @@ -91389,14 +94746,13 @@ function () { /***/ ((module) => { "use strict"; - // undocumented cb() API, needed for core, not for public API + +// 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); @@ -91408,21 +94764,20 @@ function destroy(err, cb) { 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 + } + // 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 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) { @@ -91440,21 +94795,17 @@ function destroy(err, cb) { 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; @@ -91462,7 +94813,6 @@ function undestroy() { this._readableState.ended = false; this._readableState.endEmitted = false; } - if (this._writableState) { this._writableState.destroyed = false; this._writableState.ended = false; @@ -91473,22 +94823,20 @@ function undestroy() { 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, @@ -91505,77 +94853,61 @@ module.exports = { // permission from the author, Mathias Buus (@mafintosh). -var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(7214)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE); +var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(7214)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.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); @@ -91585,7 +94917,6 @@ function eos(stream, opts, callback) { stream.on('end', onlegacyfinish); stream.on('close', onlegacyfinish); } - stream.on('end', onend); stream.on('finish', onfinish); if (opts.error !== false) stream.on('error', onerror); @@ -91603,7 +94934,6 @@ function eos(stream, opts, callback) { stream.removeListener('close', onclose); }; } - module.exports = eos; /***/ }), @@ -91615,52 +94945,42 @@ module.exports = eos; 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; } - +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var ERR_INVALID_ARG_TYPE = (__nccwpck_require__(7214)/* .codes.ERR_INVALID_ARG_TYPE */ .q.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 + }, 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; - + var _yield$iterator$next = yield iterator.next(), + value = _yield$iterator$next.value, + done = _yield$iterator$next.done; if (done) { readable.push(null); - } else if (readable.push((yield value))) { + } else if (readable.push(yield value)) { next(); } else { reading = false; @@ -91671,12 +94991,11 @@ function from(Readable, iterable, opts) { }); return _next2.apply(this, arguments); } - return readable; } - module.exports = from; + /***/ }), /***/ 6989: @@ -91687,8 +95006,8 @@ module.exports = from; // permission from the author, Mathias Buus (@mafintosh). -var eos; +var eos; function once(callback) { var called = false; return function () { @@ -91697,20 +95016,16 @@ function once(callback) { callback.apply(void 0, arguments); }; } - var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q), - ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, - ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; - + 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; @@ -91730,40 +95045,34 @@ function destroyer(stream, reading, writing, callback) { return function (err) { if (closed) return; if (destroyed) return; - destroyed = true; // request.destroy just do .end - .abort is what we want + 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; @@ -91778,7 +95087,6 @@ function pipeline() { }); return streams.reduce(pipe); } - module.exports = pipeline; /***/ }), @@ -91790,27 +95098,22 @@ module.exports = pipeline; var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(7214)/* .codes.ERR_INVALID_OPT_VALUE */ .q.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 - + } + // Default value return state.objectMode ? 16 : 16 * 1024; } - module.exports = { getHighWaterMark: getHighWaterMark }; @@ -104092,6 +107395,7 @@ function restoreCache() { const paths = (0, utils_1.getInputAsArray)("path"); const restoreKeys = (0, utils_1.getInputAsArray)("restore-keys"); const local = core.getInput("local"); + const errorOnS3Exception = (0, utils_1.getInputAsBoolean)("error-on-s3-exception"); try { const compressionMethod = yield utils.getCompressionMethod(); const cacheFileName = utils.getCacheFileName(compressionMethod); @@ -104102,14 +107406,14 @@ function restoreCache() { core.saveState(state_1.State.SecretKey, core.getInput("secretKey")); core.saveState(state_1.State.SessionToken, core.getInput("sessionToken")); if (local) { - core.info('Local cache is enabled'); + core.info("Local cache is enabled"); const localKey = path.join(local, key, cacheFileName); core.info(`Looking for exact match: ${localKey}`); if (fs.existsSync(localKey)) { - core.info('Local cache HIT! ✅'); + core.info("Local cache HIT! ✅"); yield fs.copy(localKey, archivePath); - core.info('Local cache copied!'); - core.info('Extracting cache file...'); + core.info("Local cache copied!"); + core.info("Extracting cache file..."); yield (0, tar_1.extractTar)(archivePath, compressionMethod); (0, utils_1.saveMatchedKey)(key); (0, utils_1.setCacheHitOutput)(true); @@ -104119,7 +107423,7 @@ function restoreCache() { } else { (0, utils_1.setCacheHitLocal)(false); - core.info('Local cache MISS! ❌'); + core.info("Local cache MISS! ❌"); } } const mc = (0, utils_1.newMinio)(); @@ -104139,8 +107443,13 @@ function restoreCache() { core.info("Cache restored from s3 successfully"); } catch (e) { - core.info("Restore s3 cache failed: " + e.message); (0, utils_1.setCacheHitOutput)(false); + if (errorOnS3Exception) { + core.setFailed("Restore s3 cache failed: " + e.message); + } + else { + core.info("Restore s3 cache failed: " + e.message); + } if (useFallback) { if ((0, utils_1.isGhes)()) { core.warning("Cache fallback is not supported on Github Enterpise."); @@ -104184,7 +107493,7 @@ var State; State["SecretKey"] = "secret-key"; State["SessionToken"] = "session-token"; State["LocalHit"] = "local-hit"; -})(State || (exports.State = State = {})); +})(State = exports.State || (exports.State = {})); /***/ }), @@ -104540,6 +107849,14 @@ module.exports = require("zlib"); /***/ 3765: /***/ ((module) => { +"use strict"; +module.exports = JSON.parse('{"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/3gpphal+json":{"source":"iana","compressible":true},"application/3gpphalforms+json":{"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/captive+json":{"source":"iana","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/clr":{"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":["es","ecma"]},"application/edi-consent":{"source":"iana"},"application/edi-x12":{"source":"iana","compressible":false},"application/edifact":{"source":"iana","compressible":false},"application/efi":{"source":"iana"},"application/elm+json":{"source":"iana","charset":"UTF-8","compressible":true},"application/elm+xml":{"source":"iana","compressible":true},"application/emergencycalldata.cap+xml":{"source":"iana","charset":"UTF-8","compressible":true},"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/jscalendar+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},"application/mrb-publish+xml":{"source":"iana","compressible":true},"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/oauth-authz-req+jwt":{"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/opc-nodeset+xml":{"source":"iana","compressible":true},"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.cyn":{"source":"iana","charset":"7-BIT"},"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/sarif+json":{"source":"iana","compressible":true},"application/sarif-external-properties+json":{"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/ubjson":{"compressible":false,"extensions":["ubj"]},"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,"extensions":["td"]},"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.5gnas":{"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.gtpc":{"source":"iana"},"application/vnd.3gpp.interworking-data":{"source":"iana"},"application/vnd.3gpp.lpp":{"source":"iana"},"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.ngap":{"source":"iana"},"application/vnd.3gpp.pfcp":{"source":"iana"},"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.s1ap":{"source":"iana"},"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.cmoca-cmresource":{"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-cmtable":{"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":["key"]},"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.cryptomator.encrypted":{"source":"iana"},"application/vnd.cryptomator.vault":{"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.cyclonedx+json":{"source":"iana","compressible":true},"application/vnd.cyclonedx+xml":{"source":"iana","compressible":true},"application/vnd.d2l.coursepackage1p0+zip":{"source":"iana","compressible":false},"application/vnd.d3m-dataset":{"source":"iana"},"application/vnd.d3m-problem":{"source":"iana"},"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","extensions":["dbf"]},"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.fujifilm.fb.docuworks":{"source":"iana"},"application/vnd.fujifilm.fb.docuworks.binder":{"source":"iana"},"application/vnd.fujifilm.fb.docuworks.container":{"source":"iana"},"application/vnd.fujifilm.fb.jfi+xml":{"source":"iana","compressible":true},"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.slides":{"source":"iana"},"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","extensions":["mvt"]},"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.nebumind.line":{"source":"iana"},"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+cbor":{"source":"iana"},"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","extensions":["rar"]},"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.seis+json":{"source":"iana","compressible":true},"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.sycle+xml":{"source":"iana","compressible":true},"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.dpp":{"source":"iana"},"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":{"source":"iana","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},"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":["xsl","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","extensions":["amr"]},"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","opus"]},"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/scip":{"source":"iana"},"audio/silk":{"source":"apache","extensions":["sil"]},"audio/smv":{"source":"iana"},"audio/smv-qcp":{"source":"iana"},"audio/smv0":{"source":"iana"},"audio/sofa":{"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/tsvcis":{"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/avif":{"source":"iana","compressible":false,"extensions":["avif"]},"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/ktx2":{"source":"iana","extensions":["ktx2"]},"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.pco.b16":{"source":"iana","extensions":["b16"]},"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/e57":{"source":"iana"},"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.pytha.pyox":{"source":"iana"},"model/vnd.rosette.annotated-data-model":{"source":"iana"},"model/vnd.sap.vds":{"source":"iana","extensions":["vds"]},"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/cql":{"source":"iana"},"text/cql-expression":{"source":"iana"},"text/cql-identifier":{"source":"iana"},"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/fhirpath":{"source":"iana"},"text/flexfec":{"source":"iana"},"text/fwdred":{"source":"iana"},"text/gff3":{"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/shaclc":{"source":"iana"},"text/shex":{"source":"iana","extensions":["shex"]},"text/slim":{"extensions":["slim","slm"]},"text/spdx":{"source":"iana","extensions":["spdx"]},"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.hans":{"source":"iana"},"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":{"compressible":true,"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/av1":{"source":"iana"},"video/bmpeg":{"source":"iana"},"video/bt656":{"source":"iana"},"video/celb":{"source":"iana"},"video/dv":{"source":"iana"},"video/encaprtp":{"source":"iana"},"video/ffv1":{"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","extensions":["m4s"]},"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/scip":{"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}}'); + +/***/ }), + +/***/ 2639: +/***/ ((module) => { + "use strict"; module.exports = JSON.parse('{"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/3gpphal+json":{"source":"iana","compressible":true},"application/3gpphalforms+json":{"source":"iana","compressible":true},"application/a2l":{"source":"iana"},"application/ace+cbor":{"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/at+jwt":{"source":"iana"},"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/captive+json":{"source":"iana","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/city+json":{"source":"iana","compressible":true},"application/clr":{"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,"extensions":["cpl"]},"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/dash-patch+xml":{"source":"iana","compressible":true,"extensions":["mpp"]},"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":["es","ecma"]},"application/edi-consent":{"source":"iana"},"application/edi-x12":{"source":"iana","compressible":false},"application/edifact":{"source":"iana","compressible":false},"application/efi":{"source":"iana"},"application/elm+json":{"source":"iana","charset":"UTF-8","compressible":true},"application/elm+xml":{"source":"iana","compressible":true},"application/emergencycalldata.cap+xml":{"source":"iana","charset":"UTF-8","compressible":true},"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/express":{"source":"iana","extensions":["exp"]},"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/jscalendar+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":{"source":"iana","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,"extensions":["mpf"]},"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/missing-blocks+cbor-seq":{"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},"application/mrb-publish+xml":{"source":"iana","compressible":true},"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/oauth-authz-req+jwt":{"source":"iana"},"application/oblivious-dns-message":{"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/opc-nodeset+xml":{"source":"iana","compressible":true},"application/oscore":{"source":"iana"},"application/oxps":{"source":"iana","extensions":["oxps"]},"application/p21":{"source":"iana"},"application/p21+zip":{"source":"iana","compressible":false},"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","extensions":["asc"]},"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.cyn":{"source":"iana","charset":"7-BIT"},"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/sarif+json":{"source":"iana","compressible":true},"application/sarif-external-properties+json":{"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/spdx+json":{"source":"iana","compressible":true},"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/token-introspection+jwt":{"source":"iana"},"application/toml":{"compressible":true,"extensions":["toml"]},"application/trickle-ice-sdpfrag":{"source":"iana"},"application/trig":{"source":"iana","extensions":["trig"]},"application/ttml+xml":{"source":"iana","compressible":true,"extensions":["ttml"]},"application/tve-trigger":{"source":"iana"},"application/tzif":{"source":"iana"},"application/tzif-leap":{"source":"iana"},"application/ubjson":{"compressible":false,"extensions":["ubj"]},"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,"extensions":["td"]},"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.5gnas":{"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.gtpc":{"source":"iana"},"application/vnd.3gpp.interworking-data":{"source":"iana"},"application/vnd.3gpp.lpp":{"source":"iana"},"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.ngap":{"source":"iana"},"application/vnd.3gpp.pfcp":{"source":"iana"},"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.s1ap":{"source":"iana"},"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.cmoca-cmresource":{"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-cmtable":{"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.age":{"source":"iana","extensions":["age"]},"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.arrow.file":{"source":"iana"},"application/vnd.apache.arrow.stream":{"source":"iana"},"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":["key"]},"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.cryptomator.encrypted":{"source":"iana"},"application/vnd.cryptomator.vault":{"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.cyclonedx+json":{"source":"iana","compressible":true},"application/vnd.cyclonedx+xml":{"source":"iana","compressible":true},"application/vnd.d2l.coursepackage1p0+zip":{"source":"iana","compressible":false},"application/vnd.d3m-dataset":{"source":"iana"},"application/vnd.d3m-problem":{"source":"iana"},"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","extensions":["dbf"]},"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.eclipse.ditto+json":{"source":"iana","compressible":true},"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.eu.kasparian.car+json":{"source":"iana","compressible":true},"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.familysearch.gedcom+zip":{"source":"iana","compressible":false},"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.fujifilm.fb.docuworks":{"source":"iana"},"application/vnd.fujifilm.fb.docuworks.binder":{"source":"iana"},"application/vnd.fujifilm.fb.docuworks.container":{"source":"iana"},"application/vnd.fujifilm.fb.jfi+xml":{"source":"iana","compressible":true},"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.slides":{"source":"iana"},"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.hl7cda+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/vnd.hl7v2+xml":{"source":"iana","charset":"UTF-8","compressible":true},"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","extensions":["mvt"]},"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.maxar.archive.3tz+zip":{"source":"iana","compressible":false},"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.nacamar.ybrid+json":{"source":"iana","compressible":true},"application/vnd.ncd.control":{"source":"iana"},"application/vnd.ncd.reference":{"source":"iana"},"application/vnd.nearst.inv+json":{"source":"iana","compressible":true},"application/vnd.nebumind.line":{"source":"iana"},"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+cbor":{"source":"iana"},"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.opentimestamps.ots":{"source":"iana"},"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","extensions":["rar"]},"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.resilient.logic":{"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.seis+json":{"source":"iana","compressible":true},"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.sycle+xml":{"source":"iana","compressible":true},"application/vnd.syft+json":{"source":"iana","compressible":true},"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.veritone.aion+json":{"source":"iana","compressible":true},"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.dpp":{"source":"iana"},"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":{"source":"iana","compressible":true,"extensions":["wasm"]},"application/watcherinfo+xml":{"source":"iana","compressible":true,"extensions":["wif"]},"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-iwork-keynote-sffkey":{"extensions":["key"]},"application/x-iwork-numbers-sffnumbers":{"extensions":["numbers"]},"application/x-iwork-pages-sffpages":{"extensions":["pages"]},"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},"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":["xsl","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","extensions":["amr"]},"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","opus"]},"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/scip":{"source":"iana"},"audio/silk":{"source":"apache","extensions":["sil"]},"audio/smv":{"source":"iana"},"audio/smv-qcp":{"source":"iana"},"audio/smv0":{"source":"iana"},"audio/sofa":{"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/tsvcis":{"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","extensions":["avci"]},"image/avcs":{"source":"iana","extensions":["avcs"]},"image/avif":{"source":"iana","compressible":false,"extensions":["avif"]},"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/ktx2":{"source":"iana","extensions":["ktx2"]},"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","compressible":true,"extensions":["ico"]},"image/vnd.mix":{"source":"iana"},"image/vnd.mozilla.apng":{"source":"iana"},"image/vnd.ms-dds":{"compressible":true,"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.pco.b16":{"source":"iana","extensions":["b16"]},"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/e57":{"source":"iana"},"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/step":{"source":"iana"},"model/step+xml":{"source":"iana","compressible":true,"extensions":["stpx"]},"model/step+zip":{"source":"iana","compressible":false,"extensions":["stpz"]},"model/step-xml+zip":{"source":"iana","compressible":false,"extensions":["stpxz"]},"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.pytha.pyox":{"source":"iana"},"model/vnd.rosette.annotated-data-model":{"source":"iana"},"model/vnd.sap.vds":{"source":"iana","extensions":["vds"]},"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/cql":{"source":"iana"},"text/cql-expression":{"source":"iana"},"text/cql-identifier":{"source":"iana"},"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/fhirpath":{"source":"iana"},"text/flexfec":{"source":"iana"},"text/fwdred":{"source":"iana"},"text/gff3":{"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/shaclc":{"source":"iana"},"text/shex":{"source":"iana","extensions":["shex"]},"text/slim":{"extensions":["slim","slm"]},"text/spdx":{"source":"iana","extensions":["spdx"]},"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.familysearch.gedcom":{"source":"iana","extensions":["ged"]},"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.hans":{"source":"iana"},"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":{"compressible":true,"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/av1":{"source":"iana"},"video/bmpeg":{"source":"iana"},"video/bt656":{"source":"iana"},"video/celb":{"source":"iana"},"video/dv":{"source":"iana"},"video/encaprtp":{"source":"iana"},"video/ffv1":{"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","extensions":["m4s"]},"video/jpeg":{"source":"iana","extensions":["jpgv"]},"video/jpeg2000":{"source":"iana"},"video/jpm":{"source":"apache","extensions":["jpm","jpgm"]},"video/jxsv":{"source":"iana"},"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/scip":{"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/vp9":{"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}}'); diff --git a/dist/save/index.js b/dist/save/index.js index e9fa1b6..a91d65f 100644 --- a/dist/save/index.js +++ b/dist/save/index.js @@ -50646,75 +50646,3328 @@ function range(a, b, str) { /***/ 7124: /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { -const { Transform } = __nccwpck_require__(1642) +const { Transform } = __nccwpck_require__(2672) + +class Block extends Transform { + constructor (size, opts = {}) { + super(opts) + + if (typeof size === 'object') { + opts = size + size = opts.size + } + + this.size = size || 512 + + const { nopad, zeroPadding = true } = opts + + if (nopad) this._zeroPadding = false + else this._zeroPadding = !!zeroPadding + + this._buffered = [] + this._bufferedBytes = 0 + } + + _transform (buf, enc, next) { + this._bufferedBytes += buf.length + this._buffered.push(buf) + + while (this._bufferedBytes >= this.size) { + this._bufferedBytes -= this.size + + // Assemble the buffers that will compose the final block + const blockBufs = [] + let blockBufsBytes = 0 + while (blockBufsBytes < this.size) { + const b = this._buffered.shift() + + if (blockBufsBytes + b.length <= this.size) { + blockBufs.push(b) + blockBufsBytes += b.length + } else { + // If the last buffer is larger than needed for the block, just + // use the needed part + const neededSize = this.size - blockBufsBytes + blockBufs.push(b.slice(0, neededSize)) + blockBufsBytes += neededSize + this._buffered.unshift(b.slice(neededSize)) + } + } + + // Then concat just those buffers, leaving the rest untouched in _buffered + this.push(Buffer.concat(blockBufs, this.size)) + } + next() + } + + _flush () { + if (this._bufferedBytes && this._zeroPadding) { + const zeroes = Buffer.alloc(this.size - this._bufferedBytes) + this._buffered.push(zeroes) + this.push(Buffer.concat(this._buffered)) + this._buffered = null + } else if (this._bufferedBytes) { + this.push(Buffer.concat(this._buffered)) + this._buffered = null + } + this.push(null) + } +} + +module.exports = Block + + +/***/ }), + +/***/ 8891: +/***/ ((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.q = codes; + + +/***/ }), + +/***/ 1153: +/***/ ((module, __unused_webpack_exports, __nccwpck_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. + +/**/ + +var objectKeys = Object.keys || function (obj) { + var keys = []; + + for (var key in obj) { + keys.push(key); + } + + return keys; +}; +/**/ + + +module.exports = Duplex; + +var Readable = __nccwpck_require__(184); + +var Writable = __nccwpck_require__(4423); + +__nccwpck_require__(4124)(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; + } +}); + +/***/ }), + +/***/ 4896: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = __nccwpck_require__(8971); + +__nccwpck_require__(4124)(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); +}; + +/***/ }), + +/***/ 184: +/***/ ((module, __unused_webpack_exports, __nccwpck_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; +/**/ + +var Duplex; +/**/ + +Readable.ReadableState = ReadableState; +/**/ + +var EE = (__nccwpck_require__(2361).EventEmitter); + +var EElistenerCount = function EElistenerCount(emitter, type) { + return emitter.listeners(type).length; +}; +/**/ + +/**/ + + +var Stream = __nccwpck_require__(8933); +/**/ + + +var Buffer = (__nccwpck_require__(4300).Buffer); + +var OurUint8Array = global.Uint8Array || function () {}; + +function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); +} + +function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; +} +/**/ + + +var debugUtil = __nccwpck_require__(3837); + +var debug; + +if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); +} else { + debug = function debug() {}; +} +/**/ + + +var BufferList = __nccwpck_require__(6305); + +var destroyImpl = __nccwpck_require__(6138); + +var _require = __nccwpck_require__(1802), + getHighWaterMark = _require.getHighWaterMark; + +var _require$codes = (__nccwpck_require__(8891)/* .codes */ .q), + 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; + +__nccwpck_require__(4124)(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 || __nccwpck_require__(1153); + 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 = (__nccwpck_require__(4841)/* .StringDecoder */ .s); + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } +} + +function Readable(options) { + Duplex = Duplex || __nccwpck_require__(1153); + 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 = (__nccwpck_require__(4841)/* .StringDecoder */ .s); + 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 = __nccwpck_require__(3276); + } + + 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 = __nccwpck_require__(2173); + } + + 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; +} + +/***/ }), + +/***/ 8971: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = (__nccwpck_require__(8891)/* .codes */ .q), + 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 = __nccwpck_require__(1153); + +__nccwpck_require__(4124)(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); +} + +/***/ }), + +/***/ 4423: +/***/ ((module, __unused_webpack_exports, __nccwpck_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; +/* */ + +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); + }; +} +/* */ + +/**/ + + +var Duplex; +/**/ + +Writable.WritableState = WritableState; +/**/ + +var internalUtil = { + deprecate: __nccwpck_require__(7127) +}; +/**/ + +/**/ + +var Stream = __nccwpck_require__(8933); +/**/ + + +var Buffer = (__nccwpck_require__(4300).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 = __nccwpck_require__(6138); + +var _require = __nccwpck_require__(1802), + getHighWaterMark = _require.getHighWaterMark; + +var _require$codes = (__nccwpck_require__(8891)/* .codes */ .q), + 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; + +__nccwpck_require__(4124)(Writable, Stream); + +function nop() {} + +function WritableState(options, stream, isDuplex) { + Duplex = Duplex || __nccwpck_require__(1153); + 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 || __nccwpck_require__(1153); // 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); +}; + +/***/ }), + +/***/ 3276: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = __nccwpck_require__(5927); + +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; + +/***/ }), + +/***/ 6305: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = __nccwpck_require__(4300), + Buffer = _require.Buffer; + +var _require2 = __nccwpck_require__(3837), + 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; +}(); + +/***/ }), + +/***/ 6138: +/***/ ((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 +}; -class Block extends Transform { - constructor (size, opts = {}) { - super(opts) +/***/ }), - if (typeof size === 'object') { - opts = size - size = opts.size +/***/ 5927: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = (__nccwpck_require__(8891)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.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]; } - this.size = size || 512 + callback.apply(this, args); + }; +} - const { nopad, zeroPadding = true } = opts +function noop() {} - if (nopad) this._zeroPadding = false - else this._zeroPadding = !!zeroPadding +function isRequest(stream) { + return stream.setHeader && typeof stream.abort === 'function'; +} - this._buffered = [] - this._bufferedBytes = 0 +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); } - _transform (buf, enc, next) { - this._bufferedBytes += buf.length - this._buffered.push(buf) + 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); + }; +} - while (this._bufferedBytes >= this.size) { - this._bufferedBytes -= this.size +module.exports = eos; - // Assemble the buffers that will compose the final block - const blockBufs = [] - let blockBufsBytes = 0 - while (blockBufsBytes < this.size) { - const b = this._buffered.shift() +/***/ }), - if (blockBufsBytes + b.length <= this.size) { - blockBufs.push(b) - blockBufsBytes += b.length +/***/ 2173: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = (__nccwpck_require__(8891)/* .codes.ERR_INVALID_ARG_TYPE */ .q.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 { - // If the last buffer is larger than needed for the block, just - // use the needed part - const neededSize = this.size - blockBufsBytes - blockBufs.push(b.slice(0, neededSize)) - blockBufsBytes += neededSize - this._buffered.unshift(b.slice(neededSize)) + reading = false; } + } catch (err) { + readable.destroy(err); } + }); + return _next2.apply(this, arguments); + } - // Then concat just those buffers, leaving the rest untouched in _buffered - this.push(Buffer.concat(blockBufs, this.size)) - } - next() + return readable; +} + +module.exports = from; + +/***/ }), + +/***/ 2468: +/***/ ((module, __unused_webpack_exports, __nccwpck_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 = (__nccwpck_require__(8891)/* .codes */ .q), + 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 = __nccwpck_require__(5927); + 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]; } - _flush () { - if (this._bufferedBytes && this._zeroPadding) { - const zeroes = Buffer.alloc(this.size - this._bufferedBytes) - this._buffered.push(zeroes) - this.push(Buffer.concat(this._buffered)) - this._buffered = null - } else if (this._bufferedBytes) { - this.push(Buffer.concat(this._buffered)) - this._buffered = null - } - this.push(null) + 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 = Block +module.exports = pipeline; + +/***/ }), + +/***/ 1802: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(8891)/* .codes.ERR_INVALID_OPT_VALUE */ .q.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 +}; + +/***/ }), + +/***/ 8933: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +module.exports = __nccwpck_require__(2781); + + +/***/ }), + +/***/ 2672: +/***/ ((module, exports, __nccwpck_require__) => { + +var Stream = __nccwpck_require__(2781); +if (process.env.READABLE_STREAM === 'disable' && Stream) { + module.exports = Stream.Readable; + Object.assign(module.exports, Stream); + module.exports.Stream = Stream; +} else { + exports = module.exports = __nccwpck_require__(184); + exports.Stream = Stream || exports; + exports.Readable = exports; + exports.Writable = __nccwpck_require__(4423); + exports.Duplex = __nccwpck_require__(1153); + exports.Transform = __nccwpck_require__(8971); + exports.PassThrough = __nccwpck_require__(4896); + exports.finished = __nccwpck_require__(5927); + exports.pipeline = __nccwpck_require__(2468); +} /***/ }), @@ -50925,40 +54178,6 @@ function expand(str, isTop) { -/***/ }), - -/***/ 9107: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); - -var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; - -var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined"; - -var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null; - -var isWebWorker = (typeof self === "undefined" ? "undefined" : _typeof(self)) === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope"; - -/** - * @see https://github.com/jsdom/jsdom/releases/tag/12.0.0 - * @see https://github.com/jsdom/jsdom/issues/1537 - */ -var isJsDom = typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && (navigator.userAgent.includes("Node.js") || navigator.userAgent.includes("jsdom")); - -var isDeno = typeof Deno !== "undefined" && typeof Deno.version !== "undefined" && typeof Deno.version.deno !== "undefined"; - -exports.isBrowser = isBrowser; -exports.isWebWorker = isWebWorker; -exports.isNode = isNode; -exports.isJsDom = isJsDom; -exports.isDeno = isDeno; - /***/ }), /***/ 4024: @@ -52144,21 +55363,11 @@ Builder.prototype.j2x = function(jObj, level) { let attrStr = ''; let val = ''; for (let key in jObj) { - if(!Object.prototype.hasOwnProperty.call(jObj, key)) continue; if (typeof jObj[key] === 'undefined') { - // supress undefined node only if it is not an attribute - if (this.isAttribute(key)) { - val += ''; - } + // supress undefined node } else if (jObj[key] === null) { - // null attribute should be ignored by the attribute list, but should not cause the tag closing - if (this.isAttribute(key)) { - val += ''; - } else if (key[0] === '?') { - val += this.indentate(level) + '<' + key + '?' + this.tagEndChar; - } else { - val += this.indentate(level) + '<' + key + '/' + this.tagEndChar; - } + if(key[0] === "?") val += this.indentate(level) + '<' + key + '?' + this.tagEndChar; + else val += this.indentate(level) + '<' + key + '/' + this.tagEndChar; // val += this.indentate(level) + '<' + key + '/' + this.tagEndChar; } else if (jObj[key] instanceof Date) { val += this.buildTextValNode(jObj[key], key, '', level); @@ -52251,8 +55460,7 @@ Builder.prototype.buildObjectNode = function(val, key, attrStr, level) { tagEndExp = ""; } - // attrStr is an empty string in case the attribute came as undefined or null - if ((attrStr || attrStr === '') && val.indexOf('<') === -1) { + if (attrStr && val.indexOf('<') === -1) { return ( this.indentate(level) + '<' + key + attrStr + piClosingChar + '>' + val + tagEndExp ); } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) { return this.indentate(level) + `` + this.newLine; @@ -52325,7 +55533,7 @@ function indentate(level) { } function isAttribute(name /*, options*/) { - if (name.startsWith(this.options.attributeNamePrefix) && name !== this.options.textNodeName) { + if (name.startsWith(this.options.attributeNamePrefix)) { return name.substr(this.attrPrefixLen); } else { return false; @@ -52363,8 +55571,6 @@ function arrToStr(arr, options, jPath, indentation) { for (let i = 0; i < arr.length; i++) { const tagObj = arr[i]; const tagName = propName(tagObj); - if(tagName === undefined) continue; - let newJPath = ""; if (jPath.length === 0) newJPath = tagName else newJPath = `${jPath}.${tagName}`; @@ -52434,7 +55640,6 @@ function propName(obj) { const keys = Object.keys(obj); for (let i = 0; i < keys.length; i++) { const key = keys[i]; - if(!obj.hasOwnProperty(key)) continue; if (key !== ":@") return key; } } @@ -52443,7 +55648,6 @@ function attr_to_str(attrMap, options) { let attrStr = ""; if (attrMap && !options.ignoreAttributes) { for (let attr in attrMap) { - if(!attrMap.hasOwnProperty(attr)) continue; let attrVal = options.attributeValueProcessor(attr, attrMap[attr]); attrVal = replaceEntitiesValue(attrVal, options); if (attrVal === true && options.suppressBooleanAttributes) { @@ -52480,9 +55684,7 @@ module.exports = toXml; /***/ }), /***/ 6072: -/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { - -const util = __nccwpck_require__(8280); +/***/ ((module) => { //TODO: handle comments function readDocType(xmlData, i){ @@ -52505,7 +55707,7 @@ function readDocType(xmlData, i){ i += 7; [entityName, val,i] = readEntityExp(xmlData,i+1); if(val.indexOf("&") === -1) //Parameter entities are not supported - entities[ validateEntityName(entityName) ] = { + entities[ entityName ] = { regx : RegExp( `&${entityName};`,"g"), val: val }; @@ -52626,16 +55828,8 @@ function isNotation(xmlData, i){ return false } -function validateEntityName(name){ - if (util.isName(name)) - return name; - else - throw new Error(`Invalid entity name ${name}`); -} - module.exports = readDocType; - /***/ }), /***/ 2821: @@ -52704,9 +55898,9 @@ const xmlNode = __nccwpck_require__(7462); const readDocType = __nccwpck_require__(6072); const toNumber = __nccwpck_require__(4526); -// const regx = -// '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)' -// .replace(/NAME/g, util.nameRegexp); +const regx = + '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)' + .replace(/NAME/g, util.nameRegexp); //const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g"); //const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g"); @@ -52963,13 +56157,14 @@ const parseXml = function(xmlData) { textData = this.saveTextToParentTag(textData, currentNode, jPath); - let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true); - if(val == undefined) val = ""; - //cdata should be set even if it is 0 length string if(this.options.cdataPropName){ + // let val = this.parseTextData(tagExp, this.options.cdataPropName, jPath + "." + this.options.cdataPropName, true, false, true); + // if(!val) val = ""; currentNode.add(this.options.cdataPropName, [ { [this.options.textNodeName] : tagExp } ]); }else{ + let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true); + if(val == undefined) val = ""; currentNode.add(this.options.textNodeName, val); } @@ -52977,7 +56172,6 @@ const parseXml = function(xmlData) { }else {//Opening tag let result = readTagExp(xmlData,i, this.options.removeNSPrefix); let tagName= result.tagName; - const rawTagName = result.rawTagName; let tagExp = result.tagExp; let attrExpPresent = result.attrExpPresent; let closeIndex = result.closeIndex; @@ -53003,7 +56197,7 @@ const parseXml = function(xmlData) { if(tagName !== xmlObj.tagname){ jPath += jPath ? "." + tagName : tagName; } - if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) { + if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) { //TODO: namespace let tagContent = ""; //self-closing tag if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){ @@ -53016,8 +56210,8 @@ const parseXml = function(xmlData) { //normal tag else{ //read until closing tag is found - const result = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1); - if(!result) throw new Error(`Unexpected end of ${rawTagName}`); + const result = this.readStopNodeData(xmlData, tagName, closeIndex + 1); + if(!result) throw new Error(`Unexpected end of ${tagName}`); i = result.i; tagContent = result.tagContent; } @@ -53039,7 +56233,6 @@ const parseXml = function(xmlData) { if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){ if(tagName[tagName.length - 1] === "/"){ //remove trailing '/' tagName = tagName.substr(0, tagName.length - 1); - jPath = jPath.substr(0, jPath.length - 1); tagExp = tagName; }else{ tagExp = tagExp.substr(0, tagExp.length - 1); @@ -53198,11 +56391,10 @@ function readTagExp(xmlData,i, removeNSPrefix, closingChar = ">"){ let tagName = tagExp; let attrExpPresent = true; if(separatorIndex !== -1){//separate tag name and attributes expression - tagName = tagExp.substring(0, separatorIndex); - tagExp = tagExp.substring(separatorIndex + 1).trimStart(); + tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, ''); + tagExp = tagExp.substr(separatorIndex + 1); } - const rawTagName = tagName; if(removeNSPrefix){ const colonIndex = tagName.indexOf(":"); if(colonIndex !== -1){ @@ -53216,7 +56408,6 @@ function readTagExp(xmlData,i, removeNSPrefix, closingChar = ">"){ tagExp: tagExp, closeIndex: closeIndex, attrExpPresent: attrExpPresent, - rawTagName: rawTagName, } } /** @@ -75069,7 +78260,6 @@ module.exports = { stringify, stripBom } /*! * mime-db * Copyright(c) 2014 Jonathan Ong - * Copyright(c) 2015-2022 Douglas Christopher Wilson * MIT Licensed */ @@ -76435,35 +79625,230 @@ class InvalidDateError extends ExtendableError {} exports.InvalidDateError = InvalidDateError; class InvalidPrefixError extends ExtendableError {} -/** - * InvalidBucketPolicyError generated when the given bucket policy is invalid. - */ -exports.InvalidPrefixError = InvalidPrefixError; -class InvalidBucketPolicyError extends ExtendableError {} +/** + * InvalidBucketPolicyError generated when the given bucket policy is invalid. + */ +exports.InvalidPrefixError = InvalidPrefixError; +class InvalidBucketPolicyError extends ExtendableError {} + +/** + * IncorrectSizeError generated when total data read mismatches with + * the input size. + */ +exports.InvalidBucketPolicyError = InvalidBucketPolicyError; +class IncorrectSizeError extends ExtendableError {} + +/** + * InvalidXMLError generated when an unknown XML is found. + */ +exports.IncorrectSizeError = IncorrectSizeError; +class InvalidXMLError extends ExtendableError {} + +/** + * S3Error is generated for errors returned from S3 server. + * see getErrorTransformer for details + */ +exports.InvalidXMLError = InvalidXMLError; +class S3Error extends ExtendableError {} +exports.S3Error = S3Error; +class IsValidBucketNameError extends ExtendableError {} +exports.IsValidBucketNameError = IsValidBucketNameError; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ExtendableError","Error","constructor","message","opt","name","AnonymousRequestError","exports","InvalidArgumentError","InvalidPortError","InvalidEndpointError","InvalidBucketNameError","InvalidObjectNameError","AccessKeyRequiredError","SecretKeyRequiredError","ExpiresParamError","InvalidDateError","InvalidPrefixError","InvalidBucketPolicyError","IncorrectSizeError","InvalidXMLError","S3Error","IsValidBucketNameError"],"sources":["errors.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/// <reference lib=\"ES2022.Error\" />\n\nclass ExtendableError extends Error {\n  constructor(message?: string, opt?: ErrorOptions) {\n    // error Option {cause?: unknown} is a 'nice to have',\n    // don't use it internally\n    super(message, opt)\n    // set error name, otherwise it's always 'Error'\n    this.name = this.constructor.name\n  }\n}\n\n/**\n * AnonymousRequestError is generated for anonymous keys on specific\n * APIs. NOTE: PresignedURL generation always requires access keys.\n */\nexport class AnonymousRequestError extends ExtendableError {}\n\n/**\n * InvalidArgumentError is generated for all invalid arguments.\n */\nexport class InvalidArgumentError extends ExtendableError {}\n\n/**\n * InvalidPortError is generated when a non integer value is provided\n * for ports.\n */\nexport class InvalidPortError extends ExtendableError {}\n\n/**\n * InvalidEndpointError is generated when an invalid end point value is\n * provided which does not follow domain standards.\n */\nexport class InvalidEndpointError extends ExtendableError {}\n\n/**\n * InvalidBucketNameError is generated when an invalid bucket name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html\n */\nexport class InvalidBucketNameError extends ExtendableError {}\n\n/**\n * InvalidObjectNameError is generated when an invalid object name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html\n */\nexport class InvalidObjectNameError extends ExtendableError {}\n\n/**\n * AccessKeyRequiredError generated by signature methods when access\n * key is not found.\n */\nexport class AccessKeyRequiredError extends ExtendableError {}\n\n/**\n * SecretKeyRequiredError generated by signature methods when secret\n * key is not found.\n */\nexport class SecretKeyRequiredError extends ExtendableError {}\n\n/**\n * ExpiresParamError generated when expires parameter value is not\n * well within stipulated limits.\n */\nexport class ExpiresParamError extends ExtendableError {}\n\n/**\n * InvalidDateError generated when invalid date is found.\n */\nexport class InvalidDateError extends ExtendableError {}\n\n/**\n * InvalidPrefixError generated when object prefix provided is invalid\n * or does not conform to AWS S3 object key restrictions.\n */\nexport class InvalidPrefixError extends ExtendableError {}\n\n/**\n * InvalidBucketPolicyError generated when the given bucket policy is invalid.\n */\nexport class InvalidBucketPolicyError extends ExtendableError {}\n\n/**\n * IncorrectSizeError generated when total data read mismatches with\n * the input size.\n */\nexport class IncorrectSizeError extends ExtendableError {}\n\n/**\n * InvalidXMLError generated when an unknown XML is found.\n */\nexport class InvalidXMLError extends ExtendableError {}\n\n/**\n * S3Error is generated for errors returned from S3 server.\n * see getErrorTransformer for details\n */\nexport class S3Error extends ExtendableError {}\n\nexport class IsValidBucketNameError extends ExtendableError {}\n"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,MAAMA,eAAe,SAASC,KAAK,CAAC;EAClCC,WAAWA,CAACC,OAAgB,EAAEC,GAAkB,EAAE;IAChD;IACA;IACA,KAAK,CAACD,OAAO,EAAEC,GAAG,CAAC;IACnB;IACA,IAAI,CAACC,IAAI,GAAG,IAAI,CAACH,WAAW,CAACG,IAAI;EACnC;AACF;;AAEA;AACA;AACA;AACA;AACO,MAAMC,qBAAqB,SAASN,eAAe,CAAC;;AAE3D;AACA;AACA;AAFAO,OAAA,CAAAD,qBAAA,GAAAA,qBAAA;AAGO,MAAME,oBAAoB,SAASR,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AAHAO,OAAA,CAAAC,oBAAA,GAAAA,oBAAA;AAIO,MAAMC,gBAAgB,SAAST,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAE,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,oBAAoB,SAASV,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAG,oBAAA,GAAAA,oBAAA;AAKO,MAAMC,sBAAsB,SAASX,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAI,sBAAA,GAAAA,sBAAA;AAKO,MAAMC,sBAAsB,SAASZ,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAK,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASb,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAM,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASd,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAO,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,iBAAiB,SAASf,eAAe,CAAC;;AAEvD;AACA;AACA;AAFAO,OAAA,CAAAQ,iBAAA,GAAAA,iBAAA;AAGO,MAAMC,gBAAgB,SAAShB,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAS,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,kBAAkB,SAASjB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAU,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,wBAAwB,SAASlB,eAAe,CAAC;;AAE9D;AACA;AACA;AACA;AAHAO,OAAA,CAAAW,wBAAA,GAAAA,wBAAA;AAIO,MAAMC,kBAAkB,SAASnB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAY,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,eAAe,SAASpB,eAAe,CAAC;;AAErD;AACA;AACA;AACA;AAHAO,OAAA,CAAAa,eAAA,GAAAA,eAAA;AAIO,MAAMC,OAAO,SAASrB,eAAe,CAAC;AAAEO,OAAA,CAAAc,OAAA,GAAAA,OAAA;AAExC,MAAMC,sBAAsB,SAAStB,eAAe,CAAC;AAAEO,OAAA,CAAAe,sBAAA,GAAAA,sBAAA"} + +/***/ }), + +/***/ 2895: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +var Stream = _interopRequireWildcard(__nccwpck_require__(2781), true); +var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); +var _helper = __nccwpck_require__(9921); +var transformers = _interopRequireWildcard(__nccwpck_require__(9237), true); +function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } +function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } +/* + * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +class extensions { + constructor(client) { + this.client = client; + } + + // List the objects in the bucket using S3 ListObjects V2 With Metadata + // + // __Arguments__ + // * `bucketName` _string_: name of the bucket + // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`) + // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`) + // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`) + // + // __Return Value__ + // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format: + // * `obj.name` _string_: name of the object + // * `obj.prefix` _string_: name of the object prefix + // * `obj.size` _number_: size of the object + // * `obj.etag` _string_: etag of the object + // * `obj.lastModified` _Date_: modified time stamp + // * `obj.metadata` _object_: metadata of the object + + listObjectsV2WithMetadata(bucketName, prefix, recursive, startAfter) { + if (prefix === undefined) { + prefix = ''; + } + if (recursive === undefined) { + recursive = false; + } + if (startAfter === undefined) { + startAfter = ''; + } + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidPrefix)(prefix)) { + throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`); + } + if (!(0, _helper.isString)(prefix)) { + throw new TypeError('prefix should be of type "string"'); + } + if (!(0, _helper.isBoolean)(recursive)) { + throw new TypeError('recursive should be of type "boolean"'); + } + if (!(0, _helper.isString)(startAfter)) { + throw new TypeError('startAfter should be of type "string"'); + } + // if recursive is false set delimiter to '/' + var delimiter = recursive ? '' : '/'; + var continuationToken = ''; + var objects = []; + var ended = false; + var readStream = Stream.Readable({ + objectMode: true + }); + readStream._read = () => { + // push one object per _read() + if (objects.length) { + readStream.push(objects.shift()); + return; + } + if (ended) { + return readStream.push(null); + } + // if there are no objects to push do query for the next batch of objects + this.listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, 1000, startAfter).on('error', e => readStream.emit('error', e)).on('data', result => { + if (result.isTruncated) { + continuationToken = result.nextContinuationToken; + } else { + ended = true; + } + objects = result.objects; + readStream._read(); + }); + }; + return readStream; + } + + // listObjectsV2WithMetadataQuery - (List Objects V2 with metadata) - List some or all (up to 1000) of the objects in a bucket. + // + // You can use the request parameters as selection criteria to return a subset of the objects in a bucket. + // request parameters :- + // * `bucketName` _string_: name of the bucket + // * `prefix` _string_: Limits the response to keys that begin with the specified prefix. + // * `continuation-token` _string_: Used to continue iterating over a set of objects. + // * `delimiter` _string_: A delimiter is a character you use to group keys. + // * `max-keys` _number_: Sets the maximum number of keys returned in the response body. + // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket. -/** - * IncorrectSizeError generated when total data read mismatches with - * the input size. - */ -exports.InvalidBucketPolicyError = InvalidBucketPolicyError; -class IncorrectSizeError extends ExtendableError {} + listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isString)(prefix)) { + throw new TypeError('prefix should be of type "string"'); + } + if (!(0, _helper.isString)(continuationToken)) { + throw new TypeError('continuationToken should be of type "string"'); + } + if (!(0, _helper.isString)(delimiter)) { + throw new TypeError('delimiter should be of type "string"'); + } + if (!(0, _helper.isNumber)(maxKeys)) { + throw new TypeError('maxKeys should be of type "number"'); + } + if (!(0, _helper.isString)(startAfter)) { + throw new TypeError('startAfter should be of type "string"'); + } + var queries = []; -/** - * InvalidXMLError generated when an unknown XML is found. - */ -exports.IncorrectSizeError = IncorrectSizeError; -class InvalidXMLError extends ExtendableError {} + // Call for listing objects v2 API + queries.push(`list-type=2`); + queries.push(`encoding-type=url`); + // escape every value in query string, except maxKeys + queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`); + queries.push(`delimiter=${(0, _helper.uriEscape)(delimiter)}`); + queries.push(`metadata=true`); + if (continuationToken) { + continuationToken = (0, _helper.uriEscape)(continuationToken); + queries.push(`continuation-token=${continuationToken}`); + } + // Set start-after + if (startAfter) { + startAfter = (0, _helper.uriEscape)(startAfter); + queries.push(`start-after=${startAfter}`); + } + // no need to escape maxKeys + if (maxKeys) { + if (maxKeys >= 1000) { + maxKeys = 1000; + } + queries.push(`max-keys=${maxKeys}`); + } + queries.sort(); + var query = ''; + if (queries.length > 0) { + query = `${queries.join('&')}`; + } + var method = 'GET'; + var transformer = transformers.getListObjectsV2WithMetadataTransformer(); + this.client.makeRequest({ + method, + bucketName, + query + }, '', [200], '', true, (e, response) => { + if (e) { + return transformer.emit('error', e); + } + (0, _helper.pipesetup)(response, transformer); + }); + return transformer; + } +} -/** - * S3Error is generated for errors returned from S3 server. - * see getErrorTransformer for details - */ -exports.InvalidXMLError = InvalidXMLError; -class S3Error extends ExtendableError {} -exports.S3Error = S3Error; -class IsValidBucketNameError extends ExtendableError {} -exports.IsValidBucketNameError = IsValidBucketNameError; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ExtendableError","Error","constructor","message","opt","name","AnonymousRequestError","exports","InvalidArgumentError","InvalidPortError","InvalidEndpointError","InvalidBucketNameError","InvalidObjectNameError","AccessKeyRequiredError","SecretKeyRequiredError","ExpiresParamError","InvalidDateError","InvalidPrefixError","InvalidBucketPolicyError","IncorrectSizeError","InvalidXMLError","S3Error","IsValidBucketNameError"],"sources":["errors.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/// <reference lib=\"ES2022.Error\" />\n\nclass ExtendableError extends Error {\n  constructor(message?: string, opt?: ErrorOptions) {\n    // error Option {cause?: unknown} is a 'nice to have',\n    // don't use it internally\n    super(message, opt)\n    // set error name, otherwise it's always 'Error'\n    this.name = this.constructor.name\n  }\n}\n\n/**\n * AnonymousRequestError is generated for anonymous keys on specific\n * APIs. NOTE: PresignedURL generation always requires access keys.\n */\nexport class AnonymousRequestError extends ExtendableError {}\n\n/**\n * InvalidArgumentError is generated for all invalid arguments.\n */\nexport class InvalidArgumentError extends ExtendableError {}\n\n/**\n * InvalidPortError is generated when a non integer value is provided\n * for ports.\n */\nexport class InvalidPortError extends ExtendableError {}\n\n/**\n * InvalidEndpointError is generated when an invalid end point value is\n * provided which does not follow domain standards.\n */\nexport class InvalidEndpointError extends ExtendableError {}\n\n/**\n * InvalidBucketNameError is generated when an invalid bucket name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html\n */\nexport class InvalidBucketNameError extends ExtendableError {}\n\n/**\n * InvalidObjectNameError is generated when an invalid object name is\n * provided which does not follow AWS S3 specifications.\n * http://docs.aws.amazon.com/AmazonS3/latest/dev/UsingMetadata.html\n */\nexport class InvalidObjectNameError extends ExtendableError {}\n\n/**\n * AccessKeyRequiredError generated by signature methods when access\n * key is not found.\n */\nexport class AccessKeyRequiredError extends ExtendableError {}\n\n/**\n * SecretKeyRequiredError generated by signature methods when secret\n * key is not found.\n */\nexport class SecretKeyRequiredError extends ExtendableError {}\n\n/**\n * ExpiresParamError generated when expires parameter value is not\n * well within stipulated limits.\n */\nexport class ExpiresParamError extends ExtendableError {}\n\n/**\n * InvalidDateError generated when invalid date is found.\n */\nexport class InvalidDateError extends ExtendableError {}\n\n/**\n * InvalidPrefixError generated when object prefix provided is invalid\n * or does not conform to AWS S3 object key restrictions.\n */\nexport class InvalidPrefixError extends ExtendableError {}\n\n/**\n * InvalidBucketPolicyError generated when the given bucket policy is invalid.\n */\nexport class InvalidBucketPolicyError extends ExtendableError {}\n\n/**\n * IncorrectSizeError generated when total data read mismatches with\n * the input size.\n */\nexport class IncorrectSizeError extends ExtendableError {}\n\n/**\n * InvalidXMLError generated when an unknown XML is found.\n */\nexport class InvalidXMLError extends ExtendableError {}\n\n/**\n * S3Error is generated for errors returned from S3 server.\n * see getErrorTransformer for details\n */\nexport class S3Error extends ExtendableError {\n  code?: string\n}\n\nexport class IsValidBucketNameError extends ExtendableError {}\n"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,MAAMA,eAAe,SAASC,KAAK,CAAC;EAClCC,WAAWA,CAACC,OAAgB,EAAEC,GAAkB,EAAE;IAChD;IACA;IACA,KAAK,CAACD,OAAO,EAAEC,GAAG,CAAC;IACnB;IACA,IAAI,CAACC,IAAI,GAAG,IAAI,CAACH,WAAW,CAACG,IAAI;EACnC;AACF;;AAEA;AACA;AACA;AACA;AACO,MAAMC,qBAAqB,SAASN,eAAe,CAAC;;AAE3D;AACA;AACA;AAFAO,OAAA,CAAAD,qBAAA,GAAAA,qBAAA;AAGO,MAAME,oBAAoB,SAASR,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AAHAO,OAAA,CAAAC,oBAAA,GAAAA,oBAAA;AAIO,MAAMC,gBAAgB,SAAST,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAE,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,oBAAoB,SAASV,eAAe,CAAC;;AAE1D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAG,oBAAA,GAAAA,oBAAA;AAKO,MAAMC,sBAAsB,SAASX,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AACA;AAJAO,OAAA,CAAAI,sBAAA,GAAAA,sBAAA;AAKO,MAAMC,sBAAsB,SAASZ,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAK,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASb,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAM,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,sBAAsB,SAASd,eAAe,CAAC;;AAE5D;AACA;AACA;AACA;AAHAO,OAAA,CAAAO,sBAAA,GAAAA,sBAAA;AAIO,MAAMC,iBAAiB,SAASf,eAAe,CAAC;;AAEvD;AACA;AACA;AAFAO,OAAA,CAAAQ,iBAAA,GAAAA,iBAAA;AAGO,MAAMC,gBAAgB,SAAShB,eAAe,CAAC;;AAEtD;AACA;AACA;AACA;AAHAO,OAAA,CAAAS,gBAAA,GAAAA,gBAAA;AAIO,MAAMC,kBAAkB,SAASjB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAU,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,wBAAwB,SAASlB,eAAe,CAAC;;AAE9D;AACA;AACA;AACA;AAHAO,OAAA,CAAAW,wBAAA,GAAAA,wBAAA;AAIO,MAAMC,kBAAkB,SAASnB,eAAe,CAAC;;AAExD;AACA;AACA;AAFAO,OAAA,CAAAY,kBAAA,GAAAA,kBAAA;AAGO,MAAMC,eAAe,SAASpB,eAAe,CAAC;;AAErD;AACA;AACA;AACA;AAHAO,OAAA,CAAAa,eAAA,GAAAA,eAAA;AAIO,MAAMC,OAAO,SAASrB,eAAe,CAAC;AAE5CO,OAAA,CAAAc,OAAA,GAAAA,OAAA;AAEM,MAAMC,sBAAsB,SAAStB,eAAe,CAAC;AAAEO,OAAA,CAAAe,sBAAA,GAAAA,sBAAA"} +// deprecated default export, please use named exports. +// keep for backward compatibility. +// eslint-disable-next-line import/no-default-export +exports.extensions = extensions; +var _default = extensions; +exports["default"] = _default; +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Stream","_interopRequireWildcard","require","errors","_helper","transformers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","extensions","constructor","client","listObjectsV2WithMetadata","bucketName","prefix","recursive","startAfter","undefined","isValidBucketName","InvalidBucketNameError","isValidPrefix","InvalidPrefixError","isString","TypeError","isBoolean","delimiter","continuationToken","objects","ended","readStream","Readable","objectMode","_read","length","push","shift","listObjectsV2WithMetadataQuery","on","e","emit","result","isTruncated","nextContinuationToken","maxKeys","isNumber","queries","uriEscape","sort","query","join","method","transformer","getListObjectsV2WithMetadataTransformer","makeRequest","response","pipesetup","exports","_default"],"sources":["extensions.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Stream from 'node:stream'\n\nimport * as errors from './errors.ts'\nimport {\n  isBoolean,\n  isNumber,\n  isString,\n  isValidBucketName,\n  isValidPrefix,\n  pipesetup,\n  uriEscape,\n} from './internal/helper.ts'\nimport * as transformers from './transformers.js'\n\nexport class extensions {\n  constructor(client) {\n    this.client = client\n  }\n\n  // List the objects in the bucket using S3 ListObjects V2 With Metadata\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  //   * `obj.name` _string_: name of the object\n  //   * `obj.prefix` _string_: name of the object prefix\n  //   * `obj.size` _number_: size of the object\n  //   * `obj.etag` _string_: etag of the object\n  //   * `obj.lastModified` _Date_: modified time stamp\n  //   * `obj.metadata` _object_: metadata of the object\n\n  listObjectsV2WithMetadata(bucketName, prefix, recursive, startAfter) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    // if recursive is false set delimiter to '/'\n    var delimiter = recursive ? '' : '/'\n    var continuationToken = ''\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, 1000, startAfter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            continuationToken = result.nextContinuationToken\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // listObjectsV2WithMetadataQuery - (List Objects V2 with metadata) - List some or all (up to 1000) of the objects in a bucket.\n  //\n  // You can use the request parameters as selection criteria to return a subset of the objects in a bucket.\n  // request parameters :-\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: Limits the response to keys that begin with the specified prefix.\n  // * `continuation-token` _string_: Used to continue iterating over a set of objects.\n  // * `delimiter` _string_: A delimiter is a character you use to group keys.\n  // * `max-keys` _number_: Sets the maximum number of keys returned in the response body.\n  // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket.\n\n  listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(continuationToken)) {\n      throw new TypeError('continuationToken should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    if (!isNumber(maxKeys)) {\n      throw new TypeError('maxKeys should be of type \"number\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    var queries = []\n\n    // Call for listing objects v2 API\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n    queries.push(`metadata=true`)\n\n    if (continuationToken) {\n      continuationToken = uriEscape(continuationToken)\n      queries.push(`continuation-token=${continuationToken}`)\n    }\n    // Set start-after\n    if (startAfter) {\n      startAfter = uriEscape(startAfter)\n      queries.push(`start-after=${startAfter}`)\n    }\n    // no need to escape maxKeys\n    if (maxKeys) {\n      if (maxKeys >= 1000) {\n        maxKeys = 1000\n      }\n      queries.push(`max-keys=${maxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListObjectsV2WithMetadataTransformer()\n    this.client.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default extensions\n"],"mappings":"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"} /***/ }), @@ -76698,34 +80083,6 @@ exports.SelectResults = SelectResults; /***/ }), -/***/ 3826: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.callbackify = callbackify; -// wrapper an async function that support callback style API. -// It will preserve 'this'. -function callbackify(fn) { - return function () { - const args = [...arguments]; - const callback = args.pop(); - - // If the last argument is a function, assume it's the callback. - if (typeof callback === 'function') { - return fn.apply(this, args).then(result => callback(null, result), err => callback(err)); - } - return fn.apply(this, arguments); - }; -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJjYWxsYmFja2lmeSIsImZuIiwiYXJncyIsImFyZ3VtZW50cyIsImNhbGxiYWNrIiwicG9wIiwiYXBwbHkiLCJ0aGVuIiwicmVzdWx0IiwiZXJyIl0sInNvdXJjZXMiOlsiY2FsbGJhY2tpZnkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiLy8gd3JhcHBlciBhbiBhc3luYyBmdW5jdGlvbiB0aGF0IHN1cHBvcnQgY2FsbGJhY2sgc3R5bGUgQVBJLlxuLy8gSXQgd2lsbCBwcmVzZXJ2ZSAndGhpcycuXG5leHBvcnQgZnVuY3Rpb24gY2FsbGJhY2tpZnkoZm4pIHtcbiAgcmV0dXJuIGZ1bmN0aW9uICgpIHtcbiAgICBjb25zdCBhcmdzID0gWy4uLmFyZ3VtZW50c11cbiAgICBjb25zdCBjYWxsYmFjayA9IGFyZ3MucG9wKClcblxuICAgIC8vIElmIHRoZSBsYXN0IGFyZ3VtZW50IGlzIGEgZnVuY3Rpb24sIGFzc3VtZSBpdCdzIHRoZSBjYWxsYmFjay5cbiAgICBpZiAodHlwZW9mIGNhbGxiYWNrID09PSAnZnVuY3Rpb24nKSB7XG4gICAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJncykudGhlbihcbiAgICAgICAgKHJlc3VsdCkgPT4gY2FsbGJhY2sobnVsbCwgcmVzdWx0KSxcbiAgICAgICAgKGVycikgPT4gY2FsbGJhY2soZXJyKSxcbiAgICAgIClcbiAgICB9XG5cbiAgICByZXR1cm4gZm4uYXBwbHkodGhpcywgYXJndW1lbnRzKVxuICB9XG59XG4iXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBO0FBQ0E7QUFDTyxTQUFTQSxXQUFXQSxDQUFDQyxFQUFFLEVBQUU7RUFDOUIsT0FBTyxZQUFZO0lBQ2pCLE1BQU1DLElBQUksR0FBRyxDQUFDLEdBQUdDLFNBQVMsQ0FBQztJQUMzQixNQUFNQyxRQUFRLEdBQUdGLElBQUksQ0FBQ0csR0FBRyxDQUFDLENBQUM7O0lBRTNCO0lBQ0EsSUFBSSxPQUFPRCxRQUFRLEtBQUssVUFBVSxFQUFFO01BQ2xDLE9BQU9ILEVBQUUsQ0FBQ0ssS0FBSyxDQUFDLElBQUksRUFBRUosSUFBSSxDQUFDLENBQUNLLElBQUksQ0FDN0JDLE1BQU0sSUFBS0osUUFBUSxDQUFDLElBQUksRUFBRUksTUFBTSxDQUFDLEVBQ2pDQyxHQUFHLElBQUtMLFFBQVEsQ0FBQ0ssR0FBRyxDQUN2QixDQUFDO0lBQ0g7SUFFQSxPQUFPUixFQUFFLENBQUNLLEtBQUssQ0FBQyxJQUFJLEVBQUVILFNBQVMsQ0FBQztFQUNsQyxDQUFDO0FBQ0gifQ== - -/***/ }), - /***/ 5586: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { @@ -76737,25 +80094,16 @@ Object.defineProperty(exports, "__esModule", ({ })); var http = _interopRequireWildcard(__nccwpck_require__(3685), true); var https = _interopRequireWildcard(__nccwpck_require__(5687), true); -var _browserOrNode = __nccwpck_require__(9107); var _lodash = __nccwpck_require__(250); -var qs = _interopRequireWildcard(__nccwpck_require__(293), true); -var _xml2js = __nccwpck_require__(4659); var _CredentialProvider = __nccwpck_require__(6570); var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); -var _helpers = __nccwpck_require__(9455); -var _signing = __nccwpck_require__(2029); -var _extensions = __nccwpck_require__(1159); var _helper = __nccwpck_require__(9921); -var _request = __nccwpck_require__(9093); -var _response = __nccwpck_require__(2644); var _s3Endpoints = __nccwpck_require__(6314); -var xmlParsers = _interopRequireWildcard(__nccwpck_require__(4040), true); function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } // will be replaced by bundler. const Package = { - version: "7.1.3" || 0 + version: "7.1.1" || 0 }; const requestOptionProperties = ['agent', 'ca', 'cert', 'ciphers', 'clientCertEngine', 'crl', 'dhparam', 'ecdhCurve', 'family', 'honorCipherOrder', 'key', 'passphrase', 'pfx', 'rejectUnauthorized', 'secureOptions', 'secureProtocol', 'servername', 'sessionIdContext']; class TypedClient { @@ -76877,14 +80225,6 @@ class TypedClient { this.enableSHA256 = !this.anonymous && !params.useSSL; this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined; this.reqOptions = {}; - this.clientExtensions = new _extensions.Extensions(this); - } - - /** - * Minio extensions that aren't necessary present for Amazon S3 compatible storage servers - */ - get extensions() { - return this.clientExtensions; } /** @@ -77034,581 +80374,9 @@ class TypedClient { } } } - /** - * log the request, response, error - */ - logHTTP(reqOptions, response, err) { - // if no logStream available return. - if (!this.logStream) { - return; - } - if (!(0, _helper.isObject)(reqOptions)) { - throw new TypeError('reqOptions should be of type "object"'); - } - if (response && !(0, _helper.isReadableStream)(response)) { - throw new TypeError('response should be of type "Stream"'); - } - if (err && !(err instanceof Error)) { - throw new TypeError('err should be of type "Error"'); - } - const logStream = this.logStream; - const logHeaders = headers => { - Object.entries(headers).forEach(([k, v]) => { - if (k == 'authorization') { - if ((0, _helper.isString)(v)) { - const redactor = new RegExp('Signature=([0-9a-f]+)'); - v = v.replace(redactor, 'Signature=**REDACTED**'); - } - } - logStream.write(`${k}: ${v}\n`); - }); - logStream.write('\n'); - }; - logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\n`); - logHeaders(reqOptions.headers); - if (response) { - this.logStream.write(`RESPONSE: ${response.statusCode}\n`); - logHeaders(response.headers); - } - if (err) { - logStream.write('ERROR BODY:\n'); - const errJSON = JSON.stringify(err, null, '\t'); - logStream.write(`${errJSON}\n`); - } - } - - /** - * Enable tracing - */ - traceOn(stream) { - if (!stream) { - stream = process.stdout; - } - this.logStream = stream; - } - - /** - * Disable tracing - */ - traceOff() { - this.logStream = undefined; - } - - /** - * makeRequest is the primitive used by the apis for making S3 requests. - * payload can be empty string in case of no payload. - * statusCode is the expected statusCode. If response.statusCode does not match - * we parse the XML error and call the callback with the error message. - * - * A valid region is passed by the calls - listBuckets, makeBucket and getBucketRegion. - * - * @internal - */ - async makeRequestAsync(options, payload = '', expectedCodes = [200], region = '') { - if (!(0, _helper.isObject)(options)) { - throw new TypeError('options should be of type "object"'); - } - if (!(0, _helper.isString)(payload) && !(0, _helper.isObject)(payload)) { - // Buffer is of type 'object' - throw new TypeError('payload should be of type "string" or "Buffer"'); - } - expectedCodes.forEach(statusCode => { - if (!(0, _helper.isNumber)(statusCode)) { - throw new TypeError('statusCode should be of type "number"'); - } - }); - if (!(0, _helper.isString)(region)) { - throw new TypeError('region should be of type "string"'); - } - if (!options.headers) { - options.headers = {}; - } - if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') { - options.headers['content-length'] = payload.length.toString(); - } - const sha256sum = this.enableSHA256 ? (0, _helper.toSha256)(payload) : ''; - return this.makeRequestStreamAsync(options, payload, sha256sum, expectedCodes, region); - } - - /** - * new request with promise - * - * No need to drain response, response body is not valid - */ - async makeRequestAsyncOmit(options, payload = '', statusCodes = [200], region = '') { - const res = await this.makeRequestAsync(options, payload, statusCodes, region); - await (0, _response.drainResponse)(res); - return res; - } - - /** - * makeRequestStream will be used directly instead of makeRequest in case the payload - * is available as a stream. for ex. putObject - * - * @internal - */ - async makeRequestStreamAsync(options, body, sha256sum, statusCodes, region) { - if (!(0, _helper.isObject)(options)) { - throw new TypeError('options should be of type "object"'); - } - if (!(Buffer.isBuffer(body) || typeof body === 'string' || (0, _helper.isReadableStream)(body))) { - throw new errors.InvalidArgumentError(`stream should be a Buffer, string or readable Stream, got ${typeof body} instead`); - } - if (!(0, _helper.isString)(sha256sum)) { - throw new TypeError('sha256sum should be of type "string"'); - } - statusCodes.forEach(statusCode => { - if (!(0, _helper.isNumber)(statusCode)) { - throw new TypeError('statusCode should be of type "number"'); - } - }); - if (!(0, _helper.isString)(region)) { - throw new TypeError('region should be of type "string"'); - } - // sha256sum will be empty for anonymous or https requests - if (!this.enableSHA256 && sha256sum.length !== 0) { - throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`); - } - // sha256sum should be valid for non-anonymous http requests. - if (this.enableSHA256 && sha256sum.length !== 64) { - throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`); - } - await this.checkAndRefreshCreds(); - - // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - region = region || (await this.getBucketRegionAsync(options.bucketName)); - const reqOptions = this.getRequestOptions({ - ...options, - region - }); - if (!this.anonymous) { - // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation. - if (!this.enableSHA256) { - sha256sum = 'UNSIGNED-PAYLOAD'; - } - const date = new Date(); - reqOptions.headers['x-amz-date'] = (0, _helper.makeDateLong)(date); - reqOptions.headers['x-amz-content-sha256'] = sha256sum; - if (this.sessionToken) { - reqOptions.headers['x-amz-security-token'] = this.sessionToken; - } - reqOptions.headers.authorization = (0, _signing.signV4)(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum); - } - const response = await (0, _request.request)(this.transport, reqOptions, body); - if (!response.statusCode) { - throw new Error("BUG: response doesn't have a statusCode"); - } - if (!statusCodes.includes(response.statusCode)) { - // For an incorrect region, S3 server always sends back 400. - // But we will do cache invalidation for all errors so that, - // in future, if AWS S3 decides to send a different status code or - // XML error code we will still work fine. - // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - delete this.regionMap[options.bucketName]; - const err = await xmlParsers.parseResponseError(response); - this.logHTTP(reqOptions, response, err); - throw err; - } - this.logHTTP(reqOptions, response); - return response; - } - - /** - * gets the region of the bucket - * - * @param bucketName - * - * @internal - */ - async getBucketRegionAsync(bucketName) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`); - } - - // Region is set with constructor, return the region right here. - if (this.region) { - return this.region; - } - const cached = this.regionMap[bucketName]; - if (cached) { - return cached; - } - const extractRegionAsync = async response => { - const body = await (0, _response.readAsString)(response); - const region = xmlParsers.parseBucketRegion(body) || _helpers.DEFAULT_REGION; - this.regionMap[bucketName] = region; - return region; - }; - const method = 'GET'; - const query = 'location'; - // `getBucketLocation` behaves differently in following ways for - // different environments. - // - // - For nodejs env we default to path style requests. - // - For browser env path style requests on buckets yields CORS - // error. To circumvent this problem we make a virtual host - // style request signed with 'us-east-1'. This request fails - // with an error 'AuthorizationHeaderMalformed', additionally - // the error XML also provides Region of the bucket. To validate - // this region is proper we retry the same request with the newly - // obtained region. - const pathStyle = this.pathStyle && !_browserOrNode.isBrowser; - let region; - try { - const res = await this.makeRequestAsync({ - method, - bucketName, - query, - pathStyle - }, '', [200], _helpers.DEFAULT_REGION); - return extractRegionAsync(res); - } catch (e) { - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - if (!(e.name === 'AuthorizationHeaderMalformed')) { - throw e; - } - // @ts-expect-error we set extra properties on error object - region = e.Region; - if (!region) { - throw e; - } - } - const res = await this.makeRequestAsync({ - method, - bucketName, - query, - pathStyle - }, '', [200], region); - return await extractRegionAsync(res); - } - - /** - * makeRequest is the primitive used by the apis for making S3 requests. - * payload can be empty string in case of no payload. - * statusCode is the expected statusCode. If response.statusCode does not match - * we parse the XML error and call the callback with the error message. - * A valid region is passed by the calls - listBuckets, makeBucket and - * getBucketRegion. - * - * @deprecated use `makeRequestAsync` instead - */ - makeRequest(options, payload = '', expectedCodes = [200], region = '', returnResponse, cb) { - let prom; - if (returnResponse) { - prom = this.makeRequestAsync(options, payload, expectedCodes, region); - } else { - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-expect-error compatible for old behaviour - prom = this.makeRequestAsyncOmit(options, payload, expectedCodes, region); - } - prom.then(result => cb(null, result), err => { - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - cb(err); - }); - } - - /** - * makeRequestStream will be used directly instead of makeRequest in case the payload - * is available as a stream. for ex. putObject - * - * @deprecated use `makeRequestStreamAsync` instead - */ - makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb) { - const executor = async () => { - const res = await this.makeRequestStreamAsync(options, stream, sha256sum, statusCodes, region); - if (!returnResponse) { - await (0, _response.drainResponse)(res); - } - return res; - }; - executor().then(result => cb(null, result), - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - err => cb(err)); - } - - /** - * @deprecated use `getBucketRegionAsync` instead - */ - getBucketRegion(bucketName, cb) { - return this.getBucketRegionAsync(bucketName).then(result => cb(null, result), - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-ignore - err => cb(err)); - } - - /** - * @deprecated use promise style API - */ - - async removeBucket(bucketName) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - const method = 'DELETE'; - await this.makeRequestAsyncOmit({ - method, - bucketName - }, '', [204]); - delete this.regionMap[bucketName]; - } - - /** - * Stat information of the object. - */ - async statObject(bucketName, objectName, statOpts = {}) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isObject)(statOpts)) { - throw new errors.InvalidArgumentError('statOpts should be of type "object"'); - } - const query = qs.stringify(statOpts); - const method = 'HEAD'; - const res = await this.makeRequestAsyncOmit({ - method, - bucketName, - objectName, - query - }); - return { - size: parseInt(res.headers['content-length']), - metaData: (0, _helper.extractMetadata)(res.headers), - lastModified: new Date(res.headers['last-modified']), - versionId: (0, _helper.getVersionId)(res.headers), - etag: (0, _helper.sanitizeETag)(res.headers.etag) - }; - } - - /** - * Remove the specified object. - * @deprecated use new promise style API - */ - - /** - * @deprecated use new promise style API - */ // @ts-ignore - async removeObject(bucketName, objectName, removeOpts = {}) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isObject)(removeOpts)) { - throw new errors.InvalidArgumentError('removeOpts should be of type "object"'); - } - const method = 'DELETE'; - const headers = {}; - if (removeOpts.governanceBypass) { - headers['X-Amz-Bypass-Governance-Retention'] = true; - } - if (removeOpts.forceDelete) { - headers['x-minio-force-delete'] = true; - } - const queryParams = {}; - if (removeOpts.versionId) { - queryParams.versionId = `${removeOpts.versionId}`; - } - const query = qs.stringify(queryParams); - await this.makeRequestAsyncOmit({ - method, - bucketName, - objectName, - headers, - query - }, '', [200, 204]); - } - - // Calls implemented below are related to multipart. - - /** - * Initiate a new multipart upload. - * @internal - */ - async initiateNewMultipartUpload(bucketName, objectName, headers) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isObject)(headers)) { - throw new errors.InvalidObjectNameError('contentType should be of type "object"'); - } - const method = 'POST'; - const query = 'uploads'; - const res = await this.makeRequestAsync({ - method, - bucketName, - objectName, - query, - headers - }); - const body = await (0, _response.readAsBuffer)(res); - return (0, xmlParsers.parseInitiateMultipart)(body.toString()); - } - - /** - * Internal Method to abort a multipart upload request in case of any errors. - * - * @param bucketName - Bucket Name - * @param objectName - Object Name - * @param uploadId - id of a multipart upload to cancel during compose object sequence. - */ - async abortMultipartUpload(bucketName, objectName, uploadId) { - const method = 'DELETE'; - const query = `uploadId=${uploadId}`; - const requestOptions = { - method, - bucketName, - objectName: objectName, - query - }; - await this.makeRequestAsyncOmit(requestOptions, '', [204]); - } - - /** - * Get part-info of all parts of an incomplete upload specified by uploadId. - */ - async listParts(bucketName, objectName, uploadId) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isString)(uploadId)) { - throw new TypeError('uploadId should be of type "string"'); - } - if (!uploadId) { - throw new errors.InvalidArgumentError('uploadId cannot be empty'); - } - const parts = []; - let marker = 0; - let result; - do { - result = await this.listPartsQuery(bucketName, objectName, uploadId, marker); - marker = result.marker; - parts.push(...result.parts); - } while (result.isTruncated); - return parts; - } - - /** - * Called by listParts to fetch a batch of part-info - */ - async listPartsQuery(bucketName, objectName, uploadId, marker) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidObjectName)(objectName)) { - throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); - } - if (!(0, _helper.isString)(uploadId)) { - throw new TypeError('uploadId should be of type "string"'); - } - if (!(0, _helper.isNumber)(marker)) { - throw new TypeError('marker should be of type "number"'); - } - if (!uploadId) { - throw new errors.InvalidArgumentError('uploadId cannot be empty'); - } - let query = `uploadId=${(0, _helper.uriEscape)(uploadId)}`; - if (marker) { - query += `&part-number-marker=${marker}`; - } - const method = 'GET'; - const res = await this.makeRequestAsync({ - method, - bucketName, - objectName, - query - }); - return xmlParsers.parseListParts(await (0, _response.readAsString)(res)); - } - async listBuckets() { - const method = 'GET'; - const httpRes = await this.makeRequestAsync({ - method - }, '', [200], _helpers.DEFAULT_REGION); - const xmlResult = await (0, _response.readAsString)(httpRes); - return xmlParsers.parseListBucket(xmlResult); - } - async removeBucketReplication(bucketName) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - const method = 'DELETE'; - const query = 'replication'; - await this.makeRequestAsyncOmit({ - method, - bucketName, - query - }, '', [200, 204], ''); - } - async setBucketReplication(bucketName, replicationConfig) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isObject)(replicationConfig)) { - throw new errors.InvalidArgumentError('replicationConfig should be of type "object"'); - } else { - if (_lodash.isEmpty(replicationConfig.role)) { - throw new errors.InvalidArgumentError('Role cannot be empty'); - } else if (replicationConfig.role && !(0, _helper.isString)(replicationConfig.role)) { - throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role); - } - if (_lodash.isEmpty(replicationConfig.rules)) { - throw new errors.InvalidArgumentError('Minimum one replication rule must be specified'); - } - } - const method = 'PUT'; - const query = 'replication'; - const headers = {}; - const replicationParamsConfig = { - ReplicationConfiguration: { - Role: replicationConfig.role, - Rule: replicationConfig.rules - } - }; - const builder = new _xml2js.Builder({ - renderOpts: { - pretty: false - }, - headless: true - }); - const payload = builder.buildObject(replicationParamsConfig); - headers['Content-MD5'] = (0, _helper.toMd5)(payload); - await this.makeRequestAsyncOmit({ - method, - bucketName, - query, - headers - }, payload); - } - async getBucketReplication(bucketName) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - const method = 'GET'; - const query = 'replication'; - const httpRes = await this.makeRequestAsync({ - method, - bucketName, - query - }, '', [200, 204]); - const xmlResult = await (0, _response.readAsString)(httpRes); - return xmlParsers.parseReplicationConfig(xmlResult); - } } exports.TypedClient = TypedClient; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["http","_interopRequireWildcard","require","https","_browserOrNode","_lodash","qs","_xml2js","_CredentialProvider","errors","_helpers","_signing","_extensions","_helper","_request","_response","_s3Endpoints","xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","Package","version","requestOptionProperties","TypedClient","partSize","maximumPartSize","maxObjectSize","constructor","params","secure","undefined","Error","useSSL","port","isValidEndpoint","endPoint","InvalidEndpointError","isValidPort","InvalidArgumentError","isBoolean","region","isString","host","toLowerCase","protocol","transport","transportAgent","globalAgent","isObject","libraryComments","process","platform","arch","libraryAgent","userAgent","pathStyle","accessKey","secretKey","sessionToken","anonymous","credentialsProvider","regionMap","overRidePartSize","enableSHA256","s3AccelerateEndpoint","reqOptions","clientExtensions","Extensions","extensions","setS3TransferAccelerate","setRequestOptions","options","TypeError","_","pick","getAccelerateEndPointIfSet","bucketName","objectName","isEmpty","includes","getRequestOptions","opts","method","headers","query","agent","virtualHostStyle","isVirtualHostStyle","path","uriResourceEscape","isAmazonEndpoint","accelerateEndPoint","getS3Endpoint","k","v","entries","assign","mapValues","pickBy","isDefined","toString","setCredentialsProvider","CredentialProvider","checkAndRefreshCreds","credentialsConf","getCredentials","getAccessKey","getSecretKey","getSessionToken","e","cause","logHTTP","response","err","logStream","isReadableStream","logHeaders","forEach","redactor","RegExp","replace","write","statusCode","errJSON","JSON","stringify","traceOn","stream","stdout","traceOff","makeRequestAsync","payload","expectedCodes","isNumber","length","sha256sum","toSha256","makeRequestStreamAsync","makeRequestAsyncOmit","statusCodes","res","drainResponse","body","Buffer","isBuffer","getBucketRegionAsync","date","Date","makeDateLong","authorization","signV4","request","parseResponseError","isValidBucketName","InvalidBucketNameError","cached","extractRegionAsync","readAsString","parseBucketRegion","DEFAULT_REGION","isBrowser","name","Region","makeRequest","returnResponse","cb","prom","then","result","makeRequestStream","executor","getBucketRegion","removeBucket","statObject","statOpts","isValidObjectName","InvalidObjectNameError","size","parseInt","metaData","extractMetadata","lastModified","versionId","getVersionId","etag","sanitizeETag","removeObject","removeOpts","governanceBypass","forceDelete","queryParams","initiateNewMultipartUpload","readAsBuffer","parseInitiateMultipart","abortMultipartUpload","uploadId","requestOptions","listParts","parts","marker","listPartsQuery","push","isTruncated","uriEscape","parseListParts","listBuckets","httpRes","xmlResult","parseListBucket","removeBucketReplication","setBucketReplication","replicationConfig","role","rules","replicationParamsConfig","ReplicationConfiguration","Role","Rule","builder","xml2js","Builder","renderOpts","pretty","headless","buildObject","toMd5","getBucketReplication","parseReplicationConfig","exports"],"sources":["client.ts"],"sourcesContent":["import * as http from 'node:http'\nimport * as https from 'node:https'\nimport type * as stream from 'node:stream'\n\nimport { isBrowser } from 'browser-or-node'\nimport _ from 'lodash'\nimport * as qs from 'query-string'\nimport xml2js from 'xml2js'\n\nimport { CredentialProvider } from '../CredentialProvider.ts'\nimport * as errors from '../errors.ts'\nimport { DEFAULT_REGION } from '../helpers.ts'\nimport { signV4 } from '../signing.ts'\nimport { Extensions } from './extensions.ts'\nimport {\n  extractMetadata,\n  getVersionId,\n  isAmazonEndpoint,\n  isBoolean,\n  isDefined,\n  isEmpty,\n  isNumber,\n  isObject,\n  isReadableStream,\n  isString,\n  isValidBucketName,\n  isValidEndpoint,\n  isValidObjectName,\n  isValidPort,\n  isVirtualHostStyle,\n  makeDateLong,\n  sanitizeETag,\n  toMd5,\n  toSha256,\n  uriEscape,\n  uriResourceEscape,\n} from './helper.ts'\nimport { request } from './request.ts'\nimport { drainResponse, readAsBuffer, readAsString } from './response.ts'\nimport type { Region } from './s3-endpoints.ts'\nimport { getS3Endpoint } from './s3-endpoints.ts'\nimport type {\n  Binary,\n  BucketItemFromList,\n  BucketItemStat,\n  IRequest,\n  ReplicationConfig,\n  ReplicationConfigOpts,\n  RequestHeaders,\n  ResponseHeader,\n  ResultCallback,\n  StatObjectOpts,\n  Transport,\n} from './type.ts'\nimport type { UploadedPart } from './xml-parser.ts'\nimport * as xmlParsers from './xml-parser.ts'\nimport { parseInitiateMultipart } from './xml-parser.ts'\n\n// will be replaced by bundler.\nconst Package = { version: process.env.MINIO_JS_PACKAGE_VERSION || 'development' }\n\nconst requestOptionProperties = [\n  'agent',\n  'ca',\n  'cert',\n  'ciphers',\n  'clientCertEngine',\n  'crl',\n  'dhparam',\n  'ecdhCurve',\n  'family',\n  'honorCipherOrder',\n  'key',\n  'passphrase',\n  'pfx',\n  'rejectUnauthorized',\n  'secureOptions',\n  'secureProtocol',\n  'servername',\n  'sessionIdContext',\n] as const\n\nexport interface ClientOptions {\n  endPoint: string\n  accessKey: string\n  secretKey: string\n  useSSL?: boolean\n  port?: number\n  region?: Region\n  transport?: Transport\n  sessionToken?: string\n  partSize?: number\n  pathStyle?: boolean\n  credentialsProvider?: CredentialProvider\n  s3AccelerateEndpoint?: string\n  transportAgent?: http.Agent\n}\n\nexport type RequestOption = Partial<IRequest> & {\n  method: string\n  bucketName?: string\n  objectName?: string\n  query?: string\n  pathStyle?: boolean\n}\n\nexport type NoResultCallback = (error: unknown) => void\n\nexport interface RemoveOptions {\n  versionId?: string\n  governanceBypass?: boolean\n  forceDelete?: boolean\n}\n\nexport class TypedClient {\n  protected transport: Transport\n  protected host: string\n  protected port: number\n  protected protocol: string\n  protected accessKey: string\n  protected secretKey: string\n  protected sessionToken?: string\n  protected userAgent: string\n  protected anonymous: boolean\n  protected pathStyle: boolean\n  protected regionMap: Record<string, string>\n  public region?: string\n  protected credentialsProvider?: CredentialProvider\n  partSize: number = 64 * 1024 * 1024\n  protected overRidePartSize?: boolean\n\n  protected maximumPartSize = 5 * 1024 * 1024 * 1024\n  protected maxObjectSize = 5 * 1024 * 1024 * 1024 * 1024\n  public enableSHA256: boolean\n  protected s3AccelerateEndpoint?: string\n  protected reqOptions: Record<string, unknown>\n\n  protected transportAgent: http.Agent\n  private readonly clientExtensions: Extensions\n\n  constructor(params: ClientOptions) {\n    // @ts-expect-error deprecated property\n    if (params.secure !== undefined) {\n      throw new Error('\"secure\" option deprecated, \"useSSL\" should be used instead')\n    }\n    // Default values if not specified.\n    if (params.useSSL === undefined) {\n      params.useSSL = true\n    }\n    if (!params.port) {\n      params.port = 0\n    }\n    // Validate input params.\n    if (!isValidEndpoint(params.endPoint)) {\n      throw new errors.InvalidEndpointError(`Invalid endPoint : ${params.endPoint}`)\n    }\n    if (!isValidPort(params.port)) {\n      throw new errors.InvalidArgumentError(`Invalid port : ${params.port}`)\n    }\n    if (!isBoolean(params.useSSL)) {\n      throw new errors.InvalidArgumentError(\n        `Invalid useSSL flag type : ${params.useSSL}, expected to be of type \"boolean\"`,\n      )\n    }\n\n    // Validate region only if its set.\n    if (params.region) {\n      if (!isString(params.region)) {\n        throw new errors.InvalidArgumentError(`Invalid region : ${params.region}`)\n      }\n    }\n\n    const host = params.endPoint.toLowerCase()\n    let port = params.port\n    let protocol: string\n    let transport\n    let transportAgent: http.Agent\n    // Validate if configuration is not using SSL\n    // for constructing relevant endpoints.\n    if (params.useSSL) {\n      // Defaults to secure.\n      transport = https\n      protocol = 'https:'\n      port = port || 443\n      transportAgent = https.globalAgent\n    } else {\n      transport = http\n      protocol = 'http:'\n      port = port || 80\n      transportAgent = http.globalAgent\n    }\n\n    // if custom transport is set, use it.\n    if (params.transport) {\n      if (!isObject(params.transport)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transport type : ${params.transport}, expected to be type \"object\"`,\n        )\n      }\n      transport = params.transport\n    }\n\n    // if custom transport agent is set, use it.\n    if (params.transportAgent) {\n      if (!isObject(params.transportAgent)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transportAgent type: ${params.transportAgent}, expected to be type \"object\"`,\n        )\n      }\n\n      transportAgent = params.transportAgent\n    }\n\n    // User Agent should always following the below style.\n    // Please open an issue to discuss any new changes here.\n    //\n    //       MinIO (OS; ARCH) LIB/VER APP/VER\n    //\n    const libraryComments = `(${process.platform}; ${process.arch})`\n    const libraryAgent = `MinIO ${libraryComments} minio-js/${Package.version}`\n    // User agent block ends.\n\n    this.transport = transport\n    this.transportAgent = transportAgent\n    this.host = host\n    this.port = port\n    this.protocol = protocol\n    this.userAgent = `${libraryAgent}`\n\n    // Default path style is true\n    if (params.pathStyle === undefined) {\n      this.pathStyle = true\n    } else {\n      this.pathStyle = params.pathStyle\n    }\n\n    this.accessKey = params.accessKey ?? ''\n    this.secretKey = params.secretKey ?? ''\n    this.sessionToken = params.sessionToken\n    this.anonymous = !this.accessKey || !this.secretKey\n\n    if (params.credentialsProvider) {\n      this.credentialsProvider = params.credentialsProvider\n    }\n\n    this.regionMap = {}\n    if (params.region) {\n      this.region = params.region\n    }\n\n    if (params.partSize) {\n      this.partSize = params.partSize\n      this.overRidePartSize = true\n    }\n    if (this.partSize < 5 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be greater than 5MB`)\n    }\n    if (this.partSize > 5 * 1024 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be less than 5GB`)\n    }\n\n    // SHA256 is enabled only for authenticated http requests. If the request is authenticated\n    // and the connection is https we use x-amz-content-sha256=UNSIGNED-PAYLOAD\n    // header for signature calculation.\n    this.enableSHA256 = !this.anonymous && !params.useSSL\n\n    this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined\n    this.reqOptions = {}\n    this.clientExtensions = new Extensions(this)\n  }\n\n  /**\n   * Minio extensions that aren't necessary present for Amazon S3 compatible storage servers\n   */\n  get extensions() {\n    return this.clientExtensions\n  }\n\n  /**\n   * @param endPoint - valid S3 acceleration end point\n   */\n  setS3TransferAccelerate(endPoint: string) {\n    this.s3AccelerateEndpoint = endPoint\n  }\n\n  /**\n   * Sets the supported request options.\n   */\n  public setRequestOptions(options: Pick<https.RequestOptions, (typeof requestOptionProperties)[number]>) {\n    if (!isObject(options)) {\n      throw new TypeError('request options should be of type \"object\"')\n    }\n    this.reqOptions = _.pick(options, requestOptionProperties)\n  }\n\n  /**\n   *  This is s3 Specific and does not hold validity in any other Object storage.\n   */\n  private getAccelerateEndPointIfSet(bucketName?: string, objectName?: string) {\n    if (!isEmpty(this.s3AccelerateEndpoint) && !isEmpty(bucketName) && !isEmpty(objectName)) {\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      // Disable transfer acceleration for non-compliant bucket names.\n      if (bucketName.includes('.')) {\n        throw new Error(`Transfer Acceleration is not supported for non compliant bucket:${bucketName}`)\n      }\n      // If transfer acceleration is requested set new host.\n      // For more details about enabling transfer acceleration read here.\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      return this.s3AccelerateEndpoint\n    }\n    return false\n  }\n\n  /**\n   * returns options object that can be used with http.request()\n   * Takes care of constructing virtual-host-style or path-style hostname\n   */\n  protected getRequestOptions(\n    opts: RequestOption & { region: string },\n  ): IRequest & { host: string; headers: Record<string, string> } {\n    const method = opts.method\n    const region = opts.region\n    const bucketName = opts.bucketName\n    let objectName = opts.objectName\n    const headers = opts.headers\n    const query = opts.query\n\n    let reqOptions = {\n      method,\n      headers: {} as RequestHeaders,\n      protocol: this.protocol,\n      // If custom transportAgent was supplied earlier, we'll inject it here\n      agent: this.transportAgent,\n    }\n\n    // Verify if virtual host supported.\n    let virtualHostStyle\n    if (bucketName) {\n      virtualHostStyle = isVirtualHostStyle(this.host, this.protocol, bucketName, this.pathStyle)\n    }\n\n    let path = '/'\n    let host = this.host\n\n    let port: undefined | number\n    if (this.port) {\n      port = this.port\n    }\n\n    if (objectName) {\n      objectName = uriResourceEscape(objectName)\n    }\n\n    // For Amazon S3 endpoint, get endpoint based on region.\n    if (isAmazonEndpoint(host)) {\n      const accelerateEndPoint = this.getAccelerateEndPointIfSet(bucketName, objectName)\n      if (accelerateEndPoint) {\n        host = `${accelerateEndPoint}`\n      } else {\n        host = getS3Endpoint(region)\n      }\n    }\n\n    if (virtualHostStyle && !opts.pathStyle) {\n      // For all hosts which support virtual host style, `bucketName`\n      // is part of the hostname in the following format:\n      //\n      //  var host = 'bucketName.example.com'\n      //\n      if (bucketName) {\n        host = `${bucketName}.${host}`\n      }\n      if (objectName) {\n        path = `/${objectName}`\n      }\n    } else {\n      // For all S3 compatible storage services we will fallback to\n      // path style requests, where `bucketName` is part of the URI\n      // path.\n      if (bucketName) {\n        path = `/${bucketName}`\n      }\n      if (objectName) {\n        path = `/${bucketName}/${objectName}`\n      }\n    }\n\n    if (query) {\n      path += `?${query}`\n    }\n    reqOptions.headers.host = host\n    if ((reqOptions.protocol === 'http:' && port !== 80) || (reqOptions.protocol === 'https:' && port !== 443)) {\n      reqOptions.headers.host = `${host}:${port}`\n    }\n    reqOptions.headers['user-agent'] = this.userAgent\n    if (headers) {\n      // have all header keys in lower case - to make signing easy\n      for (const [k, v] of Object.entries(headers)) {\n        reqOptions.headers[k.toLowerCase()] = v\n      }\n    }\n\n    // Use any request option specified in minioClient.setRequestOptions()\n    reqOptions = Object.assign({}, this.reqOptions, reqOptions)\n\n    return {\n      ...reqOptions,\n      headers: _.mapValues(_.pickBy(reqOptions.headers, isDefined), (v) => v.toString()),\n      host,\n      port,\n      path,\n    } satisfies https.RequestOptions\n  }\n\n  public async setCredentialsProvider(credentialsProvider: CredentialProvider) {\n    if (!(credentialsProvider instanceof CredentialProvider)) {\n      throw new Error('Unable to get credentials. Expected instance of CredentialProvider')\n    }\n    this.credentialsProvider = credentialsProvider\n    await this.checkAndRefreshCreds()\n  }\n\n  private async checkAndRefreshCreds() {\n    if (this.credentialsProvider) {\n      try {\n        const credentialsConf = await this.credentialsProvider.getCredentials()\n        this.accessKey = credentialsConf.getAccessKey()\n        this.secretKey = credentialsConf.getSecretKey()\n        this.sessionToken = credentialsConf.getSessionToken()\n      } catch (e) {\n        throw new Error(`Unable to get credentials: ${e}`, { cause: e })\n      }\n    }\n  }\n\n  private logStream?: stream.Writable\n\n  /**\n   * log the request, response, error\n   */\n  private logHTTP(reqOptions: IRequest, response: http.IncomingMessage | null, err?: unknown) {\n    // if no logStream available return.\n    if (!this.logStream) {\n      return\n    }\n    if (!isObject(reqOptions)) {\n      throw new TypeError('reqOptions should be of type \"object\"')\n    }\n    if (response && !isReadableStream(response)) {\n      throw new TypeError('response should be of type \"Stream\"')\n    }\n    if (err && !(err instanceof Error)) {\n      throw new TypeError('err should be of type \"Error\"')\n    }\n    const logStream = this.logStream\n    const logHeaders = (headers: RequestHeaders) => {\n      Object.entries(headers).forEach(([k, v]) => {\n        if (k == 'authorization') {\n          if (isString(v)) {\n            const redactor = new RegExp('Signature=([0-9a-f]+)')\n            v = v.replace(redactor, 'Signature=**REDACTED**')\n          }\n        }\n        logStream.write(`${k}: ${v}\\n`)\n      })\n      logStream.write('\\n')\n    }\n    logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\\n`)\n    logHeaders(reqOptions.headers)\n    if (response) {\n      this.logStream.write(`RESPONSE: ${response.statusCode}\\n`)\n      logHeaders(response.headers as RequestHeaders)\n    }\n    if (err) {\n      logStream.write('ERROR BODY:\\n')\n      const errJSON = JSON.stringify(err, null, '\\t')\n      logStream.write(`${errJSON}\\n`)\n    }\n  }\n\n  /**\n   * Enable tracing\n   */\n  public traceOn(stream?: stream.Writable) {\n    if (!stream) {\n      stream = process.stdout\n    }\n    this.logStream = stream\n  }\n\n  /**\n   * Disable tracing\n   */\n  public traceOff() {\n    this.logStream = undefined\n  }\n\n  /**\n   * makeRequest is the primitive used by the apis for making S3 requests.\n   * payload can be empty string in case of no payload.\n   * statusCode is the expected statusCode. If response.statusCode does not match\n   * we parse the XML error and call the callback with the error message.\n   *\n   * A valid region is passed by the calls - listBuckets, makeBucket and getBucketRegion.\n   *\n   * @internal\n   */\n  async makeRequestAsync(\n    options: RequestOption,\n    payload: Binary = '',\n    expectedCodes: number[] = [200],\n    region = '',\n  ): Promise<http.IncomingMessage> {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!isString(payload) && !isObject(payload)) {\n      // Buffer is of type 'object'\n      throw new TypeError('payload should be of type \"string\" or \"Buffer\"')\n    }\n    expectedCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!options.headers) {\n      options.headers = {}\n    }\n    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') {\n      options.headers['content-length'] = payload.length.toString()\n    }\n    const sha256sum = this.enableSHA256 ? toSha256(payload) : ''\n    return this.makeRequestStreamAsync(options, payload, sha256sum, expectedCodes, region)\n  }\n\n  /**\n   * new request with promise\n   *\n   * No need to drain response, response body is not valid\n   */\n  async makeRequestAsyncOmit(\n    options: RequestOption,\n    payload: Binary = '',\n    statusCodes: number[] = [200],\n    region = '',\n  ): Promise<Omit<http.IncomingMessage, 'on'>> {\n    const res = await this.makeRequestAsync(options, payload, statusCodes, region)\n    await drainResponse(res)\n    return res\n  }\n\n  /**\n   * makeRequestStream will be used directly instead of makeRequest in case the payload\n   * is available as a stream. for ex. putObject\n   *\n   * @internal\n   */\n  async makeRequestStreamAsync(\n    options: RequestOption,\n    body: stream.Readable | Binary,\n    sha256sum: string,\n    statusCodes: number[],\n    region: string,\n  ): Promise<http.IncomingMessage> {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!(Buffer.isBuffer(body) || typeof body === 'string' || isReadableStream(body))) {\n      throw new errors.InvalidArgumentError(\n        `stream should be a Buffer, string or readable Stream, got ${typeof body} instead`,\n      )\n    }\n    if (!isString(sha256sum)) {\n      throw new TypeError('sha256sum should be of type \"string\"')\n    }\n    statusCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    // sha256sum will be empty for anonymous or https requests\n    if (!this.enableSHA256 && sha256sum.length !== 0) {\n      throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`)\n    }\n    // sha256sum should be valid for non-anonymous http requests.\n    if (this.enableSHA256 && sha256sum.length !== 64) {\n      throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`)\n    }\n\n    await this.checkAndRefreshCreds()\n\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    region = region || (await this.getBucketRegionAsync(options.bucketName!))\n\n    const reqOptions = this.getRequestOptions({ ...options, region })\n    if (!this.anonymous) {\n      // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation.\n      if (!this.enableSHA256) {\n        sha256sum = 'UNSIGNED-PAYLOAD'\n      }\n      const date = new Date()\n      reqOptions.headers['x-amz-date'] = makeDateLong(date)\n      reqOptions.headers['x-amz-content-sha256'] = sha256sum\n      if (this.sessionToken) {\n        reqOptions.headers['x-amz-security-token'] = this.sessionToken\n      }\n      reqOptions.headers.authorization = signV4(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum)\n    }\n\n    const response = await request(this.transport, reqOptions, body)\n    if (!response.statusCode) {\n      throw new Error(\"BUG: response doesn't have a statusCode\")\n    }\n\n    if (!statusCodes.includes(response.statusCode)) {\n      // For an incorrect region, S3 server always sends back 400.\n      // But we will do cache invalidation for all errors so that,\n      // in future, if AWS S3 decides to send a different status code or\n      // XML error code we will still work fine.\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      delete this.regionMap[options.bucketName!]\n\n      const err = await xmlParsers.parseResponseError(response)\n      this.logHTTP(reqOptions, response, err)\n      throw err\n    }\n\n    this.logHTTP(reqOptions, response)\n\n    return response\n  }\n\n  /**\n   * gets the region of the bucket\n   *\n   * @param bucketName\n   *\n   * @internal\n   */\n  protected async getBucketRegionAsync(bucketName: string): Promise<string> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`)\n    }\n\n    // Region is set with constructor, return the region right here.\n    if (this.region) {\n      return this.region\n    }\n\n    const cached = this.regionMap[bucketName]\n    if (cached) {\n      return cached\n    }\n\n    const extractRegionAsync = async (response: http.IncomingMessage) => {\n      const body = await readAsString(response)\n      const region = xmlParsers.parseBucketRegion(body) || DEFAULT_REGION\n      this.regionMap[bucketName] = region\n      return region\n    }\n\n    const method = 'GET'\n    const query = 'location'\n    // `getBucketLocation` behaves differently in following ways for\n    // different environments.\n    //\n    // - For nodejs env we default to path style requests.\n    // - For browser env path style requests on buckets yields CORS\n    //   error. To circumvent this problem we make a virtual host\n    //   style request signed with 'us-east-1'. This request fails\n    //   with an error 'AuthorizationHeaderMalformed', additionally\n    //   the error XML also provides Region of the bucket. To validate\n    //   this region is proper we retry the same request with the newly\n    //   obtained region.\n    const pathStyle = this.pathStyle && !isBrowser\n    let region: string\n    try {\n      const res = await this.makeRequestAsync({ method, bucketName, query, pathStyle }, '', [200], DEFAULT_REGION)\n      return extractRegionAsync(res)\n    } catch (e) {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      if (!(e.name === 'AuthorizationHeaderMalformed')) {\n        throw e\n      }\n      // @ts-expect-error we set extra properties on error object\n      region = e.Region as string\n      if (!region) {\n        throw e\n      }\n    }\n\n    const res = await this.makeRequestAsync({ method, bucketName, query, pathStyle }, '', [200], region)\n    return await extractRegionAsync(res)\n  }\n\n  /**\n   * makeRequest is the primitive used by the apis for making S3 requests.\n   * payload can be empty string in case of no payload.\n   * statusCode is the expected statusCode. If response.statusCode does not match\n   * we parse the XML error and call the callback with the error message.\n   * A valid region is passed by the calls - listBuckets, makeBucket and\n   * getBucketRegion.\n   *\n   * @deprecated use `makeRequestAsync` instead\n   */\n  makeRequest(\n    options: RequestOption,\n    payload: Binary = '',\n    expectedCodes: number[] = [200],\n    region = '',\n    returnResponse: boolean,\n    cb: (cb: unknown, result: http.IncomingMessage) => void,\n  ) {\n    let prom: Promise<http.IncomingMessage>\n    if (returnResponse) {\n      prom = this.makeRequestAsync(options, payload, expectedCodes, region)\n    } else {\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-expect-error compatible for old behaviour\n      prom = this.makeRequestAsyncOmit(options, payload, expectedCodes, region)\n    }\n\n    prom.then(\n      (result) => cb(null, result),\n      (err) => {\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        cb(err)\n      },\n    )\n  }\n\n  /**\n   * makeRequestStream will be used directly instead of makeRequest in case the payload\n   * is available as a stream. for ex. putObject\n   *\n   * @deprecated use `makeRequestStreamAsync` instead\n   */\n  makeRequestStream(\n    options: RequestOption,\n    stream: stream.Readable | Buffer,\n    sha256sum: string,\n    statusCodes: number[],\n    region: string,\n    returnResponse: boolean,\n    cb: (cb: unknown, result: http.IncomingMessage) => void,\n  ) {\n    const executor = async () => {\n      const res = await this.makeRequestStreamAsync(options, stream, sha256sum, statusCodes, region)\n      if (!returnResponse) {\n        await drainResponse(res)\n      }\n\n      return res\n    }\n\n    executor().then(\n      (result) => cb(null, result),\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      (err) => cb(err),\n    )\n  }\n\n  /**\n   * @deprecated use `getBucketRegionAsync` instead\n   */\n  getBucketRegion(bucketName: string, cb: (err: unknown, region: string) => void) {\n    return this.getBucketRegionAsync(bucketName).then(\n      (result) => cb(null, result),\n      // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n      // @ts-ignore\n      (err) => cb(err),\n    )\n  }\n\n  async removeBucket(bucketName: string): Promise<void>\n\n  /**\n   * @deprecated use promise style API\n   */\n  removeBucket(bucketName: string, callback: NoResultCallback): void\n\n  async removeBucket(bucketName: string): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    await this.makeRequestAsyncOmit({ method, bucketName }, '', [204])\n    delete this.regionMap[bucketName]\n  }\n\n  /**\n   * Stat information of the object.\n   */\n  async statObject(bucketName: string, objectName: string, statOpts: StatObjectOpts = {}): Promise<BucketItemStat> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isObject(statOpts)) {\n      throw new errors.InvalidArgumentError('statOpts should be of type \"object\"')\n    }\n\n    const query = qs.stringify(statOpts)\n    const method = 'HEAD'\n    const res = await this.makeRequestAsyncOmit({ method, bucketName, objectName, query })\n\n    return {\n      size: parseInt(res.headers['content-length'] as string),\n      metaData: extractMetadata(res.headers as ResponseHeader),\n      lastModified: new Date(res.headers['last-modified'] as string),\n      versionId: getVersionId(res.headers as ResponseHeader),\n      etag: sanitizeETag(res.headers.etag),\n    }\n  }\n\n  /**\n   * Remove the specified object.\n   * @deprecated use new promise style API\n   */\n  removeObject(bucketName: string, objectName: string, removeOpts: RemoveOptions, callback: NoResultCallback): void\n  /**\n   * @deprecated use new promise style API\n   */\n  // @ts-ignore\n  removeObject(bucketName: string, objectName: string, callback: NoResultCallback): void\n  async removeObject(bucketName: string, objectName: string, removeOpts?: RemoveOptions): Promise<void>\n\n  async removeObject(bucketName: string, objectName: string, removeOpts: RemoveOptions = {}): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n\n    const method = 'DELETE'\n\n    const headers: RequestHeaders = {}\n    if (removeOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n    if (removeOpts.forceDelete) {\n      headers['x-minio-force-delete'] = true\n    }\n\n    const queryParams: Record<string, string> = {}\n    if (removeOpts.versionId) {\n      queryParams.versionId = `${removeOpts.versionId}`\n    }\n    const query = qs.stringify(queryParams)\n\n    await this.makeRequestAsyncOmit({ method, bucketName, objectName, headers, query }, '', [200, 204])\n  }\n\n  // Calls implemented below are related to multipart.\n\n  /**\n   * Initiate a new multipart upload.\n   * @internal\n   */\n  async initiateNewMultipartUpload(bucketName: string, objectName: string, headers: RequestHeaders): Promise<string> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(headers)) {\n      throw new errors.InvalidObjectNameError('contentType should be of type \"object\"')\n    }\n    const method = 'POST'\n    const query = 'uploads'\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query, headers })\n    const body = await readAsBuffer(res)\n    return parseInitiateMultipart(body.toString())\n  }\n\n  /**\n   * Internal Method to abort a multipart upload request in case of any errors.\n   *\n   * @param bucketName - Bucket Name\n   * @param objectName - Object Name\n   * @param uploadId - id of a multipart upload to cancel during compose object sequence.\n   */\n  async abortMultipartUpload(bucketName: string, objectName: string, uploadId: string): Promise<void> {\n    const method = 'DELETE'\n    const query = `uploadId=${uploadId}`\n\n    const requestOptions = { method, bucketName, objectName: objectName, query }\n    await this.makeRequestAsyncOmit(requestOptions, '', [204])\n  }\n\n  /**\n   * Get part-info of all parts of an incomplete upload specified by uploadId.\n   */\n  protected async listParts(bucketName: string, objectName: string, uploadId: string): Promise<UploadedPart[]> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    const parts: UploadedPart[] = []\n    let marker = 0\n    let result\n    do {\n      result = await this.listPartsQuery(bucketName, objectName, uploadId, marker)\n      marker = result.marker\n      parts.push(...result.parts)\n    } while (result.isTruncated)\n\n    return parts\n  }\n\n  /**\n   * Called by listParts to fetch a batch of part-info\n   */\n  private async listPartsQuery(bucketName: string, objectName: string, uploadId: string, marker: number) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isNumber(marker)) {\n      throw new TypeError('marker should be of type \"number\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    let query = `uploadId=${uriEscape(uploadId)}`\n    if (marker) {\n      query += `&part-number-marker=${marker}`\n    }\n\n    const method = 'GET'\n    const res = await this.makeRequestAsync({ method, bucketName, objectName, query })\n    return xmlParsers.parseListParts(await readAsString(res))\n  }\n\n  async listBuckets(): Promise<BucketItemFromList[]> {\n    const method = 'GET'\n    const httpRes = await this.makeRequestAsync({ method }, '', [200], DEFAULT_REGION)\n    const xmlResult = await readAsString(httpRes)\n    return xmlParsers.parseListBucket(xmlResult)\n  }\n\n  async removeBucketReplication(bucketName: string): Promise<void>\n  removeBucketReplication(bucketName: string, callback: NoResultCallback): void\n  async removeBucketReplication(bucketName: string): Promise<void> {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'replication'\n    await this.makeRequestAsyncOmit({ method, bucketName, query }, '', [200, 204], '')\n  }\n\n  setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts, callback: NoResultCallback): void\n  async setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts): Promise<void>\n  async setBucketReplication(bucketName: string, replicationConfig: ReplicationConfigOpts) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(replicationConfig)) {\n      throw new errors.InvalidArgumentError('replicationConfig should be of type \"object\"')\n    } else {\n      if (_.isEmpty(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Role cannot be empty')\n      } else if (replicationConfig.role && !isString(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role)\n      }\n      if (_.isEmpty(replicationConfig.rules)) {\n        throw new errors.InvalidArgumentError('Minimum one replication rule must be specified')\n      }\n    }\n    const method = 'PUT'\n    const query = 'replication'\n    const headers: Record<string, string> = {}\n\n    const replicationParamsConfig = {\n      ReplicationConfiguration: {\n        Role: replicationConfig.role,\n        Rule: replicationConfig.rules,\n      },\n    }\n\n    const builder = new xml2js.Builder({ renderOpts: { pretty: false }, headless: true })\n    const payload = builder.buildObject(replicationParamsConfig)\n    headers['Content-MD5'] = toMd5(payload)\n    await this.makeRequestAsyncOmit({ method, bucketName, query, headers }, payload)\n  }\n\n  getBucketReplication(bucketName: string, callback: ResultCallback<ReplicationConfig>): void\n  async getBucketReplication(bucketName: string): Promise<ReplicationConfig>\n  async getBucketReplication(bucketName: string) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'replication'\n\n    const httpRes = await this.makeRequestAsync({ method, bucketName, query }, '', [200, 204])\n    const xmlResult = await readAsString(httpRes)\n    return xmlParsers.parseReplicationConfig(xmlResult)\n  }\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["http","_interopRequireWildcard","require","https","_lodash","_CredentialProvider","errors","_helper","_s3Endpoints","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","Package","version","requestOptionProperties","TypedClient","partSize","maximumPartSize","maxObjectSize","constructor","params","secure","undefined","Error","useSSL","port","isValidEndpoint","endPoint","InvalidEndpointError","isValidPort","InvalidArgumentError","isBoolean","region","isString","host","toLowerCase","protocol","transport","transportAgent","globalAgent","isObject","libraryComments","process","platform","arch","libraryAgent","userAgent","pathStyle","accessKey","secretKey","sessionToken","anonymous","credentialsProvider","regionMap","overRidePartSize","enableSHA256","s3AccelerateEndpoint","reqOptions","setS3TransferAccelerate","setRequestOptions","options","TypeError","_","pick","getAccelerateEndPointIfSet","bucketName","objectName","isEmpty","includes","getRequestOptions","opts","method","headers","query","agent","virtualHostStyle","isVirtualHostStyle","path","uriResourceEscape","isAmazonEndpoint","accelerateEndPoint","getS3Endpoint","k","v","entries","assign","mapValues","pickBy","isDefined","toString","setCredentialsProvider","CredentialProvider","checkAndRefreshCreds","credentialsConf","getCredentials","getAccessKey","getSecretKey","getSessionToken","e","cause","exports"],"sources":["client.ts"],"sourcesContent":["import * as http from 'node:http'\nimport * as https from 'node:https'\n\nimport _ from 'lodash'\n\nimport { CredentialProvider } from '../CredentialProvider.ts'\nimport * as errors from '../errors.ts'\nimport {\n  isAmazonEndpoint,\n  isBoolean,\n  isDefined,\n  isEmpty,\n  isObject,\n  isString,\n  isValidEndpoint,\n  isValidPort,\n  isVirtualHostStyle,\n  uriResourceEscape,\n} from './helper.ts'\nimport type { Region } from './s3-endpoints.ts'\nimport { getS3Endpoint } from './s3-endpoints.ts'\nimport type { IRequest, RequestHeaders, Transport } from './type.ts'\n\n// will be replaced by bundler.\nconst Package = { version: process.env.MINIO_JS_PACKAGE_VERSION || 'development' }\n\nconst requestOptionProperties = [\n  'agent',\n  'ca',\n  'cert',\n  'ciphers',\n  'clientCertEngine',\n  'crl',\n  'dhparam',\n  'ecdhCurve',\n  'family',\n  'honorCipherOrder',\n  'key',\n  'passphrase',\n  'pfx',\n  'rejectUnauthorized',\n  'secureOptions',\n  'secureProtocol',\n  'servername',\n  'sessionIdContext',\n] as const\n\nexport interface ClientOptions {\n  endPoint: string\n  accessKey: string\n  secretKey: string\n  useSSL?: boolean\n  port?: number\n  region?: Region\n  transport?: Transport\n  sessionToken?: string\n  partSize?: number\n  pathStyle?: boolean\n  credentialsProvider?: CredentialProvider\n  s3AccelerateEndpoint?: string\n  transportAgent?: http.Agent\n}\n\nexport type RequestOption = Partial<IRequest> & {\n  method: string\n  bucketName?: string\n  objectName?: string\n  region?: string\n  query?: string\n  pathStyle?: boolean\n}\n\nexport class TypedClient {\n  protected transport: Transport\n  protected host: string\n  protected port: number\n  protected protocol: string\n  protected accessKey: string\n  protected secretKey: string\n  protected sessionToken?: string\n  protected userAgent: string\n  protected anonymous: boolean\n  protected pathStyle: boolean\n  protected regionMap: Record<string, string>\n  public region?: string\n  protected credentialsProvider?: CredentialProvider\n  partSize: number = 64 * 1024 * 1024\n  protected overRidePartSize?: boolean\n\n  protected maximumPartSize = 5 * 1024 * 1024 * 1024\n  protected maxObjectSize = 5 * 1024 * 1024 * 1024 * 1024\n  public enableSHA256: boolean\n  protected s3AccelerateEndpoint?: string\n  protected reqOptions: Record<string, unknown>\n\n  protected transportAgent: http.Agent\n\n  constructor(params: ClientOptions) {\n    // @ts-expect-error deprecated property\n    if (params.secure !== undefined) {\n      throw new Error('\"secure\" option deprecated, \"useSSL\" should be used instead')\n    }\n    // Default values if not specified.\n    if (params.useSSL === undefined) {\n      params.useSSL = true\n    }\n    if (!params.port) {\n      params.port = 0\n    }\n    // Validate input params.\n    if (!isValidEndpoint(params.endPoint)) {\n      throw new errors.InvalidEndpointError(`Invalid endPoint : ${params.endPoint}`)\n    }\n    if (!isValidPort(params.port)) {\n      throw new errors.InvalidArgumentError(`Invalid port : ${params.port}`)\n    }\n    if (!isBoolean(params.useSSL)) {\n      throw new errors.InvalidArgumentError(\n        `Invalid useSSL flag type : ${params.useSSL}, expected to be of type \"boolean\"`,\n      )\n    }\n\n    // Validate region only if its set.\n    if (params.region) {\n      if (!isString(params.region)) {\n        throw new errors.InvalidArgumentError(`Invalid region : ${params.region}`)\n      }\n    }\n\n    const host = params.endPoint.toLowerCase()\n    let port = params.port\n    let protocol: string\n    let transport\n    let transportAgent: http.Agent\n    // Validate if configuration is not using SSL\n    // for constructing relevant endpoints.\n    if (params.useSSL) {\n      // Defaults to secure.\n      transport = https\n      protocol = 'https:'\n      port = port || 443\n      transportAgent = https.globalAgent\n    } else {\n      transport = http\n      protocol = 'http:'\n      port = port || 80\n      transportAgent = http.globalAgent\n    }\n\n    // if custom transport is set, use it.\n    if (params.transport) {\n      if (!isObject(params.transport)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transport type : ${params.transport}, expected to be type \"object\"`,\n        )\n      }\n      transport = params.transport\n    }\n\n    // if custom transport agent is set, use it.\n    if (params.transportAgent) {\n      if (!isObject(params.transportAgent)) {\n        throw new errors.InvalidArgumentError(\n          `Invalid transportAgent type: ${params.transportAgent}, expected to be type \"object\"`,\n        )\n      }\n\n      transportAgent = params.transportAgent\n    }\n\n    // User Agent should always following the below style.\n    // Please open an issue to discuss any new changes here.\n    //\n    //       MinIO (OS; ARCH) LIB/VER APP/VER\n    //\n    const libraryComments = `(${process.platform}; ${process.arch})`\n    const libraryAgent = `MinIO ${libraryComments} minio-js/${Package.version}`\n    // User agent block ends.\n\n    this.transport = transport\n    this.transportAgent = transportAgent\n    this.host = host\n    this.port = port\n    this.protocol = protocol\n    this.userAgent = `${libraryAgent}`\n\n    // Default path style is true\n    if (params.pathStyle === undefined) {\n      this.pathStyle = true\n    } else {\n      this.pathStyle = params.pathStyle\n    }\n\n    this.accessKey = params.accessKey ?? ''\n    this.secretKey = params.secretKey ?? ''\n    this.sessionToken = params.sessionToken\n    this.anonymous = !this.accessKey || !this.secretKey\n\n    if (params.credentialsProvider) {\n      this.credentialsProvider = params.credentialsProvider\n    }\n\n    this.regionMap = {}\n    if (params.region) {\n      this.region = params.region\n    }\n\n    if (params.partSize) {\n      this.partSize = params.partSize\n      this.overRidePartSize = true\n    }\n    if (this.partSize < 5 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be greater than 5MB`)\n    }\n    if (this.partSize > 5 * 1024 * 1024 * 1024) {\n      throw new errors.InvalidArgumentError(`Part size should be less than 5GB`)\n    }\n\n    // SHA256 is enabled only for authenticated http requests. If the request is authenticated\n    // and the connection is https we use x-amz-content-sha256=UNSIGNED-PAYLOAD\n    // header for signature calculation.\n    this.enableSHA256 = !this.anonymous && !params.useSSL\n\n    this.s3AccelerateEndpoint = params.s3AccelerateEndpoint || undefined\n    this.reqOptions = {}\n  }\n\n  /**\n   * @param endPoint - valid S3 acceleration end point\n   */\n  setS3TransferAccelerate(endPoint: string) {\n    this.s3AccelerateEndpoint = endPoint\n  }\n\n  /**\n   * Sets the supported request options.\n   */\n  public setRequestOptions(options: Pick<https.RequestOptions, (typeof requestOptionProperties)[number]>) {\n    if (!isObject(options)) {\n      throw new TypeError('request options should be of type \"object\"')\n    }\n    this.reqOptions = _.pick(options, requestOptionProperties)\n  }\n\n  /**\n   *  This is s3 Specific and does not hold validity in any other Object storage.\n   */\n  private getAccelerateEndPointIfSet(bucketName?: string, objectName?: string) {\n    if (!isEmpty(this.s3AccelerateEndpoint) && !isEmpty(bucketName) && !isEmpty(objectName)) {\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      // Disable transfer acceleration for non-compliant bucket names.\n      if (bucketName.includes('.')) {\n        throw new Error(`Transfer Acceleration is not supported for non compliant bucket:${bucketName}`)\n      }\n      // If transfer acceleration is requested set new host.\n      // For more details about enabling transfer acceleration read here.\n      // http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html\n      return this.s3AccelerateEndpoint\n    }\n    return false\n  }\n\n  /**\n   * returns options object that can be used with http.request()\n   * Takes care of constructing virtual-host-style or path-style hostname\n   */\n  protected getRequestOptions(opts: RequestOption): IRequest & { host: string; headers: Record<string, string> } {\n    const method = opts.method\n    const region = opts.region\n    const bucketName = opts.bucketName\n    let objectName = opts.objectName\n    const headers = opts.headers\n    const query = opts.query\n\n    let reqOptions = {\n      method,\n      headers: {} as RequestHeaders,\n      protocol: this.protocol,\n      // If custom transportAgent was supplied earlier, we'll inject it here\n      agent: this.transportAgent,\n    }\n\n    // Verify if virtual host supported.\n    let virtualHostStyle\n    if (bucketName) {\n      virtualHostStyle = isVirtualHostStyle(this.host, this.protocol, bucketName, this.pathStyle)\n    }\n\n    let path = '/'\n    let host = this.host\n\n    let port: undefined | number\n    if (this.port) {\n      port = this.port\n    }\n\n    if (objectName) {\n      objectName = uriResourceEscape(objectName)\n    }\n\n    // For Amazon S3 endpoint, get endpoint based on region.\n    if (isAmazonEndpoint(host)) {\n      const accelerateEndPoint = this.getAccelerateEndPointIfSet(bucketName, objectName)\n      if (accelerateEndPoint) {\n        host = `${accelerateEndPoint}`\n      } else {\n        host = getS3Endpoint(region!)\n      }\n    }\n\n    if (virtualHostStyle && !opts.pathStyle) {\n      // For all hosts which support virtual host style, `bucketName`\n      // is part of the hostname in the following format:\n      //\n      //  var host = 'bucketName.example.com'\n      //\n      if (bucketName) {\n        host = `${bucketName}.${host}`\n      }\n      if (objectName) {\n        path = `/${objectName}`\n      }\n    } else {\n      // For all S3 compatible storage services we will fallback to\n      // path style requests, where `bucketName` is part of the URI\n      // path.\n      if (bucketName) {\n        path = `/${bucketName}`\n      }\n      if (objectName) {\n        path = `/${bucketName}/${objectName}`\n      }\n    }\n\n    if (query) {\n      path += `?${query}`\n    }\n    reqOptions.headers.host = host\n    if ((reqOptions.protocol === 'http:' && port !== 80) || (reqOptions.protocol === 'https:' && port !== 443)) {\n      reqOptions.headers.host = `${host}:${port}`\n    }\n    reqOptions.headers['user-agent'] = this.userAgent\n    if (headers) {\n      // have all header keys in lower case - to make signing easy\n      for (const [k, v] of Object.entries(headers)) {\n        reqOptions.headers[k.toLowerCase()] = v\n      }\n    }\n\n    // Use any request option specified in minioClient.setRequestOptions()\n    reqOptions = Object.assign({}, this.reqOptions, reqOptions)\n\n    return {\n      ...reqOptions,\n      headers: _.mapValues(_.pickBy(reqOptions.headers, isDefined), (v) => v.toString()),\n      host,\n      port,\n      path,\n    } satisfies https.RequestOptions\n  }\n\n  public async setCredentialsProvider(credentialsProvider: CredentialProvider) {\n    if (!(credentialsProvider instanceof CredentialProvider)) {\n      throw new Error('Unable to get credentials. Expected instance of CredentialProvider')\n    }\n    this.credentialsProvider = credentialsProvider\n    await this.checkAndRefreshCreds()\n  }\n\n  private async checkAndRefreshCreds() {\n    if (this.credentialsProvider) {\n      try {\n        const credentialsConf = await this.credentialsProvider.getCredentials()\n        this.accessKey = credentialsConf.getAccessKey()\n        this.secretKey = credentialsConf.getSecretKey()\n        this.sessionToken = credentialsConf.getSessionToken()\n      } catch (e) {\n        throw new Error(`Unable to get credentials: ${e}`, { cause: e })\n      }\n    }\n  }\n}\n"],"mappings":"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"} /***/ }), @@ -77650,135 +80418,6 @@ exports.CopyConditions = CopyConditions; /***/ }), -/***/ 1159: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -var stream = _interopRequireWildcard(__nccwpck_require__(2781), true); -var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); -var _helper = __nccwpck_require__(9921); -var _response = __nccwpck_require__(2644); -var _xmlParser = __nccwpck_require__(4040); -function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } -function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } -/* - * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, Inc. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -class Extensions { - constructor(client) { - this.client = client; - } - - /** - * List the objects in the bucket using S3 ListObjects V2 With Metadata - * - * @param bucketName - name of the bucket - * @param prefix - the prefix of the objects that should be listed (optional, default `''`) - * @param recursive - `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`) - * @param startAfter - Specifies the key to start after when listing objects in a bucket. (optional, default `''`) - * @returns stream emitting the objects in the bucket, the object is of the format: - */ - listObjectsV2WithMetadata(bucketName, prefix, recursive, startAfter) { - if (prefix === undefined) { - prefix = ''; - } - if (recursive === undefined) { - recursive = false; - } - if (startAfter === undefined) { - startAfter = ''; - } - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); - } - if (!(0, _helper.isValidPrefix)(prefix)) { - throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`); - } - if (!(0, _helper.isString)(prefix)) { - throw new TypeError('prefix should be of type "string"'); - } - if (!(0, _helper.isBoolean)(recursive)) { - throw new TypeError('recursive should be of type "boolean"'); - } - if (!(0, _helper.isString)(startAfter)) { - throw new TypeError('startAfter should be of type "string"'); - } - - // if recursive is false set delimiter to '/' - const delimiter = recursive ? '' : '/'; - return stream.Readable.from(this.listObjectsV2WithMetadataGen(bucketName, prefix, delimiter, startAfter), { - objectMode: true - }); - } - async *listObjectsV2WithMetadataGen(bucketName, prefix, delimiter, startAfter) { - let ended = false; - let continuationToken = ''; - do { - const result = await this.listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, startAfter); - ended = !result.isTruncated; - continuationToken = result.nextContinuationToken; - for (const obj of result.objects) { - yield obj; - } - } while (!ended); - } - async listObjectsV2WithMetadataQuery(bucketName, prefix, continuationToken, delimiter, startAfter) { - const queries = []; - - // Call for listing objects v2 API - queries.push(`list-type=2`); - queries.push(`encoding-type=url`); - // escape every value in query string, except maxKeys - queries.push(`prefix=${(0, _helper.uriEscape)(prefix)}`); - queries.push(`delimiter=${(0, _helper.uriEscape)(delimiter)}`); - queries.push(`metadata=true`); - if (continuationToken) { - continuationToken = (0, _helper.uriEscape)(continuationToken); - queries.push(`continuation-token=${continuationToken}`); - } - // Set start-after - if (startAfter) { - startAfter = (0, _helper.uriEscape)(startAfter); - queries.push(`start-after=${startAfter}`); - } - queries.push(`max-keys=1000`); - queries.sort(); - let query = ''; - if (queries.length > 0) { - query = `${queries.join('&')}`; - } - const method = 'GET'; - const res = await this.client.makeRequestAsync({ - method, - bucketName, - query - }); - return (0, _xmlParser.parseListObjectsV2WithMetadata)(await (0, _response.readAsString)(res)); - } -} -exports.Extensions = Extensions; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["stream","_interopRequireWildcard","require","errors","_helper","_response","_xmlParser","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","Extensions","constructor","client","listObjectsV2WithMetadata","bucketName","prefix","recursive","startAfter","undefined","isValidBucketName","InvalidBucketNameError","isValidPrefix","InvalidPrefixError","isString","TypeError","isBoolean","delimiter","Readable","from","listObjectsV2WithMetadataGen","objectMode","ended","continuationToken","result","listObjectsV2WithMetadataQuery","isTruncated","nextContinuationToken","objects","queries","push","uriEscape","sort","query","length","join","method","res","makeRequestAsync","parseListObjectsV2WithMetadata","readAsString","exports"],"sources":["extensions.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2020 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as stream from 'node:stream'\n\nimport * as errors from '../errors.ts'\nimport type { TypedClient } from './client.ts'\nimport { isBoolean, isString, isValidBucketName, isValidPrefix, uriEscape } from './helper.ts'\nimport { readAsString } from './response.ts'\nimport type { BucketItemWithMetadata, BucketStream } from './type.ts'\nimport { parseListObjectsV2WithMetadata } from './xml-parser.ts'\n\nexport class Extensions {\n  constructor(private readonly client: TypedClient) {}\n\n  /**\n   * List the objects in the bucket using S3 ListObjects V2 With Metadata\n   *\n   * @param bucketName - name of the bucket\n   * @param prefix - the prefix of the objects that should be listed (optional, default `''`)\n   * @param recursive - `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n   * @param startAfter - Specifies the key to start after when listing objects in a bucket. (optional, default `''`)\n   * @returns stream emitting the objects in the bucket, the object is of the format:\n   */\n  public listObjectsV2WithMetadata(\n    bucketName: string,\n    prefix?: string,\n    recursive?: boolean,\n    startAfter?: string,\n  ): BucketStream<BucketItemWithMetadata> {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n\n    // if recursive is false set delimiter to '/'\n    const delimiter = recursive ? '' : '/'\n    return stream.Readable.from(this.listObjectsV2WithMetadataGen(bucketName, prefix, delimiter, startAfter), {\n      objectMode: true,\n    })\n  }\n\n  private async *listObjectsV2WithMetadataGen(\n    bucketName: string,\n    prefix: string,\n    delimiter: string,\n    startAfter: string,\n  ): AsyncIterable<BucketItemWithMetadata> {\n    let ended = false\n    let continuationToken = ''\n    do {\n      const result = await this.listObjectsV2WithMetadataQuery(\n        bucketName,\n        prefix,\n        continuationToken,\n        delimiter,\n        startAfter,\n      )\n      ended = !result.isTruncated\n      continuationToken = result.nextContinuationToken\n      for (const obj of result.objects) {\n        yield obj\n      }\n    } while (!ended)\n  }\n\n  private async listObjectsV2WithMetadataQuery(\n    bucketName: string,\n    prefix: string,\n    continuationToken: string,\n    delimiter: string,\n    startAfter: string,\n  ) {\n    const queries = []\n\n    // Call for listing objects v2 API\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n    queries.push(`metadata=true`)\n\n    if (continuationToken) {\n      continuationToken = uriEscape(continuationToken)\n      queries.push(`continuation-token=${continuationToken}`)\n    }\n    // Set start-after\n    if (startAfter) {\n      startAfter = uriEscape(startAfter)\n      queries.push(`start-after=${startAfter}`)\n    }\n    queries.push(`max-keys=1000`)\n    queries.sort()\n    let query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    const method = 'GET'\n    const res = await this.client.makeRequestAsync({ method, bucketName, query })\n    return parseListObjectsV2WithMetadata(await readAsString(res))\n  }\n}\n"],"mappings":"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"} - -/***/ }), - /***/ 9921: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { @@ -77827,7 +80466,6 @@ exports.probeContentType = probeContentType; exports.readableStream = readableStream; exports.sanitizeETag = sanitizeETag; exports.sanitizeObjectKey = sanitizeObjectKey; -exports.sanitizeSize = sanitizeSize; exports.toArray = toArray; exports.toMd5 = toMd5; exports.toSha256 = toSha256; @@ -77838,7 +80476,7 @@ var stream = _interopRequireWildcard(__nccwpck_require__(2781), true); var _fastXmlParser = __nccwpck_require__(2603); var _ipaddr = __nccwpck_require__(7263); var _lodash = __nccwpck_require__(250); -var mime = _interopRequireWildcard(__nccwpck_require__(3583), true); +var mime = _interopRequireWildcard(__nccwpck_require__(7920), true); var _type = __nccwpck_require__(7293); function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } @@ -78249,9 +80887,6 @@ function sanitizeObjectKey(objectName) { const asStrName = (objectName ? objectName.toString() : '').replace(/\+/g, ' '); return decodeURIComponent(asStrName); } -function sanitizeSize(size) { - return size ? Number.parseInt(size) : undefined; -} const PART_CONSTRAINTS = { // absMinPartSize - absolute minimum part size (5 MiB) ABS_MIN_PART_SIZE: 1024 * 1024 * 5, @@ -78356,7 +80991,7 @@ function parseXml(xml) { } return result; } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["crypto","_interopRequireWildcard","require","stream","_fastXmlParser","_ipaddr","_lodash","mime","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","MetaDataHeaderPrefix","uriEscape","string","split","reduce","acc","elem","buf","Buffer","from","length","char","toString","toUpperCase","uriResourceEscape","replace","getScope","region","date","serviceName","makeDateShort","isAmazonEndpoint","endpoint","isVirtualHostStyle","protocol","bucket","pathStyle","includes","isValidIP","ip","ipaddr","isValid","isValidEndpoint","isValidDomain","host","isString","slice","alphaNumerics","probeContentType","path","contentType","lookup","isValidPort","port","isNumber","isValidBucketName","test","isValidObjectName","objectName","isValidPrefix","prefix","arg","isFunction","isObject","isReadableStream","_read","isBoolean","isEmpty","o","_","isEmptyObject","values","filter","x","undefined","isDefined","isValidDate","Date","isNaN","makeDateLong","s","toISOString","pipesetup","streams","src","dst","on","err","emit","pipe","readableStream","data","Readable","push","insertContentType","metaData","filePath","toLowerCase","prependXAMZMeta","mapKeys","value","isAmzHeader","isSupportedHeader","isStorageClassHeader","temp","startsWith","supported_headers","extractMetadata","headers","pickBy","lower","getVersionId","getSourceVersionId","sanitizeETag","etag","replaceChars","m","toMd5","payload","createHash","update","digest","toSha256","toArray","param","Array","isArray","sanitizeObjectKey","asStrName","decodeURIComponent","sanitizeSize","size","Number","parseInt","PART_CONSTRAINTS","ABS_MIN_PART_SIZE","MIN_PART_SIZE","MAX_PARTS_COUNT","MAX_PART_SIZE","MAX_SINGLE_PUT_OBJECT_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","exports","GENERIC_SSE_HEADER","ENCRYPTION_HEADERS","sseGenericHeader","sseKmsKeyID","getEncryptionHeaders","encConfig","encType","type","ENCRYPTION_TYPES","SSEC","KMS","SSEAlgorithm","KMSMasterKeyID","partsRequired","maxPartSize","requiredPartSize","Math","trunc","calculateEvenSplits","objInfo","reqParts","startIndexParts","endIndexParts","start","Start","divisorValue","reminderValue","nextStart","i","curPartSize","currentStart","currentEnd","startIndex","endIndex","fxp","XMLParser","parseXml","xml","result","parse","Error"],"sources":["helper.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as crypto from 'node:crypto'\nimport * as stream from 'node:stream'\n\nimport { XMLParser } from 'fast-xml-parser'\nimport ipaddr from 'ipaddr.js'\nimport _ from 'lodash'\nimport * as mime from 'mime-types'\n\nimport type { Binary, Encryption, ObjectMetaData, RequestHeaders, ResponseHeader } from './type.ts'\nimport { ENCRYPTION_TYPES } from './type.ts'\n\nconst MetaDataHeaderPrefix = 'x-amz-meta-'\n\n/**\n * All characters in string which are NOT unreserved should be percent encoded.\n * Unreserved characters are : ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\n * Reference https://tools.ietf.org/html/rfc3986#section-2.2\n */\nexport function uriEscape(string: string) {\n  return string.split('').reduce((acc: string, elem: string) => {\n    const buf = Buffer.from(elem)\n    if (buf.length === 1) {\n      // length 1 indicates that elem is not a unicode character.\n      // Check if it is an unreserved characer.\n      if (\n        ('A' <= elem && elem <= 'Z') ||\n        ('a' <= elem && elem <= 'z') ||\n        ('0' <= elem && elem <= '9') ||\n        elem === '_' ||\n        elem === '.' ||\n        elem === '~' ||\n        elem === '-'\n      ) {\n        // Unreserved characer should not be encoded.\n        acc = acc + elem\n        return acc\n      }\n    }\n    // elem needs encoding - i.e elem should be encoded if it's not unreserved\n    // character or if it's a unicode character.\n    for (const char of buf) {\n      acc = acc + '%' + char.toString(16).toUpperCase()\n    }\n    return acc\n  }, '')\n}\n\nexport function uriResourceEscape(string: string) {\n  return uriEscape(string).replace(/%2F/g, '/')\n}\n\nexport function getScope(region: string, date: Date, serviceName = 's3') {\n  return `${makeDateShort(date)}/${region}/${serviceName}/aws4_request`\n}\n\n/**\n * isAmazonEndpoint - true if endpoint is 's3.amazonaws.com' or 's3.cn-north-1.amazonaws.com.cn'\n */\nexport function isAmazonEndpoint(endpoint: string) {\n  return endpoint === 's3.amazonaws.com' || endpoint === 's3.cn-north-1.amazonaws.com.cn'\n}\n\n/**\n * isVirtualHostStyle - verify if bucket name is support with virtual\n * hosts. bucketNames with periods should be always treated as path\n * style if the protocol is 'https:', this is due to SSL wildcard\n * limitation. For all other buckets and Amazon S3 endpoint we will\n * default to virtual host style.\n */\nexport function isVirtualHostStyle(endpoint: string, protocol: string, bucket: string, pathStyle: boolean) {\n  if (protocol === 'https:' && bucket.includes('.')) {\n    return false\n  }\n  return isAmazonEndpoint(endpoint) || !pathStyle\n}\n\nexport function isValidIP(ip: string) {\n  return ipaddr.isValid(ip)\n}\n\n/**\n * @returns if endpoint is valid domain.\n */\nexport function isValidEndpoint(endpoint: string) {\n  return isValidDomain(endpoint) || isValidIP(endpoint)\n}\n\n/**\n * @returns if input host is a valid domain.\n */\nexport function isValidDomain(host: string) {\n  if (!isString(host)) {\n    return false\n  }\n  // See RFC 1035, RFC 3696.\n  if (host.length === 0 || host.length > 255) {\n    return false\n  }\n  // Host cannot start or end with a '-'\n  if (host[0] === '-' || host.slice(-1) === '-') {\n    return false\n  }\n  // Host cannot start or end with a '_'\n  if (host[0] === '_' || host.slice(-1) === '_') {\n    return false\n  }\n  // Host cannot start with a '.'\n  if (host[0] === '.') {\n    return false\n  }\n\n  const alphaNumerics = '`~!@#$%^&*()+={}[]|\\\\\"\\';:><?/'\n  // All non alphanumeric characters are invalid.\n  for (const char of alphaNumerics) {\n    if (host.includes(char)) {\n      return false\n    }\n  }\n  // No need to regexp match, since the list is non-exhaustive.\n  // We let it be valid and fail later.\n  return true\n}\n\n/**\n * Probes contentType using file extensions.\n *\n * @example\n * ```\n * // return 'image/png'\n * probeContentType('file.png')\n * ```\n */\nexport function probeContentType(path: string) {\n  let contentType = mime.lookup(path)\n  if (!contentType) {\n    contentType = 'application/octet-stream'\n  }\n  return contentType\n}\n\n/**\n * is input port valid.\n */\nexport function isValidPort(port: unknown): port is number {\n  // verify if port is a number.\n  if (!isNumber(port)) {\n    return false\n  }\n\n  // port `0` is valid and special case\n  return 0 <= port && port <= 65535\n}\n\nexport function isValidBucketName(bucket: unknown) {\n  if (!isString(bucket)) {\n    return false\n  }\n\n  // bucket length should be less than and no more than 63\n  // characters long.\n  if (bucket.length < 3 || bucket.length > 63) {\n    return false\n  }\n  // bucket with successive periods is invalid.\n  if (bucket.includes('..')) {\n    return false\n  }\n  // bucket cannot have ip address style.\n  if (/[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+/.test(bucket)) {\n    return false\n  }\n  // bucket should begin with alphabet/number and end with alphabet/number,\n  // with alphabet/number/.- in the middle.\n  if (/^[a-z0-9][a-z0-9.-]+[a-z0-9]$/.test(bucket)) {\n    return true\n  }\n  return false\n}\n\n/**\n * check if objectName is a valid object name\n */\nexport function isValidObjectName(objectName: unknown) {\n  if (!isValidPrefix(objectName)) {\n    return false\n  }\n\n  return objectName.length !== 0\n}\n\n/**\n * check if prefix is valid\n */\nexport function isValidPrefix(prefix: unknown): prefix is string {\n  if (!isString(prefix)) {\n    return false\n  }\n  if (prefix.length > 1024) {\n    return false\n  }\n  return true\n}\n\n/**\n * check if typeof arg number\n */\nexport function isNumber(arg: unknown): arg is number {\n  return typeof arg === 'number'\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyFunction = (...args: any[]) => any\n\n/**\n * check if typeof arg function\n */\nexport function isFunction(arg: unknown): arg is AnyFunction {\n  return typeof arg === 'function'\n}\n\n/**\n * check if typeof arg string\n */\nexport function isString(arg: unknown): arg is string {\n  return typeof arg === 'string'\n}\n\n/**\n * check if typeof arg object\n */\nexport function isObject(arg: unknown): arg is object {\n  return typeof arg === 'object' && arg !== null\n}\n\n/**\n * check if object is readable stream\n */\nexport function isReadableStream(arg: unknown): arg is stream.Readable {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  return isObject(arg) && isFunction((arg as stream.Readable)._read)\n}\n\n/**\n * check if arg is boolean\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean'\n}\n\nexport function isEmpty(o: unknown): o is null | undefined {\n  return _.isEmpty(o)\n}\n\nexport function isEmptyObject(o: Record<string, unknown>): boolean {\n  return Object.values(o).filter((x) => x !== undefined).length !== 0\n}\n\nexport function isDefined<T>(o: T): o is Exclude<T, null | undefined> {\n  return o !== null && o !== undefined\n}\n\n/**\n * check if arg is a valid date\n */\nexport function isValidDate(arg: unknown): arg is Date {\n  // @ts-expect-error checknew Date(Math.NaN)\n  return arg instanceof Date && !isNaN(arg)\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDDTHHmmss' + Z\n */\nexport function makeDateLong(date?: Date): string {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 13) + s.slice(14, 16) + s.slice(17, 19) + 'Z'\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDD'\n */\nexport function makeDateShort(date?: Date) {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 10)\n}\n\n/**\n * pipesetup sets up pipe() from left to right os streams array\n * pipesetup will also make sure that error emitted at any of the upstream Stream\n * will be emitted at the last stream. This makes error handling simple\n */\nexport function pipesetup(...streams: [stream.Readable, ...stream.Duplex[], stream.Writable]) {\n  // @ts-expect-error ts can't narrow this\n  return streams.reduce((src: stream.Readable, dst: stream.Writable) => {\n    src.on('error', (err) => dst.emit('error', err))\n    return src.pipe(dst)\n  })\n}\n\n/**\n * return a Readable stream that emits data\n */\nexport function readableStream(data: unknown): stream.Readable {\n  const s = new stream.Readable()\n  s._read = () => {}\n  s.push(data)\n  s.push(null)\n  return s\n}\n\n/**\n * Process metadata to insert appropriate value to `content-type` attribute\n */\nexport function insertContentType(metaData: ObjectMetaData, filePath: string): ObjectMetaData {\n  // check if content-type attribute present in metaData\n  for (const key in metaData) {\n    if (key.toLowerCase() === 'content-type') {\n      return metaData\n    }\n  }\n\n  // if `content-type` attribute is not present in metadata, then infer it from the extension in filePath\n  return {\n    ...metaData,\n    'content-type': probeContentType(filePath),\n  }\n}\n\n/**\n * Function prepends metadata with the appropriate prefix if it is not already on\n */\nexport function prependXAMZMeta(metaData?: ObjectMetaData): RequestHeaders {\n  if (!metaData) {\n    return {}\n  }\n\n  return _.mapKeys(metaData, (value, key) => {\n    if (isAmzHeader(key) || isSupportedHeader(key) || isStorageClassHeader(key)) {\n      return key\n    }\n\n    return MetaDataHeaderPrefix + key\n  })\n}\n\n/**\n * Checks if it is a valid header according to the AmazonS3 API\n */\nexport function isAmzHeader(key: string) {\n  const temp = key.toLowerCase()\n  return (\n    temp.startsWith(MetaDataHeaderPrefix) ||\n    temp === 'x-amz-acl' ||\n    temp.startsWith('x-amz-server-side-encryption-') ||\n    temp === 'x-amz-server-side-encryption'\n  )\n}\n\n/**\n * Checks if it is a supported Header\n */\nexport function isSupportedHeader(key: string) {\n  const supported_headers = [\n    'content-type',\n    'cache-control',\n    'content-encoding',\n    'content-disposition',\n    'content-language',\n    'x-amz-website-redirect-location',\n  ]\n  return supported_headers.includes(key.toLowerCase())\n}\n\n/**\n * Checks if it is a storage header\n */\nexport function isStorageClassHeader(key: string) {\n  return key.toLowerCase() === 'x-amz-storage-class'\n}\n\nexport function extractMetadata(headers: ResponseHeader) {\n  return _.mapKeys(\n    _.pickBy(headers, (value, key) => isSupportedHeader(key) || isStorageClassHeader(key) || isAmzHeader(key)),\n    (value, key) => {\n      const lower = key.toLowerCase()\n      if (lower.startsWith(MetaDataHeaderPrefix)) {\n        return lower.slice(MetaDataHeaderPrefix.length)\n      }\n\n      return key\n    },\n  )\n}\n\nexport function getVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-version-id'] || null\n}\n\nexport function getSourceVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-copy-source-version-id'] || null\n}\n\nexport function sanitizeETag(etag = ''): string {\n  const replaceChars: Record<string, string> = {\n    '\"': '',\n    '&quot;': '',\n    '&#34;': '',\n    '&QUOT;': '',\n    '&#x00022': '',\n  }\n  return etag.replace(/^(\"|&quot;|&#34;)|(\"|&quot;|&#34;)$/g, (m) => replaceChars[m] as string)\n}\n\nexport function toMd5(payload: Binary): string {\n  // use string from browser and buffer from nodejs\n  // browser support is tested only against minio server\n  return crypto.createHash('md5').update(Buffer.from(payload)).digest().toString('base64')\n}\n\nexport function toSha256(payload: Binary): string {\n  return crypto.createHash('sha256').update(payload).digest('hex')\n}\n\n/**\n * toArray returns a single element array with param being the element,\n * if param is just a string, and returns 'param' back if it is an array\n * So, it makes sure param is always an array\n */\nexport function toArray<T = unknown>(param: T | T[]): Array<T> {\n  if (!Array.isArray(param)) {\n    return [param] as T[]\n  }\n  return param\n}\n\nexport function sanitizeObjectKey(objectName: string): string {\n  // + symbol characters are not decoded as spaces in JS. so replace them first and decode to get the correct result.\n  const asStrName = (objectName ? objectName.toString() : '').replace(/\\+/g, ' ')\n  return decodeURIComponent(asStrName)\n}\n\nexport function sanitizeSize(size?: string): number | undefined {\n  return size ? Number.parseInt(size) : undefined\n}\n\nexport const PART_CONSTRAINTS = {\n  // absMinPartSize - absolute minimum part size (5 MiB)\n  ABS_MIN_PART_SIZE: 1024 * 1024 * 5,\n  // MIN_PART_SIZE - minimum part size 16MiB per object after which\n  MIN_PART_SIZE: 1024 * 1024 * 16,\n  // MAX_PARTS_COUNT - maximum number of parts for a single multipart session.\n  MAX_PARTS_COUNT: 10000,\n  // MAX_PART_SIZE - maximum part size 5GiB for a single multipart upload\n  // operation.\n  MAX_PART_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_SINGLE_PUT_OBJECT_SIZE - maximum size 5GiB of object per PUT\n  // operation.\n  MAX_SINGLE_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_MULTIPART_PUT_OBJECT_SIZE - maximum size 5TiB of object for\n  // Multipart operation.\n  MAX_MULTIPART_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 1024 * 5,\n}\n\nconst GENERIC_SSE_HEADER = 'X-Amz-Server-Side-Encryption'\n\nconst ENCRYPTION_HEADERS = {\n  // sseGenericHeader is the AWS SSE header used for SSE-S3 and SSE-KMS.\n  sseGenericHeader: GENERIC_SSE_HEADER,\n  // sseKmsKeyID is the AWS SSE-KMS key id.\n  sseKmsKeyID: GENERIC_SSE_HEADER + '-Aws-Kms-Key-Id',\n} as const\n\n/**\n * Return Encryption headers\n * @param encConfig\n * @returns an object with key value pairs that can be used in headers.\n */\nexport function getEncryptionHeaders(encConfig: Encryption): RequestHeaders {\n  const encType = encConfig.type\n\n  if (!isEmpty(encType)) {\n    if (encType === ENCRYPTION_TYPES.SSEC) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: 'AES256',\n      }\n    } else if (encType === ENCRYPTION_TYPES.KMS) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: encConfig.SSEAlgorithm,\n        [ENCRYPTION_HEADERS.sseKmsKeyID]: encConfig.KMSMasterKeyID,\n      }\n    }\n  }\n\n  return {}\n}\n\nexport function partsRequired(size: number): number {\n  const maxPartSize = PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE / (PART_CONSTRAINTS.MAX_PARTS_COUNT - 1)\n  let requiredPartSize = size / maxPartSize\n  if (size % maxPartSize > 0) {\n    requiredPartSize++\n  }\n  requiredPartSize = Math.trunc(requiredPartSize)\n  return requiredPartSize\n}\n\n/**\n * calculateEvenSplits - computes splits for a source and returns\n * start and end index slices. Splits happen evenly to be sure that no\n * part is less than 5MiB, as that could fail the multipart request if\n * it is not the last part.\n */\nexport function calculateEvenSplits<T extends { Start?: number }>(\n  size: number,\n  objInfo: T,\n): {\n  startIndex: number[]\n  objInfo: T\n  endIndex: number[]\n} | null {\n  if (size === 0) {\n    return null\n  }\n  const reqParts = partsRequired(size)\n  const startIndexParts: number[] = []\n  const endIndexParts: number[] = []\n\n  let start = objInfo.Start\n  if (isEmpty(start) || start === -1) {\n    start = 0\n  }\n  const divisorValue = Math.trunc(size / reqParts)\n\n  const reminderValue = size % reqParts\n\n  let nextStart = start\n\n  for (let i = 0; i < reqParts; i++) {\n    let curPartSize = divisorValue\n    if (i < reminderValue) {\n      curPartSize++\n    }\n\n    const currentStart = nextStart\n    const currentEnd = currentStart + curPartSize - 1\n    nextStart = currentEnd + 1\n\n    startIndexParts.push(currentStart)\n    endIndexParts.push(currentEnd)\n  }\n\n  return { startIndex: startIndexParts, endIndex: endIndexParts, objInfo: objInfo }\n}\n\nconst fxp = new XMLParser()\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function parseXml(xml: string): any {\n  const result = fxp.parse(xml)\n  if (result.Error) {\n    throw result.Error\n  }\n\n  return result\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["crypto","_interopRequireWildcard","require","stream","_fastXmlParser","_ipaddr","_lodash","mime","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","MetaDataHeaderPrefix","uriEscape","string","split","reduce","acc","elem","buf","Buffer","from","length","char","toString","toUpperCase","uriResourceEscape","replace","getScope","region","date","serviceName","makeDateShort","isAmazonEndpoint","endpoint","isVirtualHostStyle","protocol","bucket","pathStyle","includes","isValidIP","ip","ipaddr","isValid","isValidEndpoint","isValidDomain","host","isString","slice","alphaNumerics","probeContentType","path","contentType","lookup","isValidPort","port","isNumber","isValidBucketName","test","isValidObjectName","objectName","isValidPrefix","prefix","arg","isFunction","isObject","isReadableStream","_read","isBoolean","isEmpty","o","_","isEmptyObject","values","filter","x","undefined","isDefined","isValidDate","Date","isNaN","makeDateLong","s","toISOString","pipesetup","streams","src","dst","on","err","emit","pipe","readableStream","data","Readable","push","insertContentType","metaData","filePath","toLowerCase","prependXAMZMeta","mapKeys","value","isAmzHeader","isSupportedHeader","isStorageClassHeader","temp","startsWith","supported_headers","extractMetadata","headers","pickBy","lower","getVersionId","getSourceVersionId","sanitizeETag","etag","replaceChars","m","toMd5","payload","createHash","update","digest","toSha256","toArray","param","Array","isArray","sanitizeObjectKey","asStrName","decodeURIComponent","PART_CONSTRAINTS","ABS_MIN_PART_SIZE","MIN_PART_SIZE","MAX_PARTS_COUNT","MAX_PART_SIZE","MAX_SINGLE_PUT_OBJECT_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","exports","GENERIC_SSE_HEADER","ENCRYPTION_HEADERS","sseGenericHeader","sseKmsKeyID","getEncryptionHeaders","encConfig","encType","type","ENCRYPTION_TYPES","SSEC","KMS","SSEAlgorithm","KMSMasterKeyID","partsRequired","size","maxPartSize","requiredPartSize","Math","trunc","calculateEvenSplits","objInfo","reqParts","startIndexParts","endIndexParts","start","Start","divisorValue","reminderValue","nextStart","i","curPartSize","currentStart","currentEnd","startIndex","endIndex","fxp","XMLParser","parseXml","xml","result","parse","Error"],"sources":["helper.ts"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as crypto from 'node:crypto'\nimport * as stream from 'node:stream'\n\nimport { XMLParser } from 'fast-xml-parser'\nimport ipaddr from 'ipaddr.js'\nimport _ from 'lodash'\nimport * as mime from 'mime-types'\n\nimport type { Binary, Encryption, ObjectMetaData, RequestHeaders, ResponseHeader } from './type.ts'\nimport { ENCRYPTION_TYPES } from './type.ts'\n\nconst MetaDataHeaderPrefix = 'x-amz-meta-'\n\n/**\n * All characters in string which are NOT unreserved should be percent encoded.\n * Unreserved characters are : ALPHA / DIGIT / \"-\" / \".\" / \"_\" / \"~\"\n * Reference https://tools.ietf.org/html/rfc3986#section-2.2\n */\nexport function uriEscape(string: string) {\n  return string.split('').reduce((acc: string, elem: string) => {\n    const buf = Buffer.from(elem)\n    if (buf.length === 1) {\n      // length 1 indicates that elem is not a unicode character.\n      // Check if it is an unreserved characer.\n      if (\n        ('A' <= elem && elem <= 'Z') ||\n        ('a' <= elem && elem <= 'z') ||\n        ('0' <= elem && elem <= '9') ||\n        elem === '_' ||\n        elem === '.' ||\n        elem === '~' ||\n        elem === '-'\n      ) {\n        // Unreserved characer should not be encoded.\n        acc = acc + elem\n        return acc\n      }\n    }\n    // elem needs encoding - i.e elem should be encoded if it's not unreserved\n    // character or if it's a unicode character.\n    for (const char of buf) {\n      acc = acc + '%' + char.toString(16).toUpperCase()\n    }\n    return acc\n  }, '')\n}\n\nexport function uriResourceEscape(string: string) {\n  return uriEscape(string).replace(/%2F/g, '/')\n}\n\nexport function getScope(region: string, date: Date, serviceName = 's3') {\n  return `${makeDateShort(date)}/${region}/${serviceName}/aws4_request`\n}\n\n/**\n * isAmazonEndpoint - true if endpoint is 's3.amazonaws.com' or 's3.cn-north-1.amazonaws.com.cn'\n */\nexport function isAmazonEndpoint(endpoint: string) {\n  return endpoint === 's3.amazonaws.com' || endpoint === 's3.cn-north-1.amazonaws.com.cn'\n}\n\n/**\n * isVirtualHostStyle - verify if bucket name is support with virtual\n * hosts. bucketNames with periods should be always treated as path\n * style if the protocol is 'https:', this is due to SSL wildcard\n * limitation. For all other buckets and Amazon S3 endpoint we will\n * default to virtual host style.\n */\nexport function isVirtualHostStyle(endpoint: string, protocol: string, bucket: string, pathStyle: boolean) {\n  if (protocol === 'https:' && bucket.includes('.')) {\n    return false\n  }\n  return isAmazonEndpoint(endpoint) || !pathStyle\n}\n\nexport function isValidIP(ip: string) {\n  return ipaddr.isValid(ip)\n}\n\n/**\n * @returns if endpoint is valid domain.\n */\nexport function isValidEndpoint(endpoint: string) {\n  return isValidDomain(endpoint) || isValidIP(endpoint)\n}\n\n/**\n * @returns if input host is a valid domain.\n */\nexport function isValidDomain(host: string) {\n  if (!isString(host)) {\n    return false\n  }\n  // See RFC 1035, RFC 3696.\n  if (host.length === 0 || host.length > 255) {\n    return false\n  }\n  // Host cannot start or end with a '-'\n  if (host[0] === '-' || host.slice(-1) === '-') {\n    return false\n  }\n  // Host cannot start or end with a '_'\n  if (host[0] === '_' || host.slice(-1) === '_') {\n    return false\n  }\n  // Host cannot start with a '.'\n  if (host[0] === '.') {\n    return false\n  }\n\n  const alphaNumerics = '`~!@#$%^&*()+={}[]|\\\\\"\\';:><?/'\n  // All non alphanumeric characters are invalid.\n  for (const char of alphaNumerics) {\n    if (host.includes(char)) {\n      return false\n    }\n  }\n  // No need to regexp match, since the list is non-exhaustive.\n  // We let it be valid and fail later.\n  return true\n}\n\n/**\n * Probes contentType using file extensions.\n *\n * @example\n * ```\n * // return 'image/png'\n * probeContentType('file.png')\n * ```\n */\nexport function probeContentType(path: string) {\n  let contentType = mime.lookup(path)\n  if (!contentType) {\n    contentType = 'application/octet-stream'\n  }\n  return contentType\n}\n\n/**\n * is input port valid.\n */\nexport function isValidPort(port: unknown): port is number {\n  // verify if port is a number.\n  if (!isNumber(port)) {\n    return false\n  }\n\n  // port `0` is valid and special case\n  return 0 <= port && port <= 65535\n}\n\nexport function isValidBucketName(bucket: unknown) {\n  if (!isString(bucket)) {\n    return false\n  }\n\n  // bucket length should be less than and no more than 63\n  // characters long.\n  if (bucket.length < 3 || bucket.length > 63) {\n    return false\n  }\n  // bucket with successive periods is invalid.\n  if (bucket.includes('..')) {\n    return false\n  }\n  // bucket cannot have ip address style.\n  if (/[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+/.test(bucket)) {\n    return false\n  }\n  // bucket should begin with alphabet/number and end with alphabet/number,\n  // with alphabet/number/.- in the middle.\n  if (/^[a-z0-9][a-z0-9.-]+[a-z0-9]$/.test(bucket)) {\n    return true\n  }\n  return false\n}\n\n/**\n * check if objectName is a valid object name\n */\nexport function isValidObjectName(objectName: unknown) {\n  if (!isValidPrefix(objectName)) {\n    return false\n  }\n\n  return objectName.length !== 0\n}\n\n/**\n * check if prefix is valid\n */\nexport function isValidPrefix(prefix: unknown): prefix is string {\n  if (!isString(prefix)) {\n    return false\n  }\n  if (prefix.length > 1024) {\n    return false\n  }\n  return true\n}\n\n/**\n * check if typeof arg number\n */\nexport function isNumber(arg: unknown): arg is number {\n  return typeof arg === 'number'\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AnyFunction = (...args: any[]) => any\n\n/**\n * check if typeof arg function\n */\nexport function isFunction(arg: unknown): arg is AnyFunction {\n  return typeof arg === 'function'\n}\n\n/**\n * check if typeof arg string\n */\nexport function isString(arg: unknown): arg is string {\n  return typeof arg === 'string'\n}\n\n/**\n * check if typeof arg object\n */\nexport function isObject(arg: unknown): arg is object {\n  return typeof arg === 'object' && arg !== null\n}\n\n/**\n * check if object is readable stream\n */\nexport function isReadableStream(arg: unknown): arg is stream.Readable {\n  // eslint-disable-next-line @typescript-eslint/unbound-method\n  return isObject(arg) && isFunction((arg as stream.Readable)._read)\n}\n\n/**\n * check if arg is boolean\n */\nexport function isBoolean(arg: unknown): arg is boolean {\n  return typeof arg === 'boolean'\n}\n\nexport function isEmpty(o: unknown): o is null | undefined {\n  return _.isEmpty(o)\n}\n\nexport function isEmptyObject(o: Record<string, unknown>): boolean {\n  return Object.values(o).filter((x) => x !== undefined).length !== 0\n}\n\nexport function isDefined<T>(o: T): o is Exclude<T, null | undefined> {\n  return o !== null && o !== undefined\n}\n\n/**\n * check if arg is a valid date\n */\nexport function isValidDate(arg: unknown): arg is Date {\n  // @ts-expect-error checknew Date(Math.NaN)\n  return arg instanceof Date && !isNaN(arg)\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDDTHHmmss' + Z\n */\nexport function makeDateLong(date?: Date): string {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 13) + s.slice(14, 16) + s.slice(17, 19) + 'Z'\n}\n\n/**\n * Create a Date string with format: 'YYYYMMDD'\n */\nexport function makeDateShort(date?: Date) {\n  date = date || new Date()\n\n  // Gives format like: '2017-08-07T16:28:59.889Z'\n  const s = date.toISOString()\n\n  return s.slice(0, 4) + s.slice(5, 7) + s.slice(8, 10)\n}\n\n/**\n * pipesetup sets up pipe() from left to right os streams array\n * pipesetup will also make sure that error emitted at any of the upstream Stream\n * will be emitted at the last stream. This makes error handling simple\n */\nexport function pipesetup(...streams: [stream.Readable, ...stream.Duplex[], stream.Writable]) {\n  // @ts-expect-error ts can't narrow this\n  return streams.reduce((src: stream.Readable, dst: stream.Writable) => {\n    src.on('error', (err) => dst.emit('error', err))\n    return src.pipe(dst)\n  })\n}\n\n/**\n * return a Readable stream that emits data\n */\nexport function readableStream(data: unknown): stream.Readable {\n  const s = new stream.Readable()\n  s._read = () => {}\n  s.push(data)\n  s.push(null)\n  return s\n}\n\n/**\n * Process metadata to insert appropriate value to `content-type` attribute\n */\nexport function insertContentType(metaData: ObjectMetaData, filePath: string): ObjectMetaData {\n  // check if content-type attribute present in metaData\n  for (const key in metaData) {\n    if (key.toLowerCase() === 'content-type') {\n      return metaData\n    }\n  }\n\n  // if `content-type` attribute is not present in metadata, then infer it from the extension in filePath\n  return {\n    ...metaData,\n    'content-type': probeContentType(filePath),\n  }\n}\n\n/**\n * Function prepends metadata with the appropriate prefix if it is not already on\n */\nexport function prependXAMZMeta(metaData?: ObjectMetaData): RequestHeaders {\n  if (!metaData) {\n    return {}\n  }\n\n  return _.mapKeys(metaData, (value, key) => {\n    if (isAmzHeader(key) || isSupportedHeader(key) || isStorageClassHeader(key)) {\n      return key\n    }\n\n    return MetaDataHeaderPrefix + key\n  })\n}\n\n/**\n * Checks if it is a valid header according to the AmazonS3 API\n */\nexport function isAmzHeader(key: string) {\n  const temp = key.toLowerCase()\n  return (\n    temp.startsWith(MetaDataHeaderPrefix) ||\n    temp === 'x-amz-acl' ||\n    temp.startsWith('x-amz-server-side-encryption-') ||\n    temp === 'x-amz-server-side-encryption'\n  )\n}\n\n/**\n * Checks if it is a supported Header\n */\nexport function isSupportedHeader(key: string) {\n  const supported_headers = [\n    'content-type',\n    'cache-control',\n    'content-encoding',\n    'content-disposition',\n    'content-language',\n    'x-amz-website-redirect-location',\n  ]\n  return supported_headers.includes(key.toLowerCase())\n}\n\n/**\n * Checks if it is a storage header\n */\nexport function isStorageClassHeader(key: string) {\n  return key.toLowerCase() === 'x-amz-storage-class'\n}\n\nexport function extractMetadata(headers: ResponseHeader) {\n  return _.mapKeys(\n    _.pickBy(headers, (value, key) => isSupportedHeader(key) || isStorageClassHeader(key) || isAmzHeader(key)),\n    (value, key) => {\n      const lower = key.toLowerCase()\n      if (lower.startsWith(MetaDataHeaderPrefix)) {\n        return lower.slice(MetaDataHeaderPrefix.length)\n      }\n\n      return key\n    },\n  )\n}\n\nexport function getVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-version-id'] || null\n}\n\nexport function getSourceVersionId(headers: ResponseHeader = {}) {\n  return headers['x-amz-copy-source-version-id'] || null\n}\n\nexport function sanitizeETag(etag = ''): string {\n  const replaceChars: Record<string, string> = {\n    '\"': '',\n    '&quot;': '',\n    '&#34;': '',\n    '&QUOT;': '',\n    '&#x00022': '',\n  }\n  return etag.replace(/^(\"|&quot;|&#34;)|(\"|&quot;|&#34;)$/g, (m) => replaceChars[m] as string)\n}\n\nexport function toMd5(payload: Binary): string {\n  // use string from browser and buffer from nodejs\n  // browser support is tested only against minio server\n  return crypto.createHash('md5').update(Buffer.from(payload)).digest().toString('base64')\n}\n\nexport function toSha256(payload: Binary): string {\n  return crypto.createHash('sha256').update(payload).digest('hex')\n}\n\n/**\n * toArray returns a single element array with param being the element,\n * if param is just a string, and returns 'param' back if it is an array\n * So, it makes sure param is always an array\n */\nexport function toArray<T = unknown>(param: T | T[]): Array<T> {\n  if (!Array.isArray(param)) {\n    return [param] as T[]\n  }\n  return param\n}\n\nexport function sanitizeObjectKey(objectName: string): string {\n  // + symbol characters are not decoded as spaces in JS. so replace them first and decode to get the correct result.\n  const asStrName = (objectName ? objectName.toString() : '').replace(/\\+/g, ' ')\n  return decodeURIComponent(asStrName)\n}\n\nexport const PART_CONSTRAINTS = {\n  // absMinPartSize - absolute minimum part size (5 MiB)\n  ABS_MIN_PART_SIZE: 1024 * 1024 * 5,\n  // MIN_PART_SIZE - minimum part size 16MiB per object after which\n  MIN_PART_SIZE: 1024 * 1024 * 16,\n  // MAX_PARTS_COUNT - maximum number of parts for a single multipart session.\n  MAX_PARTS_COUNT: 10000,\n  // MAX_PART_SIZE - maximum part size 5GiB for a single multipart upload\n  // operation.\n  MAX_PART_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_SINGLE_PUT_OBJECT_SIZE - maximum size 5GiB of object per PUT\n  // operation.\n  MAX_SINGLE_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 5,\n  // MAX_MULTIPART_PUT_OBJECT_SIZE - maximum size 5TiB of object for\n  // Multipart operation.\n  MAX_MULTIPART_PUT_OBJECT_SIZE: 1024 * 1024 * 1024 * 1024 * 5,\n}\n\nconst GENERIC_SSE_HEADER = 'X-Amz-Server-Side-Encryption'\n\nconst ENCRYPTION_HEADERS = {\n  // sseGenericHeader is the AWS SSE header used for SSE-S3 and SSE-KMS.\n  sseGenericHeader: GENERIC_SSE_HEADER,\n  // sseKmsKeyID is the AWS SSE-KMS key id.\n  sseKmsKeyID: GENERIC_SSE_HEADER + '-Aws-Kms-Key-Id',\n} as const\n\n/**\n * Return Encryption headers\n * @param encConfig\n * @returns an object with key value pairs that can be used in headers.\n */\nexport function getEncryptionHeaders(encConfig: Encryption): RequestHeaders {\n  const encType = encConfig.type\n\n  if (!isEmpty(encType)) {\n    if (encType === ENCRYPTION_TYPES.SSEC) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: 'AES256',\n      }\n    } else if (encType === ENCRYPTION_TYPES.KMS) {\n      return {\n        [ENCRYPTION_HEADERS.sseGenericHeader]: encConfig.SSEAlgorithm,\n        [ENCRYPTION_HEADERS.sseKmsKeyID]: encConfig.KMSMasterKeyID,\n      }\n    }\n  }\n\n  return {}\n}\n\nexport function partsRequired(size: number): number {\n  const maxPartSize = PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE / (PART_CONSTRAINTS.MAX_PARTS_COUNT - 1)\n  let requiredPartSize = size / maxPartSize\n  if (size % maxPartSize > 0) {\n    requiredPartSize++\n  }\n  requiredPartSize = Math.trunc(requiredPartSize)\n  return requiredPartSize\n}\n\n/**\n * calculateEvenSplits - computes splits for a source and returns\n * start and end index slices. Splits happen evenly to be sure that no\n * part is less than 5MiB, as that could fail the multipart request if\n * it is not the last part.\n */\nexport function calculateEvenSplits<T extends { Start?: number }>(\n  size: number,\n  objInfo: T,\n): {\n  startIndex: number[]\n  objInfo: T\n  endIndex: number[]\n} | null {\n  if (size === 0) {\n    return null\n  }\n  const reqParts = partsRequired(size)\n  const startIndexParts: number[] = []\n  const endIndexParts: number[] = []\n\n  let start = objInfo.Start\n  if (isEmpty(start) || start === -1) {\n    start = 0\n  }\n  const divisorValue = Math.trunc(size / reqParts)\n\n  const reminderValue = size % reqParts\n\n  let nextStart = start\n\n  for (let i = 0; i < reqParts; i++) {\n    let curPartSize = divisorValue\n    if (i < reminderValue) {\n      curPartSize++\n    }\n\n    const currentStart = nextStart\n    const currentEnd = currentStart + curPartSize - 1\n    nextStart = currentEnd + 1\n\n    startIndexParts.push(currentStart)\n    endIndexParts.push(currentEnd)\n  }\n\n  return { startIndex: startIndexParts, endIndex: endIndexParts, objInfo: objInfo }\n}\n\nconst fxp = new XMLParser()\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function parseXml(xml: string): any {\n  const result = fxp.parse(xml)\n  if (result.Error) {\n    throw result.Error\n  }\n\n  return result\n}\n"],"mappings":"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"} /***/ }), @@ -78474,72 +81109,6 @@ exports.PostPolicy = PostPolicy; /***/ }), -/***/ 9093: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.request = request; -var _stream = __nccwpck_require__(2781); -async function request(transport, opt, body = null) { - return new Promise((resolve, reject) => { - const requestObj = transport.request(opt, resp => { - resolve(resp); - }); - if (!body || Buffer.isBuffer(body) || typeof body === 'string') { - requestObj.on('error', e => { - reject(e); - }).end(body); - return; - } - - // pump readable stream - (0, _stream.pipeline)(body, requestObj, err => { - if (err) { - reject(err); - } - }); - }); -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 - -/***/ }), - -/***/ 2644: -/***/ ((__unused_webpack_module, exports) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.drainResponse = drainResponse; -exports.readAsBuffer = readAsBuffer; -exports.readAsString = readAsString; -async function readAsBuffer(res) { - return new Promise((resolve, reject) => { - const body = []; - res.on('data', chunk => body.push(chunk)).on('error', e => reject(e)).on('end', () => resolve(Buffer.concat(body))); - }); -} -async function readAsString(res) { - const body = await readAsBuffer(res); - return body.toString(); -} -async function drainResponse(res) { - return new Promise((resolve, reject) => { - res.on('data', () => {}).on('error', e => reject(e)).on('end', () => resolve()); - }); -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 - -/***/ }), - /***/ 6314: /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { @@ -78636,249 +81205,8 @@ let LEGAL_HOLD_STATUS = /*#__PURE__*/function (LEGAL_HOLD_STATUS) { LEGAL_HOLD_STATUS["DISABLED"] = "OFF"; return LEGAL_HOLD_STATUS; }({}); -/* Replication Config types */ -/* Replication Config types */ exports.LEGAL_HOLD_STATUS = LEGAL_HOLD_STATUS; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 - -/***/ }), - -/***/ 4040: -/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { - -"use strict"; - - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.parseBucketRegion = parseBucketRegion; -exports.parseError = parseError; -exports.parseInitiateMultipart = parseInitiateMultipart; -exports.parseListBucket = parseListBucket; -exports.parseListObjectsV2WithMetadata = parseListObjectsV2WithMetadata; -exports.parseListParts = parseListParts; -exports.parseReplicationConfig = parseReplicationConfig; -exports.parseResponseError = parseResponseError; -var _fastXmlParser = __nccwpck_require__(2603); -var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); -var _helper = __nccwpck_require__(9921); -var _response = __nccwpck_require__(2644); -function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } -function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } -// parse XML response for bucket region -function parseBucketRegion(xml) { - // return region information - return (0, _helper.parseXml)(xml).LocationConstraint; -} -const fxp = new _fastXmlParser.XMLParser(); - -// Parse XML and return information as Javascript types -// parse error XML response -function parseError(xml, headerInfo) { - let xmlErr = {}; - const xmlObj = fxp.parse(xml); - if (xmlObj.Error) { - xmlErr = xmlObj.Error; - } - const e = new errors.S3Error(); - Object.entries(xmlErr).forEach(([key, value]) => { - e[key.toLowerCase()] = value; - }); - Object.entries(headerInfo).forEach(([key, value]) => { - e[key] = value; - }); - return e; -} - -// Generates an Error object depending on http statusCode and XML body -async function parseResponseError(response) { - const statusCode = response.statusCode; - let code, message; - if (statusCode === 301) { - code = 'MovedPermanently'; - message = 'Moved Permanently'; - } else if (statusCode === 307) { - code = 'TemporaryRedirect'; - message = 'Are you using the correct endpoint URL?'; - } else if (statusCode === 403) { - code = 'AccessDenied'; - message = 'Valid and authorized credentials required'; - } else if (statusCode === 404) { - code = 'NotFound'; - message = 'Not Found'; - } else if (statusCode === 405) { - code = 'MethodNotAllowed'; - message = 'Method Not Allowed'; - } else if (statusCode === 501) { - code = 'MethodNotAllowed'; - message = 'Method Not Allowed'; - } else { - code = 'UnknownError'; - message = `${statusCode}`; - } - const headerInfo = {}; - // A value created by S3 compatible server that uniquely identifies the request. - headerInfo.amzRequestid = response.headers['x-amz-request-id']; - // A special token that helps troubleshoot API replies and issues. - headerInfo.amzId2 = response.headers['x-amz-id-2']; - - // Region where the bucket is located. This header is returned only - // in HEAD bucket and ListObjects response. - headerInfo.amzBucketRegion = response.headers['x-amz-bucket-region']; - const xmlString = await (0, _response.readAsString)(response); - if (xmlString) { - throw parseError(xmlString, headerInfo); - } - - // Message should be instantiated for each S3Errors. - const e = new errors.S3Error(message, { - cause: headerInfo - }); - // S3 Error code. - e.code = code; - Object.entries(headerInfo).forEach(([key, value]) => { - // @ts-expect-error force set error properties - e[key] = value; - }); - throw e; -} - -/** - * parse XML response for list objects v2 with metadata in a bucket - */ -function parseListObjectsV2WithMetadata(xml) { - const result = { - objects: [], - isTruncated: false, - nextContinuationToken: '' - }; - let xmlobj = (0, _helper.parseXml)(xml); - if (!xmlobj.ListBucketResult) { - throw new errors.InvalidXMLError('Missing tag: "ListBucketResult"'); - } - xmlobj = xmlobj.ListBucketResult; - if (xmlobj.IsTruncated) { - result.isTruncated = xmlobj.IsTruncated; - } - if (xmlobj.NextContinuationToken) { - result.nextContinuationToken = xmlobj.NextContinuationToken; - } - if (xmlobj.Contents) { - (0, _helper.toArray)(xmlobj.Contents).forEach(content => { - const name = (0, _helper.sanitizeObjectKey)(content.Key); - const lastModified = new Date(content.LastModified); - const etag = (0, _helper.sanitizeETag)(content.ETag); - const size = content.Size; - let metadata; - if (content.UserMetadata != null) { - metadata = (0, _helper.toArray)(content.UserMetadata)[0]; - } else { - metadata = null; - } - result.objects.push({ - name, - lastModified, - etag, - size, - metadata - }); - }); - } - if (xmlobj.CommonPrefixes) { - (0, _helper.toArray)(xmlobj.CommonPrefixes).forEach(commonPrefix => { - result.objects.push({ - prefix: (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(commonPrefix.Prefix)[0]), - size: 0 - }); - }); - } - return result; -} -// parse XML response for list parts of an in progress multipart upload -function parseListParts(xml) { - let xmlobj = (0, _helper.parseXml)(xml); - const result = { - isTruncated: false, - parts: [], - marker: 0 - }; - if (!xmlobj.ListPartsResult) { - throw new errors.InvalidXMLError('Missing tag: "ListPartsResult"'); - } - xmlobj = xmlobj.ListPartsResult; - if (xmlobj.IsTruncated) { - result.isTruncated = xmlobj.IsTruncated; - } - if (xmlobj.NextPartNumberMarker) { - result.marker = (0, _helper.toArray)(xmlobj.NextPartNumberMarker)[0] || ''; - } - if (xmlobj.Part) { - (0, _helper.toArray)(xmlobj.Part).forEach(p => { - const part = parseInt((0, _helper.toArray)(p.PartNumber)[0], 10); - const lastModified = new Date(p.LastModified); - const etag = p.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, ''); - result.parts.push({ - part, - lastModified, - etag, - size: parseInt(p.Size, 10) - }); - }); - } - return result; -} -function parseListBucket(xml) { - let result = []; - const parsedXmlRes = (0, _helper.parseXml)(xml); - if (!parsedXmlRes.ListAllMyBucketsResult) { - throw new errors.InvalidXMLError('Missing tag: "ListAllMyBucketsResult"'); - } - const { - ListAllMyBucketsResult: { - Buckets = {} - } = {} - } = parsedXmlRes; - if (Buckets.Bucket) { - result = (0, _helper.toArray)(Buckets.Bucket).map((bucket = {}) => { - const { - Name: bucketName, - CreationDate - } = bucket; - const creationDate = new Date(CreationDate); - return { - name: bucketName, - creationDate: creationDate - }; - }); - } - return result; -} -function parseInitiateMultipart(xml) { - let xmlobj = (0, _helper.parseXml)(xml); - if (!xmlobj.InitiateMultipartUploadResult) { - throw new errors.InvalidXMLError('Missing tag: "InitiateMultipartUploadResult"'); - } - xmlobj = xmlobj.InitiateMultipartUploadResult; - if (xmlobj.UploadId) { - return xmlobj.UploadId; - } - throw new errors.InvalidXMLError('Missing tag: "UploadId"'); -} -function parseReplicationConfig(xml) { - const xmlObj = (0, _helper.parseXml)(xml); - const { - Role, - Rule - } = xmlObj.ReplicationConfiguration; - return { - ReplicationConfiguration: { - role: Role, - rules: (0, _helper.toArray)(Rule) - } - }; -} -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_fastXmlParser","require","errors","_interopRequireWildcard","_helper","_response","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","parseBucketRegion","xml","parseXml","LocationConstraint","fxp","XMLParser","parseError","headerInfo","xmlErr","xmlObj","parse","Error","e","S3Error","entries","forEach","value","toLowerCase","parseResponseError","response","statusCode","code","message","amzRequestid","headers","amzId2","amzBucketRegion","xmlString","readAsString","cause","parseListObjectsV2WithMetadata","result","objects","isTruncated","nextContinuationToken","xmlobj","ListBucketResult","InvalidXMLError","IsTruncated","NextContinuationToken","Contents","toArray","content","name","sanitizeObjectKey","Key","lastModified","Date","LastModified","etag","sanitizeETag","ETag","size","Size","metadata","UserMetadata","push","CommonPrefixes","commonPrefix","prefix","Prefix","parseListParts","parts","marker","ListPartsResult","NextPartNumberMarker","Part","p","part","parseInt","PartNumber","replace","parseListBucket","parsedXmlRes","ListAllMyBucketsResult","Buckets","Bucket","map","bucket","Name","bucketName","CreationDate","creationDate","parseInitiateMultipart","InitiateMultipartUploadResult","UploadId","parseReplicationConfig","Role","Rule","ReplicationConfiguration","role","rules"],"sources":["xml-parser.ts"],"sourcesContent":["import type * as http from 'node:http'\n\nimport { XMLParser } from 'fast-xml-parser'\n\nimport * as errors from '../errors.ts'\nimport { parseXml, sanitizeETag, sanitizeObjectKey, toArray } from './helper.ts'\nimport { readAsString } from './response.ts'\nimport type { BucketItemFromList, BucketItemWithMetadata, ReplicationConfig } from './type.ts'\n\n// parse XML response for bucket region\nexport function parseBucketRegion(xml: string): string {\n  // return region information\n  return parseXml(xml).LocationConstraint\n}\n\nconst fxp = new XMLParser()\n\n// Parse XML and return information as Javascript types\n// parse error XML response\nexport function parseError(xml: string, headerInfo: Record<string, unknown>) {\n  let xmlErr = {}\n  const xmlObj = fxp.parse(xml)\n  if (xmlObj.Error) {\n    xmlErr = xmlObj.Error\n  }\n  const e = new errors.S3Error() as unknown as Record<string, unknown>\n  Object.entries(xmlErr).forEach(([key, value]) => {\n    e[key.toLowerCase()] = value\n  })\n  Object.entries(headerInfo).forEach(([key, value]) => {\n    e[key] = value\n  })\n  return e\n}\n\n// Generates an Error object depending on http statusCode and XML body\nexport async function parseResponseError(response: http.IncomingMessage) {\n  const statusCode = response.statusCode\n  let code: string, message: string\n  if (statusCode === 301) {\n    code = 'MovedPermanently'\n    message = 'Moved Permanently'\n  } else if (statusCode === 307) {\n    code = 'TemporaryRedirect'\n    message = 'Are you using the correct endpoint URL?'\n  } else if (statusCode === 403) {\n    code = 'AccessDenied'\n    message = 'Valid and authorized credentials required'\n  } else if (statusCode === 404) {\n    code = 'NotFound'\n    message = 'Not Found'\n  } else if (statusCode === 405) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else if (statusCode === 501) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else {\n    code = 'UnknownError'\n    message = `${statusCode}`\n  }\n  const headerInfo: Record<string, string | undefined | null> = {}\n  // A value created by S3 compatible server that uniquely identifies the request.\n  headerInfo.amzRequestid = response.headers['x-amz-request-id'] as string | undefined\n  // A special token that helps troubleshoot API replies and issues.\n  headerInfo.amzId2 = response.headers['x-amz-id-2'] as string | undefined\n\n  // Region where the bucket is located. This header is returned only\n  // in HEAD bucket and ListObjects response.\n  headerInfo.amzBucketRegion = response.headers['x-amz-bucket-region'] as string | undefined\n\n  const xmlString = await readAsString(response)\n\n  if (xmlString) {\n    throw parseError(xmlString, headerInfo)\n  }\n\n  // Message should be instantiated for each S3Errors.\n  const e = new errors.S3Error(message, { cause: headerInfo })\n  // S3 Error code.\n  e.code = code\n  Object.entries(headerInfo).forEach(([key, value]) => {\n    // @ts-expect-error force set error properties\n    e[key] = value\n  })\n\n  throw e\n}\n\n/**\n * parse XML response for list objects v2 with metadata in a bucket\n */\nexport function parseListObjectsV2WithMetadata(xml: string) {\n  const result: {\n    objects: Array<BucketItemWithMetadata>\n    isTruncated: boolean\n    nextContinuationToken: string\n  } = {\n    objects: [],\n    isTruncated: false,\n    nextContinuationToken: '',\n  }\n\n  let xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      const name = sanitizeObjectKey(content.Key)\n      const lastModified = new Date(content.LastModified)\n      const etag = sanitizeETag(content.ETag)\n      const size = content.Size\n      let metadata\n      if (content.UserMetadata != null) {\n        metadata = toArray(content.UserMetadata)[0]\n      } else {\n        metadata = null\n      }\n      result.objects.push({ name, lastModified, etag, size, metadata })\n    })\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\nexport type Multipart = {\n  uploads: Array<{\n    key: string\n    uploadId: string\n    initiator: unknown\n    owner: unknown\n    storageClass: unknown\n    initiated: unknown\n  }>\n  prefixes: { prefix: string }[]\n  isTruncated: boolean\n  nextKeyMarker: undefined\n  nextUploadIdMarker: undefined\n}\n\nexport type UploadedPart = {\n  part: number\n  lastModified?: Date\n  etag: string\n  size: number\n}\n\n// parse XML response for list parts of an in progress multipart upload\nexport function parseListParts(xml: string): {\n  isTruncated: boolean\n  marker: number\n  parts: UploadedPart[]\n} {\n  let xmlobj = parseXml(xml)\n  const result: { isTruncated: boolean; marker: number; parts: UploadedPart[] } = {\n    isTruncated: false,\n    parts: [],\n    marker: 0,\n  }\n  if (!xmlobj.ListPartsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListPartsResult\"')\n  }\n  xmlobj = xmlobj.ListPartsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextPartNumberMarker) {\n    result.marker = toArray(xmlobj.NextPartNumberMarker)[0] || ''\n  }\n  if (xmlobj.Part) {\n    toArray(xmlobj.Part).forEach((p) => {\n      const part = parseInt(toArray(p.PartNumber)[0], 10)\n      const lastModified = new Date(p.LastModified)\n      const etag = p.ETag.replace(/^\"/g, '')\n        .replace(/\"$/g, '')\n        .replace(/^&quot;/g, '')\n        .replace(/&quot;$/g, '')\n        .replace(/^&#34;/g, '')\n        .replace(/&#34;$/g, '')\n      result.parts.push({ part, lastModified, etag, size: parseInt(p.Size, 10) })\n    })\n  }\n  return result\n}\n\nexport function parseListBucket(xml: string) {\n  let result: BucketItemFromList[] = []\n  const parsedXmlRes = parseXml(xml)\n\n  if (!parsedXmlRes.ListAllMyBucketsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListAllMyBucketsResult\"')\n  }\n  const { ListAllMyBucketsResult: { Buckets = {} } = {} } = parsedXmlRes\n\n  if (Buckets.Bucket) {\n    result = toArray(Buckets.Bucket).map((bucket = {}) => {\n      const { Name: bucketName, CreationDate } = bucket\n      const creationDate = new Date(CreationDate)\n\n      return { name: bucketName, creationDate: creationDate }\n    })\n  }\n  return result\n}\n\nexport function parseInitiateMultipart(xml: string): string {\n  let xmlobj = parseXml(xml)\n\n  if (!xmlobj.InitiateMultipartUploadResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"InitiateMultipartUploadResult\"')\n  }\n  xmlobj = xmlobj.InitiateMultipartUploadResult\n\n  if (xmlobj.UploadId) {\n    return xmlobj.UploadId\n  }\n  throw new errors.InvalidXMLError('Missing tag: \"UploadId\"')\n}\n\nexport function parseReplicationConfig(xml: string): ReplicationConfig {\n  const xmlObj = parseXml(xml)\n  const { Role, Rule } = xmlObj.ReplicationConfiguration\n  return {\n    ReplicationConfiguration: {\n      role: Role,\n      rules: toArray(Rule),\n    },\n  }\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 /***/ }), @@ -78907,6 +81235,7 @@ var _webEncoding = __nccwpck_require__(1430); var _xml = __nccwpck_require__(7578); var _xml2js = __nccwpck_require__(4659); var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); +var _extensions = __nccwpck_require__(2895); var _helpers = __nccwpck_require__(9455); Object.keys(_helpers).forEach(function (key) { if (key === "default" || key === "__esModule") return; @@ -78914,7 +81243,6 @@ Object.keys(_helpers).forEach(function (key) { if (key in exports && exports[key] === _helpers[key]) return; exports[key] = _helpers[key]; }); -var _callbackify = __nccwpck_require__(3826); var _client = __nccwpck_require__(5586); var _copyConditions = __nccwpck_require__(3250); exports.CopyConditions = _copyConditions.CopyConditions; @@ -79001,6 +81329,263 @@ class Client extends _client.TypedClient { } } + // log the request, response, error + logHTTP(reqOptions, response, err) { + // if no logstreamer available return. + if (!this.logStream) { + return; + } + if (!(0, _helper.isObject)(reqOptions)) { + throw new TypeError('reqOptions should be of type "object"'); + } + if (response && !(0, _helper.isReadableStream)(response)) { + throw new TypeError('response should be of type "Stream"'); + } + if (err && !(err instanceof Error)) { + throw new TypeError('err should be of type "Error"'); + } + var logHeaders = headers => { + _lodash.forEach(headers, (v, k) => { + if (k == 'authorization') { + var redacter = new RegExp('Signature=([0-9a-f]+)'); + v = v.replace(redacter, 'Signature=**REDACTED**'); + } + this.logStream.write(`${k}: ${v}\n`); + }); + this.logStream.write('\n'); + }; + this.logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\n`); + logHeaders(reqOptions.headers); + if (response) { + this.logStream.write(`RESPONSE: ${response.statusCode}\n`); + logHeaders(response.headers); + } + if (err) { + this.logStream.write('ERROR BODY:\n'); + var errJSON = JSON.stringify(err, null, '\t'); + this.logStream.write(`${errJSON}\n`); + } + } + + // Enable tracing + traceOn(stream) { + if (!stream) { + stream = process.stdout; + } + this.logStream = stream; + } + + // Disable tracing + traceOff() { + this.logStream = null; + } + + // makeRequest is the primitive used by the apis for making S3 requests. + // payload can be empty string in case of no payload. + // statusCode is the expected statusCode. If response.statusCode does not match + // we parse the XML error and call the callback with the error message. + // A valid region is passed by the calls - listBuckets, makeBucket and + // getBucketRegion. + makeRequest(options, payload, statusCodes, region, returnResponse, cb) { + if (!(0, _helper.isObject)(options)) { + throw new TypeError('options should be of type "object"'); + } + if (!(0, _helper.isString)(payload) && !(0, _helper.isObject)(payload)) { + // Buffer is of type 'object' + throw new TypeError('payload should be of type "string" or "Buffer"'); + } + statusCodes.forEach(statusCode => { + if (!(0, _helper.isNumber)(statusCode)) { + throw new TypeError('statusCode should be of type "number"'); + } + }); + if (!(0, _helper.isString)(region)) { + throw new TypeError('region should be of type "string"'); + } + if (!(0, _helper.isBoolean)(returnResponse)) { + throw new TypeError('returnResponse should be of type "boolean"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + if (!options.headers) { + options.headers = {}; + } + if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') { + options.headers['content-length'] = payload.length; + } + var sha256sum = ''; + if (this.enableSHA256) { + sha256sum = (0, _helper.toSha256)(payload); + } + var stream = (0, _helper.readableStream)(payload); + this.makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb); + } + + // makeRequestStream will be used directly instead of makeRequest in case the payload + // is available as a stream. for ex. putObject + makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb) { + if (!(0, _helper.isObject)(options)) { + throw new TypeError('options should be of type "object"'); + } + if (!(0, _helper.isReadableStream)(stream)) { + throw new errors.InvalidArgumentError('stream should be a readable Stream'); + } + if (!(0, _helper.isString)(sha256sum)) { + throw new TypeError('sha256sum should be of type "string"'); + } + statusCodes.forEach(statusCode => { + if (!(0, _helper.isNumber)(statusCode)) { + throw new TypeError('statusCode should be of type "number"'); + } + }); + if (!(0, _helper.isString)(region)) { + throw new TypeError('region should be of type "string"'); + } + if (!(0, _helper.isBoolean)(returnResponse)) { + throw new TypeError('returnResponse should be of type "boolean"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + + // sha256sum will be empty for anonymous or https requests + if (!this.enableSHA256 && sha256sum.length !== 0) { + throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`); + } + // sha256sum should be valid for non-anonymous http requests. + if (this.enableSHA256 && sha256sum.length !== 64) { + throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`); + } + var _makeRequest = (e, region) => { + if (e) { + return cb(e); + } + options.region = region; + var reqOptions = this.getRequestOptions(options); + if (!this.anonymous) { + // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation. + if (!this.enableSHA256) { + sha256sum = 'UNSIGNED-PAYLOAD'; + } + let date = new Date(); + reqOptions.headers['x-amz-date'] = (0, _helper.makeDateLong)(date); + reqOptions.headers['x-amz-content-sha256'] = sha256sum; + if (this.sessionToken) { + reqOptions.headers['x-amz-security-token'] = this.sessionToken; + } + this.checkAndRefreshCreds(); + var authorization = (0, _signing.signV4)(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum); + reqOptions.headers.authorization = authorization; + } + var req = this.transport.request(reqOptions, response => { + if (!statusCodes.includes(response.statusCode)) { + // For an incorrect region, S3 server always sends back 400. + // But we will do cache invalidation for all errors so that, + // in future, if AWS S3 decides to send a different status code or + // XML error code we will still work fine. + delete this.regionMap[options.bucketName]; + var errorTransformer = transformers.getErrorTransformer(response); + (0, _helper.pipesetup)(response, errorTransformer).on('error', e => { + this.logHTTP(reqOptions, response, e); + cb(e); + }); + return; + } + this.logHTTP(reqOptions, response); + if (returnResponse) { + return cb(null, response); + } + // We drain the socket so that the connection gets closed. Note that this + // is not expensive as the socket will not have any data. + response.on('data', () => {}); + cb(null); + }); + let pipe = (0, _helper.pipesetup)(stream, req); + pipe.on('error', e => { + this.logHTTP(reqOptions, null, e); + cb(e); + }); + }; + if (region) { + return _makeRequest(null, region); + } + this.getBucketRegion(options.bucketName, _makeRequest); + } + + // gets the region of the bucket + getBucketRegion(bucketName, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('cb should be of type "function"'); + } + + // Region is set with constructor, return the region right here. + if (this.region) { + return cb(null, this.region); + } + if (this.regionMap[bucketName]) { + return cb(null, this.regionMap[bucketName]); + } + var extractRegion = response => { + var transformer = transformers.getBucketRegionTransformer(); + var region = _helpers.DEFAULT_REGION; + (0, _helper.pipesetup)(response, transformer).on('error', cb).on('data', data => { + if (data) { + region = data; + } + }).on('end', () => { + this.regionMap[bucketName] = region; + cb(null, region); + }); + }; + var method = 'GET'; + var query = 'location'; + + // `getBucketLocation` behaves differently in following ways for + // different environments. + // + // - For nodejs env we default to path style requests. + // - For browser env path style requests on buckets yields CORS + // error. To circumvent this problem we make a virtual host + // style request signed with 'us-east-1'. This request fails + // with an error 'AuthorizationHeaderMalformed', additionally + // the error XML also provides Region of the bucket. To validate + // this region is proper we retry the same request with the newly + // obtained region. + var pathStyle = this.pathStyle && typeof window === 'undefined'; + this.makeRequest({ + method, + bucketName, + query, + pathStyle + }, '', [200], _helpers.DEFAULT_REGION, true, (e, response) => { + if (e) { + if (e.name === 'AuthorizationHeaderMalformed') { + var region = e.Region; + if (!region) { + return cb(e); + } + this.makeRequest({ + method, + bucketName, + query + }, '', [200], region, true, (e, response) => { + if (e) { + return cb(e); + } + extractRegion(response); + }); + return; + } + return cb(e); + } + extractRegion(response); + }); + } + // Creates the bucket `bucketName`. // // __Arguments__ @@ -79092,6 +81677,31 @@ class Client extends _client.TypedClient { }, payload, [200], region, false, processWithRetry); } + // List of buckets created. + // + // __Arguments__ + // * `callback(err, buckets)` _function_ - callback function with error as the first argument. `buckets` is an array of bucket information + // + // `buckets` array element: + // * `bucket.name` _string_ : bucket name + // * `bucket.creationDate` _Date_: date when bucket was created + listBuckets(cb) { + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + var method = 'GET'; + this.makeRequest({ + method + }, '', [200], _helpers.DEFAULT_REGION, true, (e, response) => { + if (e) { + return cb(e); + } + var transformer = transformers.getListBucketTransformer(); + var buckets; + (0, _helper.pipesetup)(response, transformer).on('data', result => buckets = result).on('error', e => cb(e)).on('end', () => cb(null, buckets)); + }); + } + // Returns a stream that emits objects that are partially uploaded. // // __Arguments__ @@ -79140,11 +81750,14 @@ class Client extends _client.TypedClient { result.prefixes.forEach(prefix => uploads.push(prefix)); _async.eachSeries(result.uploads, (upload, cb) => { // for each incomplete upload add the sizes of its uploaded parts - this.listParts(bucket, upload.key, upload.uploadId).then(parts => { + this.listParts(bucket, upload.key, upload.uploadId, (err, parts) => { + if (err) { + return cb(err); + } upload.size = parts.reduce((acc, item) => acc + item.size, 0); uploads.push(upload); cb(); - }, cb); + }); }, err => { if (err) { readStream.emit('error', err); @@ -79190,6 +81803,31 @@ class Client extends _client.TypedClient { }); } + // Remove a bucket. + // + // __Arguments__ + // * `bucketName` _string_ : name of the bucket + // * `callback(err)` _function_ : `err` is `null` if the bucket is removed successfully. + removeBucket(bucketName, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + var method = 'DELETE'; + this.makeRequest({ + method, + bucketName + }, '', [204], '', false, e => { + // If the bucket was successfully removed, remove the region map entry. + if (!e) { + delete this.regionMap[bucketName]; + } + cb(e); + }); + } + // Remove the partially uploaded object. // // __Arguments__ @@ -79421,11 +82059,150 @@ class Client extends _client.TypedClient { // Inserts correct `content-type` attribute based on metaData and filePath metaData = (0, _helper.insertContentType)(metaData, filePath); - fs.lstat(filePath, (err, stat) => { - if (err) { - return callback(err); + + // Updates metaData to have the correct prefix if needed + metaData = (0, _helper.prependXAMZMeta)(metaData); + var size; + var partSize; + _async.waterfall([cb => fs.stat(filePath, cb), (stats, cb) => { + size = stats.size; + var stream; + var cbTriggered = false; + var origCb = cb; + cb = function () { + if (cbTriggered) { + return; + } + cbTriggered = true; + if (stream) { + stream.destroy(); + } + return origCb.apply(this, arguments); + }; + if (size > this.maxObjectSize) { + return cb(new Error(`${filePath} size : ${stats.size}, max allowed size : 5TB`)); + } + if (size <= this.partSize) { + // simple PUT request, no multipart + var multipart = false; + var uploader = this.getUploader(bucketName, objectName, metaData, multipart); + var hash = transformers.getHashSummer(this.enableSHA256); + var start = 0; + var end = size - 1; + var autoClose = true; + if (size === 0) { + end = 0; + } + var options = { + start, + end, + autoClose + }; + (0, _helper.pipesetup)(fs.createReadStream(filePath, options), hash).on('data', data => { + var md5sum = data.md5sum; + var sha256sum = data.sha256sum; + stream = fs.createReadStream(filePath, options); + uploader(stream, size, sha256sum, md5sum, (err, objInfo) => { + callback(err, objInfo); + cb(true); + }); + }).on('error', e => cb(e)); + return; } - return this.putObject(bucketName, objectName, fs.createReadStream(filePath), stat.size, metaData, callback); + this.findUploadId(bucketName, objectName, cb); + }, (uploadId, cb) => { + // if there was a previous incomplete upload, fetch all its uploaded parts info + if (uploadId) { + return this.listParts(bucketName, objectName, uploadId, (e, etags) => cb(e, uploadId, etags)); + } + // there was no previous upload, initiate a new one + this.initiateNewMultipartUpload(bucketName, objectName, metaData, (e, uploadId) => cb(e, uploadId, [])); + }, (uploadId, etags, cb) => { + partSize = this.calculatePartSize(size); + var multipart = true; + var uploader = this.getUploader(bucketName, objectName, metaData, multipart); + + // convert array to object to make things easy + var parts = etags.reduce(function (acc, item) { + if (!acc[item.part]) { + acc[item.part] = item; + } + return acc; + }, {}); + var partsDone = []; + var partNumber = 1; + var uploadedSize = 0; + _async.whilst(cb => { + cb(null, uploadedSize < size); + }, cb => { + var stream; + var cbTriggered = false; + var origCb = cb; + cb = function () { + if (cbTriggered) { + return; + } + cbTriggered = true; + if (stream) { + stream.destroy(); + } + return origCb.apply(this, arguments); + }; + var part = parts[partNumber]; + var hash = transformers.getHashSummer(this.enableSHA256); + var length = partSize; + if (length > size - uploadedSize) { + length = size - uploadedSize; + } + var start = uploadedSize; + var end = uploadedSize + length - 1; + var autoClose = true; + var options = { + autoClose, + start, + end + }; + // verify md5sum of each part + (0, _helper.pipesetup)(fs.createReadStream(filePath, options), hash).on('data', data => { + var md5sumHex = Buffer.from(data.md5sum, 'base64').toString('hex'); + if (part && md5sumHex === part.etag) { + // md5 matches, chunk already uploaded + partsDone.push({ + part: partNumber, + etag: part.etag + }); + partNumber++; + uploadedSize += length; + return cb(); + } + // part is not uploaded yet, or md5 mismatch + stream = fs.createReadStream(filePath, options); + uploader(uploadId, partNumber, stream, length, data.sha256sum, data.md5sum, (e, objInfo) => { + if (e) { + return cb(e); + } + partsDone.push({ + part: partNumber, + etag: objInfo.etag + }); + partNumber++; + uploadedSize += length; + return cb(); + }); + }).on('error', e => cb(e)); + }, e => { + if (e) { + return cb(e); + } + cb(null, partsDone, uploadId); + }); + }, + // all parts uploaded, complete the multipart upload + (etags, uploadId, cb) => this.completeMultipartUpload(bucketName, objectName, uploadId, etags, cb)], (err, ...rest) => { + if (err === true) { + return; + } + callback(err, ...rest); }); } @@ -79925,6 +82702,112 @@ class Client extends _client.TypedClient { return readStream; } + // Stat information of the object. + // + // __Arguments__ + // * `bucketName` _string_: name of the bucket + // * `objectName` _string_: name of the object + // * `statOpts` _object_ : Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional). + // * `callback(err, stat)` _function_: `err` is not `null` in case of error, `stat` contains the object information: + // * `stat.size` _number_: size of the object + // * `stat.etag` _string_: etag of the object + // * `stat.metaData` _string_: MetaData of the object + // * `stat.lastModified` _Date_: modified time stamp + // * `stat.versionId` _string_: version id of the object if available + statObject(bucketName, objectName, statOpts = {}, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + // backward compatibility + if ((0, _helper.isFunction)(statOpts)) { + cb = statOpts; + statOpts = {}; + } + if (!(0, _helper.isObject)(statOpts)) { + throw new errors.InvalidArgumentError('statOpts should be of type "object"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + var query = querystring.stringify(statOpts); + var method = 'HEAD'; + this.makeRequest({ + method, + bucketName, + objectName, + query + }, '', [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + + // We drain the socket so that the connection gets closed. Note that this + // is not expensive as the socket will not have any data. + response.on('data', () => {}); + const result = { + size: +response.headers['content-length'], + metaData: (0, _helper.extractMetadata)(response.headers), + lastModified: new Date(response.headers['last-modified']), + versionId: (0, _helper.getVersionId)(response.headers), + etag: (0, _helper.sanitizeETag)(response.headers.etag) + }; + cb(null, result); + }); + } + + // Remove the specified object. + // + // __Arguments__ + // * `bucketName` _string_: name of the bucket + // * `objectName` _string_: name of the object + // * `removeOpts` _object_: Version of the object in the form `{versionId:'my-uuid', governanceBypass:true|false, forceDelete:true|false}`. Default is `{}`. (optional) + // * `callback(err)` _function_: callback function is called with non `null` value in case of error + removeObject(bucketName, objectName, removeOpts = {}, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + // backward compatibility + if ((0, _helper.isFunction)(removeOpts)) { + cb = removeOpts; + removeOpts = {}; + } + if (!(0, _helper.isObject)(removeOpts)) { + throw new errors.InvalidArgumentError('removeOpts should be of type "object"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + const method = 'DELETE'; + const queryParams = {}; + if (removeOpts.versionId) { + queryParams.versionId = `${removeOpts.versionId}`; + } + const headers = {}; + if (removeOpts.governanceBypass) { + headers['X-Amz-Bypass-Governance-Retention'] = true; + } + if (removeOpts.forceDelete) { + headers['x-minio-force-delete'] = true; + } + const query = querystring.stringify(queryParams); + let requestOptions = { + method, + bucketName, + objectName, + headers + }; + if (query) { + requestOptions['query'] = query; + } + this.makeRequest(requestOptions, '', [200, 204], '', false, cb); + } + // Remove all the objects residing in the objectsList. // // __Arguments__ @@ -79986,7 +82869,7 @@ class Client extends _client.TypedClient { headless: true }); let payload = builder.buildObject(deleteObjects); - payload = Buffer.from(encoder.encode(payload)); + payload = encoder.encode(payload); const headers = {}; headers['Content-MD5'] = (0, _helper.toMd5)(payload); let removeObjectsResult; @@ -80242,6 +83125,37 @@ class Client extends _client.TypedClient { }); } + // Calls implemented below are related to multipart. + + // Initiate a new multipart upload. + initiateNewMultipartUpload(bucketName, objectName, metaData, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + if (!(0, _helper.isObject)(metaData)) { + throw new errors.InvalidObjectNameError('contentType should be of type "object"'); + } + var method = 'POST'; + let headers = Object.assign({}, metaData); + var query = 'uploads'; + this.makeRequest({ + method, + bucketName, + objectName, + query, + headers + }, '', [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + var transformer = transformers.getInitiateMultipartTransformer(); + (0, _helper.pipesetup)(response, transformer).on('error', e => cb(e)).on('data', uploadId => cb(null, uploadId)); + }); + } + // Complete the multipart upload. After all the parts are uploaded issuing // this call will aggregate the parts on the server into a single object. completeMultipartUpload(bucketName, objectName, uploadId, etags, cb) { @@ -80304,6 +83218,78 @@ class Client extends _client.TypedClient { }); } + // Get part-info of all parts of an incomplete upload specified by uploadId. + listParts(bucketName, objectName, uploadId, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + if (!(0, _helper.isString)(uploadId)) { + throw new TypeError('uploadId should be of type "string"'); + } + if (!uploadId) { + throw new errors.InvalidArgumentError('uploadId cannot be empty'); + } + var parts = []; + var listNext = marker => { + this.listPartsQuery(bucketName, objectName, uploadId, marker, (e, result) => { + if (e) { + cb(e); + return; + } + parts = parts.concat(result.parts); + if (result.isTruncated) { + listNext(result.marker); + return; + } + cb(null, parts); + }); + }; + listNext(0); + } + + // Called by listParts to fetch a batch of part-info + listPartsQuery(bucketName, objectName, uploadId, marker, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + if (!(0, _helper.isString)(uploadId)) { + throw new TypeError('uploadId should be of type "string"'); + } + if (!(0, _helper.isNumber)(marker)) { + throw new TypeError('marker should be of type "number"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + if (!uploadId) { + throw new errors.InvalidArgumentError('uploadId cannot be empty'); + } + var query = ''; + if (marker && marker !== 0) { + query += `part-number-marker=${marker}&`; + } + query += `uploadId=${(0, _helper.uriEscape)(uploadId)}`; + var method = 'GET'; + this.makeRequest({ + method, + bucketName, + objectName, + query + }, '', [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + var transformer = transformers.getListPartsTransformer(); + (0, _helper.pipesetup)(response, transformer).on('error', e => cb(e)).on('data', data => cb(null, data)); + }); + } + // Called by listIncompleteUploads to fetch a batch of incomplete uploads. listIncompleteUploadsQuery(bucketName, prefix, keyMarker, uploadIdMarker, delimiter) { if (!(0, _helper.isValidBucketName)(bucketName)) { @@ -80389,6 +83375,97 @@ class Client extends _client.TypedClient { listNext('', ''); } + // Returns a function that can be used for uploading objects. + // If multipart === true, it returns function that is used to upload + // a part of the multipart. + getUploader(bucketName, objectName, metaData, multipart) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isValidObjectName)(objectName)) { + throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`); + } + if (!(0, _helper.isBoolean)(multipart)) { + throw new TypeError('multipart should be of type "boolean"'); + } + if (!(0, _helper.isObject)(metaData)) { + throw new TypeError('metadata should be of type "object"'); + } + var validate = (stream, length, sha256sum, md5sum, cb) => { + if (!(0, _helper.isReadableStream)(stream)) { + throw new TypeError('stream should be of type "Stream"'); + } + if (!(0, _helper.isNumber)(length)) { + throw new TypeError('length should be of type "number"'); + } + if (!(0, _helper.isString)(sha256sum)) { + throw new TypeError('sha256sum should be of type "string"'); + } + if (!(0, _helper.isString)(md5sum)) { + throw new TypeError('md5sum should be of type "string"'); + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + }; + var simpleUploader = (...args) => { + validate(...args); + var query = ''; + upload(query, ...args); + }; + var multipartUploader = (uploadId, partNumber, ...rest) => { + if (!(0, _helper.isString)(uploadId)) { + throw new TypeError('uploadId should be of type "string"'); + } + if (!(0, _helper.isNumber)(partNumber)) { + throw new TypeError('partNumber should be of type "number"'); + } + if (!uploadId) { + throw new errors.InvalidArgumentError('Empty uploadId'); + } + if (!partNumber) { + throw new errors.InvalidArgumentError('partNumber cannot be 0'); + } + validate(...rest); + var query = `partNumber=${partNumber}&uploadId=${(0, _helper.uriEscape)(uploadId)}`; + upload(query, ...rest); + }; + var upload = (query, stream, length, sha256sum, md5sum, cb) => { + var method = 'PUT'; + let headers = { + 'Content-Length': length + }; + if (!multipart) { + headers = Object.assign({}, metaData, headers); + } + if (!this.enableSHA256) { + headers['Content-MD5'] = md5sum; + } + this.makeRequestStream({ + method, + bucketName, + objectName, + query, + headers + }, stream, sha256sum, [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + const result = { + etag: (0, _helper.sanitizeETag)(response.headers.etag), + versionId: (0, _helper.getVersionId)(response.headers) + }; + // Ignore the 'data' event so that the stream closes. (nodejs stream requirement) + response.on('data', () => {}); + cb(null, result); + }); + }; + if (multipart) { + return multipartUploader; + } + return simpleUploader; + } + // Remove all the notification configurations in the S3 provider setBucketNotification(bucketName, config, cb) { if (!(0, _helper.isValidBucketName)(bucketName)) { @@ -80560,7 +83637,7 @@ class Client extends _client.TypedClient { } }); let payload = builder.buildObject(taggingConfig); - payload = Buffer.from(encoder.encode(payload)); + payload = encoder.encode(payload); headers['Content-MD5'] = (0, _helper.toMd5)(payload); const requestOptions = { method, @@ -80724,9 +83801,6 @@ class Client extends _client.TypedClient { * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful. */ getBucketTagging(bucketName, cb) { - if (!(0, _helper.isValidBucketName)(bucketName)) { - throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`); - } const method = 'GET'; const query = 'tagging'; const requestOptions = { @@ -80809,7 +83883,7 @@ class Client extends _client.TypedClient { } }); let payload = builder.buildObject(policyConfig); - payload = Buffer.from(encoder.encode(payload)); + payload = encoder.encode(payload); const requestOptions = { method, bucketName, @@ -81138,6 +84212,86 @@ class Client extends _client.TypedClient { query }, '', [204], '', false, cb); } + setBucketReplication(bucketName, replicationConfig = {}, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isObject)(replicationConfig)) { + throw new errors.InvalidArgumentError('replicationConfig should be of type "object"'); + } else { + if (_lodash.isEmpty(replicationConfig.role)) { + throw new errors.InvalidArgumentError('Role cannot be empty'); + } else if (replicationConfig.role && !(0, _helper.isString)(replicationConfig.role)) { + throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role); + } + if (_lodash.isEmpty(replicationConfig.rules)) { + throw new errors.InvalidArgumentError('Minimum one replication rule must be specified'); + } + } + if (!(0, _helper.isFunction)(cb)) { + throw new TypeError('callback should be of type "function"'); + } + const method = 'PUT'; + let query = 'replication'; + const headers = {}; + const replicationParamsConfig = { + ReplicationConfiguration: { + Role: replicationConfig.role, + Rule: replicationConfig.rules + } + }; + const builder = new _xml2js.Builder({ + renderOpts: { + pretty: false + }, + headless: true + }); + let payload = builder.buildObject(replicationParamsConfig); + headers['Content-MD5'] = (0, _helper.toMd5)(payload); + this.makeRequest({ + method, + bucketName, + query, + headers + }, payload, [200], '', false, cb); + } + getBucketReplication(bucketName, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + if (!(0, _helper.isFunction)(cb)) { + throw new errors.InvalidArgumentError('callback should be of type "function"'); + } + const method = 'GET'; + const query = 'replication'; + this.makeRequest({ + method, + bucketName, + query + }, '', [200], '', true, (e, response) => { + if (e) { + return cb(e); + } + let replicationConfig = Buffer.from(''); + (0, _helper.pipesetup)(response, transformers.replicationConfigTransformer()).on('data', data => { + replicationConfig = data; + }).on('error', cb).on('end', () => { + cb(null, replicationConfig); + }); + }); + } + removeBucketReplication(bucketName, cb) { + if (!(0, _helper.isValidBucketName)(bucketName)) { + throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); + } + const method = 'DELETE'; + const query = 'replication'; + this.makeRequest({ + method, + bucketName, + query + }, '', [200, 204], '', false, cb); + } getObjectLegalHold(bucketName, objectName, getOpts = {}, cb) { if (!(0, _helper.isValidBucketName)(bucketName)) { throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName); @@ -81238,6 +84392,25 @@ class Client extends _client.TypedClient { }, payload, [200], '', false, cb); } + /** + * Internal Method to abort a multipart upload request in case of any errors. + * @param bucketName __string__ Bucket Name + * @param objectName __string__ Object Name + * @param uploadId __string__ id of a multipart upload to cancel during compose object sequence. + * @param cb __function__ callback function + */ + abortMultipartUpload(bucketName, objectName, uploadId, cb) { + const method = 'DELETE'; + let query = `uploadId=${uploadId}`; + const requestOptions = { + method, + bucketName, + objectName: objectName, + query + }; + this.makeRequest(requestOptions, '', [204], '', false, cb); + } + /** * Internal method to upload a part during compose object. * @param partConfig __object__ contains the following. @@ -81403,8 +84576,7 @@ class Client extends _client.TypedClient { const uploadList = getUploadPartConfigList(uploadId); _async.map(uploadList, me.uploadPartCopy.bind(me), (err, res) => { if (err) { - this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId).then(() => cb(), err => cb(err)); - return; + return this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, cb); } const partsDone = res.map(partCopy => ({ etag: partCopy.etag, @@ -81414,10 +84586,11 @@ class Client extends _client.TypedClient { }); }; const newUploadHeaders = destObjConfig.getHeaders(); - me.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders).then(uploadId => { + me.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders, (err, uploadId) => { + if (err) { + return cb(err, null); + } performUploadParts(uploadId); - }, err => { - cb(err, null); }); }).catch(error => { cb(error, null); @@ -81504,18 +84677,28 @@ class Client extends _client.TypedClient { }); }); } + get extensions() { + if (!this.clientExtensions) { + this.clientExtensions = new _extensions.extensions(this); + } + return this.clientExtensions; + } } // Promisify various public-facing APIs on the Client module. exports.Client = Client; Client.prototype.makeBucket = (0, _promisify.promisify)(Client.prototype.makeBucket); +Client.prototype.listBuckets = (0, _promisify.promisify)(Client.prototype.listBuckets); Client.prototype.bucketExists = (0, _promisify.promisify)(Client.prototype.bucketExists); +Client.prototype.removeBucket = (0, _promisify.promisify)(Client.prototype.removeBucket); Client.prototype.getObject = (0, _promisify.promisify)(Client.prototype.getObject); Client.prototype.getPartialObject = (0, _promisify.promisify)(Client.prototype.getPartialObject); Client.prototype.fGetObject = (0, _promisify.promisify)(Client.prototype.fGetObject); Client.prototype.putObject = (0, _promisify.promisify)(Client.prototype.putObject); Client.prototype.fPutObject = (0, _promisify.promisify)(Client.prototype.fPutObject); Client.prototype.copyObject = (0, _promisify.promisify)(Client.prototype.copyObject); +Client.prototype.statObject = (0, _promisify.promisify)(Client.prototype.statObject); +Client.prototype.removeObject = (0, _promisify.promisify)(Client.prototype.removeObject); Client.prototype.removeObjects = (0, _promisify.promisify)(Client.prototype.removeObjects); Client.prototype.presignedUrl = (0, _promisify.promisify)(Client.prototype.presignedUrl); Client.prototype.presignedGetObject = (0, _promisify.promisify)(Client.prototype.presignedGetObject); @@ -81545,20 +84728,14 @@ Client.prototype.getObjectRetention = (0, _promisify.promisify)(Client.prototype Client.prototype.setBucketEncryption = (0, _promisify.promisify)(Client.prototype.setBucketEncryption); Client.prototype.getBucketEncryption = (0, _promisify.promisify)(Client.prototype.getBucketEncryption); Client.prototype.removeBucketEncryption = (0, _promisify.promisify)(Client.prototype.removeBucketEncryption); +Client.prototype.setBucketReplication = (0, _promisify.promisify)(Client.prototype.setBucketReplication); +Client.prototype.getBucketReplication = (0, _promisify.promisify)(Client.prototype.getBucketReplication); +Client.prototype.removeBucketReplication = (0, _promisify.promisify)(Client.prototype.removeBucketReplication); Client.prototype.setObjectLegalHold = (0, _promisify.promisify)(Client.prototype.setObjectLegalHold); Client.prototype.getObjectLegalHold = (0, _promisify.promisify)(Client.prototype.getObjectLegalHold); Client.prototype.composeObject = (0, _promisify.promisify)(Client.prototype.composeObject); Client.prototype.selectObjectContent = (0, _promisify.promisify)(Client.prototype.selectObjectContent); - -// refactored API use promise internally -Client.prototype.removeObject = (0, _callbackify.callbackify)(Client.prototype.removeObject); -Client.prototype.statObject = (0, _callbackify.callbackify)(Client.prototype.statObject); -Client.prototype.removeBucket = (0, _callbackify.callbackify)(Client.prototype.removeBucket); -Client.prototype.listBuckets = (0, _callbackify.callbackify)(Client.prototype.listBuckets); -Client.prototype.removeBucketReplication = (0, _callbackify.callbackify)(Client.prototype.removeBucketReplication); -Client.prototype.setBucketReplication = (0, _callbackify.callbackify)(Client.prototype.setBucketReplication); -Client.prototype.getBucketReplication = (0, _callbackify.callbackify)(Client.prototype.getBucketReplication); -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","_interopRequireWildcard","require","path","Stream","_async","_blockStream","_lodash","querystring","_webEncoding","_xml","_xml2js","errors","_helpers","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","_callbackify","_client","_copyConditions","CopyConditions","_helper","_postPolicy","PostPolicy","_type","_notification","_objectUploader","_promisify","_signing","transformers","_xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","defineProperty","getOwnPropertyDescriptor","desc","set","Client","TypedClient","setAppInfo","appName","appVersion","isString","TypeError","trim","InvalidArgumentError","userAgent","calculatePartSize","size","isNumber","maxObjectSize","overRidePartSize","partSize","makeBucket","bucketName","region","makeOpts","cb","isValidBucketName","InvalidBucketNameError","isObject","isFunction","payload","DEFAULT_REGION","createBucketConfiguration","push","_attr","xmlns","LocationConstraint","payloadObject","CreateBucketConfiguration","Xml","method","headers","ObjectLocking","processWithRetry","err","code","makeRequest","listIncompleteUploads","bucket","prefix","recursive","undefined","isValidPrefix","InvalidPrefixError","isBoolean","delimiter","keyMarker","uploadIdMarker","uploads","ended","readStream","Readable","objectMode","_read","length","shift","listIncompleteUploadsQuery","on","e","emit","result","prefixes","async","eachSeries","upload","listParts","uploadId","then","parts","reduce","acc","item","isTruncated","nextKeyMarker","nextUploadIdMarker","bucketExists","removeIncompleteUpload","objectName","IsValidBucketNameError","isValidObjectName","InvalidObjectNameError","removeUploadId","during","findUploadId","query","fGetObject","filePath","getOpts","partFile","partFileStream","objStat","rename","waterfall","statObject","mkdir","dirname","etag","stat","stats","offset","createWriteStream","flags","getPartialObject","downloadStream","pipesetup","Error","getObject","range","expectedStatusCodes","stringify","fPutObject","metaData","callback","insertContentType","lstat","putObject","createReadStream","stream","prependXAMZMeta","Buffer","readableStream","isReadableStream","chunker","BlockStream2","zeroPadding","uploader","ObjectUploader","copyObjectV1","arg1","arg2","arg3","arg4","arg5","srcObject","conditions","uriResourceEscape","modified","unmodified","matchETag","matchEtagExcept","matchETagExcept","response","transformer","getCopyObjectTransformer","data","copyObjectV2","sourceConfig","destConfig","CopySourceOptions","CopyDestinationOptions","validate","assign","getHeaders","Bucket","resHeaders","copyObjResponse","Key","LastModified","MetaData","extractMetadata","VersionId","getVersionId","SourceVersionId","getSourceVersionId","Etag","sanitizeETag","Size","copyObject","allArgs","arguments","listObjectsQuery","marker","listQueryOpts","Delimiter","MaxKeys","IncludeVersion","queries","uriEscape","sort","join","getListObjectsTransformer","listObjects","listOpts","objects","nextMarker","versionIdMarker","listObjectsV2Query","continuationToken","maxKeys","startAfter","getListObjectsV2Transformer","listObjectsV2","nextContinuationToken","removeObjects","objectsList","Array","isArray","maxEntries","entry","list","listOfList","encoder","TextEncoder","batchResults","batchCb","value","name","versionId","deleteObjects","Delete","Quiet","builder","xml2js","Builder","headless","buildObject","from","encode","toMd5","removeObjectsResult","removeObjectsTransformer","_","flatten","getBucketPolicy","policy","getConcater","toString","setBucketPolicy","InvalidBucketPolicyError","presignedUrl","expires","reqParams","requestDate","anonymous","AnonymousRequestError","Date","isValidDate","getBucketRegion","url","reqOptions","getRequestOptions","checkAndRefreshCreds","presignSignatureV4","accessKey","secretKey","sessionToken","pe","presignedGetObject","respHeaders","validRespHeaders","header","presignedPutObject","newPostPolicy","presignedPostPolicy","postPolicy","formData","date","dateStr","makeDateLong","expiration","setSeconds","setExpires","getScope","policyBase64","JSON","signature","postPresignSignatureV4","opts","portStr","port","urlStr","protocol","host","postURL","completeMultipartUpload","etags","element","Part","PartNumber","part","ETag","CompleteMultipartUpload","getCompleteMultipartTransformer","errCode","S3Error","errMessage","completeMultipartResult","maxUploads","unshift","getListMultipartTransformer","latestUpload","listNext","initiated","getTime","setBucketNotification","config","rootName","renderOpts","pretty","removeAllBucketNotification","NotificationConfig","getBucketNotification","getBucketNotificationTransformer","bucketNotification","listenBucketNotification","suffix","events","listener","NotificationPoller","start","getBucketVersioning","versionConfig","bucketVersioningTransformer","setBucketVersioning","setTagging","taggingParams","tags","putOpts","tagsList","entries","Value","taggingConfig","Tagging","TagSet","Tag","requestOptions","setBucketTagging","setObjectTagging","removeTagging","removeOpts","removeBucketTagging","removeObjectTagging","getBucketTagging","getTagsTransformer","getObjectTagging","applyBucketLifecycle","policyConfig","removeBucketLifecycle","setBucketLifecycle","lifeCycleConfig","isEmpty","getBucketLifecycle","lifecycleTransformer","lifecycleConfig","setObjectLockConfig","lockConfigOpts","retentionModes","RETENTION_MODES","COMPLIANCE","GOVERNANCE","validUnits","RETENTION_VALIDITY_UNITS","DAYS","YEARS","mode","includes","unit","validity","ObjectLockEnabled","configKeys","difference","Rule","DefaultRetention","Mode","Days","Years","getObjectLockConfig","objectLockConfig","objectLockTransformer","putObjectRetention","retentionOpts","governanceBypass","retainUntilDate","params","RetainUntilDate","getObjectRetention","retentionConfig","objectRetentionTransformer","setBucketEncryption","encryptionConfig","encryptionObj","ApplyServerSideEncryptionByDefault","SSEAlgorithm","getBucketEncryption","bucketEncConfig","bucketEncryptionTransformer","removeBucketEncryption","getObjectLegalHold","legalHoldConfig","objectLegalHoldTransformer","setObjectLegalHold","setOpts","defaultOpts","status","LEGAL_HOLD_STATUS","ENABLED","DISABLED","Status","uploadPartCopy","partConfig","uploadID","partNumber","partCopyResult","uploadPartTransformer","uploadPartCopyRes","composeObject","destObjConfig","sourceObjList","me","sourceFilesLength","PART_CONSTRAINTS","MAX_PARTS_COUNT","i","getStatOptions","srcConfig","statOpts","VersionID","srcObjectSizes","totalSize","totalParts","sourceObjStats","map","srcItem","Promise","all","srcObjectInfos","validatedStats","resItemStat","index","srcCopySize","MatchRange","srcStart","Start","srcEnd","End","ABS_MIN_PART_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","partsRequired","MAX_PART_SIZE","MatchETag","splitPartSizeList","idx","calSize","calculateEvenSplits","getUploadPartConfigList","uploadPartConfigList","splitSize","splitIndex","startIndex","startIdx","endIndex","endIdx","objInfo","objConfig","partIndex","totalUploads","splitStart","upldCtrIdx","splitEnd","sourceObj","uploadPartConfig","performUploadParts","uploadList","bind","res","abortMultipartUpload","partsDone","partCopy","newUploadHeaders","initiateNewMultipartUpload","catch","error","selectObjectContent","selectOpts","expression","inputSerialization","outputSerialization","Expression","ExpressionType","expressionType","InputSerialization","OutputSerialization","requestProgress","RequestProgress","scanRange","ScanRange","selectResult","selectObjectContentTransformer","parseSelectObjectContentResponse","promisify","removeObject","callbackify","removeBucket","listBuckets","removeBucketReplication","setBucketReplication","getBucketReplication"],"sources":["minio.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport * as Stream from 'node:stream'\n\nimport async from 'async'\nimport BlockStream2 from 'block-stream2'\nimport _ from 'lodash'\nimport * as querystring from 'query-string'\nimport { TextEncoder } from 'web-encoding'\nimport Xml from 'xml'\nimport xml2js from 'xml2js'\n\nimport * as errors from './errors.ts'\nimport { CopyDestinationOptions, CopySourceOptions, DEFAULT_REGION } from './helpers.ts'\nimport { callbackify } from './internal/callbackify.js'\nimport { TypedClient } from './internal/client.ts'\nimport { CopyConditions } from './internal/copy-conditions.ts'\nimport {\n  calculateEvenSplits,\n  extractMetadata,\n  getScope,\n  getSourceVersionId,\n  getVersionId,\n  insertContentType,\n  isBoolean,\n  isFunction,\n  isNumber,\n  isObject,\n  isReadableStream,\n  isString,\n  isValidBucketName,\n  isValidDate,\n  isValidObjectName,\n  isValidPrefix,\n  makeDateLong,\n  PART_CONSTRAINTS,\n  partsRequired,\n  pipesetup,\n  prependXAMZMeta,\n  readableStream,\n  sanitizeETag,\n  toMd5,\n  uriEscape,\n  uriResourceEscape,\n} from './internal/helper.ts'\nimport { PostPolicy } from './internal/post-policy.ts'\nimport { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './internal/type.ts'\nimport { NotificationConfig, NotificationPoller } from './notification.js'\nimport { ObjectUploader } from './object-uploader.js'\nimport { promisify } from './promisify.js'\nimport { postPresignSignatureV4, presignSignatureV4 } from './signing.ts'\nimport * as transformers from './transformers.js'\nimport { parseSelectObjectContentResponse } from './xml-parsers.js'\n\nexport * from './helpers.ts'\nexport * from './notification.js'\nexport { CopyConditions, PostPolicy }\n\nexport class Client extends TypedClient {\n  // Set application specific information.\n  //\n  // Generates User-Agent in the following style.\n  //\n  //       MinIO (OS; ARCH) LIB/VER APP/VER\n  //\n  // __Arguments__\n  // * `appName` _string_ - Application name.\n  // * `appVersion` _string_ - Application version.\n  setAppInfo(appName, appVersion) {\n    if (!isString(appName)) {\n      throw new TypeError(`Invalid appName: ${appName}`)\n    }\n    if (appName.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appName cannot be empty.')\n    }\n    if (!isString(appVersion)) {\n      throw new TypeError(`Invalid appVersion: ${appVersion}`)\n    }\n    if (appVersion.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appVersion cannot be empty.')\n    }\n    this.userAgent = `${this.userAgent} ${appName}/${appVersion}`\n  }\n\n  // Calculate part size given the object size. Part size will be atleast this.partSize\n  calculatePartSize(size) {\n    if (!isNumber(size)) {\n      throw new TypeError('size should be of type \"number\"')\n    }\n    if (size > this.maxObjectSize) {\n      throw new TypeError(`size should not be more than ${this.maxObjectSize}`)\n    }\n    if (this.overRidePartSize) {\n      return this.partSize\n    }\n    var partSize = this.partSize\n    for (;;) {\n      // while(true) {...} throws linting error.\n      // If partSize is big enough to accomodate the object size, then use it.\n      if (partSize * 10000 > size) {\n        return partSize\n      }\n      // Try part sizes as 64MB, 80MB, 96MB etc.\n      partSize += 16 * 1024 * 1024\n    }\n  }\n\n  // Creates the bucket `bucketName`.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ - Name of the bucket\n  // * `region` _string_ - region valid values are _us-west-1_, _us-west-2_,  _eu-west-1_, _eu-central-1_, _ap-southeast-1_, _ap-northeast-1_, _ap-southeast-2_, _sa-east-1_.\n  // * `makeOpts` _object_ - Options to create a bucket. e.g {ObjectLocking:true} (Optional)\n  // * `callback(err)` _function_ - callback function with `err` as the error argument. `err` is null if the bucket is successfully created.\n  makeBucket(bucketName, region, makeOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    // Backward Compatibility\n    if (isObject(region)) {\n      cb = makeOpts\n      makeOpts = region\n      region = ''\n    }\n    if (isFunction(region)) {\n      cb = region\n      region = ''\n      makeOpts = {}\n    }\n    if (isFunction(makeOpts)) {\n      cb = makeOpts\n      makeOpts = {}\n    }\n\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!isObject(makeOpts)) {\n      throw new TypeError('makeOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var payload = ''\n\n    // Region already set in constructor, validate if\n    // caller requested bucket location is same.\n    if (region && this.region) {\n      if (region !== this.region) {\n        throw new errors.InvalidArgumentError(`Configured region ${this.region}, requested ${region}`)\n      }\n    }\n    // sending makeBucket request with XML containing 'us-east-1' fails. For\n    // default region server expects the request without body\n    if (region && region !== DEFAULT_REGION) {\n      var createBucketConfiguration = []\n      createBucketConfiguration.push({\n        _attr: {\n          xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/',\n        },\n      })\n      createBucketConfiguration.push({\n        LocationConstraint: region,\n      })\n      var payloadObject = {\n        CreateBucketConfiguration: createBucketConfiguration,\n      }\n      payload = Xml(payloadObject)\n    }\n    var method = 'PUT'\n    var headers = {}\n\n    if (makeOpts.ObjectLocking) {\n      headers['x-amz-bucket-object-lock-enabled'] = true\n    }\n\n    if (!region) {\n      region = DEFAULT_REGION\n    }\n\n    const processWithRetry = (err) => {\n      if (err && (region === '' || region === DEFAULT_REGION)) {\n        if (err.code === 'AuthorizationHeaderMalformed' && err.region !== '') {\n          // Retry with region returned as part of error\n          this.makeRequest({ method, bucketName, headers }, payload, [200], err.region, false, cb)\n        } else {\n          return cb && cb(err)\n        }\n      }\n      return cb && cb(err)\n    }\n    this.makeRequest({ method, bucketName, headers }, payload, [200], region, false, processWithRetry)\n  }\n\n  // Returns a stream that emits objects that are partially uploaded.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: prefix of the object names that are partially uploaded (optional, default `''`)\n  // * `recursive` _bool_: directory style listing when false, recursive listing when true (optional, default `false`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_ : emits objects of the format:\n  //   * `object.key` _string_: name of the object\n  //   * `object.uploadId` _string_: upload ID of the object\n  //   * `object.size` _Integer_: size of the partially uploaded object\n  listIncompleteUploads(bucket, prefix, recursive) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucket)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    var delimiter = recursive ? '' : '/'\n    var keyMarker = ''\n    var uploadIdMarker = ''\n    var uploads = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one upload info per _read()\n      if (uploads.length) {\n        return readStream.push(uploads.shift())\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      this.listIncompleteUploadsQuery(bucket, prefix, keyMarker, uploadIdMarker, delimiter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          result.prefixes.forEach((prefix) => uploads.push(prefix))\n          async.eachSeries(\n            result.uploads,\n            (upload, cb) => {\n              // for each incomplete upload add the sizes of its uploaded parts\n              this.listParts(bucket, upload.key, upload.uploadId).then((parts) => {\n                upload.size = parts.reduce((acc, item) => acc + item.size, 0)\n                uploads.push(upload)\n                cb()\n              }, cb)\n            },\n            (err) => {\n              if (err) {\n                readStream.emit('error', err)\n                return\n              }\n              if (result.isTruncated) {\n                keyMarker = result.nextKeyMarker\n                uploadIdMarker = result.nextUploadIdMarker\n              } else {\n                ended = true\n              }\n              readStream._read()\n            },\n          )\n        })\n    }\n    return readStream\n  }\n\n  // To check if a bucket already exists.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ : name of the bucket\n  // * `callback(err)` _function_ : `err` is `null` if the bucket exists\n  bucketExists(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'HEAD'\n    this.makeRequest({ method, bucketName }, '', [200], '', false, (err) => {\n      if (err) {\n        if (err.code == 'NoSuchBucket' || err.code == 'NotFound') {\n          return cb(null, false)\n        }\n        return cb(err)\n      }\n      cb(null, true)\n    })\n  }\n\n  // Remove the partially uploaded object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `callback(err)` _function_: callback function is called with non `null` value in case of error\n  removeIncompleteUpload(bucketName, objectName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.IsValidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var removeUploadId\n    async.during(\n      (cb) => {\n        this.findUploadId(bucketName, objectName, (e, uploadId) => {\n          if (e) {\n            return cb(e)\n          }\n          removeUploadId = uploadId\n          cb(null, uploadId)\n        })\n      },\n      (cb) => {\n        var method = 'DELETE'\n        var query = `uploadId=${removeUploadId}`\n        this.makeRequest({ method, bucketName, objectName, query }, '', [204], '', false, (e) => cb(e))\n      },\n      cb,\n    )\n  }\n\n  // Callback is called with `error` in case of error or `null` in case of success\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `filePath` _string_: path to which the object data will be written to\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err)` _function_: callback is called with `err` in case of error.\n  fGetObject(bucketName, objectName, filePath, getOpts = {}, cb) {\n    // Input validation.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    // Internal data.\n    var partFile\n    var partFileStream\n    var objStat\n\n    // Rename wrapper.\n    var rename = (err) => {\n      if (err) {\n        return cb(err)\n      }\n      fs.rename(partFile, filePath, cb)\n    }\n\n    async.waterfall(\n      [\n        (cb) => this.statObject(bucketName, objectName, getOpts, cb),\n        (result, cb) => {\n          objStat = result\n          // Create any missing top level directories.\n          fs.mkdir(path.dirname(filePath), { recursive: true }, (err) => cb(err))\n        },\n        (cb) => {\n          partFile = `${filePath}.${objStat.etag}.part.minio`\n          fs.stat(partFile, (e, stats) => {\n            var offset = 0\n            if (e) {\n              partFileStream = fs.createWriteStream(partFile, { flags: 'w' })\n            } else {\n              if (objStat.size === stats.size) {\n                return rename()\n              }\n              offset = stats.size\n              partFileStream = fs.createWriteStream(partFile, { flags: 'a' })\n            }\n            this.getPartialObject(bucketName, objectName, offset, 0, getOpts, cb)\n          })\n        },\n        (downloadStream, cb) => {\n          pipesetup(downloadStream, partFileStream)\n            .on('error', (e) => cb(e))\n            .on('finish', cb)\n        },\n        (cb) => fs.stat(partFile, cb),\n        (stats, cb) => {\n          if (stats.size === objStat.size) {\n            return cb()\n          }\n          cb(new Error('Size mismatch between downloaded file and the object'))\n        },\n      ],\n      rename,\n    )\n  }\n\n  // Callback is called with readable stream of the object content.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err, stream)` _function_: callback is called with `err` in case of error. `stream` is the object content stream\n  getObject(bucketName, objectName, getOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    this.getPartialObject(bucketName, objectName, 0, 0, getOpts, cb)\n  }\n\n  // Callback is called with readable stream of the partial object content.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `offset` _number_: offset of the object from where the stream will start\n  // * `length` _number_: length of the object that will be read in the stream (optional, if not specified we read the rest of the file from the offset)\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err, stream)` _function_: callback is called with `err` in case of error. `stream` is the object content stream\n  getPartialObject(bucketName, objectName, offset, length, getOpts = {}, cb) {\n    if (isFunction(length)) {\n      cb = length\n      length = 0\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isNumber(offset)) {\n      throw new TypeError('offset should be of type \"number\"')\n    }\n    if (!isNumber(length)) {\n      throw new TypeError('length should be of type \"number\"')\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var range = ''\n    if (offset || length) {\n      if (offset) {\n        range = `bytes=${+offset}-`\n      } else {\n        range = 'bytes=0-'\n        offset = 0\n      }\n      if (length) {\n        range += `${+length + offset - 1}`\n      }\n    }\n\n    var headers = {}\n    if (range !== '') {\n      headers.range = range\n    }\n\n    var expectedStatusCodes = [200]\n    if (range) {\n      expectedStatusCodes.push(206)\n    }\n    var method = 'GET'\n\n    var query = querystring.stringify(getOpts)\n    this.makeRequest({ method, bucketName, objectName, headers, query }, '', expectedStatusCodes, '', true, cb)\n  }\n\n  // Uploads the object using contents from a file\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `filePath` _string_: file path of the file to be uploaded\n  // * `metaData` _Javascript Object_: metaData assosciated with the object\n  // * `callback(err, objInfo)` _function_: non null `err` indicates error, `objInfo` _object_ which contains versionId and etag.\n  fPutObject(bucketName, objectName, filePath, metaData, callback) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    if (isFunction(metaData)) {\n      callback = metaData\n      metaData = {} // Set metaData empty if no metaData provided.\n    }\n    if (!isObject(metaData)) {\n      throw new TypeError('metaData should be of type \"object\"')\n    }\n\n    // Inserts correct `content-type` attribute based on metaData and filePath\n    metaData = insertContentType(metaData, filePath)\n\n    fs.lstat(filePath, (err, stat) => {\n      if (err) {\n        return callback(err)\n      }\n      return this.putObject(bucketName, objectName, fs.createReadStream(filePath), stat.size, metaData, callback)\n    })\n  }\n\n  // Uploads the object.\n  //\n  // Uploading a stream\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `stream` _Stream_: Readable stream\n  // * `size` _number_: size of the object (optional)\n  // * `callback(err, etag)` _function_: non null `err` indicates error, `etag` _string_ is the etag of the object uploaded.\n  //\n  // Uploading \"Buffer\" or \"string\"\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `string or Buffer` _string_ or _Buffer_: string or buffer\n  // * `callback(err, objInfo)` _function_: `err` is `null` in case of success and `info` will have the following object details:\n  //   * `etag` _string_: etag of the object\n  //   * `versionId` _string_: versionId of the object\n  putObject(bucketName, objectName, stream, size, metaData, callback) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    // We'll need to shift arguments to the left because of size and metaData.\n    if (isFunction(size)) {\n      callback = size\n      metaData = {}\n    } else if (isFunction(metaData)) {\n      callback = metaData\n      metaData = {}\n    }\n\n    // We'll need to shift arguments to the left because of metaData\n    // and size being optional.\n    if (isObject(size)) {\n      metaData = size\n    }\n\n    // Ensures Metadata has appropriate prefix for A3 API\n    metaData = prependXAMZMeta(metaData)\n    if (typeof stream === 'string' || stream instanceof Buffer) {\n      // Adapts the non-stream interface into a stream.\n      size = stream.length\n      stream = readableStream(stream)\n    } else if (!isReadableStream(stream)) {\n      throw new TypeError('third argument should be of type \"stream.Readable\" or \"Buffer\" or \"string\"')\n    }\n\n    if (!isFunction(callback)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    if (isNumber(size) && size < 0) {\n      throw new errors.InvalidArgumentError(`size cannot be negative, given size: ${size}`)\n    }\n\n    // Get the part size and forward that to the BlockStream. Default to the\n    // largest block size possible if necessary.\n    if (!isNumber(size)) {\n      size = this.maxObjectSize\n    }\n\n    size = this.calculatePartSize(size)\n\n    // s3 requires that all non-end chunks be at least `this.partSize`,\n    // so we chunk the stream until we hit either that size or the end before\n    // we flush it to s3.\n    let chunker = new BlockStream2({ size, zeroPadding: false })\n\n    // This is a Writable stream that can be written to in order to upload\n    // to the specified bucket and object automatically.\n    let uploader = new ObjectUploader(this, bucketName, objectName, size, metaData, callback)\n    // stream => chunker => uploader\n    pipesetup(stream, chunker, uploader)\n  }\n\n  // Copy the object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `srcObject` _string_: path of the source object to be copied\n  // * `conditions` _CopyConditions_: copy conditions that needs to be satisfied (optional, default `null`)\n  // * `callback(err, {etag, lastModified})` _function_: non null `err` indicates error, `etag` _string_ and `listModifed` _Date_ are respectively the etag and the last modified date of the newly copied object\n  copyObjectV1(arg1, arg2, arg3, arg4, arg5) {\n    var bucketName = arg1\n    var objectName = arg2\n    var srcObject = arg3\n    var conditions, cb\n    if (typeof arg4 == 'function' && arg5 === undefined) {\n      conditions = null\n      cb = arg4\n    } else {\n      conditions = arg4\n      cb = arg5\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(srcObject)) {\n      throw new TypeError('srcObject should be of type \"string\"')\n    }\n    if (srcObject === '') {\n      throw new errors.InvalidPrefixError(`Empty source prefix`)\n    }\n\n    if (conditions !== null && !(conditions instanceof CopyConditions)) {\n      throw new TypeError('conditions should be of type \"CopyConditions\"')\n    }\n\n    var headers = {}\n    headers['x-amz-copy-source'] = uriResourceEscape(srcObject)\n\n    if (conditions !== null) {\n      if (conditions.modified !== '') {\n        headers['x-amz-copy-source-if-modified-since'] = conditions.modified\n      }\n      if (conditions.unmodified !== '') {\n        headers['x-amz-copy-source-if-unmodified-since'] = conditions.unmodified\n      }\n      if (conditions.matchETag !== '') {\n        headers['x-amz-copy-source-if-match'] = conditions.matchETag\n      }\n      if (conditions.matchEtagExcept !== '') {\n        headers['x-amz-copy-source-if-none-match'] = conditions.matchETagExcept\n      }\n    }\n\n    var method = 'PUT'\n    this.makeRequest({ method, bucketName, objectName, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getCopyObjectTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => cb(null, data))\n    })\n  }\n\n  /**\n   * Internal Method to perform copy of an object.\n   * @param sourceConfig __object__   instance of CopySourceOptions @link ./helpers/CopySourceOptions\n   * @param destConfig  __object__   instance of CopyDestinationOptions @link ./helpers/CopyDestinationOptions\n   * @param cb __function__ called with null if there is an error\n   * @returns Promise if no callack is passed.\n   */\n  copyObjectV2(sourceConfig, destConfig, cb) {\n    if (!(sourceConfig instanceof CopySourceOptions)) {\n      throw new errors.InvalidArgumentError('sourceConfig should of type CopySourceOptions ')\n    }\n    if (!(destConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n    if (!destConfig.validate()) {\n      return false\n    }\n    if (!destConfig.validate()) {\n      return false\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const headers = Object.assign({}, sourceConfig.getHeaders(), destConfig.getHeaders())\n\n    const bucketName = destConfig.Bucket\n    const objectName = destConfig.Object\n\n    const method = 'PUT'\n    this.makeRequest({ method, bucketName, objectName, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      const transformer = transformers.getCopyObjectTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => {\n          const resHeaders = response.headers\n\n          const copyObjResponse = {\n            Bucket: destConfig.Bucket,\n            Key: destConfig.Object,\n            LastModified: data.LastModified,\n            MetaData: extractMetadata(resHeaders),\n            VersionId: getVersionId(resHeaders),\n            SourceVersionId: getSourceVersionId(resHeaders),\n            Etag: sanitizeETag(resHeaders.etag),\n            Size: +resHeaders['content-length'],\n          }\n\n          return cb(null, copyObjResponse)\n        })\n    })\n  }\n\n  // Backward compatibility for Copy Object API.\n  copyObject(...allArgs) {\n    if (allArgs[0] instanceof CopySourceOptions && allArgs[1] instanceof CopyDestinationOptions) {\n      return this.copyObjectV2(...arguments)\n    }\n    return this.copyObjectV1(...arguments)\n  }\n\n  // list a batch of objects\n  listObjectsQuery(bucketName, prefix, marker, listQueryOpts = {}) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(marker)) {\n      throw new TypeError('marker should be of type \"string\"')\n    }\n    let { Delimiter, MaxKeys, IncludeVersion } = listQueryOpts\n\n    if (!isObject(listQueryOpts)) {\n      throw new TypeError('listQueryOpts should be of type \"object\"')\n    }\n\n    if (!isString(Delimiter)) {\n      throw new TypeError('Delimiter should be of type \"string\"')\n    }\n    if (!isNumber(MaxKeys)) {\n      throw new TypeError('MaxKeys should be of type \"number\"')\n    }\n\n    const queries = []\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(Delimiter)}`)\n    queries.push(`encoding-type=url`)\n\n    if (IncludeVersion) {\n      queries.push(`versions`)\n    }\n\n    if (marker) {\n      marker = uriEscape(marker)\n      if (IncludeVersion) {\n        queries.push(`key-marker=${marker}`)\n      } else {\n        queries.push(`marker=${marker}`)\n      }\n    }\n\n    // no need to escape maxKeys\n    if (MaxKeys) {\n      if (MaxKeys >= 1000) {\n        MaxKeys = 1000\n      }\n      queries.push(`max-keys=${MaxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n\n    var method = 'GET'\n    var transformer = transformers.getListObjectsTransformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // List the objects in the bucket.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `listOpts _object_: query params to list object with below keys\n  // *    listOpts.MaxKeys _int_ maximum number of keys to return\n  // *    listOpts.IncludeVersion  _bool_ true|false to include versions.\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  // * `obj.name` _string_: name of the object\n  // * `obj.prefix` _string_: name of the object prefix\n  // * `obj.size` _number_: size of the object\n  // * `obj.etag` _string_: etag of the object\n  // * `obj.lastModified` _Date_: modified time stamp\n  // * `obj.isDeleteMarker` _boolean_: true if it is a delete marker\n  // * `obj.versionId` _string_: versionId of the object\n  listObjects(bucketName, prefix, recursive, listOpts = {}) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isObject(listOpts)) {\n      throw new TypeError('listOpts should be of type \"object\"')\n    }\n    var marker = ''\n    const listQueryOpts = {\n      Delimiter: recursive ? '' : '/', // if recursive is false set delimiter to '/'\n      MaxKeys: 1000,\n      IncludeVersion: listOpts.IncludeVersion,\n    }\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsQuery(bucketName, prefix, marker, listQueryOpts)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            marker = result.nextMarker || result.versionIdMarker\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // listObjectsV2Query - (List Objects V2) - List some or all (up to 1000) of the objects in a bucket.\n  //\n  // You can use the request parameters as selection criteria to return a subset of the objects in a bucket.\n  // request parameters :-\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: Limits the response to keys that begin with the specified prefix.\n  // * `continuation-token` _string_: Used to continue iterating over a set of objects.\n  // * `delimiter` _string_: A delimiter is a character you use to group keys.\n  // * `max-keys` _number_: Sets the maximum number of keys returned in the response body.\n  // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket.\n  listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(continuationToken)) {\n      throw new TypeError('continuationToken should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    if (!isNumber(maxKeys)) {\n      throw new TypeError('maxKeys should be of type \"number\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    var queries = []\n\n    // Call for listing objects v2 API\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (continuationToken) {\n      continuationToken = uriEscape(continuationToken)\n      queries.push(`continuation-token=${continuationToken}`)\n    }\n    // Set start-after\n    if (startAfter) {\n      startAfter = uriEscape(startAfter)\n      queries.push(`start-after=${startAfter}`)\n    }\n    // no need to escape maxKeys\n    if (maxKeys) {\n      if (maxKeys >= 1000) {\n        maxKeys = 1000\n      }\n      queries.push(`max-keys=${maxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListObjectsV2Transformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // List the objects in the bucket using S3 ListObjects V2\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  //   * `obj.name` _string_: name of the object\n  //   * `obj.prefix` _string_: name of the object prefix\n  //   * `obj.size` _number_: size of the object\n  //   * `obj.etag` _string_: etag of the object\n  //   * `obj.lastModified` _Date_: modified time stamp\n  listObjectsV2(bucketName, prefix, recursive, startAfter) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    // if recursive is false set delimiter to '/'\n    var delimiter = recursive ? '' : '/'\n    var continuationToken = ''\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, 1000, startAfter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            continuationToken = result.nextContinuationToken\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // Remove all the objects residing in the objectsList.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectsList` _array_: array of objects of one of the following:\n  // *         List of Object names as array of strings which are object keys:  ['objectname1','objectname2']\n  // *         List of Object name and versionId as an object:  [{name:\"objectname\",versionId:\"my-version-id\"}]\n\n  removeObjects(bucketName, objectsList, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Array.isArray(objectsList)) {\n      throw new errors.InvalidArgumentError('objectsList should be a list')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const maxEntries = 1000\n    const query = 'delete'\n    const method = 'POST'\n\n    let result = objectsList.reduce(\n      (result, entry) => {\n        result.list.push(entry)\n        if (result.list.length === maxEntries) {\n          result.listOfList.push(result.list)\n          result.list = []\n        }\n        return result\n      },\n      { listOfList: [], list: [] },\n    )\n\n    if (result.list.length > 0) {\n      result.listOfList.push(result.list)\n    }\n\n    const encoder = new TextEncoder()\n    const batchResults = []\n\n    async.eachSeries(\n      result.listOfList,\n      (list, batchCb) => {\n        var objects = []\n        list.forEach(function (value) {\n          if (isObject(value)) {\n            objects.push({ Key: value.name, VersionId: value.versionId })\n          } else {\n            objects.push({ Key: value })\n          }\n        })\n        let deleteObjects = { Delete: { Quiet: true, Object: objects } }\n        const builder = new xml2js.Builder({ headless: true })\n        let payload = builder.buildObject(deleteObjects)\n        payload = Buffer.from(encoder.encode(payload))\n        const headers = {}\n\n        headers['Content-MD5'] = toMd5(payload)\n\n        let removeObjectsResult\n        this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', true, (e, response) => {\n          if (e) {\n            return batchCb(e)\n          }\n          pipesetup(response, transformers.removeObjectsTransformer())\n            .on('data', (data) => {\n              removeObjectsResult = data\n            })\n            .on('error', (e) => {\n              return batchCb(e, null)\n            })\n            .on('end', () => {\n              batchResults.push(removeObjectsResult)\n              return batchCb(null, removeObjectsResult)\n            })\n        })\n      },\n      () => {\n        cb(null, _.flatten(batchResults))\n      },\n    )\n  }\n\n  // Get the policy on a bucket or an object prefix.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `callback(err, policy)` _function_: callback function\n  getBucketPolicy(bucketName, cb) {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let method = 'GET'\n    let query = 'policy'\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let policy = Buffer.from('')\n      pipesetup(response, transformers.getConcater())\n        .on('data', (data) => (policy = data))\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, policy.toString())\n        })\n    })\n  }\n\n  // Set the policy on a bucket or an object prefix.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `bucketPolicy` _string_: bucket policy (JSON stringify'ed)\n  // * `callback(err)` _function_: callback function\n  setBucketPolicy(bucketName, policy, cb) {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(policy)) {\n      throw new errors.InvalidBucketPolicyError(`Invalid bucket policy: ${policy} - must be \"string\"`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let method = 'DELETE'\n    let query = 'policy'\n\n    if (policy) {\n      method = 'PUT'\n    }\n\n    this.makeRequest({ method, bucketName, query }, policy, [204], '', false, cb)\n  }\n\n  // Generate a generic presigned URL which can be\n  // used for HTTP methods GET, PUT, HEAD and DELETE\n  //\n  // __Arguments__\n  // * `method` _string_: name of the HTTP method\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  // * `reqParams` _object_: request parameters (optional) e.g {versionId:\"10fa9946-3f64-4137-a58f-888065c0732e\"}\n  // * `requestDate` _Date_: A date object, the url will be issued at (optional)\n  presignedUrl(method, bucketName, objectName, expires, reqParams, requestDate, cb) {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned ' + method + ' url cannot be generated for anonymous requests')\n    }\n    if (isFunction(requestDate)) {\n      cb = requestDate\n      requestDate = new Date()\n    }\n    if (isFunction(reqParams)) {\n      cb = reqParams\n      reqParams = {}\n      requestDate = new Date()\n    }\n    if (isFunction(expires)) {\n      cb = expires\n      reqParams = {}\n      expires = 24 * 60 * 60 * 7 // 7 days in seconds\n      requestDate = new Date()\n    }\n    if (!isNumber(expires)) {\n      throw new TypeError('expires should be of type \"number\"')\n    }\n    if (!isObject(reqParams)) {\n      throw new TypeError('reqParams should be of type \"object\"')\n    }\n    if (!isValidDate(requestDate)) {\n      throw new TypeError('requestDate should be of type \"Date\" and valid')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var query = querystring.stringify(reqParams)\n    this.getBucketRegion(bucketName, (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      // This statement is added to ensure that we send error through\n      // callback on presign failure.\n      var url\n      var reqOptions = this.getRequestOptions({ method, region, bucketName, objectName, query })\n\n      this.checkAndRefreshCreds()\n      try {\n        url = presignSignatureV4(\n          reqOptions,\n          this.accessKey,\n          this.secretKey,\n          this.sessionToken,\n          region,\n          requestDate,\n          expires,\n        )\n      } catch (pe) {\n        return cb(pe)\n      }\n      cb(null, url)\n    })\n  }\n\n  // Generate a presigned URL for GET\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  // * `respHeaders` _object_: response headers to override or request params for query (optional) e.g {versionId:\"10fa9946-3f64-4137-a58f-888065c0732e\"}\n  // * `requestDate` _Date_: A date object, the url will be issued at (optional)\n  presignedGetObject(bucketName, objectName, expires, respHeaders, requestDate, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (isFunction(respHeaders)) {\n      cb = respHeaders\n      respHeaders = {}\n      requestDate = new Date()\n    }\n\n    var validRespHeaders = [\n      'response-content-type',\n      'response-content-language',\n      'response-expires',\n      'response-cache-control',\n      'response-content-disposition',\n      'response-content-encoding',\n    ]\n    validRespHeaders.forEach((header) => {\n      if (respHeaders !== undefined && respHeaders[header] !== undefined && !isString(respHeaders[header])) {\n        throw new TypeError(`response header ${header} should be of type \"string\"`)\n      }\n    })\n    return this.presignedUrl('GET', bucketName, objectName, expires, respHeaders, requestDate, cb)\n  }\n\n  // Generate a presigned URL for PUT. Using this URL, the browser can upload to S3 only with the specified object name.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  presignedPutObject(bucketName, objectName, expires, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    return this.presignedUrl('PUT', bucketName, objectName, expires, cb)\n  }\n\n  // return PostPolicy object\n  newPostPolicy() {\n    return new PostPolicy()\n  }\n\n  // presignedPostPolicy can be used in situations where we want more control on the upload than what\n  // presignedPutObject() provides. i.e Using presignedPostPolicy we will be able to put policy restrictions\n  // on the object's `name` `bucket` `expiry` `Content-Type` `Content-Disposition` `metaData`\n  presignedPostPolicy(postPolicy, cb) {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned POST policy cannot be generated for anonymous requests')\n    }\n    if (!isObject(postPolicy)) {\n      throw new TypeError('postPolicy should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n    this.getBucketRegion(postPolicy.formData.bucket, (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      var date = new Date()\n      var dateStr = makeDateLong(date)\n\n      this.checkAndRefreshCreds()\n\n      if (!postPolicy.policy.expiration) {\n        // 'expiration' is mandatory field for S3.\n        // Set default expiration date of 7 days.\n        var expires = new Date()\n        expires.setSeconds(24 * 60 * 60 * 7)\n        postPolicy.setExpires(expires)\n      }\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-date', dateStr])\n      postPolicy.formData['x-amz-date'] = dateStr\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-algorithm', 'AWS4-HMAC-SHA256'])\n      postPolicy.formData['x-amz-algorithm'] = 'AWS4-HMAC-SHA256'\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-credential', this.accessKey + '/' + getScope(region, date)])\n      postPolicy.formData['x-amz-credential'] = this.accessKey + '/' + getScope(region, date)\n\n      if (this.sessionToken) {\n        postPolicy.policy.conditions.push(['eq', '$x-amz-security-token', this.sessionToken])\n        postPolicy.formData['x-amz-security-token'] = this.sessionToken\n      }\n\n      var policyBase64 = Buffer.from(JSON.stringify(postPolicy.policy)).toString('base64')\n\n      postPolicy.formData.policy = policyBase64\n\n      var signature = postPresignSignatureV4(region, date, this.secretKey, policyBase64)\n\n      postPolicy.formData['x-amz-signature'] = signature\n      var opts = {}\n      opts.region = region\n      opts.bucketName = postPolicy.formData.bucket\n      var reqOptions = this.getRequestOptions(opts)\n      var portStr = this.port == 80 || this.port === 443 ? '' : `:${this.port.toString()}`\n      var urlStr = `${reqOptions.protocol}//${reqOptions.host}${portStr}${reqOptions.path}`\n      cb(null, { postURL: urlStr, formData: postPolicy.formData })\n    })\n  }\n\n  // Complete the multipart upload. After all the parts are uploaded issuing\n  // this call will aggregate the parts on the server into a single object.\n  completeMultipartUpload(bucketName, objectName, uploadId, etags, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isObject(etags)) {\n      throw new TypeError('etags should be of type \"Array\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    var method = 'POST'\n    var query = `uploadId=${uriEscape(uploadId)}`\n\n    var parts = []\n\n    etags.forEach((element) => {\n      parts.push({\n        Part: [\n          {\n            PartNumber: element.part,\n          },\n          {\n            ETag: element.etag,\n          },\n        ],\n      })\n    })\n\n    var payloadObject = { CompleteMultipartUpload: parts }\n    var payload = Xml(payloadObject)\n\n    this.makeRequest({ method, bucketName, objectName, query }, payload, [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getCompleteMultipartTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (result) => {\n          if (result.errCode) {\n            // Multipart Complete API returns an error XML after a 200 http status\n            cb(new errors.S3Error(result.errMessage))\n          } else {\n            const completeMultipartResult = {\n              etag: result.etag,\n              versionId: getVersionId(response.headers),\n            }\n            cb(null, completeMultipartResult)\n          }\n        })\n    })\n  }\n\n  // Called by listIncompleteUploads to fetch a batch of incomplete uploads.\n  listIncompleteUploadsQuery(bucketName, prefix, keyMarker, uploadIdMarker, delimiter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(keyMarker)) {\n      throw new TypeError('keyMarker should be of type \"string\"')\n    }\n    if (!isString(uploadIdMarker)) {\n      throw new TypeError('uploadIdMarker should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    var queries = []\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (keyMarker) {\n      keyMarker = uriEscape(keyMarker)\n      queries.push(`key-marker=${keyMarker}`)\n    }\n    if (uploadIdMarker) {\n      queries.push(`upload-id-marker=${uploadIdMarker}`)\n    }\n\n    var maxUploads = 1000\n    queries.push(`max-uploads=${maxUploads}`)\n    queries.sort()\n    queries.unshift('uploads')\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListMultipartTransformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // Find uploadId of an incomplete upload.\n  findUploadId(bucketName, objectName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n    var latestUpload\n    var listNext = (keyMarker, uploadIdMarker) => {\n      this.listIncompleteUploadsQuery(bucketName, objectName, keyMarker, uploadIdMarker, '')\n        .on('error', (e) => cb(e))\n        .on('data', (result) => {\n          result.uploads.forEach((upload) => {\n            if (upload.key === objectName) {\n              if (!latestUpload || upload.initiated.getTime() > latestUpload.initiated.getTime()) {\n                latestUpload = upload\n                return\n              }\n            }\n          })\n          if (result.isTruncated) {\n            listNext(result.nextKeyMarker, result.nextUploadIdMarker)\n            return\n          }\n          if (latestUpload) {\n            return cb(null, latestUpload.uploadId)\n          }\n          cb(null, undefined)\n        })\n    }\n    listNext('', '')\n  }\n\n  // Remove all the notification configurations in the S3 provider\n  setBucketNotification(bucketName, config, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(config)) {\n      throw new TypeError('notification config should be of type \"Object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'PUT'\n    var query = 'notification'\n    var builder = new xml2js.Builder({\n      rootName: 'NotificationConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    var payload = builder.buildObject(config)\n    this.makeRequest({ method, bucketName, query }, payload, [200], '', false, cb)\n  }\n\n  removeAllBucketNotification(bucketName, cb) {\n    this.setBucketNotification(bucketName, new NotificationConfig(), cb)\n  }\n\n  // Return the list of notification configurations stored\n  // in the S3 provider\n  getBucketNotification(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    var query = 'notification'\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getBucketNotificationTransformer()\n      var bucketNotification\n      pipesetup(response, transformer)\n        .on('data', (result) => (bucketNotification = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, bucketNotification))\n    })\n  }\n\n  // Listens for bucket notifications. Returns an EventEmitter.\n  listenBucketNotification(bucketName, prefix, suffix, events) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix must be of type string')\n    }\n    if (!isString(suffix)) {\n      throw new TypeError('suffix must be of type string')\n    }\n    if (!Array.isArray(events)) {\n      throw new TypeError('events must be of type Array')\n    }\n    let listener = new NotificationPoller(this, bucketName, prefix, suffix, events)\n    listener.start()\n\n    return listener\n  }\n\n  getBucketVersioning(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    var query = 'versioning'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let versionConfig = Buffer.from('')\n      pipesetup(response, transformers.bucketVersioningTransformer())\n        .on('data', (data) => {\n          versionConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, versionConfig)\n        })\n    })\n  }\n\n  setBucketVersioning(bucketName, versionConfig, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Object.keys(versionConfig).length) {\n      throw new errors.InvalidArgumentError('versionConfig should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var method = 'PUT'\n    var query = 'versioning'\n    var builder = new xml2js.Builder({\n      rootName: 'VersioningConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    var payload = builder.buildObject(versionConfig)\n\n    this.makeRequest({ method, bucketName, query }, payload, [200], '', false, cb)\n  }\n\n  /** To set Tags on a bucket or object based on the params\n   *  __Arguments__\n   * taggingParams _object_ Which contains the following properties\n   *  bucketName _string_,\n   *  objectName _string_ (Optional),\n   *  tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   *  putOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   *  cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setTagging(taggingParams) {\n    const { bucketName, objectName, tags, putOpts = {}, cb } = taggingParams\n    const method = 'PUT'\n    let query = 'tagging'\n\n    if (putOpts && putOpts.versionId) {\n      query = `${query}&versionId=${putOpts.versionId}`\n    }\n    const tagsList = []\n    for (const [key, value] of Object.entries(tags)) {\n      tagsList.push({ Key: key, Value: value })\n    }\n    const taggingConfig = {\n      Tagging: {\n        TagSet: {\n          Tag: tagsList,\n        },\n      },\n    }\n    const encoder = new TextEncoder()\n    const headers = {}\n    const builder = new xml2js.Builder({ headless: true, renderOpts: { pretty: false } })\n    let payload = builder.buildObject(taggingConfig)\n    payload = Buffer.from(encoder.encode(payload))\n    headers['Content-MD5'] = toMd5(payload)\n    const requestOptions = { method, bucketName, query, headers }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest(requestOptions, payload, [200], '', false, cb)\n  }\n\n  /** Set Tags on a Bucket\n   * __Arguments__\n   * bucketName _string_\n   * tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setBucketTagging(bucketName, tags, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('maximum tags allowed is 10\"')\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    return this.setTagging({ bucketName, tags, cb })\n  }\n\n  /** Set Tags on an Object\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_\n   *  * tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   *  putOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setObjectTagging(bucketName, objectName, tags, putOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n\n    if (isFunction(putOpts)) {\n      cb = putOpts\n      putOpts = {}\n    }\n\n    if (!isObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('Maximum tags allowed is 10\"')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    return this.setTagging({ bucketName, objectName, tags, putOpts, cb })\n  }\n\n  /** Remove Tags on an Bucket/Object based on params\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_ (optional)\n   * removeOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeTagging({ bucketName, objectName, removeOpts, cb }) {\n    const method = 'DELETE'\n    let query = 'tagging'\n\n    if (removeOpts && Object.keys(removeOpts).length && removeOpts.versionId) {\n      query = `${query}&versionId=${removeOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, objectName, query }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    this.makeRequest(requestOptions, '', [200, 204], '', true, cb)\n  }\n\n  /** Remove Tags associated with a bucket\n   *  __Arguments__\n   * bucketName _string_\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeBucketTagging(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    return this.removeTagging({ bucketName, cb })\n  }\n\n  /** Remove tags associated with an object\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_\n   * removeOpts _object_ (Optional) e.g. {VersionID:\"my-object-version-id\"}\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeObjectTagging(bucketName, objectName, removeOpts, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (isFunction(removeOpts)) {\n      cb = removeOpts\n      removeOpts = {}\n    }\n    if (removeOpts && Object.keys(removeOpts).length && !isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    return this.removeTagging({ bucketName, objectName, removeOpts, cb })\n  }\n\n  /** Get Tags associated with a Bucket\n   *  __Arguments__\n   * bucketName _string_\n   * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  getBucketTagging(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n\n    const method = 'GET'\n    const query = 'tagging'\n    const requestOptions = { method, bucketName, query }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      var transformer = transformers.getTagsTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let tagsList\n      pipesetup(response, transformer)\n        .on('data', (result) => (tagsList = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, tagsList))\n    })\n  }\n\n  /** Get the tags associated with a bucket OR an object\n   * bucketName _string_\n   * objectName _string_ (Optional)\n   * getOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"}\n   * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  getObjectTagging(bucketName, objectName, getOpts = {}, cb = () => false) {\n    const method = 'GET'\n    let query = 'tagging'\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n    if (!isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('getOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    if (getOpts && getOpts.versionId) {\n      query = `${query}&versionId=${getOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, query }\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      const transformer = transformers.getTagsTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let tagsList\n      pipesetup(response, transformer)\n        .on('data', (result) => (tagsList = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, tagsList))\n    })\n  }\n\n  /**\n   * Apply lifecycle configuration on a bucket.\n   * bucketName _string_\n   * policyConfig _object_ a valid policy configuration object.\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  applyBucketLifecycle(bucketName, policyConfig, cb) {\n    const method = 'PUT'\n    const query = 'lifecycle'\n\n    const encoder = new TextEncoder()\n    const headers = {}\n    const builder = new xml2js.Builder({\n      rootName: 'LifecycleConfiguration',\n      headless: true,\n      renderOpts: { pretty: false },\n    })\n    let payload = builder.buildObject(policyConfig)\n    payload = Buffer.from(encoder.encode(payload))\n    const requestOptions = { method, bucketName, query, headers }\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest(requestOptions, payload, [200], '', false, cb)\n  }\n\n  /** Remove lifecycle configuration of a bucket.\n   * bucketName _string_\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeBucketLifecycle(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'lifecycle'\n    this.makeRequest({ method, bucketName, query }, '', [204], '', false, cb)\n  }\n\n  /** Set/Override lifecycle configuration on a bucket. if the configuration is empty, it removes the configuration.\n   * bucketName _string_\n   * lifeCycleConfig _object_ one of the following values: (null or '') to remove the lifecycle configuration. or a valid lifecycle configuration\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setBucketLifecycle(bucketName, lifeCycleConfig = null, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (_.isEmpty(lifeCycleConfig)) {\n      this.removeBucketLifecycle(bucketName, cb)\n    } else {\n      this.applyBucketLifecycle(bucketName, lifeCycleConfig, cb)\n    }\n  }\n\n  /** Get lifecycle configuration on a bucket.\n   * bucketName _string_\n   * `cb(config)` _function_ - callback function with lifecycle configuration as the error argument.\n   */\n  getBucketLifecycle(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'lifecycle'\n    const requestOptions = { method, bucketName, query }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      const transformer = transformers.lifecycleTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let lifecycleConfig\n      pipesetup(response, transformer)\n        .on('data', (result) => (lifecycleConfig = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, lifecycleConfig))\n    })\n  }\n\n  setObjectLockConfig(bucketName, lockConfigOpts = {}, cb) {\n    const retentionModes = [RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE]\n    const validUnits = [RETENTION_VALIDITY_UNITS.DAYS, RETENTION_VALIDITY_UNITS.YEARS]\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (lockConfigOpts.mode && !retentionModes.includes(lockConfigOpts.mode)) {\n      throw new TypeError(`lockConfigOpts.mode should be one of ${retentionModes}`)\n    }\n    if (lockConfigOpts.unit && !validUnits.includes(lockConfigOpts.unit)) {\n      throw new TypeError(`lockConfigOpts.unit should be one of ${validUnits}`)\n    }\n    if (lockConfigOpts.validity && !isNumber(lockConfigOpts.validity)) {\n      throw new TypeError(`lockConfigOpts.validity should be a number`)\n    }\n\n    const method = 'PUT'\n    const query = 'object-lock'\n\n    let config = {\n      ObjectLockEnabled: 'Enabled',\n    }\n    const configKeys = Object.keys(lockConfigOpts)\n    // Check if keys are present and all keys are present.\n    if (configKeys.length > 0) {\n      if (_.difference(configKeys, ['unit', 'mode', 'validity']).length !== 0) {\n        throw new TypeError(\n          `lockConfigOpts.mode,lockConfigOpts.unit,lockConfigOpts.validity all the properties should be specified.`,\n        )\n      } else {\n        config.Rule = {\n          DefaultRetention: {},\n        }\n        if (lockConfigOpts.mode) {\n          config.Rule.DefaultRetention.Mode = lockConfigOpts.mode\n        }\n        if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.DAYS) {\n          config.Rule.DefaultRetention.Days = lockConfigOpts.validity\n        } else if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.YEARS) {\n          config.Rule.DefaultRetention.Years = lockConfigOpts.validity\n        }\n      }\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'ObjectLockConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getObjectLockConfig(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'object-lock'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let objectLockConfig = Buffer.from('')\n      pipesetup(response, transformers.objectLockTransformer())\n        .on('data', (data) => {\n          objectLockConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, objectLockConfig)\n        })\n    })\n  }\n\n  putObjectRetention(bucketName, objectName, retentionOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(retentionOpts)) {\n      throw new errors.InvalidArgumentError('retentionOpts should be of type \"object\"')\n    } else {\n      if (retentionOpts.governanceBypass && !isBoolean(retentionOpts.governanceBypass)) {\n        throw new errors.InvalidArgumentError('Invalid value for governanceBypass', retentionOpts.governanceBypass)\n      }\n      if (\n        retentionOpts.mode &&\n        ![RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE].includes(retentionOpts.mode)\n      ) {\n        throw new errors.InvalidArgumentError('Invalid object retention mode ', retentionOpts.mode)\n      }\n      if (retentionOpts.retainUntilDate && !isString(retentionOpts.retainUntilDate)) {\n        throw new errors.InvalidArgumentError('Invalid value for retainUntilDate', retentionOpts.retainUntilDate)\n      }\n      if (retentionOpts.versionId && !isString(retentionOpts.versionId)) {\n        throw new errors.InvalidArgumentError('Invalid value for versionId', retentionOpts.versionId)\n      }\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'PUT'\n    let query = 'retention'\n\n    const headers = {}\n    if (retentionOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'Retention', renderOpts: { pretty: false }, headless: true })\n    const params = {}\n\n    if (retentionOpts.mode) {\n      params.Mode = retentionOpts.mode\n    }\n    if (retentionOpts.retainUntilDate) {\n      params.RetainUntilDate = retentionOpts.retainUntilDate\n    }\n    if (retentionOpts.versionId) {\n      query += `&versionId=${retentionOpts.versionId}`\n    }\n\n    let payload = builder.buildObject(params)\n\n    headers['Content-MD5'] = toMd5(payload)\n    this.makeRequest({ method, bucketName, objectName, query, headers }, payload, [200, 204], '', false, cb)\n  }\n\n  getObjectRetention(bucketName, objectName, getOpts, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"object\"')\n    } else if (getOpts.versionId && !isString(getOpts.versionId)) {\n      throw new errors.InvalidArgumentError('VersionID should be of type \"string\"')\n    }\n    if (cb && !isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    let query = 'retention'\n    if (getOpts.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let retentionConfig = Buffer.from('')\n      pipesetup(response, transformers.objectRetentionTransformer())\n        .on('data', (data) => {\n          retentionConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, retentionConfig)\n        })\n    })\n  }\n\n  setBucketEncryption(bucketName, encryptionConfig, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (isFunction(encryptionConfig)) {\n      cb = encryptionConfig\n      encryptionConfig = null\n    }\n\n    if (!_.isEmpty(encryptionConfig) && encryptionConfig.Rule.length > 1) {\n      throw new errors.InvalidArgumentError('Invalid Rule length. Only one rule is allowed.: ' + encryptionConfig.Rule)\n    }\n    if (cb && !isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let encryptionObj = encryptionConfig\n    if (_.isEmpty(encryptionConfig)) {\n      encryptionObj = {\n        // Default MinIO Server Supported Rule\n        Rule: [\n          {\n            ApplyServerSideEncryptionByDefault: {\n              SSEAlgorithm: 'AES256',\n            },\n          },\n        ],\n      }\n    }\n\n    let method = 'PUT'\n    let query = 'encryption'\n    let builder = new xml2js.Builder({\n      rootName: 'ServerSideEncryptionConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    let payload = builder.buildObject(encryptionObj)\n\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getBucketEncryption(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'encryption'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let bucketEncConfig = Buffer.from('')\n      pipesetup(response, transformers.bucketEncryptionTransformer())\n        .on('data', (data) => {\n          bucketEncConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, bucketEncConfig)\n        })\n    })\n  }\n  removeBucketEncryption(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'DELETE'\n    const query = 'encryption'\n\n    this.makeRequest({ method, bucketName, query }, '', [204], '', false, cb)\n  }\n\n  getObjectLegalHold(bucketName, objectName, getOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isObject(getOpts)) {\n      throw new TypeError('getOpts should be of type \"Object\"')\n    } else if (Object.keys(getOpts).length > 0 && getOpts.versionId && !isString(getOpts.versionId)) {\n      throw new TypeError('versionId should be of type string.:', getOpts.versionId)\n    }\n\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    const method = 'GET'\n    let query = 'legal-hold'\n\n    if (getOpts.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let legalHoldConfig = Buffer.from('')\n      pipesetup(response, transformers.objectLegalHoldTransformer())\n        .on('data', (data) => {\n          legalHoldConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, legalHoldConfig)\n        })\n    })\n  }\n\n  setObjectLegalHold(bucketName, objectName, setOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    const defaultOpts = {\n      status: LEGAL_HOLD_STATUS.ENABLED,\n    }\n    if (isFunction(setOpts)) {\n      cb = setOpts\n      setOpts = defaultOpts\n    }\n\n    if (!isObject(setOpts)) {\n      throw new TypeError('setOpts should be of type \"Object\"')\n    } else {\n      if (![LEGAL_HOLD_STATUS.ENABLED, LEGAL_HOLD_STATUS.DISABLED].includes(setOpts.status)) {\n        throw new TypeError('Invalid status: ' + setOpts.status)\n      }\n      if (setOpts.versionId && !setOpts.versionId.length) {\n        throw new TypeError('versionId should be of type string.:' + setOpts.versionId)\n      }\n    }\n\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    if (_.isEmpty(setOpts)) {\n      setOpts = {\n        defaultOpts,\n      }\n    }\n\n    const method = 'PUT'\n    let query = 'legal-hold'\n\n    if (setOpts.versionId) {\n      query += `&versionId=${setOpts.versionId}`\n    }\n\n    let config = {\n      Status: setOpts.status,\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'LegalHold', renderOpts: { pretty: false }, headless: true })\n    const payload = builder.buildObject(config)\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, objectName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  /**\n   * Internal method to upload a part during compose object.\n   * @param partConfig __object__ contains the following.\n   *    bucketName __string__\n   *    objectName __string__\n   *    uploadID __string__\n   *    partNumber __number__\n   *    headers __object__\n   * @param cb called with null incase of error.\n   */\n  uploadPartCopy(partConfig, cb) {\n    const { bucketName, objectName, uploadID, partNumber, headers } = partConfig\n\n    const method = 'PUT'\n    let query = `uploadId=${uploadID}&partNumber=${partNumber}`\n    const requestOptions = { method, bucketName, objectName: objectName, query, headers }\n    return this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      let partCopyResult = Buffer.from('')\n      if (e) {\n        return cb(e)\n      }\n      pipesetup(response, transformers.uploadPartTransformer())\n        .on('data', (data) => {\n          partCopyResult = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          let uploadPartCopyRes = {\n            etag: sanitizeETag(partCopyResult.ETag),\n            key: objectName,\n            part: partNumber,\n          }\n\n          cb(null, uploadPartCopyRes)\n        })\n    })\n  }\n\n  composeObject(destObjConfig = {}, sourceObjList = [], cb) {\n    const me = this // many async flows. so store the ref.\n    const sourceFilesLength = sourceObjList.length\n\n    if (!Array.isArray(sourceObjList)) {\n      throw new errors.InvalidArgumentError('sourceConfig should an array of CopySourceOptions ')\n    }\n    if (!(destObjConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n\n    if (sourceFilesLength < 1 || sourceFilesLength > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n      throw new errors.InvalidArgumentError(\n        `\"There must be as least one and up to ${PART_CONSTRAINTS.MAX_PARTS_COUNT} source objects.`,\n      )\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    for (let i = 0; i < sourceFilesLength; i++) {\n      if (!sourceObjList[i].validate()) {\n        return false\n      }\n    }\n\n    if (!destObjConfig.validate()) {\n      return false\n    }\n\n    const getStatOptions = (srcConfig) => {\n      let statOpts = {}\n      if (!_.isEmpty(srcConfig.VersionID)) {\n        statOpts = {\n          versionId: srcConfig.VersionID,\n        }\n      }\n      return statOpts\n    }\n    const srcObjectSizes = []\n    let totalSize = 0\n    let totalParts = 0\n\n    const sourceObjStats = sourceObjList.map((srcItem) =>\n      me.statObject(srcItem.Bucket, srcItem.Object, getStatOptions(srcItem)),\n    )\n\n    return Promise.all(sourceObjStats)\n      .then((srcObjectInfos) => {\n        const validatedStats = srcObjectInfos.map((resItemStat, index) => {\n          const srcConfig = sourceObjList[index]\n\n          let srcCopySize = resItemStat.size\n          // Check if a segment is specified, and if so, is the\n          // segment within object bounds?\n          if (srcConfig.MatchRange) {\n            // Since range is specified,\n            //    0 <= src.srcStart <= src.srcEnd\n            // so only invalid case to check is:\n            const srcStart = srcConfig.Start\n            const srcEnd = srcConfig.End\n            if (srcEnd >= srcCopySize || srcStart < 0) {\n              throw new errors.InvalidArgumentError(\n                `CopySrcOptions ${index} has invalid segment-to-copy [${srcStart}, ${srcEnd}] (size is ${srcCopySize})`,\n              )\n            }\n            srcCopySize = srcEnd - srcStart + 1\n          }\n\n          // Only the last source may be less than `absMinPartSize`\n          if (srcCopySize < PART_CONSTRAINTS.ABS_MIN_PART_SIZE && index < sourceFilesLength - 1) {\n            throw new errors.InvalidArgumentError(\n              `CopySrcOptions ${index} is too small (${srcCopySize}) and it is not the last part.`,\n            )\n          }\n\n          // Is data to copy too large?\n          totalSize += srcCopySize\n          if (totalSize > PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE) {\n            throw new errors.InvalidArgumentError(`Cannot compose an object of size ${totalSize} (> 5TiB)`)\n          }\n\n          // record source size\n          srcObjectSizes[index] = srcCopySize\n\n          // calculate parts needed for current source\n          totalParts += partsRequired(srcCopySize)\n          // Do we need more parts than we are allowed?\n          if (totalParts > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n            throw new errors.InvalidArgumentError(\n              `Your proposed compose object requires more than ${PART_CONSTRAINTS.MAX_PARTS_COUNT} parts`,\n            )\n          }\n\n          return resItemStat\n        })\n\n        if ((totalParts === 1 && totalSize <= PART_CONSTRAINTS.MAX_PART_SIZE) || totalSize === 0) {\n          return this.copyObject(sourceObjList[0], destObjConfig, cb) // use copyObjectV2\n        }\n\n        // preserve etag to avoid modification of object while copying.\n        for (let i = 0; i < sourceFilesLength; i++) {\n          sourceObjList[i].MatchETag = validatedStats[i].etag\n        }\n\n        const splitPartSizeList = validatedStats.map((resItemStat, idx) => {\n          const calSize = calculateEvenSplits(srcObjectSizes[idx], sourceObjList[idx])\n          return calSize\n        })\n\n        function getUploadPartConfigList(uploadId) {\n          const uploadPartConfigList = []\n\n          splitPartSizeList.forEach((splitSize, splitIndex) => {\n            const { startIndex: startIdx, endIndex: endIdx, objInfo: objConfig } = splitSize\n\n            let partIndex = splitIndex + 1 // part index starts from 1.\n            const totalUploads = Array.from(startIdx)\n\n            const headers = sourceObjList[splitIndex].getHeaders()\n\n            totalUploads.forEach((splitStart, upldCtrIdx) => {\n              let splitEnd = endIdx[upldCtrIdx]\n\n              const sourceObj = `${objConfig.Bucket}/${objConfig.Object}`\n              headers['x-amz-copy-source'] = `${sourceObj}`\n              headers['x-amz-copy-source-range'] = `bytes=${splitStart}-${splitEnd}`\n\n              const uploadPartConfig = {\n                bucketName: destObjConfig.Bucket,\n                objectName: destObjConfig.Object,\n                uploadID: uploadId,\n                partNumber: partIndex,\n                headers: headers,\n                sourceObj: sourceObj,\n              }\n\n              uploadPartConfigList.push(uploadPartConfig)\n            })\n          })\n\n          return uploadPartConfigList\n        }\n\n        const performUploadParts = (uploadId) => {\n          const uploadList = getUploadPartConfigList(uploadId)\n\n          async.map(uploadList, me.uploadPartCopy.bind(me), (err, res) => {\n            if (err) {\n              this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId).then(\n                () => cb(),\n                (err) => cb(err),\n              )\n              return\n            }\n            const partsDone = res.map((partCopy) => ({ etag: partCopy.etag, part: partCopy.part }))\n            return me.completeMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, partsDone, cb)\n          })\n        }\n\n        const newUploadHeaders = destObjConfig.getHeaders()\n\n        me.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders).then(\n          (uploadId) => {\n            performUploadParts(uploadId)\n          },\n          (err) => {\n            cb(err, null)\n          },\n        )\n      })\n      .catch((error) => {\n        cb(error, null)\n      })\n  }\n  selectObjectContent(bucketName, objectName, selectOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!_.isEmpty(selectOpts)) {\n      if (!isString(selectOpts.expression)) {\n        throw new TypeError('sqlExpression should be of type \"string\"')\n      }\n      if (!_.isEmpty(selectOpts.inputSerialization)) {\n        if (!isObject(selectOpts.inputSerialization)) {\n          throw new TypeError('inputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('inputSerialization is required')\n      }\n      if (!_.isEmpty(selectOpts.outputSerialization)) {\n        if (!isObject(selectOpts.outputSerialization)) {\n          throw new TypeError('outputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('outputSerialization is required')\n      }\n    } else {\n      throw new TypeError('valid select configuration is required')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'POST'\n    let query = `select`\n    query += '&select-type=2'\n\n    const config = [\n      {\n        Expression: selectOpts.expression,\n      },\n      {\n        ExpressionType: selectOpts.expressionType || 'SQL',\n      },\n      {\n        InputSerialization: [selectOpts.inputSerialization],\n      },\n      {\n        OutputSerialization: [selectOpts.outputSerialization],\n      },\n    ]\n\n    // Optional\n    if (selectOpts.requestProgress) {\n      config.push({ RequestProgress: selectOpts.requestProgress })\n    }\n    // Optional\n    if (selectOpts.scanRange) {\n      config.push({ ScanRange: selectOpts.scanRange })\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'SelectObjectContentRequest',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    this.makeRequest({ method, bucketName, objectName, query }, payload, [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let selectResult\n      pipesetup(response, transformers.selectObjectContentTransformer())\n        .on('data', (data) => {\n          selectResult = parseSelectObjectContentResponse(data)\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, selectResult)\n        })\n    })\n  }\n}\n\n// Promisify various public-facing APIs on the Client module.\nClient.prototype.makeBucket = promisify(Client.prototype.makeBucket)\nClient.prototype.bucketExists = promisify(Client.prototype.bucketExists)\n\nClient.prototype.getObject = promisify(Client.prototype.getObject)\nClient.prototype.getPartialObject = promisify(Client.prototype.getPartialObject)\nClient.prototype.fGetObject = promisify(Client.prototype.fGetObject)\nClient.prototype.putObject = promisify(Client.prototype.putObject)\nClient.prototype.fPutObject = promisify(Client.prototype.fPutObject)\nClient.prototype.copyObject = promisify(Client.prototype.copyObject)\nClient.prototype.removeObjects = promisify(Client.prototype.removeObjects)\n\nClient.prototype.presignedUrl = promisify(Client.prototype.presignedUrl)\nClient.prototype.presignedGetObject = promisify(Client.prototype.presignedGetObject)\nClient.prototype.presignedPutObject = promisify(Client.prototype.presignedPutObject)\nClient.prototype.presignedPostPolicy = promisify(Client.prototype.presignedPostPolicy)\nClient.prototype.getBucketNotification = promisify(Client.prototype.getBucketNotification)\nClient.prototype.setBucketNotification = promisify(Client.prototype.setBucketNotification)\nClient.prototype.removeAllBucketNotification = promisify(Client.prototype.removeAllBucketNotification)\nClient.prototype.getBucketPolicy = promisify(Client.prototype.getBucketPolicy)\nClient.prototype.setBucketPolicy = promisify(Client.prototype.setBucketPolicy)\nClient.prototype.removeIncompleteUpload = promisify(Client.prototype.removeIncompleteUpload)\nClient.prototype.getBucketVersioning = promisify(Client.prototype.getBucketVersioning)\nClient.prototype.setBucketVersioning = promisify(Client.prototype.setBucketVersioning)\nClient.prototype.setBucketTagging = promisify(Client.prototype.setBucketTagging)\nClient.prototype.removeBucketTagging = promisify(Client.prototype.removeBucketTagging)\nClient.prototype.getBucketTagging = promisify(Client.prototype.getBucketTagging)\nClient.prototype.setObjectTagging = promisify(Client.prototype.setObjectTagging)\nClient.prototype.removeObjectTagging = promisify(Client.prototype.removeObjectTagging)\nClient.prototype.getObjectTagging = promisify(Client.prototype.getObjectTagging)\nClient.prototype.setBucketLifecycle = promisify(Client.prototype.setBucketLifecycle)\nClient.prototype.getBucketLifecycle = promisify(Client.prototype.getBucketLifecycle)\nClient.prototype.removeBucketLifecycle = promisify(Client.prototype.removeBucketLifecycle)\nClient.prototype.setObjectLockConfig = promisify(Client.prototype.setObjectLockConfig)\nClient.prototype.getObjectLockConfig = promisify(Client.prototype.getObjectLockConfig)\nClient.prototype.putObjectRetention = promisify(Client.prototype.putObjectRetention)\nClient.prototype.getObjectRetention = promisify(Client.prototype.getObjectRetention)\nClient.prototype.setBucketEncryption = promisify(Client.prototype.setBucketEncryption)\nClient.prototype.getBucketEncryption = promisify(Client.prototype.getBucketEncryption)\nClient.prototype.removeBucketEncryption = promisify(Client.prototype.removeBucketEncryption)\nClient.prototype.setObjectLegalHold = promisify(Client.prototype.setObjectLegalHold)\nClient.prototype.getObjectLegalHold = promisify(Client.prototype.getObjectLegalHold)\nClient.prototype.composeObject = promisify(Client.prototype.composeObject)\nClient.prototype.selectObjectContent = promisify(Client.prototype.selectObjectContent)\n\n// refactored API use promise internally\nClient.prototype.removeObject = callbackify(Client.prototype.removeObject)\nClient.prototype.statObject = callbackify(Client.prototype.statObject)\nClient.prototype.removeBucket = callbackify(Client.prototype.removeBucket)\nClient.prototype.listBuckets = callbackify(Client.prototype.listBuckets)\nClient.prototype.removeBucketReplication = callbackify(Client.prototype.removeBucketReplication)\nClient.prototype.setBucketReplication = callbackify(Client.prototype.setBucketReplication)\nClient.prototype.getBucketReplication = callbackify(Client.prototype.getBucketReplication)\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["fs","_interopRequireWildcard","require","path","Stream","_async","_blockStream","_lodash","querystring","_webEncoding","_xml","_xml2js","errors","_extensions","_helpers","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","_client","_copyConditions","CopyConditions","_helper","_postPolicy","PostPolicy","_type","_notification","_objectUploader","_promisify","_signing","transformers","_xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","defineProperty","getOwnPropertyDescriptor","desc","set","Client","TypedClient","setAppInfo","appName","appVersion","isString","TypeError","trim","InvalidArgumentError","userAgent","calculatePartSize","size","isNumber","maxObjectSize","overRidePartSize","partSize","logHTTP","reqOptions","response","err","logStream","isObject","isReadableStream","Error","logHeaders","headers","_","v","k","redacter","RegExp","replace","write","method","statusCode","errJSON","JSON","stringify","traceOn","stream","process","stdout","traceOff","makeRequest","options","payload","statusCodes","region","returnResponse","cb","isBoolean","isFunction","length","sha256sum","enableSHA256","toSha256","readableStream","makeRequestStream","_makeRequest","e","getRequestOptions","anonymous","date","Date","makeDateLong","sessionToken","checkAndRefreshCreds","authorization","signV4","accessKey","secretKey","req","transport","request","includes","regionMap","bucketName","errorTransformer","getErrorTransformer","pipesetup","on","pipe","getBucketRegion","isValidBucketName","InvalidBucketNameError","extractRegion","transformer","getBucketRegionTransformer","DEFAULT_REGION","data","query","pathStyle","window","name","Region","makeBucket","makeOpts","createBucketConfiguration","push","_attr","xmlns","LocationConstraint","payloadObject","CreateBucketConfiguration","Xml","ObjectLocking","processWithRetry","code","listBuckets","getListBucketTransformer","buckets","result","listIncompleteUploads","bucket","prefix","recursive","undefined","isValidPrefix","InvalidPrefixError","delimiter","keyMarker","uploadIdMarker","uploads","ended","readStream","Readable","objectMode","_read","shift","listIncompleteUploadsQuery","emit","prefixes","async","eachSeries","upload","listParts","uploadId","parts","reduce","acc","item","isTruncated","nextKeyMarker","nextUploadIdMarker","bucketExists","removeBucket","removeIncompleteUpload","objectName","IsValidBucketNameError","isValidObjectName","InvalidObjectNameError","removeUploadId","during","findUploadId","fGetObject","filePath","getOpts","partFile","partFileStream","objStat","rename","waterfall","statObject","mkdir","dirname","etag","stat","stats","offset","createWriteStream","flags","getPartialObject","downloadStream","getObject","range","expectedStatusCodes","fPutObject","metaData","callback","insertContentType","prependXAMZMeta","cbTriggered","origCb","destroy","apply","arguments","multipart","uploader","getUploader","hash","getHashSummer","start","end","autoClose","createReadStream","md5sum","objInfo","etags","initiateNewMultipartUpload","part","partsDone","partNumber","uploadedSize","whilst","md5sumHex","Buffer","from","toString","completeMultipartUpload","rest","putObject","chunker","BlockStream2","zeroPadding","ObjectUploader","copyObjectV1","arg1","arg2","arg3","arg4","arg5","srcObject","conditions","uriResourceEscape","modified","unmodified","matchETag","matchEtagExcept","matchETagExcept","getCopyObjectTransformer","copyObjectV2","sourceConfig","destConfig","CopySourceOptions","CopyDestinationOptions","validate","assign","getHeaders","Bucket","resHeaders","copyObjResponse","Key","LastModified","MetaData","extractMetadata","VersionId","getVersionId","SourceVersionId","getSourceVersionId","Etag","sanitizeETag","Size","copyObject","allArgs","listObjectsQuery","marker","listQueryOpts","Delimiter","MaxKeys","IncludeVersion","queries","uriEscape","sort","join","getListObjectsTransformer","listObjects","listOpts","objects","nextMarker","versionIdMarker","listObjectsV2Query","continuationToken","maxKeys","startAfter","getListObjectsV2Transformer","listObjectsV2","nextContinuationToken","statOpts","lastModified","versionId","removeObject","removeOpts","queryParams","governanceBypass","forceDelete","requestOptions","removeObjects","objectsList","Array","isArray","maxEntries","entry","list","listOfList","encoder","TextEncoder","batchResults","batchCb","value","deleteObjects","Delete","Quiet","builder","xml2js","Builder","headless","buildObject","encode","toMd5","removeObjectsResult","removeObjectsTransformer","flatten","getBucketPolicy","policy","getConcater","setBucketPolicy","InvalidBucketPolicyError","presignedUrl","expires","reqParams","requestDate","AnonymousRequestError","isValidDate","url","presignSignatureV4","pe","presignedGetObject","respHeaders","validRespHeaders","header","presignedPutObject","newPostPolicy","presignedPostPolicy","postPolicy","formData","dateStr","expiration","setSeconds","setExpires","getScope","policyBase64","signature","postPresignSignatureV4","opts","portStr","port","urlStr","protocol","host","postURL","getInitiateMultipartTransformer","element","Part","PartNumber","ETag","CompleteMultipartUpload","getCompleteMultipartTransformer","errCode","S3Error","errMessage","completeMultipartResult","listNext","listPartsQuery","concat","getListPartsTransformer","maxUploads","unshift","getListMultipartTransformer","latestUpload","initiated","getTime","simpleUploader","args","multipartUploader","setBucketNotification","config","rootName","renderOpts","pretty","removeAllBucketNotification","NotificationConfig","getBucketNotification","getBucketNotificationTransformer","bucketNotification","listenBucketNotification","suffix","events","listener","NotificationPoller","getBucketVersioning","versionConfig","bucketVersioningTransformer","setBucketVersioning","setTagging","taggingParams","tags","putOpts","tagsList","entries","Value","taggingConfig","Tagging","TagSet","Tag","setBucketTagging","setObjectTagging","removeTagging","removeBucketTagging","removeObjectTagging","getBucketTagging","getTagsTransformer","getObjectTagging","applyBucketLifecycle","policyConfig","removeBucketLifecycle","setBucketLifecycle","lifeCycleConfig","isEmpty","getBucketLifecycle","lifecycleTransformer","lifecycleConfig","setObjectLockConfig","lockConfigOpts","retentionModes","RETENTION_MODES","COMPLIANCE","GOVERNANCE","validUnits","RETENTION_VALIDITY_UNITS","DAYS","YEARS","mode","unit","validity","ObjectLockEnabled","configKeys","difference","Rule","DefaultRetention","Mode","Days","Years","getObjectLockConfig","objectLockConfig","objectLockTransformer","putObjectRetention","retentionOpts","retainUntilDate","params","RetainUntilDate","getObjectRetention","retentionConfig","objectRetentionTransformer","setBucketEncryption","encryptionConfig","encryptionObj","ApplyServerSideEncryptionByDefault","SSEAlgorithm","getBucketEncryption","bucketEncConfig","bucketEncryptionTransformer","removeBucketEncryption","setBucketReplication","replicationConfig","role","rules","replicationParamsConfig","ReplicationConfiguration","Role","getBucketReplication","replicationConfigTransformer","removeBucketReplication","getObjectLegalHold","legalHoldConfig","objectLegalHoldTransformer","setObjectLegalHold","setOpts","defaultOpts","status","LEGAL_HOLD_STATUS","ENABLED","DISABLED","Status","abortMultipartUpload","uploadPartCopy","partConfig","uploadID","partCopyResult","uploadPartTransformer","uploadPartCopyRes","composeObject","destObjConfig","sourceObjList","me","sourceFilesLength","PART_CONSTRAINTS","MAX_PARTS_COUNT","i","getStatOptions","srcConfig","VersionID","srcObjectSizes","totalSize","totalParts","sourceObjStats","map","srcItem","Promise","all","then","srcObjectInfos","validatedStats","resItemStat","index","srcCopySize","MatchRange","srcStart","Start","srcEnd","End","ABS_MIN_PART_SIZE","MAX_MULTIPART_PUT_OBJECT_SIZE","partsRequired","MAX_PART_SIZE","MatchETag","splitPartSizeList","idx","calSize","calculateEvenSplits","getUploadPartConfigList","uploadPartConfigList","splitSize","splitIndex","startIndex","startIdx","endIndex","endIdx","objConfig","partIndex","totalUploads","splitStart","upldCtrIdx","splitEnd","sourceObj","uploadPartConfig","performUploadParts","uploadList","bind","res","partCopy","newUploadHeaders","catch","error","selectObjectContent","selectOpts","expression","inputSerialization","outputSerialization","Expression","ExpressionType","expressionType","InputSerialization","OutputSerialization","requestProgress","RequestProgress","scanRange","ScanRange","selectResult","selectObjectContentTransformer","parseSelectObjectContentResponse","extensions","clientExtensions","promisify"],"sources":["minio.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport * as Stream from 'node:stream'\n\nimport async from 'async'\nimport BlockStream2 from 'block-stream2'\nimport _ from 'lodash'\nimport * as querystring from 'query-string'\nimport { TextEncoder } from 'web-encoding'\nimport Xml from 'xml'\nimport xml2js from 'xml2js'\n\nimport * as errors from './errors.ts'\nimport { extensions } from './extensions.js'\nimport { CopyDestinationOptions, CopySourceOptions, DEFAULT_REGION } from './helpers.ts'\nimport { TypedClient } from './internal/client.ts'\nimport { CopyConditions } from './internal/copy-conditions.ts'\nimport {\n  calculateEvenSplits,\n  extractMetadata,\n  getScope,\n  getSourceVersionId,\n  getVersionId,\n  insertContentType,\n  isBoolean,\n  isFunction,\n  isNumber,\n  isObject,\n  isReadableStream,\n  isString,\n  isValidBucketName,\n  isValidDate,\n  isValidObjectName,\n  isValidPrefix,\n  makeDateLong,\n  PART_CONSTRAINTS,\n  partsRequired,\n  pipesetup,\n  prependXAMZMeta,\n  readableStream,\n  sanitizeETag,\n  toMd5,\n  toSha256,\n  uriEscape,\n  uriResourceEscape,\n} from './internal/helper.ts'\nimport { PostPolicy } from './internal/post-policy.ts'\nimport { LEGAL_HOLD_STATUS, RETENTION_MODES, RETENTION_VALIDITY_UNITS } from './internal/type.ts'\nimport { NotificationConfig, NotificationPoller } from './notification.js'\nimport { ObjectUploader } from './object-uploader.js'\nimport { promisify } from './promisify.js'\nimport { postPresignSignatureV4, presignSignatureV4, signV4 } from './signing.ts'\nimport * as transformers from './transformers.js'\nimport { parseSelectObjectContentResponse } from './xml-parsers.js'\n\nexport * from './helpers.ts'\nexport * from './notification.js'\nexport { CopyConditions, PostPolicy }\n\nexport class Client extends TypedClient {\n  // Set application specific information.\n  //\n  // Generates User-Agent in the following style.\n  //\n  //       MinIO (OS; ARCH) LIB/VER APP/VER\n  //\n  // __Arguments__\n  // * `appName` _string_ - Application name.\n  // * `appVersion` _string_ - Application version.\n  setAppInfo(appName, appVersion) {\n    if (!isString(appName)) {\n      throw new TypeError(`Invalid appName: ${appName}`)\n    }\n    if (appName.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appName cannot be empty.')\n    }\n    if (!isString(appVersion)) {\n      throw new TypeError(`Invalid appVersion: ${appVersion}`)\n    }\n    if (appVersion.trim() === '') {\n      throw new errors.InvalidArgumentError('Input appVersion cannot be empty.')\n    }\n    this.userAgent = `${this.userAgent} ${appName}/${appVersion}`\n  }\n\n  // Calculate part size given the object size. Part size will be atleast this.partSize\n  calculatePartSize(size) {\n    if (!isNumber(size)) {\n      throw new TypeError('size should be of type \"number\"')\n    }\n    if (size > this.maxObjectSize) {\n      throw new TypeError(`size should not be more than ${this.maxObjectSize}`)\n    }\n    if (this.overRidePartSize) {\n      return this.partSize\n    }\n    var partSize = this.partSize\n    for (;;) {\n      // while(true) {...} throws linting error.\n      // If partSize is big enough to accomodate the object size, then use it.\n      if (partSize * 10000 > size) {\n        return partSize\n      }\n      // Try part sizes as 64MB, 80MB, 96MB etc.\n      partSize += 16 * 1024 * 1024\n    }\n  }\n\n  // log the request, response, error\n  logHTTP(reqOptions, response, err) {\n    // if no logstreamer available return.\n    if (!this.logStream) {\n      return\n    }\n    if (!isObject(reqOptions)) {\n      throw new TypeError('reqOptions should be of type \"object\"')\n    }\n    if (response && !isReadableStream(response)) {\n      throw new TypeError('response should be of type \"Stream\"')\n    }\n    if (err && !(err instanceof Error)) {\n      throw new TypeError('err should be of type \"Error\"')\n    }\n    var logHeaders = (headers) => {\n      _.forEach(headers, (v, k) => {\n        if (k == 'authorization') {\n          var redacter = new RegExp('Signature=([0-9a-f]+)')\n          v = v.replace(redacter, 'Signature=**REDACTED**')\n        }\n        this.logStream.write(`${k}: ${v}\\n`)\n      })\n      this.logStream.write('\\n')\n    }\n    this.logStream.write(`REQUEST: ${reqOptions.method} ${reqOptions.path}\\n`)\n    logHeaders(reqOptions.headers)\n    if (response) {\n      this.logStream.write(`RESPONSE: ${response.statusCode}\\n`)\n      logHeaders(response.headers)\n    }\n    if (err) {\n      this.logStream.write('ERROR BODY:\\n')\n      var errJSON = JSON.stringify(err, null, '\\t')\n      this.logStream.write(`${errJSON}\\n`)\n    }\n  }\n\n  // Enable tracing\n  traceOn(stream) {\n    if (!stream) {\n      stream = process.stdout\n    }\n    this.logStream = stream\n  }\n\n  // Disable tracing\n  traceOff() {\n    this.logStream = null\n  }\n\n  // makeRequest is the primitive used by the apis for making S3 requests.\n  // payload can be empty string in case of no payload.\n  // statusCode is the expected statusCode. If response.statusCode does not match\n  // we parse the XML error and call the callback with the error message.\n  // A valid region is passed by the calls - listBuckets, makeBucket and\n  // getBucketRegion.\n  makeRequest(options, payload, statusCodes, region, returnResponse, cb) {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!isString(payload) && !isObject(payload)) {\n      // Buffer is of type 'object'\n      throw new TypeError('payload should be of type \"string\" or \"Buffer\"')\n    }\n    statusCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!isBoolean(returnResponse)) {\n      throw new TypeError('returnResponse should be of type \"boolean\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    if (!options.headers) {\n      options.headers = {}\n    }\n    if (options.method === 'POST' || options.method === 'PUT' || options.method === 'DELETE') {\n      options.headers['content-length'] = payload.length\n    }\n    var sha256sum = ''\n    if (this.enableSHA256) {\n      sha256sum = toSha256(payload)\n    }\n    var stream = readableStream(payload)\n    this.makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb)\n  }\n\n  // makeRequestStream will be used directly instead of makeRequest in case the payload\n  // is available as a stream. for ex. putObject\n  makeRequestStream(options, stream, sha256sum, statusCodes, region, returnResponse, cb) {\n    if (!isObject(options)) {\n      throw new TypeError('options should be of type \"object\"')\n    }\n    if (!isReadableStream(stream)) {\n      throw new errors.InvalidArgumentError('stream should be a readable Stream')\n    }\n    if (!isString(sha256sum)) {\n      throw new TypeError('sha256sum should be of type \"string\"')\n    }\n    statusCodes.forEach((statusCode) => {\n      if (!isNumber(statusCode)) {\n        throw new TypeError('statusCode should be of type \"number\"')\n      }\n    })\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!isBoolean(returnResponse)) {\n      throw new TypeError('returnResponse should be of type \"boolean\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    // sha256sum will be empty for anonymous or https requests\n    if (!this.enableSHA256 && sha256sum.length !== 0) {\n      throw new errors.InvalidArgumentError(`sha256sum expected to be empty for anonymous or https requests`)\n    }\n    // sha256sum should be valid for non-anonymous http requests.\n    if (this.enableSHA256 && sha256sum.length !== 64) {\n      throw new errors.InvalidArgumentError(`Invalid sha256sum : ${sha256sum}`)\n    }\n\n    var _makeRequest = (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      options.region = region\n      var reqOptions = this.getRequestOptions(options)\n      if (!this.anonymous) {\n        // For non-anonymous https requests sha256sum is 'UNSIGNED-PAYLOAD' for signature calculation.\n        if (!this.enableSHA256) {\n          sha256sum = 'UNSIGNED-PAYLOAD'\n        }\n\n        let date = new Date()\n\n        reqOptions.headers['x-amz-date'] = makeDateLong(date)\n        reqOptions.headers['x-amz-content-sha256'] = sha256sum\n        if (this.sessionToken) {\n          reqOptions.headers['x-amz-security-token'] = this.sessionToken\n        }\n\n        this.checkAndRefreshCreds()\n        var authorization = signV4(reqOptions, this.accessKey, this.secretKey, region, date, sha256sum)\n        reqOptions.headers.authorization = authorization\n      }\n      var req = this.transport.request(reqOptions, (response) => {\n        if (!statusCodes.includes(response.statusCode)) {\n          // For an incorrect region, S3 server always sends back 400.\n          // But we will do cache invalidation for all errors so that,\n          // in future, if AWS S3 decides to send a different status code or\n          // XML error code we will still work fine.\n          delete this.regionMap[options.bucketName]\n          var errorTransformer = transformers.getErrorTransformer(response)\n          pipesetup(response, errorTransformer).on('error', (e) => {\n            this.logHTTP(reqOptions, response, e)\n            cb(e)\n          })\n          return\n        }\n        this.logHTTP(reqOptions, response)\n        if (returnResponse) {\n          return cb(null, response)\n        }\n        // We drain the socket so that the connection gets closed. Note that this\n        // is not expensive as the socket will not have any data.\n        response.on('data', () => {})\n        cb(null)\n      })\n      let pipe = pipesetup(stream, req)\n      pipe.on('error', (e) => {\n        this.logHTTP(reqOptions, null, e)\n        cb(e)\n      })\n    }\n    if (region) {\n      return _makeRequest(null, region)\n    }\n    this.getBucketRegion(options.bucketName, _makeRequest)\n  }\n\n  // gets the region of the bucket\n  getBucketRegion(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name : ${bucketName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n\n    // Region is set with constructor, return the region right here.\n    if (this.region) {\n      return cb(null, this.region)\n    }\n\n    if (this.regionMap[bucketName]) {\n      return cb(null, this.regionMap[bucketName])\n    }\n    var extractRegion = (response) => {\n      var transformer = transformers.getBucketRegionTransformer()\n      var region = DEFAULT_REGION\n      pipesetup(response, transformer)\n        .on('error', cb)\n        .on('data', (data) => {\n          if (data) {\n            region = data\n          }\n        })\n        .on('end', () => {\n          this.regionMap[bucketName] = region\n          cb(null, region)\n        })\n    }\n\n    var method = 'GET'\n    var query = 'location'\n\n    // `getBucketLocation` behaves differently in following ways for\n    // different environments.\n    //\n    // - For nodejs env we default to path style requests.\n    // - For browser env path style requests on buckets yields CORS\n    //   error. To circumvent this problem we make a virtual host\n    //   style request signed with 'us-east-1'. This request fails\n    //   with an error 'AuthorizationHeaderMalformed', additionally\n    //   the error XML also provides Region of the bucket. To validate\n    //   this region is proper we retry the same request with the newly\n    //   obtained region.\n    var pathStyle = this.pathStyle && typeof window === 'undefined'\n\n    this.makeRequest({ method, bucketName, query, pathStyle }, '', [200], DEFAULT_REGION, true, (e, response) => {\n      if (e) {\n        if (e.name === 'AuthorizationHeaderMalformed') {\n          var region = e.Region\n          if (!region) {\n            return cb(e)\n          }\n          this.makeRequest({ method, bucketName, query }, '', [200], region, true, (e, response) => {\n            if (e) {\n              return cb(e)\n            }\n            extractRegion(response)\n          })\n          return\n        }\n        return cb(e)\n      }\n      extractRegion(response)\n    })\n  }\n\n  // Creates the bucket `bucketName`.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ - Name of the bucket\n  // * `region` _string_ - region valid values are _us-west-1_, _us-west-2_,  _eu-west-1_, _eu-central-1_, _ap-southeast-1_, _ap-northeast-1_, _ap-southeast-2_, _sa-east-1_.\n  // * `makeOpts` _object_ - Options to create a bucket. e.g {ObjectLocking:true} (Optional)\n  // * `callback(err)` _function_ - callback function with `err` as the error argument. `err` is null if the bucket is successfully created.\n  makeBucket(bucketName, region, makeOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    // Backward Compatibility\n    if (isObject(region)) {\n      cb = makeOpts\n      makeOpts = region\n      region = ''\n    }\n    if (isFunction(region)) {\n      cb = region\n      region = ''\n      makeOpts = {}\n    }\n    if (isFunction(makeOpts)) {\n      cb = makeOpts\n      makeOpts = {}\n    }\n\n    if (!isString(region)) {\n      throw new TypeError('region should be of type \"string\"')\n    }\n    if (!isObject(makeOpts)) {\n      throw new TypeError('makeOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var payload = ''\n\n    // Region already set in constructor, validate if\n    // caller requested bucket location is same.\n    if (region && this.region) {\n      if (region !== this.region) {\n        throw new errors.InvalidArgumentError(`Configured region ${this.region}, requested ${region}`)\n      }\n    }\n    // sending makeBucket request with XML containing 'us-east-1' fails. For\n    // default region server expects the request without body\n    if (region && region !== DEFAULT_REGION) {\n      var createBucketConfiguration = []\n      createBucketConfiguration.push({\n        _attr: {\n          xmlns: 'http://s3.amazonaws.com/doc/2006-03-01/',\n        },\n      })\n      createBucketConfiguration.push({\n        LocationConstraint: region,\n      })\n      var payloadObject = {\n        CreateBucketConfiguration: createBucketConfiguration,\n      }\n      payload = Xml(payloadObject)\n    }\n    var method = 'PUT'\n    var headers = {}\n\n    if (makeOpts.ObjectLocking) {\n      headers['x-amz-bucket-object-lock-enabled'] = true\n    }\n\n    if (!region) {\n      region = DEFAULT_REGION\n    }\n\n    const processWithRetry = (err) => {\n      if (err && (region === '' || region === DEFAULT_REGION)) {\n        if (err.code === 'AuthorizationHeaderMalformed' && err.region !== '') {\n          // Retry with region returned as part of error\n          this.makeRequest({ method, bucketName, headers }, payload, [200], err.region, false, cb)\n        } else {\n          return cb && cb(err)\n        }\n      }\n      return cb && cb(err)\n    }\n    this.makeRequest({ method, bucketName, headers }, payload, [200], region, false, processWithRetry)\n  }\n\n  // List of buckets created.\n  //\n  // __Arguments__\n  // * `callback(err, buckets)` _function_ - callback function with error as the first argument. `buckets` is an array of bucket information\n  //\n  // `buckets` array element:\n  // * `bucket.name` _string_ : bucket name\n  // * `bucket.creationDate` _Date_: date when bucket was created\n  listBuckets(cb) {\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    this.makeRequest({ method }, '', [200], DEFAULT_REGION, true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getListBucketTransformer()\n      var buckets\n      pipesetup(response, transformer)\n        .on('data', (result) => (buckets = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, buckets))\n    })\n  }\n\n  // Returns a stream that emits objects that are partially uploaded.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: prefix of the object names that are partially uploaded (optional, default `''`)\n  // * `recursive` _bool_: directory style listing when false, recursive listing when true (optional, default `false`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_ : emits objects of the format:\n  //   * `object.key` _string_: name of the object\n  //   * `object.uploadId` _string_: upload ID of the object\n  //   * `object.size` _Integer_: size of the partially uploaded object\n  listIncompleteUploads(bucket, prefix, recursive) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucket)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucket)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    var delimiter = recursive ? '' : '/'\n    var keyMarker = ''\n    var uploadIdMarker = ''\n    var uploads = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one upload info per _read()\n      if (uploads.length) {\n        return readStream.push(uploads.shift())\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      this.listIncompleteUploadsQuery(bucket, prefix, keyMarker, uploadIdMarker, delimiter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          result.prefixes.forEach((prefix) => uploads.push(prefix))\n          async.eachSeries(\n            result.uploads,\n            (upload, cb) => {\n              // for each incomplete upload add the sizes of its uploaded parts\n              this.listParts(bucket, upload.key, upload.uploadId, (err, parts) => {\n                if (err) {\n                  return cb(err)\n                }\n                upload.size = parts.reduce((acc, item) => acc + item.size, 0)\n                uploads.push(upload)\n                cb()\n              })\n            },\n            (err) => {\n              if (err) {\n                readStream.emit('error', err)\n                return\n              }\n              if (result.isTruncated) {\n                keyMarker = result.nextKeyMarker\n                uploadIdMarker = result.nextUploadIdMarker\n              } else {\n                ended = true\n              }\n              readStream._read()\n            },\n          )\n        })\n    }\n    return readStream\n  }\n\n  // To check if a bucket already exists.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ : name of the bucket\n  // * `callback(err)` _function_ : `err` is `null` if the bucket exists\n  bucketExists(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'HEAD'\n    this.makeRequest({ method, bucketName }, '', [200], '', false, (err) => {\n      if (err) {\n        if (err.code == 'NoSuchBucket' || err.code == 'NotFound') {\n          return cb(null, false)\n        }\n        return cb(err)\n      }\n      cb(null, true)\n    })\n  }\n\n  // Remove a bucket.\n  //\n  // __Arguments__\n  // * `bucketName` _string_ : name of the bucket\n  // * `callback(err)` _function_ : `err` is `null` if the bucket is removed successfully.\n  removeBucket(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'DELETE'\n    this.makeRequest({ method, bucketName }, '', [204], '', false, (e) => {\n      // If the bucket was successfully removed, remove the region map entry.\n      if (!e) {\n        delete this.regionMap[bucketName]\n      }\n      cb(e)\n    })\n  }\n\n  // Remove the partially uploaded object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `callback(err)` _function_: callback function is called with non `null` value in case of error\n  removeIncompleteUpload(bucketName, objectName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.IsValidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var removeUploadId\n    async.during(\n      (cb) => {\n        this.findUploadId(bucketName, objectName, (e, uploadId) => {\n          if (e) {\n            return cb(e)\n          }\n          removeUploadId = uploadId\n          cb(null, uploadId)\n        })\n      },\n      (cb) => {\n        var method = 'DELETE'\n        var query = `uploadId=${removeUploadId}`\n        this.makeRequest({ method, bucketName, objectName, query }, '', [204], '', false, (e) => cb(e))\n      },\n      cb,\n    )\n  }\n\n  // Callback is called with `error` in case of error or `null` in case of success\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `filePath` _string_: path to which the object data will be written to\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err)` _function_: callback is called with `err` in case of error.\n  fGetObject(bucketName, objectName, filePath, getOpts = {}, cb) {\n    // Input validation.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    // Internal data.\n    var partFile\n    var partFileStream\n    var objStat\n\n    // Rename wrapper.\n    var rename = (err) => {\n      if (err) {\n        return cb(err)\n      }\n      fs.rename(partFile, filePath, cb)\n    }\n\n    async.waterfall(\n      [\n        (cb) => this.statObject(bucketName, objectName, getOpts, cb),\n        (result, cb) => {\n          objStat = result\n          // Create any missing top level directories.\n          fs.mkdir(path.dirname(filePath), { recursive: true }, (err) => cb(err))\n        },\n        (cb) => {\n          partFile = `${filePath}.${objStat.etag}.part.minio`\n          fs.stat(partFile, (e, stats) => {\n            var offset = 0\n            if (e) {\n              partFileStream = fs.createWriteStream(partFile, { flags: 'w' })\n            } else {\n              if (objStat.size === stats.size) {\n                return rename()\n              }\n              offset = stats.size\n              partFileStream = fs.createWriteStream(partFile, { flags: 'a' })\n            }\n            this.getPartialObject(bucketName, objectName, offset, 0, getOpts, cb)\n          })\n        },\n        (downloadStream, cb) => {\n          pipesetup(downloadStream, partFileStream)\n            .on('error', (e) => cb(e))\n            .on('finish', cb)\n        },\n        (cb) => fs.stat(partFile, cb),\n        (stats, cb) => {\n          if (stats.size === objStat.size) {\n            return cb()\n          }\n          cb(new Error('Size mismatch between downloaded file and the object'))\n        },\n      ],\n      rename,\n    )\n  }\n\n  // Callback is called with readable stream of the object content.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err, stream)` _function_: callback is called with `err` in case of error. `stream` is the object content stream\n  getObject(bucketName, objectName, getOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    this.getPartialObject(bucketName, objectName, 0, 0, getOpts, cb)\n  }\n\n  // Callback is called with readable stream of the partial object content.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `offset` _number_: offset of the object from where the stream will start\n  // * `length` _number_: length of the object that will be read in the stream (optional, if not specified we read the rest of the file from the offset)\n  // * `getOpts` _object_: Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional)\n  // * `callback(err, stream)` _function_: callback is called with `err` in case of error. `stream` is the object content stream\n  getPartialObject(bucketName, objectName, offset, length, getOpts = {}, cb) {\n    if (isFunction(length)) {\n      cb = length\n      length = 0\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isNumber(offset)) {\n      throw new TypeError('offset should be of type \"number\"')\n    }\n    if (!isNumber(length)) {\n      throw new TypeError('length should be of type \"number\"')\n    }\n    // Backward Compatibility\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var range = ''\n    if (offset || length) {\n      if (offset) {\n        range = `bytes=${+offset}-`\n      } else {\n        range = 'bytes=0-'\n        offset = 0\n      }\n      if (length) {\n        range += `${+length + offset - 1}`\n      }\n    }\n\n    var headers = {}\n    if (range !== '') {\n      headers.range = range\n    }\n\n    var expectedStatusCodes = [200]\n    if (range) {\n      expectedStatusCodes.push(206)\n    }\n    var method = 'GET'\n\n    var query = querystring.stringify(getOpts)\n    this.makeRequest({ method, bucketName, objectName, headers, query }, '', expectedStatusCodes, '', true, cb)\n  }\n\n  // Uploads the object using contents from a file\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `filePath` _string_: file path of the file to be uploaded\n  // * `metaData` _Javascript Object_: metaData assosciated with the object\n  // * `callback(err, objInfo)` _function_: non null `err` indicates error, `objInfo` _object_ which contains versionId and etag.\n  fPutObject(bucketName, objectName, filePath, metaData, callback) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (!isString(filePath)) {\n      throw new TypeError('filePath should be of type \"string\"')\n    }\n    if (isFunction(metaData)) {\n      callback = metaData\n      metaData = {} // Set metaData empty if no metaData provided.\n    }\n    if (!isObject(metaData)) {\n      throw new TypeError('metaData should be of type \"object\"')\n    }\n\n    // Inserts correct `content-type` attribute based on metaData and filePath\n    metaData = insertContentType(metaData, filePath)\n\n    // Updates metaData to have the correct prefix if needed\n    metaData = prependXAMZMeta(metaData)\n    var size\n    var partSize\n\n    async.waterfall(\n      [\n        (cb) => fs.stat(filePath, cb),\n        (stats, cb) => {\n          size = stats.size\n          var stream\n          var cbTriggered = false\n          var origCb = cb\n          cb = function () {\n            if (cbTriggered) {\n              return\n            }\n            cbTriggered = true\n            if (stream) {\n              stream.destroy()\n            }\n            return origCb.apply(this, arguments)\n          }\n          if (size > this.maxObjectSize) {\n            return cb(new Error(`${filePath} size : ${stats.size}, max allowed size : 5TB`))\n          }\n          if (size <= this.partSize) {\n            // simple PUT request, no multipart\n            var multipart = false\n            var uploader = this.getUploader(bucketName, objectName, metaData, multipart)\n            var hash = transformers.getHashSummer(this.enableSHA256)\n            var start = 0\n            var end = size - 1\n            var autoClose = true\n            if (size === 0) {\n              end = 0\n            }\n            var options = { start, end, autoClose }\n            pipesetup(fs.createReadStream(filePath, options), hash)\n              .on('data', (data) => {\n                var md5sum = data.md5sum\n                var sha256sum = data.sha256sum\n                stream = fs.createReadStream(filePath, options)\n                uploader(stream, size, sha256sum, md5sum, (err, objInfo) => {\n                  callback(err, objInfo)\n                  cb(true)\n                })\n              })\n              .on('error', (e) => cb(e))\n            return\n          }\n          this.findUploadId(bucketName, objectName, cb)\n        },\n        (uploadId, cb) => {\n          // if there was a previous incomplete upload, fetch all its uploaded parts info\n          if (uploadId) {\n            return this.listParts(bucketName, objectName, uploadId, (e, etags) => cb(e, uploadId, etags))\n          }\n          // there was no previous upload, initiate a new one\n          this.initiateNewMultipartUpload(bucketName, objectName, metaData, (e, uploadId) => cb(e, uploadId, []))\n        },\n        (uploadId, etags, cb) => {\n          partSize = this.calculatePartSize(size)\n          var multipart = true\n          var uploader = this.getUploader(bucketName, objectName, metaData, multipart)\n\n          // convert array to object to make things easy\n          var parts = etags.reduce(function (acc, item) {\n            if (!acc[item.part]) {\n              acc[item.part] = item\n            }\n            return acc\n          }, {})\n          var partsDone = []\n          var partNumber = 1\n          var uploadedSize = 0\n          async.whilst(\n            (cb) => {\n              cb(null, uploadedSize < size)\n            },\n            (cb) => {\n              var stream\n              var cbTriggered = false\n              var origCb = cb\n              cb = function () {\n                if (cbTriggered) {\n                  return\n                }\n                cbTriggered = true\n                if (stream) {\n                  stream.destroy()\n                }\n                return origCb.apply(this, arguments)\n              }\n              var part = parts[partNumber]\n              var hash = transformers.getHashSummer(this.enableSHA256)\n              var length = partSize\n              if (length > size - uploadedSize) {\n                length = size - uploadedSize\n              }\n              var start = uploadedSize\n              var end = uploadedSize + length - 1\n              var autoClose = true\n              var options = { autoClose, start, end }\n              // verify md5sum of each part\n              pipesetup(fs.createReadStream(filePath, options), hash)\n                .on('data', (data) => {\n                  var md5sumHex = Buffer.from(data.md5sum, 'base64').toString('hex')\n                  if (part && md5sumHex === part.etag) {\n                    // md5 matches, chunk already uploaded\n                    partsDone.push({ part: partNumber, etag: part.etag })\n                    partNumber++\n                    uploadedSize += length\n                    return cb()\n                  }\n                  // part is not uploaded yet, or md5 mismatch\n                  stream = fs.createReadStream(filePath, options)\n                  uploader(uploadId, partNumber, stream, length, data.sha256sum, data.md5sum, (e, objInfo) => {\n                    if (e) {\n                      return cb(e)\n                    }\n                    partsDone.push({ part: partNumber, etag: objInfo.etag })\n                    partNumber++\n                    uploadedSize += length\n                    return cb()\n                  })\n                })\n                .on('error', (e) => cb(e))\n            },\n            (e) => {\n              if (e) {\n                return cb(e)\n              }\n              cb(null, partsDone, uploadId)\n            },\n          )\n        },\n        // all parts uploaded, complete the multipart upload\n        (etags, uploadId, cb) => this.completeMultipartUpload(bucketName, objectName, uploadId, etags, cb),\n      ],\n      (err, ...rest) => {\n        if (err === true) {\n          return\n        }\n        callback(err, ...rest)\n      },\n    )\n  }\n\n  // Uploads the object.\n  //\n  // Uploading a stream\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `stream` _Stream_: Readable stream\n  // * `size` _number_: size of the object (optional)\n  // * `callback(err, etag)` _function_: non null `err` indicates error, `etag` _string_ is the etag of the object uploaded.\n  //\n  // Uploading \"Buffer\" or \"string\"\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `string or Buffer` _string_ or _Buffer_: string or buffer\n  // * `callback(err, objInfo)` _function_: `err` is `null` in case of success and `info` will have the following object details:\n  //   * `etag` _string_: etag of the object\n  //   * `versionId` _string_: versionId of the object\n  putObject(bucketName, objectName, stream, size, metaData, callback) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    // We'll need to shift arguments to the left because of size and metaData.\n    if (isFunction(size)) {\n      callback = size\n      metaData = {}\n    } else if (isFunction(metaData)) {\n      callback = metaData\n      metaData = {}\n    }\n\n    // We'll need to shift arguments to the left because of metaData\n    // and size being optional.\n    if (isObject(size)) {\n      metaData = size\n    }\n\n    // Ensures Metadata has appropriate prefix for A3 API\n    metaData = prependXAMZMeta(metaData)\n    if (typeof stream === 'string' || stream instanceof Buffer) {\n      // Adapts the non-stream interface into a stream.\n      size = stream.length\n      stream = readableStream(stream)\n    } else if (!isReadableStream(stream)) {\n      throw new TypeError('third argument should be of type \"stream.Readable\" or \"Buffer\" or \"string\"')\n    }\n\n    if (!isFunction(callback)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    if (isNumber(size) && size < 0) {\n      throw new errors.InvalidArgumentError(`size cannot be negative, given size: ${size}`)\n    }\n\n    // Get the part size and forward that to the BlockStream. Default to the\n    // largest block size possible if necessary.\n    if (!isNumber(size)) {\n      size = this.maxObjectSize\n    }\n\n    size = this.calculatePartSize(size)\n\n    // s3 requires that all non-end chunks be at least `this.partSize`,\n    // so we chunk the stream until we hit either that size or the end before\n    // we flush it to s3.\n    let chunker = new BlockStream2({ size, zeroPadding: false })\n\n    // This is a Writable stream that can be written to in order to upload\n    // to the specified bucket and object automatically.\n    let uploader = new ObjectUploader(this, bucketName, objectName, size, metaData, callback)\n    // stream => chunker => uploader\n    pipesetup(stream, chunker, uploader)\n  }\n\n  // Copy the object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `srcObject` _string_: path of the source object to be copied\n  // * `conditions` _CopyConditions_: copy conditions that needs to be satisfied (optional, default `null`)\n  // * `callback(err, {etag, lastModified})` _function_: non null `err` indicates error, `etag` _string_ and `listModifed` _Date_ are respectively the etag and the last modified date of the newly copied object\n  copyObjectV1(arg1, arg2, arg3, arg4, arg5) {\n    var bucketName = arg1\n    var objectName = arg2\n    var srcObject = arg3\n    var conditions, cb\n    if (typeof arg4 == 'function' && arg5 === undefined) {\n      conditions = null\n      cb = arg4\n    } else {\n      conditions = arg4\n      cb = arg5\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(srcObject)) {\n      throw new TypeError('srcObject should be of type \"string\"')\n    }\n    if (srcObject === '') {\n      throw new errors.InvalidPrefixError(`Empty source prefix`)\n    }\n\n    if (conditions !== null && !(conditions instanceof CopyConditions)) {\n      throw new TypeError('conditions should be of type \"CopyConditions\"')\n    }\n\n    var headers = {}\n    headers['x-amz-copy-source'] = uriResourceEscape(srcObject)\n\n    if (conditions !== null) {\n      if (conditions.modified !== '') {\n        headers['x-amz-copy-source-if-modified-since'] = conditions.modified\n      }\n      if (conditions.unmodified !== '') {\n        headers['x-amz-copy-source-if-unmodified-since'] = conditions.unmodified\n      }\n      if (conditions.matchETag !== '') {\n        headers['x-amz-copy-source-if-match'] = conditions.matchETag\n      }\n      if (conditions.matchEtagExcept !== '') {\n        headers['x-amz-copy-source-if-none-match'] = conditions.matchETagExcept\n      }\n    }\n\n    var method = 'PUT'\n    this.makeRequest({ method, bucketName, objectName, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getCopyObjectTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => cb(null, data))\n    })\n  }\n\n  /**\n   * Internal Method to perform copy of an object.\n   * @param sourceConfig __object__   instance of CopySourceOptions @link ./helpers/CopySourceOptions\n   * @param destConfig  __object__   instance of CopyDestinationOptions @link ./helpers/CopyDestinationOptions\n   * @param cb __function__ called with null if there is an error\n   * @returns Promise if no callack is passed.\n   */\n  copyObjectV2(sourceConfig, destConfig, cb) {\n    if (!(sourceConfig instanceof CopySourceOptions)) {\n      throw new errors.InvalidArgumentError('sourceConfig should of type CopySourceOptions ')\n    }\n    if (!(destConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n    if (!destConfig.validate()) {\n      return false\n    }\n    if (!destConfig.validate()) {\n      return false\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const headers = Object.assign({}, sourceConfig.getHeaders(), destConfig.getHeaders())\n\n    const bucketName = destConfig.Bucket\n    const objectName = destConfig.Object\n\n    const method = 'PUT'\n    this.makeRequest({ method, bucketName, objectName, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      const transformer = transformers.getCopyObjectTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => {\n          const resHeaders = response.headers\n\n          const copyObjResponse = {\n            Bucket: destConfig.Bucket,\n            Key: destConfig.Object,\n            LastModified: data.LastModified,\n            MetaData: extractMetadata(resHeaders),\n            VersionId: getVersionId(resHeaders),\n            SourceVersionId: getSourceVersionId(resHeaders),\n            Etag: sanitizeETag(resHeaders.etag),\n            Size: +resHeaders['content-length'],\n          }\n\n          return cb(null, copyObjResponse)\n        })\n    })\n  }\n\n  // Backward compatibility for Copy Object API.\n  copyObject(...allArgs) {\n    if (allArgs[0] instanceof CopySourceOptions && allArgs[1] instanceof CopyDestinationOptions) {\n      return this.copyObjectV2(...arguments)\n    }\n    return this.copyObjectV1(...arguments)\n  }\n\n  // list a batch of objects\n  listObjectsQuery(bucketName, prefix, marker, listQueryOpts = {}) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(marker)) {\n      throw new TypeError('marker should be of type \"string\"')\n    }\n    let { Delimiter, MaxKeys, IncludeVersion } = listQueryOpts\n\n    if (!isObject(listQueryOpts)) {\n      throw new TypeError('listQueryOpts should be of type \"object\"')\n    }\n\n    if (!isString(Delimiter)) {\n      throw new TypeError('Delimiter should be of type \"string\"')\n    }\n    if (!isNumber(MaxKeys)) {\n      throw new TypeError('MaxKeys should be of type \"number\"')\n    }\n\n    const queries = []\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(Delimiter)}`)\n    queries.push(`encoding-type=url`)\n\n    if (IncludeVersion) {\n      queries.push(`versions`)\n    }\n\n    if (marker) {\n      marker = uriEscape(marker)\n      if (IncludeVersion) {\n        queries.push(`key-marker=${marker}`)\n      } else {\n        queries.push(`marker=${marker}`)\n      }\n    }\n\n    // no need to escape maxKeys\n    if (MaxKeys) {\n      if (MaxKeys >= 1000) {\n        MaxKeys = 1000\n      }\n      queries.push(`max-keys=${MaxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n\n    var method = 'GET'\n    var transformer = transformers.getListObjectsTransformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // List the objects in the bucket.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `listOpts _object_: query params to list object with below keys\n  // *    listOpts.MaxKeys _int_ maximum number of keys to return\n  // *    listOpts.IncludeVersion  _bool_ true|false to include versions.\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  // * `obj.name` _string_: name of the object\n  // * `obj.prefix` _string_: name of the object prefix\n  // * `obj.size` _number_: size of the object\n  // * `obj.etag` _string_: etag of the object\n  // * `obj.lastModified` _Date_: modified time stamp\n  // * `obj.isDeleteMarker` _boolean_: true if it is a delete marker\n  // * `obj.versionId` _string_: versionId of the object\n  listObjects(bucketName, prefix, recursive, listOpts = {}) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isObject(listOpts)) {\n      throw new TypeError('listOpts should be of type \"object\"')\n    }\n    var marker = ''\n    const listQueryOpts = {\n      Delimiter: recursive ? '' : '/', // if recursive is false set delimiter to '/'\n      MaxKeys: 1000,\n      IncludeVersion: listOpts.IncludeVersion,\n    }\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsQuery(bucketName, prefix, marker, listQueryOpts)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            marker = result.nextMarker || result.versionIdMarker\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // listObjectsV2Query - (List Objects V2) - List some or all (up to 1000) of the objects in a bucket.\n  //\n  // You can use the request parameters as selection criteria to return a subset of the objects in a bucket.\n  // request parameters :-\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: Limits the response to keys that begin with the specified prefix.\n  // * `continuation-token` _string_: Used to continue iterating over a set of objects.\n  // * `delimiter` _string_: A delimiter is a character you use to group keys.\n  // * `max-keys` _number_: Sets the maximum number of keys returned in the response body.\n  // * `start-after` _string_: Specifies the key to start after when listing objects in a bucket.\n  listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, maxKeys, startAfter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(continuationToken)) {\n      throw new TypeError('continuationToken should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    if (!isNumber(maxKeys)) {\n      throw new TypeError('maxKeys should be of type \"number\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    var queries = []\n\n    // Call for listing objects v2 API\n    queries.push(`list-type=2`)\n    queries.push(`encoding-type=url`)\n\n    // escape every value in query string, except maxKeys\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (continuationToken) {\n      continuationToken = uriEscape(continuationToken)\n      queries.push(`continuation-token=${continuationToken}`)\n    }\n    // Set start-after\n    if (startAfter) {\n      startAfter = uriEscape(startAfter)\n      queries.push(`start-after=${startAfter}`)\n    }\n    // no need to escape maxKeys\n    if (maxKeys) {\n      if (maxKeys >= 1000) {\n        maxKeys = 1000\n      }\n      queries.push(`max-keys=${maxKeys}`)\n    }\n    queries.sort()\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListObjectsV2Transformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // List the objects in the bucket using S3 ListObjects V2\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `prefix` _string_: the prefix of the objects that should be listed (optional, default `''`)\n  // * `recursive` _bool_: `true` indicates recursive style listing and `false` indicates directory style listing delimited by '/'. (optional, default `false`)\n  // * `startAfter` _string_: Specifies the key to start after when listing objects in a bucket. (optional, default `''`)\n  //\n  // __Return Value__\n  // * `stream` _Stream_: stream emitting the objects in the bucket, the object is of the format:\n  //   * `obj.name` _string_: name of the object\n  //   * `obj.prefix` _string_: name of the object prefix\n  //   * `obj.size` _number_: size of the object\n  //   * `obj.etag` _string_: etag of the object\n  //   * `obj.lastModified` _Date_: modified time stamp\n  listObjectsV2(bucketName, prefix, recursive, startAfter) {\n    if (prefix === undefined) {\n      prefix = ''\n    }\n    if (recursive === undefined) {\n      recursive = false\n    }\n    if (startAfter === undefined) {\n      startAfter = ''\n    }\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidPrefix(prefix)) {\n      throw new errors.InvalidPrefixError(`Invalid prefix : ${prefix}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isBoolean(recursive)) {\n      throw new TypeError('recursive should be of type \"boolean\"')\n    }\n    if (!isString(startAfter)) {\n      throw new TypeError('startAfter should be of type \"string\"')\n    }\n    // if recursive is false set delimiter to '/'\n    var delimiter = recursive ? '' : '/'\n    var continuationToken = ''\n    var objects = []\n    var ended = false\n    var readStream = Stream.Readable({ objectMode: true })\n    readStream._read = () => {\n      // push one object per _read()\n      if (objects.length) {\n        readStream.push(objects.shift())\n        return\n      }\n      if (ended) {\n        return readStream.push(null)\n      }\n      // if there are no objects to push do query for the next batch of objects\n      this.listObjectsV2Query(bucketName, prefix, continuationToken, delimiter, 1000, startAfter)\n        .on('error', (e) => readStream.emit('error', e))\n        .on('data', (result) => {\n          if (result.isTruncated) {\n            continuationToken = result.nextContinuationToken\n          } else {\n            ended = true\n          }\n          objects = result.objects\n          readStream._read()\n        })\n    }\n    return readStream\n  }\n\n  // Stat information of the object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `statOpts`  _object_ : Version of the object in the form `{versionId:'my-uuid'}`. Default is `{}`. (optional).\n  // * `callback(err, stat)` _function_: `err` is not `null` in case of error, `stat` contains the object information:\n  //   * `stat.size` _number_: size of the object\n  //   * `stat.etag` _string_: etag of the object\n  //   * `stat.metaData` _string_: MetaData of the object\n  //   * `stat.lastModified` _Date_: modified time stamp\n  //   * `stat.versionId` _string_: version id of the object if available\n  statObject(bucketName, objectName, statOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    // backward compatibility\n    if (isFunction(statOpts)) {\n      cb = statOpts\n      statOpts = {}\n    }\n\n    if (!isObject(statOpts)) {\n      throw new errors.InvalidArgumentError('statOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var query = querystring.stringify(statOpts)\n    var method = 'HEAD'\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      // We drain the socket so that the connection gets closed. Note that this\n      // is not expensive as the socket will not have any data.\n      response.on('data', () => {})\n\n      const result = {\n        size: +response.headers['content-length'],\n        metaData: extractMetadata(response.headers),\n        lastModified: new Date(response.headers['last-modified']),\n        versionId: getVersionId(response.headers),\n        etag: sanitizeETag(response.headers.etag),\n      }\n\n      cb(null, result)\n    })\n  }\n\n  // Remove the specified object.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `removeOpts` _object_: Version of the object in the form `{versionId:'my-uuid', governanceBypass:true|false, forceDelete:true|false}`. Default is `{}`. (optional)\n  // * `callback(err)` _function_: callback function is called with non `null` value in case of error\n  removeObject(bucketName, objectName, removeOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    // backward compatibility\n    if (isFunction(removeOpts)) {\n      cb = removeOpts\n      removeOpts = {}\n    }\n\n    if (!isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    const method = 'DELETE'\n    const queryParams = {}\n\n    if (removeOpts.versionId) {\n      queryParams.versionId = `${removeOpts.versionId}`\n    }\n    const headers = {}\n    if (removeOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n    if (removeOpts.forceDelete) {\n      headers['x-minio-force-delete'] = true\n    }\n\n    const query = querystring.stringify(queryParams)\n\n    let requestOptions = { method, bucketName, objectName, headers }\n    if (query) {\n      requestOptions['query'] = query\n    }\n\n    this.makeRequest(requestOptions, '', [200, 204], '', false, cb)\n  }\n\n  // Remove all the objects residing in the objectsList.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectsList` _array_: array of objects of one of the following:\n  // *         List of Object names as array of strings which are object keys:  ['objectname1','objectname2']\n  // *         List of Object name and versionId as an object:  [{name:\"objectname\",versionId:\"my-version-id\"}]\n\n  removeObjects(bucketName, objectsList, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Array.isArray(objectsList)) {\n      throw new errors.InvalidArgumentError('objectsList should be a list')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const maxEntries = 1000\n    const query = 'delete'\n    const method = 'POST'\n\n    let result = objectsList.reduce(\n      (result, entry) => {\n        result.list.push(entry)\n        if (result.list.length === maxEntries) {\n          result.listOfList.push(result.list)\n          result.list = []\n        }\n        return result\n      },\n      { listOfList: [], list: [] },\n    )\n\n    if (result.list.length > 0) {\n      result.listOfList.push(result.list)\n    }\n\n    const encoder = new TextEncoder()\n    const batchResults = []\n\n    async.eachSeries(\n      result.listOfList,\n      (list, batchCb) => {\n        var objects = []\n        list.forEach(function (value) {\n          if (isObject(value)) {\n            objects.push({ Key: value.name, VersionId: value.versionId })\n          } else {\n            objects.push({ Key: value })\n          }\n        })\n        let deleteObjects = { Delete: { Quiet: true, Object: objects } }\n        const builder = new xml2js.Builder({ headless: true })\n        let payload = builder.buildObject(deleteObjects)\n        payload = encoder.encode(payload)\n        const headers = {}\n\n        headers['Content-MD5'] = toMd5(payload)\n\n        let removeObjectsResult\n        this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', true, (e, response) => {\n          if (e) {\n            return batchCb(e)\n          }\n          pipesetup(response, transformers.removeObjectsTransformer())\n            .on('data', (data) => {\n              removeObjectsResult = data\n            })\n            .on('error', (e) => {\n              return batchCb(e, null)\n            })\n            .on('end', () => {\n              batchResults.push(removeObjectsResult)\n              return batchCb(null, removeObjectsResult)\n            })\n        })\n      },\n      () => {\n        cb(null, _.flatten(batchResults))\n      },\n    )\n  }\n\n  // Get the policy on a bucket or an object prefix.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `callback(err, policy)` _function_: callback function\n  getBucketPolicy(bucketName, cb) {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let method = 'GET'\n    let query = 'policy'\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let policy = Buffer.from('')\n      pipesetup(response, transformers.getConcater())\n        .on('data', (data) => (policy = data))\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, policy.toString())\n        })\n    })\n  }\n\n  // Set the policy on a bucket or an object prefix.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `bucketPolicy` _string_: bucket policy (JSON stringify'ed)\n  // * `callback(err)` _function_: callback function\n  setBucketPolicy(bucketName, policy, cb) {\n    // Validate arguments.\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(policy)) {\n      throw new errors.InvalidBucketPolicyError(`Invalid bucket policy: ${policy} - must be \"string\"`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let method = 'DELETE'\n    let query = 'policy'\n\n    if (policy) {\n      method = 'PUT'\n    }\n\n    this.makeRequest({ method, bucketName, query }, policy, [204], '', false, cb)\n  }\n\n  // Generate a generic presigned URL which can be\n  // used for HTTP methods GET, PUT, HEAD and DELETE\n  //\n  // __Arguments__\n  // * `method` _string_: name of the HTTP method\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  // * `reqParams` _object_: request parameters (optional) e.g {versionId:\"10fa9946-3f64-4137-a58f-888065c0732e\"}\n  // * `requestDate` _Date_: A date object, the url will be issued at (optional)\n  presignedUrl(method, bucketName, objectName, expires, reqParams, requestDate, cb) {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned ' + method + ' url cannot be generated for anonymous requests')\n    }\n    if (isFunction(requestDate)) {\n      cb = requestDate\n      requestDate = new Date()\n    }\n    if (isFunction(reqParams)) {\n      cb = reqParams\n      reqParams = {}\n      requestDate = new Date()\n    }\n    if (isFunction(expires)) {\n      cb = expires\n      reqParams = {}\n      expires = 24 * 60 * 60 * 7 // 7 days in seconds\n      requestDate = new Date()\n    }\n    if (!isNumber(expires)) {\n      throw new TypeError('expires should be of type \"number\"')\n    }\n    if (!isObject(reqParams)) {\n      throw new TypeError('reqParams should be of type \"object\"')\n    }\n    if (!isValidDate(requestDate)) {\n      throw new TypeError('requestDate should be of type \"Date\" and valid')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var query = querystring.stringify(reqParams)\n    this.getBucketRegion(bucketName, (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      // This statement is added to ensure that we send error through\n      // callback on presign failure.\n      var url\n      var reqOptions = this.getRequestOptions({ method, region, bucketName, objectName, query })\n\n      this.checkAndRefreshCreds()\n      try {\n        url = presignSignatureV4(\n          reqOptions,\n          this.accessKey,\n          this.secretKey,\n          this.sessionToken,\n          region,\n          requestDate,\n          expires,\n        )\n      } catch (pe) {\n        return cb(pe)\n      }\n      cb(null, url)\n    })\n  }\n\n  // Generate a presigned URL for GET\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  // * `respHeaders` _object_: response headers to override or request params for query (optional) e.g {versionId:\"10fa9946-3f64-4137-a58f-888065c0732e\"}\n  // * `requestDate` _Date_: A date object, the url will be issued at (optional)\n  presignedGetObject(bucketName, objectName, expires, respHeaders, requestDate, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (isFunction(respHeaders)) {\n      cb = respHeaders\n      respHeaders = {}\n      requestDate = new Date()\n    }\n\n    var validRespHeaders = [\n      'response-content-type',\n      'response-content-language',\n      'response-expires',\n      'response-cache-control',\n      'response-content-disposition',\n      'response-content-encoding',\n    ]\n    validRespHeaders.forEach((header) => {\n      if (respHeaders !== undefined && respHeaders[header] !== undefined && !isString(respHeaders[header])) {\n        throw new TypeError(`response header ${header} should be of type \"string\"`)\n      }\n    })\n    return this.presignedUrl('GET', bucketName, objectName, expires, respHeaders, requestDate, cb)\n  }\n\n  // Generate a presigned URL for PUT. Using this URL, the browser can upload to S3 only with the specified object name.\n  //\n  // __Arguments__\n  // * `bucketName` _string_: name of the bucket\n  // * `objectName` _string_: name of the object\n  // * `expiry` _number_: expiry in seconds (optional, default 7 days)\n  presignedPutObject(bucketName, objectName, expires, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    return this.presignedUrl('PUT', bucketName, objectName, expires, cb)\n  }\n\n  // return PostPolicy object\n  newPostPolicy() {\n    return new PostPolicy()\n  }\n\n  // presignedPostPolicy can be used in situations where we want more control on the upload than what\n  // presignedPutObject() provides. i.e Using presignedPostPolicy we will be able to put policy restrictions\n  // on the object's `name` `bucket` `expiry` `Content-Type` `Content-Disposition` `metaData`\n  presignedPostPolicy(postPolicy, cb) {\n    if (this.anonymous) {\n      throw new errors.AnonymousRequestError('Presigned POST policy cannot be generated for anonymous requests')\n    }\n    if (!isObject(postPolicy)) {\n      throw new TypeError('postPolicy should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n    this.getBucketRegion(postPolicy.formData.bucket, (e, region) => {\n      if (e) {\n        return cb(e)\n      }\n      var date = new Date()\n      var dateStr = makeDateLong(date)\n\n      this.checkAndRefreshCreds()\n\n      if (!postPolicy.policy.expiration) {\n        // 'expiration' is mandatory field for S3.\n        // Set default expiration date of 7 days.\n        var expires = new Date()\n        expires.setSeconds(24 * 60 * 60 * 7)\n        postPolicy.setExpires(expires)\n      }\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-date', dateStr])\n      postPolicy.formData['x-amz-date'] = dateStr\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-algorithm', 'AWS4-HMAC-SHA256'])\n      postPolicy.formData['x-amz-algorithm'] = 'AWS4-HMAC-SHA256'\n\n      postPolicy.policy.conditions.push(['eq', '$x-amz-credential', this.accessKey + '/' + getScope(region, date)])\n      postPolicy.formData['x-amz-credential'] = this.accessKey + '/' + getScope(region, date)\n\n      if (this.sessionToken) {\n        postPolicy.policy.conditions.push(['eq', '$x-amz-security-token', this.sessionToken])\n        postPolicy.formData['x-amz-security-token'] = this.sessionToken\n      }\n\n      var policyBase64 = Buffer.from(JSON.stringify(postPolicy.policy)).toString('base64')\n\n      postPolicy.formData.policy = policyBase64\n\n      var signature = postPresignSignatureV4(region, date, this.secretKey, policyBase64)\n\n      postPolicy.formData['x-amz-signature'] = signature\n      var opts = {}\n      opts.region = region\n      opts.bucketName = postPolicy.formData.bucket\n      var reqOptions = this.getRequestOptions(opts)\n      var portStr = this.port == 80 || this.port === 443 ? '' : `:${this.port.toString()}`\n      var urlStr = `${reqOptions.protocol}//${reqOptions.host}${portStr}${reqOptions.path}`\n      cb(null, { postURL: urlStr, formData: postPolicy.formData })\n    })\n  }\n\n  // Calls implemented below are related to multipart.\n\n  // Initiate a new multipart upload.\n  initiateNewMultipartUpload(bucketName, objectName, metaData, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(metaData)) {\n      throw new errors.InvalidObjectNameError('contentType should be of type \"object\"')\n    }\n    var method = 'POST'\n    let headers = Object.assign({}, metaData)\n    var query = 'uploads'\n    this.makeRequest({ method, bucketName, objectName, query, headers }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getInitiateMultipartTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (uploadId) => cb(null, uploadId))\n    })\n  }\n\n  // Complete the multipart upload. After all the parts are uploaded issuing\n  // this call will aggregate the parts on the server into a single object.\n  completeMultipartUpload(bucketName, objectName, uploadId, etags, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isObject(etags)) {\n      throw new TypeError('etags should be of type \"Array\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n\n    var method = 'POST'\n    var query = `uploadId=${uriEscape(uploadId)}`\n\n    var parts = []\n\n    etags.forEach((element) => {\n      parts.push({\n        Part: [\n          {\n            PartNumber: element.part,\n          },\n          {\n            ETag: element.etag,\n          },\n        ],\n      })\n    })\n\n    var payloadObject = { CompleteMultipartUpload: parts }\n    var payload = Xml(payloadObject)\n\n    this.makeRequest({ method, bucketName, objectName, query }, payload, [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getCompleteMultipartTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (result) => {\n          if (result.errCode) {\n            // Multipart Complete API returns an error XML after a 200 http status\n            cb(new errors.S3Error(result.errMessage))\n          } else {\n            const completeMultipartResult = {\n              etag: result.etag,\n              versionId: getVersionId(response.headers),\n            }\n            cb(null, completeMultipartResult)\n          }\n        })\n    })\n  }\n\n  // Get part-info of all parts of an incomplete upload specified by uploadId.\n  listParts(bucketName, objectName, uploadId, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n    var parts = []\n    var listNext = (marker) => {\n      this.listPartsQuery(bucketName, objectName, uploadId, marker, (e, result) => {\n        if (e) {\n          cb(e)\n          return\n        }\n        parts = parts.concat(result.parts)\n        if (result.isTruncated) {\n          listNext(result.marker)\n          return\n        }\n        cb(null, parts)\n      })\n    }\n    listNext(0)\n  }\n\n  // Called by listParts to fetch a batch of part-info\n  listPartsQuery(bucketName, objectName, uploadId, marker, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isString(uploadId)) {\n      throw new TypeError('uploadId should be of type \"string\"')\n    }\n    if (!isNumber(marker)) {\n      throw new TypeError('marker should be of type \"number\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    if (!uploadId) {\n      throw new errors.InvalidArgumentError('uploadId cannot be empty')\n    }\n    var query = ''\n    if (marker && marker !== 0) {\n      query += `part-number-marker=${marker}&`\n    }\n    query += `uploadId=${uriEscape(uploadId)}`\n\n    var method = 'GET'\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getListPartsTransformer()\n      pipesetup(response, transformer)\n        .on('error', (e) => cb(e))\n        .on('data', (data) => cb(null, data))\n    })\n  }\n\n  // Called by listIncompleteUploads to fetch a batch of incomplete uploads.\n  listIncompleteUploadsQuery(bucketName, prefix, keyMarker, uploadIdMarker, delimiter) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix should be of type \"string\"')\n    }\n    if (!isString(keyMarker)) {\n      throw new TypeError('keyMarker should be of type \"string\"')\n    }\n    if (!isString(uploadIdMarker)) {\n      throw new TypeError('uploadIdMarker should be of type \"string\"')\n    }\n    if (!isString(delimiter)) {\n      throw new TypeError('delimiter should be of type \"string\"')\n    }\n    var queries = []\n    queries.push(`prefix=${uriEscape(prefix)}`)\n    queries.push(`delimiter=${uriEscape(delimiter)}`)\n\n    if (keyMarker) {\n      keyMarker = uriEscape(keyMarker)\n      queries.push(`key-marker=${keyMarker}`)\n    }\n    if (uploadIdMarker) {\n      queries.push(`upload-id-marker=${uploadIdMarker}`)\n    }\n\n    var maxUploads = 1000\n    queries.push(`max-uploads=${maxUploads}`)\n    queries.sort()\n    queries.unshift('uploads')\n    var query = ''\n    if (queries.length > 0) {\n      query = `${queries.join('&')}`\n    }\n    var method = 'GET'\n    var transformer = transformers.getListMultipartTransformer()\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return transformer.emit('error', e)\n      }\n      pipesetup(response, transformer)\n    })\n    return transformer\n  }\n\n  // Find uploadId of an incomplete upload.\n  findUploadId(bucketName, objectName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('cb should be of type \"function\"')\n    }\n    var latestUpload\n    var listNext = (keyMarker, uploadIdMarker) => {\n      this.listIncompleteUploadsQuery(bucketName, objectName, keyMarker, uploadIdMarker, '')\n        .on('error', (e) => cb(e))\n        .on('data', (result) => {\n          result.uploads.forEach((upload) => {\n            if (upload.key === objectName) {\n              if (!latestUpload || upload.initiated.getTime() > latestUpload.initiated.getTime()) {\n                latestUpload = upload\n                return\n              }\n            }\n          })\n          if (result.isTruncated) {\n            listNext(result.nextKeyMarker, result.nextUploadIdMarker)\n            return\n          }\n          if (latestUpload) {\n            return cb(null, latestUpload.uploadId)\n          }\n          cb(null, undefined)\n        })\n    }\n    listNext('', '')\n  }\n\n  // Returns a function that can be used for uploading objects.\n  // If multipart === true, it returns function that is used to upload\n  // a part of the multipart.\n  getUploader(bucketName, objectName, metaData, multipart) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isBoolean(multipart)) {\n      throw new TypeError('multipart should be of type \"boolean\"')\n    }\n    if (!isObject(metaData)) {\n      throw new TypeError('metadata should be of type \"object\"')\n    }\n\n    var validate = (stream, length, sha256sum, md5sum, cb) => {\n      if (!isReadableStream(stream)) {\n        throw new TypeError('stream should be of type \"Stream\"')\n      }\n      if (!isNumber(length)) {\n        throw new TypeError('length should be of type \"number\"')\n      }\n      if (!isString(sha256sum)) {\n        throw new TypeError('sha256sum should be of type \"string\"')\n      }\n      if (!isString(md5sum)) {\n        throw new TypeError('md5sum should be of type \"string\"')\n      }\n      if (!isFunction(cb)) {\n        throw new TypeError('callback should be of type \"function\"')\n      }\n    }\n    var simpleUploader = (...args) => {\n      validate(...args)\n      var query = ''\n      upload(query, ...args)\n    }\n    var multipartUploader = (uploadId, partNumber, ...rest) => {\n      if (!isString(uploadId)) {\n        throw new TypeError('uploadId should be of type \"string\"')\n      }\n      if (!isNumber(partNumber)) {\n        throw new TypeError('partNumber should be of type \"number\"')\n      }\n      if (!uploadId) {\n        throw new errors.InvalidArgumentError('Empty uploadId')\n      }\n      if (!partNumber) {\n        throw new errors.InvalidArgumentError('partNumber cannot be 0')\n      }\n      validate(...rest)\n      var query = `partNumber=${partNumber}&uploadId=${uriEscape(uploadId)}`\n      upload(query, ...rest)\n    }\n    var upload = (query, stream, length, sha256sum, md5sum, cb) => {\n      var method = 'PUT'\n      let headers = { 'Content-Length': length }\n\n      if (!multipart) {\n        headers = Object.assign({}, metaData, headers)\n      }\n\n      if (!this.enableSHA256) {\n        headers['Content-MD5'] = md5sum\n      }\n      this.makeRequestStream(\n        { method, bucketName, objectName, query, headers },\n        stream,\n        sha256sum,\n        [200],\n        '',\n        true,\n        (e, response) => {\n          if (e) {\n            return cb(e)\n          }\n          const result = {\n            etag: sanitizeETag(response.headers.etag),\n            versionId: getVersionId(response.headers),\n          }\n          // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n          response.on('data', () => {})\n          cb(null, result)\n        },\n      )\n    }\n    if (multipart) {\n      return multipartUploader\n    }\n    return simpleUploader\n  }\n\n  // Remove all the notification configurations in the S3 provider\n  setBucketNotification(bucketName, config, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(config)) {\n      throw new TypeError('notification config should be of type \"Object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'PUT'\n    var query = 'notification'\n    var builder = new xml2js.Builder({\n      rootName: 'NotificationConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    var payload = builder.buildObject(config)\n    this.makeRequest({ method, bucketName, query }, payload, [200], '', false, cb)\n  }\n\n  removeAllBucketNotification(bucketName, cb) {\n    this.setBucketNotification(bucketName, new NotificationConfig(), cb)\n  }\n\n  // Return the list of notification configurations stored\n  // in the S3 provider\n  getBucketNotification(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    var query = 'notification'\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n      var transformer = transformers.getBucketNotificationTransformer()\n      var bucketNotification\n      pipesetup(response, transformer)\n        .on('data', (result) => (bucketNotification = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, bucketNotification))\n    })\n  }\n\n  // Listens for bucket notifications. Returns an EventEmitter.\n  listenBucketNotification(bucketName, prefix, suffix, events) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isString(prefix)) {\n      throw new TypeError('prefix must be of type string')\n    }\n    if (!isString(suffix)) {\n      throw new TypeError('suffix must be of type string')\n    }\n    if (!Array.isArray(events)) {\n      throw new TypeError('events must be of type Array')\n    }\n    let listener = new NotificationPoller(this, bucketName, prefix, suffix, events)\n    listener.start()\n\n    return listener\n  }\n\n  getBucketVersioning(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    var method = 'GET'\n    var query = 'versioning'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let versionConfig = Buffer.from('')\n      pipesetup(response, transformers.bucketVersioningTransformer())\n        .on('data', (data) => {\n          versionConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, versionConfig)\n        })\n    })\n  }\n\n  setBucketVersioning(bucketName, versionConfig, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!Object.keys(versionConfig).length) {\n      throw new errors.InvalidArgumentError('versionConfig should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    var method = 'PUT'\n    var query = 'versioning'\n    var builder = new xml2js.Builder({\n      rootName: 'VersioningConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    var payload = builder.buildObject(versionConfig)\n\n    this.makeRequest({ method, bucketName, query }, payload, [200], '', false, cb)\n  }\n\n  /** To set Tags on a bucket or object based on the params\n   *  __Arguments__\n   * taggingParams _object_ Which contains the following properties\n   *  bucketName _string_,\n   *  objectName _string_ (Optional),\n   *  tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   *  putOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   *  cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setTagging(taggingParams) {\n    const { bucketName, objectName, tags, putOpts = {}, cb } = taggingParams\n    const method = 'PUT'\n    let query = 'tagging'\n\n    if (putOpts && putOpts.versionId) {\n      query = `${query}&versionId=${putOpts.versionId}`\n    }\n    const tagsList = []\n    for (const [key, value] of Object.entries(tags)) {\n      tagsList.push({ Key: key, Value: value })\n    }\n    const taggingConfig = {\n      Tagging: {\n        TagSet: {\n          Tag: tagsList,\n        },\n      },\n    }\n    const encoder = new TextEncoder()\n    const headers = {}\n    const builder = new xml2js.Builder({ headless: true, renderOpts: { pretty: false } })\n    let payload = builder.buildObject(taggingConfig)\n    payload = encoder.encode(payload)\n    headers['Content-MD5'] = toMd5(payload)\n    const requestOptions = { method, bucketName, query, headers }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest(requestOptions, payload, [200], '', false, cb)\n  }\n\n  /** Set Tags on a Bucket\n   * __Arguments__\n   * bucketName _string_\n   * tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setBucketTagging(bucketName, tags, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('maximum tags allowed is 10\"')\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    return this.setTagging({ bucketName, tags, cb })\n  }\n\n  /** Set Tags on an Object\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_\n   *  * tags _object_ of the form {'<tag-key-1>':'<tag-value-1>','<tag-key-2>':'<tag-value-2>'}\n   *  putOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setObjectTagging(bucketName, objectName, tags, putOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n\n    if (isFunction(putOpts)) {\n      cb = putOpts\n      putOpts = {}\n    }\n\n    if (!isObject(tags)) {\n      throw new errors.InvalidArgumentError('tags should be of type \"object\"')\n    }\n    if (Object.keys(tags).length > 10) {\n      throw new errors.InvalidArgumentError('Maximum tags allowed is 10\"')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    return this.setTagging({ bucketName, objectName, tags, putOpts, cb })\n  }\n\n  /** Remove Tags on an Bucket/Object based on params\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_ (optional)\n   * removeOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"},\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeTagging({ bucketName, objectName, removeOpts, cb }) {\n    const method = 'DELETE'\n    let query = 'tagging'\n\n    if (removeOpts && Object.keys(removeOpts).length && removeOpts.versionId) {\n      query = `${query}&versionId=${removeOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, objectName, query }\n\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n    this.makeRequest(requestOptions, '', [200, 204], '', true, cb)\n  }\n\n  /** Remove Tags associated with a bucket\n   *  __Arguments__\n   * bucketName _string_\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeBucketTagging(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n    return this.removeTagging({ bucketName, cb })\n  }\n\n  /** Remove tags associated with an object\n   * __Arguments__\n   * bucketName _string_\n   * objectName _string_\n   * removeOpts _object_ (Optional) e.g. {VersionID:\"my-object-version-id\"}\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeObjectTagging(bucketName, objectName, removeOpts, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (isFunction(removeOpts)) {\n      cb = removeOpts\n      removeOpts = {}\n    }\n    if (removeOpts && Object.keys(removeOpts).length && !isObject(removeOpts)) {\n      throw new errors.InvalidArgumentError('removeOpts should be of type \"object\"')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    return this.removeTagging({ bucketName, objectName, removeOpts, cb })\n  }\n\n  /** Get Tags associated with a Bucket\n   *  __Arguments__\n   * bucketName _string_\n   * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  getBucketTagging(bucketName, cb) {\n    const method = 'GET'\n    const query = 'tagging'\n    const requestOptions = { method, bucketName, query }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      var transformer = transformers.getTagsTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let tagsList\n      pipesetup(response, transformer)\n        .on('data', (result) => (tagsList = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, tagsList))\n    })\n  }\n\n  /** Get the tags associated with a bucket OR an object\n   * bucketName _string_\n   * objectName _string_ (Optional)\n   * getOpts _object_ (Optional) e.g {versionId:\"my-object-version-id\"}\n   * `cb(error, tags)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  getObjectTagging(bucketName, objectName, getOpts = {}, cb = () => false) {\n    const method = 'GET'\n    let query = 'tagging'\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidBucketNameError('Invalid object name: ' + objectName)\n    }\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n    if (!isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('getOpts should be of type \"object\"')\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    if (getOpts && getOpts.versionId) {\n      query = `${query}&versionId=${getOpts.versionId}`\n    }\n    const requestOptions = { method, bucketName, query }\n    if (objectName) {\n      requestOptions['objectName'] = objectName\n    }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      const transformer = transformers.getTagsTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let tagsList\n      pipesetup(response, transformer)\n        .on('data', (result) => (tagsList = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, tagsList))\n    })\n  }\n\n  /**\n   * Apply lifecycle configuration on a bucket.\n   * bucketName _string_\n   * policyConfig _object_ a valid policy configuration object.\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  applyBucketLifecycle(bucketName, policyConfig, cb) {\n    const method = 'PUT'\n    const query = 'lifecycle'\n\n    const encoder = new TextEncoder()\n    const headers = {}\n    const builder = new xml2js.Builder({\n      rootName: 'LifecycleConfiguration',\n      headless: true,\n      renderOpts: { pretty: false },\n    })\n    let payload = builder.buildObject(policyConfig)\n    payload = encoder.encode(payload)\n    const requestOptions = { method, bucketName, query, headers }\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest(requestOptions, payload, [200], '', false, cb)\n  }\n\n  /** Remove lifecycle configuration of a bucket.\n   * bucketName _string_\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  removeBucketLifecycle(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'lifecycle'\n    this.makeRequest({ method, bucketName, query }, '', [204], '', false, cb)\n  }\n\n  /** Set/Override lifecycle configuration on a bucket. if the configuration is empty, it removes the configuration.\n   * bucketName _string_\n   * lifeCycleConfig _object_ one of the following values: (null or '') to remove the lifecycle configuration. or a valid lifecycle configuration\n   * `cb(error)` _function_ - callback function with `err` as the error argument. `err` is null if the operation is successful.\n   */\n  setBucketLifecycle(bucketName, lifeCycleConfig = null, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (_.isEmpty(lifeCycleConfig)) {\n      this.removeBucketLifecycle(bucketName, cb)\n    } else {\n      this.applyBucketLifecycle(bucketName, lifeCycleConfig, cb)\n    }\n  }\n\n  /** Get lifecycle configuration on a bucket.\n   * bucketName _string_\n   * `cb(config)` _function_ - callback function with lifecycle configuration as the error argument.\n   */\n  getBucketLifecycle(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'GET'\n    const query = 'lifecycle'\n    const requestOptions = { method, bucketName, query }\n\n    this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      const transformer = transformers.lifecycleTransformer()\n      if (e) {\n        return cb(e)\n      }\n      let lifecycleConfig\n      pipesetup(response, transformer)\n        .on('data', (result) => (lifecycleConfig = result))\n        .on('error', (e) => cb(e))\n        .on('end', () => cb(null, lifecycleConfig))\n    })\n  }\n\n  setObjectLockConfig(bucketName, lockConfigOpts = {}, cb) {\n    const retentionModes = [RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE]\n    const validUnits = [RETENTION_VALIDITY_UNITS.DAYS, RETENTION_VALIDITY_UNITS.YEARS]\n\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (lockConfigOpts.mode && !retentionModes.includes(lockConfigOpts.mode)) {\n      throw new TypeError(`lockConfigOpts.mode should be one of ${retentionModes}`)\n    }\n    if (lockConfigOpts.unit && !validUnits.includes(lockConfigOpts.unit)) {\n      throw new TypeError(`lockConfigOpts.unit should be one of ${validUnits}`)\n    }\n    if (lockConfigOpts.validity && !isNumber(lockConfigOpts.validity)) {\n      throw new TypeError(`lockConfigOpts.validity should be a number`)\n    }\n\n    const method = 'PUT'\n    const query = 'object-lock'\n\n    let config = {\n      ObjectLockEnabled: 'Enabled',\n    }\n    const configKeys = Object.keys(lockConfigOpts)\n    // Check if keys are present and all keys are present.\n    if (configKeys.length > 0) {\n      if (_.difference(configKeys, ['unit', 'mode', 'validity']).length !== 0) {\n        throw new TypeError(\n          `lockConfigOpts.mode,lockConfigOpts.unit,lockConfigOpts.validity all the properties should be specified.`,\n        )\n      } else {\n        config.Rule = {\n          DefaultRetention: {},\n        }\n        if (lockConfigOpts.mode) {\n          config.Rule.DefaultRetention.Mode = lockConfigOpts.mode\n        }\n        if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.DAYS) {\n          config.Rule.DefaultRetention.Days = lockConfigOpts.validity\n        } else if (lockConfigOpts.unit === RETENTION_VALIDITY_UNITS.YEARS) {\n          config.Rule.DefaultRetention.Years = lockConfigOpts.validity\n        }\n      }\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'ObjectLockConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getObjectLockConfig(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'object-lock'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let objectLockConfig = Buffer.from('')\n      pipesetup(response, transformers.objectLockTransformer())\n        .on('data', (data) => {\n          objectLockConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, objectLockConfig)\n        })\n    })\n  }\n\n  putObjectRetention(bucketName, objectName, retentionOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(retentionOpts)) {\n      throw new errors.InvalidArgumentError('retentionOpts should be of type \"object\"')\n    } else {\n      if (retentionOpts.governanceBypass && !isBoolean(retentionOpts.governanceBypass)) {\n        throw new errors.InvalidArgumentError('Invalid value for governanceBypass', retentionOpts.governanceBypass)\n      }\n      if (\n        retentionOpts.mode &&\n        ![RETENTION_MODES.COMPLIANCE, RETENTION_MODES.GOVERNANCE].includes(retentionOpts.mode)\n      ) {\n        throw new errors.InvalidArgumentError('Invalid object retention mode ', retentionOpts.mode)\n      }\n      if (retentionOpts.retainUntilDate && !isString(retentionOpts.retainUntilDate)) {\n        throw new errors.InvalidArgumentError('Invalid value for retainUntilDate', retentionOpts.retainUntilDate)\n      }\n      if (retentionOpts.versionId && !isString(retentionOpts.versionId)) {\n        throw new errors.InvalidArgumentError('Invalid value for versionId', retentionOpts.versionId)\n      }\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'PUT'\n    let query = 'retention'\n\n    const headers = {}\n    if (retentionOpts.governanceBypass) {\n      headers['X-Amz-Bypass-Governance-Retention'] = true\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'Retention', renderOpts: { pretty: false }, headless: true })\n    const params = {}\n\n    if (retentionOpts.mode) {\n      params.Mode = retentionOpts.mode\n    }\n    if (retentionOpts.retainUntilDate) {\n      params.RetainUntilDate = retentionOpts.retainUntilDate\n    }\n    if (retentionOpts.versionId) {\n      query += `&versionId=${retentionOpts.versionId}`\n    }\n\n    let payload = builder.buildObject(params)\n\n    headers['Content-MD5'] = toMd5(payload)\n    this.makeRequest({ method, bucketName, objectName, query, headers }, payload, [200, 204], '', false, cb)\n  }\n\n  getObjectRetention(bucketName, objectName, getOpts, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!isObject(getOpts)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"object\"')\n    } else if (getOpts.versionId && !isString(getOpts.versionId)) {\n      throw new errors.InvalidArgumentError('VersionID should be of type \"string\"')\n    }\n    if (cb && !isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    let query = 'retention'\n    if (getOpts.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let retentionConfig = Buffer.from('')\n      pipesetup(response, transformers.objectRetentionTransformer())\n        .on('data', (data) => {\n          retentionConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, retentionConfig)\n        })\n    })\n  }\n\n  setBucketEncryption(bucketName, encryptionConfig, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n\n    if (isFunction(encryptionConfig)) {\n      cb = encryptionConfig\n      encryptionConfig = null\n    }\n\n    if (!_.isEmpty(encryptionConfig) && encryptionConfig.Rule.length > 1) {\n      throw new errors.InvalidArgumentError('Invalid Rule length. Only one rule is allowed.: ' + encryptionConfig.Rule)\n    }\n    if (cb && !isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    let encryptionObj = encryptionConfig\n    if (_.isEmpty(encryptionConfig)) {\n      encryptionObj = {\n        // Default MinIO Server Supported Rule\n        Rule: [\n          {\n            ApplyServerSideEncryptionByDefault: {\n              SSEAlgorithm: 'AES256',\n            },\n          },\n        ],\n      }\n    }\n\n    let method = 'PUT'\n    let query = 'encryption'\n    let builder = new xml2js.Builder({\n      rootName: 'ServerSideEncryptionConfiguration',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    let payload = builder.buildObject(encryptionObj)\n\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getBucketEncryption(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'encryption'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let bucketEncConfig = Buffer.from('')\n      pipesetup(response, transformers.bucketEncryptionTransformer())\n        .on('data', (data) => {\n          bucketEncConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, bucketEncConfig)\n        })\n    })\n  }\n  removeBucketEncryption(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'DELETE'\n    const query = 'encryption'\n\n    this.makeRequest({ method, bucketName, query }, '', [204], '', false, cb)\n  }\n\n  setBucketReplication(bucketName, replicationConfig = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isObject(replicationConfig)) {\n      throw new errors.InvalidArgumentError('replicationConfig should be of type \"object\"')\n    } else {\n      if (_.isEmpty(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Role cannot be empty')\n      } else if (replicationConfig.role && !isString(replicationConfig.role)) {\n        throw new errors.InvalidArgumentError('Invalid value for role', replicationConfig.role)\n      }\n      if (_.isEmpty(replicationConfig.rules)) {\n        throw new errors.InvalidArgumentError('Minimum one replication rule must be specified')\n      }\n    }\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'PUT'\n    let query = 'replication'\n    const headers = {}\n\n    const replicationParamsConfig = {\n      ReplicationConfiguration: {\n        Role: replicationConfig.role,\n        Rule: replicationConfig.rules,\n      },\n    }\n\n    const builder = new xml2js.Builder({ renderOpts: { pretty: false }, headless: true })\n\n    let payload = builder.buildObject(replicationParamsConfig)\n\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  getBucketReplication(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n    const method = 'GET'\n    const query = 'replication'\n\n    this.makeRequest({ method, bucketName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let replicationConfig = Buffer.from('')\n      pipesetup(response, transformers.replicationConfigTransformer())\n        .on('data', (data) => {\n          replicationConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, replicationConfig)\n        })\n    })\n  }\n\n  removeBucketReplication(bucketName, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    const method = 'DELETE'\n    const query = 'replication'\n    this.makeRequest({ method, bucketName, query }, '', [200, 204], '', false, cb)\n  }\n\n  getObjectLegalHold(bucketName, objectName, getOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    if (isFunction(getOpts)) {\n      cb = getOpts\n      getOpts = {}\n    }\n\n    if (!isObject(getOpts)) {\n      throw new TypeError('getOpts should be of type \"Object\"')\n    } else if (Object.keys(getOpts).length > 0 && getOpts.versionId && !isString(getOpts.versionId)) {\n      throw new TypeError('versionId should be of type string.:', getOpts.versionId)\n    }\n\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    const method = 'GET'\n    let query = 'legal-hold'\n\n    if (getOpts.versionId) {\n      query += `&versionId=${getOpts.versionId}`\n    }\n\n    this.makeRequest({ method, bucketName, objectName, query }, '', [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let legalHoldConfig = Buffer.from('')\n      pipesetup(response, transformers.objectLegalHoldTransformer())\n        .on('data', (data) => {\n          legalHoldConfig = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, legalHoldConfig)\n        })\n    })\n  }\n\n  setObjectLegalHold(bucketName, objectName, setOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError('Invalid bucket name: ' + bucketName)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n\n    const defaultOpts = {\n      status: LEGAL_HOLD_STATUS.ENABLED,\n    }\n    if (isFunction(setOpts)) {\n      cb = setOpts\n      setOpts = defaultOpts\n    }\n\n    if (!isObject(setOpts)) {\n      throw new TypeError('setOpts should be of type \"Object\"')\n    } else {\n      if (![LEGAL_HOLD_STATUS.ENABLED, LEGAL_HOLD_STATUS.DISABLED].includes(setOpts.status)) {\n        throw new TypeError('Invalid status: ' + setOpts.status)\n      }\n      if (setOpts.versionId && !setOpts.versionId.length) {\n        throw new TypeError('versionId should be of type string.:' + setOpts.versionId)\n      }\n    }\n\n    if (!isFunction(cb)) {\n      throw new errors.InvalidArgumentError('callback should be of type \"function\"')\n    }\n\n    if (_.isEmpty(setOpts)) {\n      setOpts = {\n        defaultOpts,\n      }\n    }\n\n    const method = 'PUT'\n    let query = 'legal-hold'\n\n    if (setOpts.versionId) {\n      query += `&versionId=${setOpts.versionId}`\n    }\n\n    let config = {\n      Status: setOpts.status,\n    }\n\n    const builder = new xml2js.Builder({ rootName: 'LegalHold', renderOpts: { pretty: false }, headless: true })\n    const payload = builder.buildObject(config)\n    const headers = {}\n    headers['Content-MD5'] = toMd5(payload)\n\n    this.makeRequest({ method, bucketName, objectName, query, headers }, payload, [200], '', false, cb)\n  }\n\n  /**\n   * Internal Method to abort a multipart upload request in case of any errors.\n   * @param bucketName __string__ Bucket Name\n   * @param objectName __string__ Object Name\n   * @param uploadId __string__ id of a multipart upload to cancel during compose object sequence.\n   * @param cb __function__ callback function\n   */\n  abortMultipartUpload(bucketName, objectName, uploadId, cb) {\n    const method = 'DELETE'\n    let query = `uploadId=${uploadId}`\n\n    const requestOptions = { method, bucketName, objectName: objectName, query }\n    this.makeRequest(requestOptions, '', [204], '', false, cb)\n  }\n\n  /**\n   * Internal method to upload a part during compose object.\n   * @param partConfig __object__ contains the following.\n   *    bucketName __string__\n   *    objectName __string__\n   *    uploadID __string__\n   *    partNumber __number__\n   *    headers __object__\n   * @param cb called with null incase of error.\n   */\n  uploadPartCopy(partConfig, cb) {\n    const { bucketName, objectName, uploadID, partNumber, headers } = partConfig\n\n    const method = 'PUT'\n    let query = `uploadId=${uploadID}&partNumber=${partNumber}`\n    const requestOptions = { method, bucketName, objectName: objectName, query, headers }\n    return this.makeRequest(requestOptions, '', [200], '', true, (e, response) => {\n      let partCopyResult = Buffer.from('')\n      if (e) {\n        return cb(e)\n      }\n      pipesetup(response, transformers.uploadPartTransformer())\n        .on('data', (data) => {\n          partCopyResult = data\n        })\n        .on('error', cb)\n        .on('end', () => {\n          let uploadPartCopyRes = {\n            etag: sanitizeETag(partCopyResult.ETag),\n            key: objectName,\n            part: partNumber,\n          }\n\n          cb(null, uploadPartCopyRes)\n        })\n    })\n  }\n\n  composeObject(destObjConfig = {}, sourceObjList = [], cb) {\n    const me = this // many async flows. so store the ref.\n    const sourceFilesLength = sourceObjList.length\n\n    if (!Array.isArray(sourceObjList)) {\n      throw new errors.InvalidArgumentError('sourceConfig should an array of CopySourceOptions ')\n    }\n    if (!(destObjConfig instanceof CopyDestinationOptions)) {\n      throw new errors.InvalidArgumentError('destConfig should of type CopyDestinationOptions ')\n    }\n\n    if (sourceFilesLength < 1 || sourceFilesLength > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n      throw new errors.InvalidArgumentError(\n        `\"There must be as least one and up to ${PART_CONSTRAINTS.MAX_PARTS_COUNT} source objects.`,\n      )\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    for (let i = 0; i < sourceFilesLength; i++) {\n      if (!sourceObjList[i].validate()) {\n        return false\n      }\n    }\n\n    if (!destObjConfig.validate()) {\n      return false\n    }\n\n    const getStatOptions = (srcConfig) => {\n      let statOpts = {}\n      if (!_.isEmpty(srcConfig.VersionID)) {\n        statOpts = {\n          versionId: srcConfig.VersionID,\n        }\n      }\n      return statOpts\n    }\n    const srcObjectSizes = []\n    let totalSize = 0\n    let totalParts = 0\n\n    const sourceObjStats = sourceObjList.map((srcItem) =>\n      me.statObject(srcItem.Bucket, srcItem.Object, getStatOptions(srcItem)),\n    )\n\n    return Promise.all(sourceObjStats)\n      .then((srcObjectInfos) => {\n        const validatedStats = srcObjectInfos.map((resItemStat, index) => {\n          const srcConfig = sourceObjList[index]\n\n          let srcCopySize = resItemStat.size\n          // Check if a segment is specified, and if so, is the\n          // segment within object bounds?\n          if (srcConfig.MatchRange) {\n            // Since range is specified,\n            //    0 <= src.srcStart <= src.srcEnd\n            // so only invalid case to check is:\n            const srcStart = srcConfig.Start\n            const srcEnd = srcConfig.End\n            if (srcEnd >= srcCopySize || srcStart < 0) {\n              throw new errors.InvalidArgumentError(\n                `CopySrcOptions ${index} has invalid segment-to-copy [${srcStart}, ${srcEnd}] (size is ${srcCopySize})`,\n              )\n            }\n            srcCopySize = srcEnd - srcStart + 1\n          }\n\n          // Only the last source may be less than `absMinPartSize`\n          if (srcCopySize < PART_CONSTRAINTS.ABS_MIN_PART_SIZE && index < sourceFilesLength - 1) {\n            throw new errors.InvalidArgumentError(\n              `CopySrcOptions ${index} is too small (${srcCopySize}) and it is not the last part.`,\n            )\n          }\n\n          // Is data to copy too large?\n          totalSize += srcCopySize\n          if (totalSize > PART_CONSTRAINTS.MAX_MULTIPART_PUT_OBJECT_SIZE) {\n            throw new errors.InvalidArgumentError(`Cannot compose an object of size ${totalSize} (> 5TiB)`)\n          }\n\n          // record source size\n          srcObjectSizes[index] = srcCopySize\n\n          // calculate parts needed for current source\n          totalParts += partsRequired(srcCopySize)\n          // Do we need more parts than we are allowed?\n          if (totalParts > PART_CONSTRAINTS.MAX_PARTS_COUNT) {\n            throw new errors.InvalidArgumentError(\n              `Your proposed compose object requires more than ${PART_CONSTRAINTS.MAX_PARTS_COUNT} parts`,\n            )\n          }\n\n          return resItemStat\n        })\n\n        if ((totalParts === 1 && totalSize <= PART_CONSTRAINTS.MAX_PART_SIZE) || totalSize === 0) {\n          return this.copyObject(sourceObjList[0], destObjConfig, cb) // use copyObjectV2\n        }\n\n        // preserve etag to avoid modification of object while copying.\n        for (let i = 0; i < sourceFilesLength; i++) {\n          sourceObjList[i].MatchETag = validatedStats[i].etag\n        }\n\n        const splitPartSizeList = validatedStats.map((resItemStat, idx) => {\n          const calSize = calculateEvenSplits(srcObjectSizes[idx], sourceObjList[idx])\n          return calSize\n        })\n\n        function getUploadPartConfigList(uploadId) {\n          const uploadPartConfigList = []\n\n          splitPartSizeList.forEach((splitSize, splitIndex) => {\n            const { startIndex: startIdx, endIndex: endIdx, objInfo: objConfig } = splitSize\n\n            let partIndex = splitIndex + 1 // part index starts from 1.\n            const totalUploads = Array.from(startIdx)\n\n            const headers = sourceObjList[splitIndex].getHeaders()\n\n            totalUploads.forEach((splitStart, upldCtrIdx) => {\n              let splitEnd = endIdx[upldCtrIdx]\n\n              const sourceObj = `${objConfig.Bucket}/${objConfig.Object}`\n              headers['x-amz-copy-source'] = `${sourceObj}`\n              headers['x-amz-copy-source-range'] = `bytes=${splitStart}-${splitEnd}`\n\n              const uploadPartConfig = {\n                bucketName: destObjConfig.Bucket,\n                objectName: destObjConfig.Object,\n                uploadID: uploadId,\n                partNumber: partIndex,\n                headers: headers,\n                sourceObj: sourceObj,\n              }\n\n              uploadPartConfigList.push(uploadPartConfig)\n            })\n          })\n\n          return uploadPartConfigList\n        }\n\n        const performUploadParts = (uploadId) => {\n          const uploadList = getUploadPartConfigList(uploadId)\n\n          async.map(uploadList, me.uploadPartCopy.bind(me), (err, res) => {\n            if (err) {\n              return this.abortMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, cb)\n            }\n            const partsDone = res.map((partCopy) => ({ etag: partCopy.etag, part: partCopy.part }))\n            return me.completeMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, uploadId, partsDone, cb)\n          })\n        }\n\n        const newUploadHeaders = destObjConfig.getHeaders()\n\n        me.initiateNewMultipartUpload(destObjConfig.Bucket, destObjConfig.Object, newUploadHeaders, (err, uploadId) => {\n          if (err) {\n            return cb(err, null)\n          }\n          performUploadParts(uploadId)\n        })\n      })\n      .catch((error) => {\n        cb(error, null)\n      })\n  }\n  selectObjectContent(bucketName, objectName, selectOpts = {}, cb) {\n    if (!isValidBucketName(bucketName)) {\n      throw new errors.InvalidBucketNameError(`Invalid bucket name: ${bucketName}`)\n    }\n    if (!isValidObjectName(objectName)) {\n      throw new errors.InvalidObjectNameError(`Invalid object name: ${objectName}`)\n    }\n    if (!_.isEmpty(selectOpts)) {\n      if (!isString(selectOpts.expression)) {\n        throw new TypeError('sqlExpression should be of type \"string\"')\n      }\n      if (!_.isEmpty(selectOpts.inputSerialization)) {\n        if (!isObject(selectOpts.inputSerialization)) {\n          throw new TypeError('inputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('inputSerialization is required')\n      }\n      if (!_.isEmpty(selectOpts.outputSerialization)) {\n        if (!isObject(selectOpts.outputSerialization)) {\n          throw new TypeError('outputSerialization should be of type \"object\"')\n        }\n      } else {\n        throw new TypeError('outputSerialization is required')\n      }\n    } else {\n      throw new TypeError('valid select configuration is required')\n    }\n\n    if (!isFunction(cb)) {\n      throw new TypeError('callback should be of type \"function\"')\n    }\n\n    const method = 'POST'\n    let query = `select`\n    query += '&select-type=2'\n\n    const config = [\n      {\n        Expression: selectOpts.expression,\n      },\n      {\n        ExpressionType: selectOpts.expressionType || 'SQL',\n      },\n      {\n        InputSerialization: [selectOpts.inputSerialization],\n      },\n      {\n        OutputSerialization: [selectOpts.outputSerialization],\n      },\n    ]\n\n    // Optional\n    if (selectOpts.requestProgress) {\n      config.push({ RequestProgress: selectOpts.requestProgress })\n    }\n    // Optional\n    if (selectOpts.scanRange) {\n      config.push({ ScanRange: selectOpts.scanRange })\n    }\n\n    const builder = new xml2js.Builder({\n      rootName: 'SelectObjectContentRequest',\n      renderOpts: { pretty: false },\n      headless: true,\n    })\n    const payload = builder.buildObject(config)\n\n    this.makeRequest({ method, bucketName, objectName, query }, payload, [200], '', true, (e, response) => {\n      if (e) {\n        return cb(e)\n      }\n\n      let selectResult\n      pipesetup(response, transformers.selectObjectContentTransformer())\n        .on('data', (data) => {\n          selectResult = parseSelectObjectContentResponse(data)\n        })\n        .on('error', cb)\n        .on('end', () => {\n          cb(null, selectResult)\n        })\n    })\n  }\n\n  get extensions() {\n    if (!this.clientExtensions) {\n      this.clientExtensions = new extensions(this)\n    }\n    return this.clientExtensions\n  }\n}\n\n// Promisify various public-facing APIs on the Client module.\nClient.prototype.makeBucket = promisify(Client.prototype.makeBucket)\nClient.prototype.listBuckets = promisify(Client.prototype.listBuckets)\nClient.prototype.bucketExists = promisify(Client.prototype.bucketExists)\nClient.prototype.removeBucket = promisify(Client.prototype.removeBucket)\n\nClient.prototype.getObject = promisify(Client.prototype.getObject)\nClient.prototype.getPartialObject = promisify(Client.prototype.getPartialObject)\nClient.prototype.fGetObject = promisify(Client.prototype.fGetObject)\nClient.prototype.putObject = promisify(Client.prototype.putObject)\nClient.prototype.fPutObject = promisify(Client.prototype.fPutObject)\nClient.prototype.copyObject = promisify(Client.prototype.copyObject)\nClient.prototype.statObject = promisify(Client.prototype.statObject)\nClient.prototype.removeObject = promisify(Client.prototype.removeObject)\nClient.prototype.removeObjects = promisify(Client.prototype.removeObjects)\n\nClient.prototype.presignedUrl = promisify(Client.prototype.presignedUrl)\nClient.prototype.presignedGetObject = promisify(Client.prototype.presignedGetObject)\nClient.prototype.presignedPutObject = promisify(Client.prototype.presignedPutObject)\nClient.prototype.presignedPostPolicy = promisify(Client.prototype.presignedPostPolicy)\nClient.prototype.getBucketNotification = promisify(Client.prototype.getBucketNotification)\nClient.prototype.setBucketNotification = promisify(Client.prototype.setBucketNotification)\nClient.prototype.removeAllBucketNotification = promisify(Client.prototype.removeAllBucketNotification)\nClient.prototype.getBucketPolicy = promisify(Client.prototype.getBucketPolicy)\nClient.prototype.setBucketPolicy = promisify(Client.prototype.setBucketPolicy)\nClient.prototype.removeIncompleteUpload = promisify(Client.prototype.removeIncompleteUpload)\nClient.prototype.getBucketVersioning = promisify(Client.prototype.getBucketVersioning)\nClient.prototype.setBucketVersioning = promisify(Client.prototype.setBucketVersioning)\nClient.prototype.setBucketTagging = promisify(Client.prototype.setBucketTagging)\nClient.prototype.removeBucketTagging = promisify(Client.prototype.removeBucketTagging)\nClient.prototype.getBucketTagging = promisify(Client.prototype.getBucketTagging)\nClient.prototype.setObjectTagging = promisify(Client.prototype.setObjectTagging)\nClient.prototype.removeObjectTagging = promisify(Client.prototype.removeObjectTagging)\nClient.prototype.getObjectTagging = promisify(Client.prototype.getObjectTagging)\nClient.prototype.setBucketLifecycle = promisify(Client.prototype.setBucketLifecycle)\nClient.prototype.getBucketLifecycle = promisify(Client.prototype.getBucketLifecycle)\nClient.prototype.removeBucketLifecycle = promisify(Client.prototype.removeBucketLifecycle)\nClient.prototype.setObjectLockConfig = promisify(Client.prototype.setObjectLockConfig)\nClient.prototype.getObjectLockConfig = promisify(Client.prototype.getObjectLockConfig)\nClient.prototype.putObjectRetention = promisify(Client.prototype.putObjectRetention)\nClient.prototype.getObjectRetention = promisify(Client.prototype.getObjectRetention)\nClient.prototype.setBucketEncryption = promisify(Client.prototype.setBucketEncryption)\nClient.prototype.getBucketEncryption = promisify(Client.prototype.getBucketEncryption)\nClient.prototype.removeBucketEncryption = promisify(Client.prototype.removeBucketEncryption)\nClient.prototype.setBucketReplication = promisify(Client.prototype.setBucketReplication)\nClient.prototype.getBucketReplication = promisify(Client.prototype.getBucketReplication)\nClient.prototype.removeBucketReplication = promisify(Client.prototype.removeBucketReplication)\nClient.prototype.setObjectLegalHold = promisify(Client.prototype.setObjectLegalHold)\nClient.prototype.getObjectLegalHold = promisify(Client.prototype.getObjectLegalHold)\nClient.prototype.composeObject = promisify(Client.prototype.composeObject)\nClient.prototype.selectObjectContent = promisify(Client.prototype.selectObjectContent)\n"],"mappings":"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"} /***/ }), @@ -81931,18 +85108,25 @@ class ObjectUploader extends _stream.Transform { // If no upload ID exists, initiate a new one. if (!id) { - this.client.initiateNewMultipartUpload(this.bucketName, this.objectName, this.metaData).then(id => { + this.client.initiateNewMultipartUpload(this.bucketName, this.objectName, this.metaData, (err, id) => { + if (err) { + return callback(err); + } this.id = id; // We are now ready to accept new chunks — this will flush the buffered chunk. this.emit('ready'); - }, err => callback(err)); + }); return; } this.id = id; // Retrieve the pre-uploaded parts, if we need to resume the upload. - this.client.listParts(this.bucketName, this.objectName, id).then(etags => { + this.client.listParts(this.bucketName, this.objectName, id, (err, etags) => { + if (err) { + return this.emit('error', err); + } + // It is possible for no parts to be already uploaded. if (!etags) { etags = []; @@ -81956,8 +85140,6 @@ class ObjectUploader extends _stream.Transform { return prev; }, {}); this.emit('ready'); - }, err => { - return this.emit('error', err); }); }); return; @@ -82083,7 +85265,7 @@ class ObjectUploader extends _stream.Transform { exports.ObjectUploader = ObjectUploader; var _default = ObjectUploader; exports["default"] = _default; -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Crypto","_interopRequireWildcard","require","_stream","querystring","_helper","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","ObjectUploader","Transform","constructor","client","bucketName","objectName","partSize","metaData","callback","emptyStream","partNumber","oldParts","etags","id","on","err","_transform","chunk","encoding","method","headers","length","md5digest","enableSHA256","createHash","update","digest","toString","options","assign","query","makeRequest","response","result","etag","sanitizeETag","versionId","getVersionId","process","nextTick","once","findUploadId","emit","initiateNewMultipartUpload","then","listParts","reduce","prev","item","part","oldPart","push","stringify","uploadId","replace","_flush","completeMultipartUpload","exports","_default"],"sources":["object-uploader.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Crypto from 'node:crypto'\nimport { Transform } from 'node:stream'\n\nimport * as querystring from 'query-string'\n\nimport { getVersionId, sanitizeETag } from './internal/helper.ts'\n\n// We extend Transform because Writable does not implement ._flush().\nexport class ObjectUploader extends Transform {\n  constructor(client, bucketName, objectName, partSize, metaData, callback) {\n    super()\n    this.emptyStream = true\n    this.client = client\n    this.bucketName = bucketName\n    this.objectName = objectName\n    // The size of each multipart, chunked by BlockStream2.\n    this.partSize = partSize\n    // This is the metadata for the object.\n    this.metaData = metaData\n\n    // Call like: callback(error, {etag, versionId}).\n    this.callback = callback\n\n    // We need to keep track of what number chunk/part we're on. This increments\n    // each time _write() is called. Starts with 1, not 0.\n    this.partNumber = 1\n\n    // A list of the previously uploaded chunks, for resuming a file upload. This\n    // will be null if we aren't resuming an upload.\n    this.oldParts = null\n\n    // Keep track of the etags for aggregating the chunks together later. Each\n    // etag represents a single chunk of the file.\n    this.etags = []\n\n    // This is for the multipart upload request — if null, we're either not initiated\n    // yet or we're flushing in one packet.\n    this.id = null\n\n    // Handle errors.\n    this.on('error', (err) => {\n      callback(err)\n    })\n  }\n\n  _transform(chunk, encoding, callback) {\n    this.emptyStream = false\n    let method = 'PUT'\n    let headers = { 'Content-Length': chunk.length }\n    let md5digest = ''\n\n    // Calculate and set Content-MD5 header if SHA256 is not set.\n    // This will happen only when there is a secure connection to the s3 server.\n    if (!this.client.enableSHA256) {\n      md5digest = Crypto.createHash('md5').update(chunk).digest()\n      headers['Content-MD5'] = md5digest.toString('base64')\n    }\n    // We can flush the object in one packet if it fits in one chunk. This is true\n    // if the chunk size is smaller than the part size, signifying the end of the\n    // stream.\n    if (this.partNumber == 1 && chunk.length < this.partSize) {\n      // PUT the chunk in a single request — use an empty query.\n      let options = {\n        method,\n        // Set user metadata as this is not a multipart upload\n        headers: Object.assign({}, this.metaData, headers),\n        query: '',\n        bucketName: this.bucketName,\n        objectName: this.objectName,\n      }\n\n      this.client.makeRequest(options, chunk, [200], '', true, (err, response) => {\n        if (err) {\n          return callback(err)\n        }\n        let result = {\n          etag: sanitizeETag(response.headers.etag),\n          versionId: getVersionId(response.headers),\n        }\n        // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n        response.on('data', () => {})\n\n        // Give the etag back, we're done!\n\n        process.nextTick(() => {\n          this.callback(null, result)\n        })\n\n        // Because we're sure the stream has ended, allow it to flush and end.\n        callback()\n      })\n\n      return\n    }\n\n    // If we aren't flushing in one packet, we need to initiate the multipart upload,\n    // if it hasn't already been done. The write will be buffered until the upload has been\n    // initiated.\n    if (this.id === null) {\n      this.once('ready', () => {\n        this._transform(chunk, encoding, callback)\n      })\n\n      // Check for an incomplete previous upload.\n      this.client.findUploadId(this.bucketName, this.objectName, (err, id) => {\n        if (err) {\n          return this.emit('error', err)\n        }\n\n        // If no upload ID exists, initiate a new one.\n        if (!id) {\n          this.client.initiateNewMultipartUpload(this.bucketName, this.objectName, this.metaData).then(\n            (id) => {\n              this.id = id\n\n              // We are now ready to accept new chunks — this will flush the buffered chunk.\n              this.emit('ready')\n            },\n            (err) => callback(err),\n          )\n\n          return\n        }\n\n        this.id = id\n\n        // Retrieve the pre-uploaded parts, if we need to resume the upload.\n        this.client.listParts(this.bucketName, this.objectName, id).then(\n          (etags) => {\n            // It is possible for no parts to be already uploaded.\n            if (!etags) {\n              etags = []\n            }\n\n            // oldParts will become an object, allowing oldParts[partNumber].etag\n            this.oldParts = etags.reduce(function (prev, item) {\n              if (!prev[item.part]) {\n                prev[item.part] = item\n              }\n              return prev\n            }, {})\n\n            this.emit('ready')\n          },\n          (err) => {\n            return this.emit('error', err)\n          },\n        )\n      })\n\n      return\n    }\n\n    // Continue uploading various parts if we have initiated multipart upload.\n    let partNumber = this.partNumber++\n\n    // Check to see if we've already uploaded this chunk. If the hash sums match,\n    // we can skip to the next chunk.\n    if (this.oldParts) {\n      let oldPart = this.oldParts[partNumber]\n\n      // Calulcate the md5 hash, if it has not already been calculated.\n      if (!md5digest) {\n        md5digest = Crypto.createHash('md5').update(chunk).digest()\n      }\n\n      if (oldPart && md5digest.toString('hex') === oldPart.etag) {\n        // The md5 matches, the chunk has already been uploaded.\n        this.etags.push({ part: partNumber, etag: oldPart.etag })\n\n        callback()\n        return\n      }\n    }\n\n    // Write the chunk with an uploader.\n    let query = querystring.stringify({\n      partNumber: partNumber,\n      uploadId: this.id,\n    })\n\n    let options = {\n      method,\n      query,\n      headers,\n      bucketName: this.bucketName,\n      objectName: this.objectName,\n    }\n\n    this.client.makeRequest(options, chunk, [200], '', true, (err, response) => {\n      if (err) {\n        return callback(err)\n      }\n\n      // In order to aggregate the parts together, we need to collect the etags.\n      let etag = response.headers.etag\n      if (etag) {\n        etag = etag.replace(/^\"/, '').replace(/\"$/, '')\n      }\n\n      this.etags.push({ part: partNumber, etag })\n\n      // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n      response.on('data', () => {})\n\n      // We're ready for the next chunk.\n      callback()\n    })\n  }\n\n  _flush(callback) {\n    if (this.emptyStream) {\n      let method = 'PUT'\n      let headers = Object.assign({}, this.metaData, { 'Content-Length': 0 })\n      let options = {\n        method,\n        headers,\n        query: '',\n        bucketName: this.bucketName,\n        objectName: this.objectName,\n      }\n\n      this.client.makeRequest(options, '', [200], '', true, (err, response) => {\n        if (err) {\n          return callback(err)\n        }\n\n        let result = {\n          etag: sanitizeETag(response.headers.etag),\n          versionId: getVersionId(response.headers),\n        }\n\n        // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n        response.on('data', () => {})\n\n        // Give the etag back, we're done!\n        process.nextTick(() => {\n          this.callback(null, result)\n        })\n\n        // Because we're sure the stream has ended, allow it to flush and end.\n        callback()\n      })\n\n      return\n    }\n    // If it has been uploaded in a single packet, we don't have to do anything.\n    if (this.id === null) {\n      return\n    }\n\n    // This is called when all of the chunks uploaded successfully, thus\n    // completing the multipart upload.\n    this.client.completeMultipartUpload(this.bucketName, this.objectName, this.id, this.etags, (err, etag) => {\n      if (err) {\n        return callback(err)\n      }\n\n      // Call our callback on the next tick to allow the streams infrastructure\n      // to finish what its doing before we continue.\n      process.nextTick(() => {\n        this.callback(null, etag)\n      })\n\n      callback()\n    })\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default ObjectUploader\n"],"mappings":";;;;;AAgBA,IAAAA,MAAA,GAAAC,uBAAA,CAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AAEA,IAAAE,WAAA,GAAAH,uBAAA,CAAAC,OAAA;AAEA,IAAAG,OAAA,GAAAH,OAAA;AAAiE,SAAAI,yBAAAC,WAAA,eAAAC,OAAA,kCAAAC,iBAAA,OAAAD,OAAA,QAAAE,gBAAA,OAAAF,OAAA,YAAAF,wBAAA,YAAAA,CAAAC,WAAA,WAAAA,WAAA,GAAAG,gBAAA,GAAAD,iBAAA,KAAAF,WAAA;AAAA,SAAAN,wBAAAU,GAAA,EAAAJ,WAAA,SAAAA,WAAA,IAAAI,GAAA,IAAAA,GAAA,CAAAC,UAAA,WAAAD,GAAA,QAAAA,GAAA,oBAAAA,GAAA,wBAAAA,GAAA,4BAAAE,OAAA,EAAAF,GAAA,UAAAG,KAAA,GAAAR,wBAAA,CAAAC,WAAA,OAAAO,KAAA,IAAAA,KAAA,CAAAC,GAAA,CAAAJ,GAAA,YAAAG,KAAA,CAAAE,GAAA,CAAAL,GAAA,SAAAM,MAAA,WAAAC,qBAAA,GAAAC,MAAA,CAAAC,cAAA,IAAAD,MAAA,CAAAE,wBAAA,WAAAC,GAAA,IAAAX,GAAA,QAAAW,GAAA,kBAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAd,GAAA,EAAAW,GAAA,SAAAI,IAAA,GAAAR,qBAAA,GAAAC,MAAA,CAAAE,wBAAA,CAAAV,GAAA,EAAAW,GAAA,cAAAI,IAAA,KAAAA,IAAA,CAAAV,GAAA,IAAAU,IAAA,CAAAC,GAAA,KAAAR,MAAA,CAAAC,cAAA,CAAAH,MAAA,EAAAK,GAAA,EAAAI,IAAA,YAAAT,MAAA,CAAAK,GAAA,IAAAX,GAAA,CAAAW,GAAA,SAAAL,MAAA,CAAAJ,OAAA,GAAAF,GAAA,MAAAG,KAAA,IAAAA,KAAA,CAAAa,GAAA,CAAAhB,GAAA,EAAAM,MAAA,YAAAA,MAAA;AArBjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AASA;AACO,MAAMW,cAAc,SAASC,iBAAS,CAAC;EAC5CC,WAAWA,CAACC,MAAM,EAAEC,UAAU,EAAEC,UAAU,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,QAAQ,EAAE;IACxE,KAAK,CAAC,CAAC;IACP,IAAI,CAACC,WAAW,GAAG,IAAI;IACvB,IAAI,CAACN,MAAM,GAAGA,MAAM;IACpB,IAAI,CAACC,UAAU,GAAGA,UAAU;IAC5B,IAAI,CAACC,UAAU,GAAGA,UAAU;IAC5B;IACA,IAAI,CAACC,QAAQ,GAAGA,QAAQ;IACxB;IACA,IAAI,CAACC,QAAQ,GAAGA,QAAQ;;IAExB;IACA,IAAI,CAACC,QAAQ,GAAGA,QAAQ;;IAExB;IACA;IACA,IAAI,CAACE,UAAU,GAAG,CAAC;;IAEnB;IACA;IACA,IAAI,CAACC,QAAQ,GAAG,IAAI;;IAEpB;IACA;IACA,IAAI,CAACC,KAAK,GAAG,EAAE;;IAEf;IACA;IACA,IAAI,CAACC,EAAE,GAAG,IAAI;;IAEd;IACA,IAAI,CAACC,EAAE,CAAC,OAAO,EAAGC,GAAG,IAAK;MACxBP,QAAQ,CAACO,GAAG,CAAC;IACf,CAAC,CAAC;EACJ;EAEAC,UAAUA,CAACC,KAAK,EAAEC,QAAQ,EAAEV,QAAQ,EAAE;IACpC,IAAI,CAACC,WAAW,GAAG,KAAK;IACxB,IAAIU,MAAM,GAAG,KAAK;IAClB,IAAIC,OAAO,GAAG;MAAE,gBAAgB,EAAEH,KAAK,CAACI;IAAO,CAAC;IAChD,IAAIC,SAAS,GAAG,EAAE;;IAElB;IACA;IACA,IAAI,CAAC,IAAI,CAACnB,MAAM,CAACoB,YAAY,EAAE;MAC7BD,SAAS,GAAGlD,MAAM,CAACoD,UAAU,CAAC,KAAK,CAAC,CAACC,MAAM,CAACR,KAAK,CAAC,CAACS,MAAM,CAAC,CAAC;MAC3DN,OAAO,CAAC,aAAa,CAAC,GAAGE,SAAS,CAACK,QAAQ,CAAC,QAAQ,CAAC;IACvD;IACA;IACA;IACA;IACA,IAAI,IAAI,CAACjB,UAAU,IAAI,CAAC,IAAIO,KAAK,CAACI,MAAM,GAAG,IAAI,CAACf,QAAQ,EAAE;MACxD;MACA,IAAIsB,OAAO,GAAG;QACZT,MAAM;QACN;QACAC,OAAO,EAAE7B,MAAM,CAACsC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAACtB,QAAQ,EAAEa,OAAO,CAAC;QAClDU,KAAK,EAAE,EAAE;QACT1B,UAAU,EAAE,IAAI,CAACA,UAAU;QAC3BC,UAAU,EAAE,IAAI,CAACA;MACnB,CAAC;MAED,IAAI,CAACF,MAAM,CAAC4B,WAAW,CAACH,OAAO,EAAEX,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAACF,GAAG,EAAEiB,QAAQ,KAAK;QAC1E,IAAIjB,GAAG,EAAE;UACP,OAAOP,QAAQ,CAACO,GAAG,CAAC;QACtB;QACA,IAAIkB,MAAM,GAAG;UACXC,IAAI,EAAE,IAAAC,oBAAY,EAACH,QAAQ,CAACZ,OAAO,CAACc,IAAI,CAAC;UACzCE,SAAS,EAAE,IAAAC,oBAAY,EAACL,QAAQ,CAACZ,OAAO;QAC1C,CAAC;QACD;QACAY,QAAQ,CAAClB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;;QAE7B;;QAEAwB,OAAO,CAACC,QAAQ,CAAC,MAAM;UACrB,IAAI,CAAC/B,QAAQ,CAAC,IAAI,EAAEyB,MAAM,CAAC;QAC7B,CAAC,CAAC;;QAEF;QACAzB,QAAQ,CAAC,CAAC;MACZ,CAAC,CAAC;MAEF;IACF;;IAEA;IACA;IACA;IACA,IAAI,IAAI,CAACK,EAAE,KAAK,IAAI,EAAE;MACpB,IAAI,CAAC2B,IAAI,CAAC,OAAO,EAAE,MAAM;QACvB,IAAI,CAACxB,UAAU,CAACC,KAAK,EAAEC,QAAQ,EAAEV,QAAQ,CAAC;MAC5C,CAAC,CAAC;;MAEF;MACA,IAAI,CAACL,MAAM,CAACsC,YAAY,CAAC,IAAI,CAACrC,UAAU,EAAE,IAAI,CAACC,UAAU,EAAE,CAACU,GAAG,EAAEF,EAAE,KAAK;QACtE,IAAIE,GAAG,EAAE;UACP,OAAO,IAAI,CAAC2B,IAAI,CAAC,OAAO,EAAE3B,GAAG,CAAC;QAChC;;QAEA;QACA,IAAI,CAACF,EAAE,EAAE;UACP,IAAI,CAACV,MAAM,CAACwC,0BAA0B,CAAC,IAAI,CAACvC,UAAU,EAAE,IAAI,CAACC,UAAU,EAAE,IAAI,CAACE,QAAQ,CAAC,CAACqC,IAAI,CACzF/B,EAAE,IAAK;YACN,IAAI,CAACA,EAAE,GAAGA,EAAE;;YAEZ;YACA,IAAI,CAAC6B,IAAI,CAAC,OAAO,CAAC;UACpB,CAAC,EACA3B,GAAG,IAAKP,QAAQ,CAACO,GAAG,CACvB,CAAC;UAED;QACF;QAEA,IAAI,CAACF,EAAE,GAAGA,EAAE;;QAEZ;QACA,IAAI,CAACV,MAAM,CAAC0C,SAAS,CAAC,IAAI,CAACzC,UAAU,EAAE,IAAI,CAACC,UAAU,EAAEQ,EAAE,CAAC,CAAC+B,IAAI,CAC7DhC,KAAK,IAAK;UACT;UACA,IAAI,CAACA,KAAK,EAAE;YACVA,KAAK,GAAG,EAAE;UACZ;;UAEA;UACA,IAAI,CAACD,QAAQ,GAAGC,KAAK,CAACkC,MAAM,CAAC,UAAUC,IAAI,EAAEC,IAAI,EAAE;YACjD,IAAI,CAACD,IAAI,CAACC,IAAI,CAACC,IAAI,CAAC,EAAE;cACpBF,IAAI,CAACC,IAAI,CAACC,IAAI,CAAC,GAAGD,IAAI;YACxB;YACA,OAAOD,IAAI;UACb,CAAC,EAAE,CAAC,CAAC,CAAC;UAEN,IAAI,CAACL,IAAI,CAAC,OAAO,CAAC;QACpB,CAAC,EACA3B,GAAG,IAAK;UACP,OAAO,IAAI,CAAC2B,IAAI,CAAC,OAAO,EAAE3B,GAAG,CAAC;QAChC,CACF,CAAC;MACH,CAAC,CAAC;MAEF;IACF;;IAEA;IACA,IAAIL,UAAU,GAAG,IAAI,CAACA,UAAU,EAAE;;IAElC;IACA;IACA,IAAI,IAAI,CAACC,QAAQ,EAAE;MACjB,IAAIuC,OAAO,GAAG,IAAI,CAACvC,QAAQ,CAACD,UAAU,CAAC;;MAEvC;MACA,IAAI,CAACY,SAAS,EAAE;QACdA,SAAS,GAAGlD,MAAM,CAACoD,UAAU,CAAC,KAAK,CAAC,CAACC,MAAM,CAACR,KAAK,CAAC,CAACS,MAAM,CAAC,CAAC;MAC7D;MAEA,IAAIwB,OAAO,IAAI5B,SAAS,CAACK,QAAQ,CAAC,KAAK,CAAC,KAAKuB,OAAO,CAAChB,IAAI,EAAE;QACzD;QACA,IAAI,CAACtB,KAAK,CAACuC,IAAI,CAAC;UAAEF,IAAI,EAAEvC,UAAU;UAAEwB,IAAI,EAAEgB,OAAO,CAAChB;QAAK,CAAC,CAAC;QAEzD1B,QAAQ,CAAC,CAAC;QACV;MACF;IACF;;IAEA;IACA,IAAIsB,KAAK,GAAGtD,WAAW,CAAC4E,SAAS,CAAC;MAChC1C,UAAU,EAAEA,UAAU;MACtB2C,QAAQ,EAAE,IAAI,CAACxC;IACjB,CAAC,CAAC;IAEF,IAAIe,OAAO,GAAG;MACZT,MAAM;MACNW,KAAK;MACLV,OAAO;MACPhB,UAAU,EAAE,IAAI,CAACA,UAAU;MAC3BC,UAAU,EAAE,IAAI,CAACA;IACnB,CAAC;IAED,IAAI,CAACF,MAAM,CAAC4B,WAAW,CAACH,OAAO,EAAEX,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAACF,GAAG,EAAEiB,QAAQ,KAAK;MAC1E,IAAIjB,GAAG,EAAE;QACP,OAAOP,QAAQ,CAACO,GAAG,CAAC;MACtB;;MAEA;MACA,IAAImB,IAAI,GAAGF,QAAQ,CAACZ,OAAO,CAACc,IAAI;MAChC,IAAIA,IAAI,EAAE;QACRA,IAAI,GAAGA,IAAI,CAACoB,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAACA,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;MACjD;MAEA,IAAI,CAAC1C,KAAK,CAACuC,IAAI,CAAC;QAAEF,IAAI,EAAEvC,UAAU;QAAEwB;MAAK,CAAC,CAAC;;MAE3C;MACAF,QAAQ,CAAClB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;;MAE7B;MACAN,QAAQ,CAAC,CAAC;IACZ,CAAC,CAAC;EACJ;EAEA+C,MAAMA,CAAC/C,QAAQ,EAAE;IACf,IAAI,IAAI,CAACC,WAAW,EAAE;MACpB,IAAIU,MAAM,GAAG,KAAK;MAClB,IAAIC,OAAO,GAAG7B,MAAM,CAACsC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAACtB,QAAQ,EAAE;QAAE,gBAAgB,EAAE;MAAE,CAAC,CAAC;MACvE,IAAIqB,OAAO,GAAG;QACZT,MAAM;QACNC,OAAO;QACPU,KAAK,EAAE,EAAE;QACT1B,UAAU,EAAE,IAAI,CAACA,UAAU;QAC3BC,UAAU,EAAE,IAAI,CAACA;MACnB,CAAC;MAED,IAAI,CAACF,MAAM,CAAC4B,WAAW,CAACH,OAAO,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAACb,GAAG,EAAEiB,QAAQ,KAAK;QACvE,IAAIjB,GAAG,EAAE;UACP,OAAOP,QAAQ,CAACO,GAAG,CAAC;QACtB;QAEA,IAAIkB,MAAM,GAAG;UACXC,IAAI,EAAE,IAAAC,oBAAY,EAACH,QAAQ,CAACZ,OAAO,CAACc,IAAI,CAAC;UACzCE,SAAS,EAAE,IAAAC,oBAAY,EAACL,QAAQ,CAACZ,OAAO;QAC1C,CAAC;;QAED;QACAY,QAAQ,CAAClB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;;QAE7B;QACAwB,OAAO,CAACC,QAAQ,CAAC,MAAM;UACrB,IAAI,CAAC/B,QAAQ,CAAC,IAAI,EAAEyB,MAAM,CAAC;QAC7B,CAAC,CAAC;;QAEF;QACAzB,QAAQ,CAAC,CAAC;MACZ,CAAC,CAAC;MAEF;IACF;IACA;IACA,IAAI,IAAI,CAACK,EAAE,KAAK,IAAI,EAAE;MACpB;IACF;;IAEA;IACA;IACA,IAAI,CAACV,MAAM,CAACqD,uBAAuB,CAAC,IAAI,CAACpD,UAAU,EAAE,IAAI,CAACC,UAAU,EAAE,IAAI,CAACQ,EAAE,EAAE,IAAI,CAACD,KAAK,EAAE,CAACG,GAAG,EAAEmB,IAAI,KAAK;MACxG,IAAInB,GAAG,EAAE;QACP,OAAOP,QAAQ,CAACO,GAAG,CAAC;MACtB;;MAEA;MACA;MACAuB,OAAO,CAACC,QAAQ,CAAC,MAAM;QACrB,IAAI,CAAC/B,QAAQ,CAAC,IAAI,EAAE0B,IAAI,CAAC;MAC3B,CAAC,CAAC;MAEF1B,QAAQ,CAAC,CAAC;IACZ,CAAC,CAAC;EACJ;AACF;;AAEA;AACA;AACA;AAAAiD,OAAA,CAAAzD,cAAA,GAAAA,cAAA;AAAA,IAAA0D,QAAA,GACe1D,cAAc;AAAAyD,OAAA,CAAAxE,OAAA,GAAAyE,QAAA"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Crypto","_interopRequireWildcard","require","_stream","querystring","_helper","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","ObjectUploader","Transform","constructor","client","bucketName","objectName","partSize","metaData","callback","emptyStream","partNumber","oldParts","etags","id","on","err","_transform","chunk","encoding","method","headers","length","md5digest","enableSHA256","createHash","update","digest","toString","options","assign","query","makeRequest","response","result","etag","sanitizeETag","versionId","getVersionId","process","nextTick","once","findUploadId","emit","initiateNewMultipartUpload","listParts","reduce","prev","item","part","oldPart","push","stringify","uploadId","replace","_flush","completeMultipartUpload","exports","_default"],"sources":["object-uploader.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Crypto from 'node:crypto'\nimport { Transform } from 'node:stream'\n\nimport * as querystring from 'query-string'\n\nimport { getVersionId, sanitizeETag } from './internal/helper.ts'\n\n// We extend Transform because Writable does not implement ._flush().\nexport class ObjectUploader extends Transform {\n  constructor(client, bucketName, objectName, partSize, metaData, callback) {\n    super()\n    this.emptyStream = true\n    this.client = client\n    this.bucketName = bucketName\n    this.objectName = objectName\n    // The size of each multipart, chunked by BlockStream2.\n    this.partSize = partSize\n    // This is the metadata for the object.\n    this.metaData = metaData\n\n    // Call like: callback(error, {etag, versionId}).\n    this.callback = callback\n\n    // We need to keep track of what number chunk/part we're on. This increments\n    // each time _write() is called. Starts with 1, not 0.\n    this.partNumber = 1\n\n    // A list of the previously uploaded chunks, for resuming a file upload. This\n    // will be null if we aren't resuming an upload.\n    this.oldParts = null\n\n    // Keep track of the etags for aggregating the chunks together later. Each\n    // etag represents a single chunk of the file.\n    this.etags = []\n\n    // This is for the multipart upload request — if null, we're either not initiated\n    // yet or we're flushing in one packet.\n    this.id = null\n\n    // Handle errors.\n    this.on('error', (err) => {\n      callback(err)\n    })\n  }\n\n  _transform(chunk, encoding, callback) {\n    this.emptyStream = false\n    let method = 'PUT'\n    let headers = { 'Content-Length': chunk.length }\n    let md5digest = ''\n\n    // Calculate and set Content-MD5 header if SHA256 is not set.\n    // This will happen only when there is a secure connection to the s3 server.\n    if (!this.client.enableSHA256) {\n      md5digest = Crypto.createHash('md5').update(chunk).digest()\n      headers['Content-MD5'] = md5digest.toString('base64')\n    }\n    // We can flush the object in one packet if it fits in one chunk. This is true\n    // if the chunk size is smaller than the part size, signifying the end of the\n    // stream.\n    if (this.partNumber == 1 && chunk.length < this.partSize) {\n      // PUT the chunk in a single request — use an empty query.\n      let options = {\n        method,\n        // Set user metadata as this is not a multipart upload\n        headers: Object.assign({}, this.metaData, headers),\n        query: '',\n        bucketName: this.bucketName,\n        objectName: this.objectName,\n      }\n\n      this.client.makeRequest(options, chunk, [200], '', true, (err, response) => {\n        if (err) {\n          return callback(err)\n        }\n        let result = {\n          etag: sanitizeETag(response.headers.etag),\n          versionId: getVersionId(response.headers),\n        }\n        // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n        response.on('data', () => {})\n\n        // Give the etag back, we're done!\n\n        process.nextTick(() => {\n          this.callback(null, result)\n        })\n\n        // Because we're sure the stream has ended, allow it to flush and end.\n        callback()\n      })\n\n      return\n    }\n\n    // If we aren't flushing in one packet, we need to initiate the multipart upload,\n    // if it hasn't already been done. The write will be buffered until the upload has been\n    // initiated.\n    if (this.id === null) {\n      this.once('ready', () => {\n        this._transform(chunk, encoding, callback)\n      })\n\n      // Check for an incomplete previous upload.\n      this.client.findUploadId(this.bucketName, this.objectName, (err, id) => {\n        if (err) {\n          return this.emit('error', err)\n        }\n\n        // If no upload ID exists, initiate a new one.\n        if (!id) {\n          this.client.initiateNewMultipartUpload(this.bucketName, this.objectName, this.metaData, (err, id) => {\n            if (err) {\n              return callback(err)\n            }\n\n            this.id = id\n\n            // We are now ready to accept new chunks — this will flush the buffered chunk.\n            this.emit('ready')\n          })\n\n          return\n        }\n\n        this.id = id\n\n        // Retrieve the pre-uploaded parts, if we need to resume the upload.\n        this.client.listParts(this.bucketName, this.objectName, id, (err, etags) => {\n          if (err) {\n            return this.emit('error', err)\n          }\n\n          // It is possible for no parts to be already uploaded.\n          if (!etags) {\n            etags = []\n          }\n\n          // oldParts will become an object, allowing oldParts[partNumber].etag\n          this.oldParts = etags.reduce(function (prev, item) {\n            if (!prev[item.part]) {\n              prev[item.part] = item\n            }\n            return prev\n          }, {})\n\n          this.emit('ready')\n        })\n      })\n\n      return\n    }\n\n    // Continue uploading various parts if we have initiated multipart upload.\n    let partNumber = this.partNumber++\n\n    // Check to see if we've already uploaded this chunk. If the hash sums match,\n    // we can skip to the next chunk.\n    if (this.oldParts) {\n      let oldPart = this.oldParts[partNumber]\n\n      // Calulcate the md5 hash, if it has not already been calculated.\n      if (!md5digest) {\n        md5digest = Crypto.createHash('md5').update(chunk).digest()\n      }\n\n      if (oldPart && md5digest.toString('hex') === oldPart.etag) {\n        // The md5 matches, the chunk has already been uploaded.\n        this.etags.push({ part: partNumber, etag: oldPart.etag })\n\n        callback()\n        return\n      }\n    }\n\n    // Write the chunk with an uploader.\n    let query = querystring.stringify({\n      partNumber: partNumber,\n      uploadId: this.id,\n    })\n\n    let options = {\n      method,\n      query,\n      headers,\n      bucketName: this.bucketName,\n      objectName: this.objectName,\n    }\n\n    this.client.makeRequest(options, chunk, [200], '', true, (err, response) => {\n      if (err) {\n        return callback(err)\n      }\n\n      // In order to aggregate the parts together, we need to collect the etags.\n      let etag = response.headers.etag\n      if (etag) {\n        etag = etag.replace(/^\"/, '').replace(/\"$/, '')\n      }\n\n      this.etags.push({ part: partNumber, etag })\n\n      // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n      response.on('data', () => {})\n\n      // We're ready for the next chunk.\n      callback()\n    })\n  }\n\n  _flush(callback) {\n    if (this.emptyStream) {\n      let method = 'PUT'\n      let headers = Object.assign({}, this.metaData, { 'Content-Length': 0 })\n      let options = {\n        method,\n        headers,\n        query: '',\n        bucketName: this.bucketName,\n        objectName: this.objectName,\n      }\n\n      this.client.makeRequest(options, '', [200], '', true, (err, response) => {\n        if (err) {\n          return callback(err)\n        }\n\n        let result = {\n          etag: sanitizeETag(response.headers.etag),\n          versionId: getVersionId(response.headers),\n        }\n\n        // Ignore the 'data' event so that the stream closes. (nodejs stream requirement)\n        response.on('data', () => {})\n\n        // Give the etag back, we're done!\n        process.nextTick(() => {\n          this.callback(null, result)\n        })\n\n        // Because we're sure the stream has ended, allow it to flush and end.\n        callback()\n      })\n\n      return\n    }\n    // If it has been uploaded in a single packet, we don't have to do anything.\n    if (this.id === null) {\n      return\n    }\n\n    // This is called when all of the chunks uploaded successfully, thus\n    // completing the multipart upload.\n    this.client.completeMultipartUpload(this.bucketName, this.objectName, this.id, this.etags, (err, etag) => {\n      if (err) {\n        return callback(err)\n      }\n\n      // Call our callback on the next tick to allow the streams infrastructure\n      // to finish what its doing before we continue.\n      process.nextTick(() => {\n        this.callback(null, etag)\n      })\n\n      callback()\n    })\n  }\n}\n\n// deprecated default export, please use named exports.\n// keep for backward compatibility.\n// eslint-disable-next-line import/no-default-export\nexport default ObjectUploader\n"],"mappings":"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"} /***/ }), @@ -82417,14 +85599,19 @@ Object.defineProperty(exports, "__esModule", ({ exports.bucketEncryptionTransformer = bucketEncryptionTransformer; exports.bucketVersioningTransformer = bucketVersioningTransformer; exports.getBucketNotificationTransformer = getBucketNotificationTransformer; +exports.getBucketRegionTransformer = getBucketRegionTransformer; exports.getCompleteMultipartTransformer = getCompleteMultipartTransformer; exports.getConcater = getConcater; exports.getCopyObjectTransformer = getCopyObjectTransformer; +exports.getErrorTransformer = getErrorTransformer; exports.getHashSummer = getHashSummer; +exports.getInitiateMultipartTransformer = getInitiateMultipartTransformer; +exports.getListBucketTransformer = getListBucketTransformer; exports.getListMultipartTransformer = getListMultipartTransformer; exports.getListObjectsTransformer = getListObjectsTransformer; exports.getListObjectsV2Transformer = getListObjectsV2Transformer; exports.getListObjectsV2WithMetadataTransformer = getListObjectsV2WithMetadataTransformer; +exports.getListPartsTransformer = getListPartsTransformer; exports.getNotificationTransformer = getNotificationTransformer; exports.getTagsTransformer = getTagsTransformer; exports.lifecycleTransformer = lifecycleTransformer; @@ -82432,11 +85619,14 @@ exports.objectLegalHoldTransformer = objectLegalHoldTransformer; exports.objectLockTransformer = objectLockTransformer; exports.objectRetentionTransformer = objectRetentionTransformer; exports.removeObjectsTransformer = removeObjectsTransformer; +exports.replicationConfigTransformer = replicationConfigTransformer; exports.selectObjectContentTransformer = selectObjectContentTransformer; exports.uploadPartTransformer = uploadPartTransformer; var Crypto = _interopRequireWildcard(__nccwpck_require__(6113), true); var _jsonStream = __nccwpck_require__(1676); +var _lodash = __nccwpck_require__(250); var _through = __nccwpck_require__(8180); +var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); var _helper = __nccwpck_require__(9921); var xmlParsers = _interopRequireWildcard(__nccwpck_require__(714), true); function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); } @@ -82493,6 +85683,65 @@ function getConcater(parser, emitError) { }); } +// Generates an Error object depending on http statusCode and XML body +function getErrorTransformer(response) { + var statusCode = response.statusCode; + var code, message; + if (statusCode === 301) { + code = 'MovedPermanently'; + message = 'Moved Permanently'; + } else if (statusCode === 307) { + code = 'TemporaryRedirect'; + message = 'Are you using the correct endpoint URL?'; + } else if (statusCode === 403) { + code = 'AccessDenied'; + message = 'Valid and authorized credentials required'; + } else if (statusCode === 404) { + code = 'NotFound'; + message = 'Not Found'; + } else if (statusCode === 405) { + code = 'MethodNotAllowed'; + message = 'Method Not Allowed'; + } else if (statusCode === 501) { + code = 'MethodNotAllowed'; + message = 'Method Not Allowed'; + } else { + code = 'UnknownError'; + message = `${statusCode}`; + } + var headerInfo = {}; + // A value created by S3 compatible server that uniquely identifies + // the request. + headerInfo.amzRequestid = response.headersSent ? response.getHeader('x-amz-request-id') : null; + // A special token that helps troubleshoot API replies and issues. + headerInfo.amzId2 = response.headersSent ? response.getHeader('x-amz-id-2') : null; + // Region where the bucket is located. This header is returned only + // in HEAD bucket and ListObjects response. + headerInfo.amzBucketRegion = response.headersSent ? response.getHeader('x-amz-bucket-region') : null; + return getConcater(xmlString => { + let getError = () => { + // Message should be instantiated for each S3Errors. + var e = new errors.S3Error(message); + // S3 Error code. + e.code = code; + _lodash.each(headerInfo, (value, key) => { + e[key] = value; + }); + return e; + }; + if (!xmlString) { + return getError(); + } + let e; + try { + e = xmlParsers.parseError(xmlString, headerInfo); + } catch (ex) { + return getError(); + } + return e; + }, true); +} + // A through stream that calculates md5sum and sha256sum function getHashSummer(enableSHA256) { var md5 = Crypto.createHash('md5'); @@ -82530,11 +85779,26 @@ function getCopyObjectTransformer() { return getConcater(xmlParsers.parseCopyObject); } +// Parses listBuckets response. +function getListBucketTransformer() { + return getConcater(xmlParsers.parseListBucket); +} + // Parses listMultipartUploads response. function getListMultipartTransformer() { return getConcater(xmlParsers.parseListMultipart); } +// Parses listParts response. +function getListPartsTransformer() { + return getConcater(xmlParsers.parseListParts); +} + +// Parses initMultipartUpload response. +function getInitiateMultipartTransformer() { + return getConcater(xmlParsers.parseInitiateMultipart); +} + // Parses listObjects response. function getListObjectsTransformer() { return getConcater(xmlParsers.parseListObjects); @@ -82555,6 +85819,11 @@ function getCompleteMultipartTransformer() { return getConcater(xmlParsers.parseCompleteMultipart); } +// Parses getBucketLocation response. +function getBucketRegionTransformer() { + return getConcater(xmlParsers.parseBucketRegion); +} + // Parses GET/SET BucketNotification response function getBucketNotificationTransformer() { return getConcater(xmlParsers.parseBucketNotification); @@ -82583,6 +85852,9 @@ function objectRetentionTransformer() { function bucketEncryptionTransformer() { return getConcater(xmlParsers.parseBucketEncryptionConfig); } +function replicationConfigTransformer() { + return getConcater(xmlParsers.parseReplicationConfig); +} function objectLegalHoldTransformer() { return getConcater(xmlParsers.parseObjectLegalHoldConfig); } @@ -82595,7 +85867,7 @@ function selectObjectContentTransformer() { function removeObjectsTransformer() { return getConcater(xmlParsers.removeObjectsParser); } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Crypto","_interopRequireWildcard","require","_jsonStream","_through","_helper","xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","getConcater","parser","emitError","objectMode","bufs","isFunction","TypeError","Through2","chunk","enc","cb","push","Buffer","concat","toString","length","getHashSummer","enableSHA256","md5","createHash","sha256","update","md5sum","sha256sum","digest","hashData","getCopyObjectTransformer","parseCopyObject","getListMultipartTransformer","parseListMultipart","getListObjectsTransformer","parseListObjects","getListObjectsV2Transformer","parseListObjectsV2","getListObjectsV2WithMetadataTransformer","parseListObjectsV2WithMetadata","getCompleteMultipartTransformer","parseCompleteMultipart","getBucketNotificationTransformer","parseBucketNotification","getNotificationTransformer","JSONParser","bucketVersioningTransformer","parseBucketVersioningConfig","getTagsTransformer","parseTagging","lifecycleTransformer","parseLifecycleConfig","objectLockTransformer","parseObjectLockConfig","objectRetentionTransformer","parseObjectRetentionConfig","bucketEncryptionTransformer","parseBucketEncryptionConfig","objectLegalHoldTransformer","parseObjectLegalHoldConfig","uploadPartTransformer","uploadPartParser","selectObjectContentTransformer","removeObjectsTransformer","removeObjectsParser"],"sources":["transformers.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015, 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Crypto from 'node:crypto'\n\nimport JSONParser from 'json-stream'\nimport Through2 from 'through2'\n\nimport { isFunction } from './internal/helper.ts'\nimport * as xmlParsers from './xml-parsers.js'\n\n// getConcater returns a stream that concatenates the input and emits\n// the concatenated output when 'end' has reached. If an optional\n// parser function is passed upon reaching the 'end' of the stream,\n// `parser(concatenated_data)` will be emitted.\nexport function getConcater(parser, emitError) {\n  var objectMode = false\n  var bufs = []\n\n  if (parser && !isFunction(parser)) {\n    throw new TypeError('parser should be of type \"function\"')\n  }\n\n  if (parser) {\n    objectMode = true\n  }\n\n  return Through2(\n    { objectMode },\n    function (chunk, enc, cb) {\n      bufs.push(chunk)\n      cb()\n    },\n    function (cb) {\n      if (emitError) {\n        cb(parser(Buffer.concat(bufs).toString()))\n        // cb(e) would mean we have to emit 'end' by explicitly calling this.push(null)\n        this.push(null)\n        return\n      }\n      if (bufs.length) {\n        if (parser) {\n          this.push(parser(Buffer.concat(bufs).toString()))\n        } else {\n          this.push(Buffer.concat(bufs))\n        }\n      }\n      cb()\n    },\n  )\n}\n\n// A through stream that calculates md5sum and sha256sum\nexport function getHashSummer(enableSHA256) {\n  var md5 = Crypto.createHash('md5')\n  var sha256 = Crypto.createHash('sha256')\n\n  return Through2.obj(\n    function (chunk, enc, cb) {\n      if (enableSHA256) {\n        sha256.update(chunk)\n      } else {\n        md5.update(chunk)\n      }\n      cb()\n    },\n    function (cb) {\n      var md5sum = ''\n      var sha256sum = ''\n      if (enableSHA256) {\n        sha256sum = sha256.digest('hex')\n      } else {\n        md5sum = md5.digest('base64')\n      }\n      var hashData = { md5sum, sha256sum }\n      this.push(hashData)\n      this.push(null)\n      cb()\n    },\n  )\n}\n\n// Following functions return a stream object that parses XML\n// and emits suitable Javascript objects.\n\n// Parses CopyObject response.\nexport function getCopyObjectTransformer() {\n  return getConcater(xmlParsers.parseCopyObject)\n}\n\n// Parses listMultipartUploads response.\nexport function getListMultipartTransformer() {\n  return getConcater(xmlParsers.parseListMultipart)\n}\n\n// Parses listObjects response.\nexport function getListObjectsTransformer() {\n  return getConcater(xmlParsers.parseListObjects)\n}\n\n// Parses listObjects response.\nexport function getListObjectsV2Transformer() {\n  return getConcater(xmlParsers.parseListObjectsV2)\n}\n\n// Parses listObjects with metadata response.\nexport function getListObjectsV2WithMetadataTransformer() {\n  return getConcater(xmlParsers.parseListObjectsV2WithMetadata)\n}\n\n// Parses completeMultipartUpload response.\nexport function getCompleteMultipartTransformer() {\n  return getConcater(xmlParsers.parseCompleteMultipart)\n}\n\n// Parses GET/SET BucketNotification response\nexport function getBucketNotificationTransformer() {\n  return getConcater(xmlParsers.parseBucketNotification)\n}\n\n// Parses a notification.\nexport function getNotificationTransformer() {\n  // This will parse and return each object.\n  return new JSONParser()\n}\n\nexport function bucketVersioningTransformer() {\n  return getConcater(xmlParsers.parseBucketVersioningConfig)\n}\n\nexport function getTagsTransformer() {\n  return getConcater(xmlParsers.parseTagging)\n}\n\nexport function lifecycleTransformer() {\n  return getConcater(xmlParsers.parseLifecycleConfig)\n}\n\nexport function objectLockTransformer() {\n  return getConcater(xmlParsers.parseObjectLockConfig)\n}\n\nexport function objectRetentionTransformer() {\n  return getConcater(xmlParsers.parseObjectRetentionConfig)\n}\nexport function bucketEncryptionTransformer() {\n  return getConcater(xmlParsers.parseBucketEncryptionConfig)\n}\n\nexport function objectLegalHoldTransformer() {\n  return getConcater(xmlParsers.parseObjectLegalHoldConfig)\n}\n\nexport function uploadPartTransformer() {\n  return getConcater(xmlParsers.uploadPartParser)\n}\nexport function selectObjectContentTransformer() {\n  return getConcater()\n}\n\nexport function removeObjectsTransformer() {\n  return getConcater(xmlParsers.removeObjectsParser)\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Crypto","_interopRequireWildcard","require","_jsonStream","_lodash","_through","errors","_helper","xmlParsers","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","getConcater","parser","emitError","objectMode","bufs","isFunction","TypeError","Through2","chunk","enc","cb","push","Buffer","concat","toString","length","getErrorTransformer","response","statusCode","code","message","headerInfo","amzRequestid","headersSent","getHeader","amzId2","amzBucketRegion","xmlString","getError","e","S3Error","_","each","value","parseError","ex","getHashSummer","enableSHA256","md5","createHash","sha256","update","md5sum","sha256sum","digest","hashData","getCopyObjectTransformer","parseCopyObject","getListBucketTransformer","parseListBucket","getListMultipartTransformer","parseListMultipart","getListPartsTransformer","parseListParts","getInitiateMultipartTransformer","parseInitiateMultipart","getListObjectsTransformer","parseListObjects","getListObjectsV2Transformer","parseListObjectsV2","getListObjectsV2WithMetadataTransformer","parseListObjectsV2WithMetadata","getCompleteMultipartTransformer","parseCompleteMultipart","getBucketRegionTransformer","parseBucketRegion","getBucketNotificationTransformer","parseBucketNotification","getNotificationTransformer","JSONParser","bucketVersioningTransformer","parseBucketVersioningConfig","getTagsTransformer","parseTagging","lifecycleTransformer","parseLifecycleConfig","objectLockTransformer","parseObjectLockConfig","objectRetentionTransformer","parseObjectRetentionConfig","bucketEncryptionTransformer","parseBucketEncryptionConfig","replicationConfigTransformer","parseReplicationConfig","objectLegalHoldTransformer","parseObjectLegalHoldConfig","uploadPartTransformer","uploadPartParser","selectObjectContentTransformer","removeObjectsTransformer","removeObjectsParser"],"sources":["transformers.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015, 2016 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as Crypto from 'node:crypto'\n\nimport JSONParser from 'json-stream'\nimport _ from 'lodash'\nimport Through2 from 'through2'\n\nimport * as errors from './errors.ts'\nimport { isFunction } from './internal/helper.ts'\nimport * as xmlParsers from './xml-parsers.js'\n\n// getConcater returns a stream that concatenates the input and emits\n// the concatenated output when 'end' has reached. If an optional\n// parser function is passed upon reaching the 'end' of the stream,\n// `parser(concatenated_data)` will be emitted.\nexport function getConcater(parser, emitError) {\n  var objectMode = false\n  var bufs = []\n\n  if (parser && !isFunction(parser)) {\n    throw new TypeError('parser should be of type \"function\"')\n  }\n\n  if (parser) {\n    objectMode = true\n  }\n\n  return Through2(\n    { objectMode },\n    function (chunk, enc, cb) {\n      bufs.push(chunk)\n      cb()\n    },\n    function (cb) {\n      if (emitError) {\n        cb(parser(Buffer.concat(bufs).toString()))\n        // cb(e) would mean we have to emit 'end' by explicitly calling this.push(null)\n        this.push(null)\n        return\n      }\n      if (bufs.length) {\n        if (parser) {\n          this.push(parser(Buffer.concat(bufs).toString()))\n        } else {\n          this.push(Buffer.concat(bufs))\n        }\n      }\n      cb()\n    },\n  )\n}\n\n// Generates an Error object depending on http statusCode and XML body\nexport function getErrorTransformer(response) {\n  var statusCode = response.statusCode\n  var code, message\n  if (statusCode === 301) {\n    code = 'MovedPermanently'\n    message = 'Moved Permanently'\n  } else if (statusCode === 307) {\n    code = 'TemporaryRedirect'\n    message = 'Are you using the correct endpoint URL?'\n  } else if (statusCode === 403) {\n    code = 'AccessDenied'\n    message = 'Valid and authorized credentials required'\n  } else if (statusCode === 404) {\n    code = 'NotFound'\n    message = 'Not Found'\n  } else if (statusCode === 405) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else if (statusCode === 501) {\n    code = 'MethodNotAllowed'\n    message = 'Method Not Allowed'\n  } else {\n    code = 'UnknownError'\n    message = `${statusCode}`\n  }\n\n  var headerInfo = {}\n  // A value created by S3 compatible server that uniquely identifies\n  // the request.\n  headerInfo.amzRequestid = response.headersSent ? response.getHeader('x-amz-request-id') : null\n  // A special token that helps troubleshoot API replies and issues.\n  headerInfo.amzId2 = response.headersSent ? response.getHeader('x-amz-id-2') : null\n  // Region where the bucket is located. This header is returned only\n  // in HEAD bucket and ListObjects response.\n  headerInfo.amzBucketRegion = response.headersSent ? response.getHeader('x-amz-bucket-region') : null\n\n  return getConcater((xmlString) => {\n    let getError = () => {\n      // Message should be instantiated for each S3Errors.\n      var e = new errors.S3Error(message)\n      // S3 Error code.\n      e.code = code\n      _.each(headerInfo, (value, key) => {\n        e[key] = value\n      })\n      return e\n    }\n    if (!xmlString) {\n      return getError()\n    }\n    let e\n    try {\n      e = xmlParsers.parseError(xmlString, headerInfo)\n    } catch (ex) {\n      return getError()\n    }\n    return e\n  }, true)\n}\n\n// A through stream that calculates md5sum and sha256sum\nexport function getHashSummer(enableSHA256) {\n  var md5 = Crypto.createHash('md5')\n  var sha256 = Crypto.createHash('sha256')\n\n  return Through2.obj(\n    function (chunk, enc, cb) {\n      if (enableSHA256) {\n        sha256.update(chunk)\n      } else {\n        md5.update(chunk)\n      }\n      cb()\n    },\n    function (cb) {\n      var md5sum = ''\n      var sha256sum = ''\n      if (enableSHA256) {\n        sha256sum = sha256.digest('hex')\n      } else {\n        md5sum = md5.digest('base64')\n      }\n      var hashData = { md5sum, sha256sum }\n      this.push(hashData)\n      this.push(null)\n      cb()\n    },\n  )\n}\n\n// Following functions return a stream object that parses XML\n// and emits suitable Javascript objects.\n\n// Parses CopyObject response.\nexport function getCopyObjectTransformer() {\n  return getConcater(xmlParsers.parseCopyObject)\n}\n\n// Parses listBuckets response.\nexport function getListBucketTransformer() {\n  return getConcater(xmlParsers.parseListBucket)\n}\n\n// Parses listMultipartUploads response.\nexport function getListMultipartTransformer() {\n  return getConcater(xmlParsers.parseListMultipart)\n}\n\n// Parses listParts response.\nexport function getListPartsTransformer() {\n  return getConcater(xmlParsers.parseListParts)\n}\n\n// Parses initMultipartUpload response.\nexport function getInitiateMultipartTransformer() {\n  return getConcater(xmlParsers.parseInitiateMultipart)\n}\n\n// Parses listObjects response.\nexport function getListObjectsTransformer() {\n  return getConcater(xmlParsers.parseListObjects)\n}\n\n// Parses listObjects response.\nexport function getListObjectsV2Transformer() {\n  return getConcater(xmlParsers.parseListObjectsV2)\n}\n\n// Parses listObjects with metadata response.\nexport function getListObjectsV2WithMetadataTransformer() {\n  return getConcater(xmlParsers.parseListObjectsV2WithMetadata)\n}\n\n// Parses completeMultipartUpload response.\nexport function getCompleteMultipartTransformer() {\n  return getConcater(xmlParsers.parseCompleteMultipart)\n}\n\n// Parses getBucketLocation response.\nexport function getBucketRegionTransformer() {\n  return getConcater(xmlParsers.parseBucketRegion)\n}\n\n// Parses GET/SET BucketNotification response\nexport function getBucketNotificationTransformer() {\n  return getConcater(xmlParsers.parseBucketNotification)\n}\n\n// Parses a notification.\nexport function getNotificationTransformer() {\n  // This will parse and return each object.\n  return new JSONParser()\n}\n\nexport function bucketVersioningTransformer() {\n  return getConcater(xmlParsers.parseBucketVersioningConfig)\n}\n\nexport function getTagsTransformer() {\n  return getConcater(xmlParsers.parseTagging)\n}\n\nexport function lifecycleTransformer() {\n  return getConcater(xmlParsers.parseLifecycleConfig)\n}\n\nexport function objectLockTransformer() {\n  return getConcater(xmlParsers.parseObjectLockConfig)\n}\n\nexport function objectRetentionTransformer() {\n  return getConcater(xmlParsers.parseObjectRetentionConfig)\n}\nexport function bucketEncryptionTransformer() {\n  return getConcater(xmlParsers.parseBucketEncryptionConfig)\n}\n\nexport function replicationConfigTransformer() {\n  return getConcater(xmlParsers.parseReplicationConfig)\n}\n\nexport function objectLegalHoldTransformer() {\n  return getConcater(xmlParsers.parseObjectLegalHoldConfig)\n}\n\nexport function uploadPartTransformer() {\n  return getConcater(xmlParsers.uploadPartParser)\n}\nexport function selectObjectContentTransformer() {\n  return getConcater()\n}\n\nexport function removeObjectsTransformer() {\n  return getConcater(xmlParsers.removeObjectsParser)\n}\n"],"mappings":"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"} /***/ }), @@ -82610,23 +85882,30 @@ Object.defineProperty(exports, "__esModule", ({ })); exports.parseBucketEncryptionConfig = parseBucketEncryptionConfig; exports.parseBucketNotification = parseBucketNotification; +exports.parseBucketRegion = parseBucketRegion; exports.parseBucketVersioningConfig = parseBucketVersioningConfig; exports.parseCompleteMultipart = parseCompleteMultipart; exports.parseCopyObject = parseCopyObject; +exports.parseError = parseError; +exports.parseInitiateMultipart = parseInitiateMultipart; exports.parseLifecycleConfig = parseLifecycleConfig; +exports.parseListBucket = parseListBucket; exports.parseListMultipart = parseListMultipart; exports.parseListObjects = parseListObjects; exports.parseListObjectsV2 = parseListObjectsV2; exports.parseListObjectsV2WithMetadata = parseListObjectsV2WithMetadata; +exports.parseListParts = parseListParts; exports.parseObjectLegalHoldConfig = parseObjectLegalHoldConfig; exports.parseObjectLockConfig = parseObjectLockConfig; exports.parseObjectRetentionConfig = parseObjectRetentionConfig; +exports.parseReplicationConfig = parseReplicationConfig; exports.parseSelectObjectContentResponse = parseSelectObjectContentResponse; exports.parseTagging = parseTagging; exports.removeObjectsParser = removeObjectsParser; exports.uploadPartParser = uploadPartParser; var _bufferCrc = __nccwpck_require__(4024); var _fastXmlParser = __nccwpck_require__(2603); +var _lodash = __nccwpck_require__(250); var errors = _interopRequireWildcard(__nccwpck_require__(1174), true); var _helpers = __nccwpck_require__(9455); var _helper = __nccwpck_require__(9921); @@ -82649,11 +85928,25 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && * limitations under the License. */ -const fxpWithoutNumParser = new _fastXmlParser.XMLParser({ - numberParseOptions: { - skipLike: /./ +// Parse XML and return information as Javascript types +const fxp = new _fastXmlParser.XMLParser(); + +// parse error XML response +function parseError(xml, headerInfo) { + var xmlErr = {}; + var xmlObj = fxp.parse(xml); + if (xmlObj.Error) { + xmlErr = xmlObj.Error; } -}); + var e = new errors.S3Error(); + _lodash.each(xmlErr, (value, key) => { + e[key.toLowerCase()] = value; + }); + _lodash.each(headerInfo, (value, key) => { + e[key] = value; + }); + return e; +} // parse XML response for copy object function parseCopyObject(xml) { @@ -82694,7 +85987,7 @@ function parseListMultipart(xml) { result.nextKeyMarker = xmlobj.NextKeyMarker; } if (xmlobj.NextUploadIdMarker) { - result.nextUploadIdMarker = xmlobj.nextUploadIdMarker || ''; + result.nextUploadIdMarker = xmlobj.nextUploadIdMarker; } if (xmlobj.CommonPrefixes) { (0, _helper.toArray)(xmlobj.CommonPrefixes).forEach(prefix => { @@ -82731,6 +86024,27 @@ function parseListMultipart(xml) { } // parse XML response to list all the owned buckets +function parseListBucket(xml) { + var result = []; + var xmlobj = (0, _helper.parseXml)(xml); + if (!xmlobj.ListAllMyBucketsResult) { + throw new errors.InvalidXMLError('Missing tag: "ListAllMyBucketsResult"'); + } + xmlobj = xmlobj.ListAllMyBucketsResult; + if (xmlobj.Buckets) { + if (xmlobj.Buckets.Bucket) { + (0, _helper.toArray)(xmlobj.Buckets.Bucket).forEach(bucket => { + var name = bucket.Name; + var creationDate = new Date(bucket.CreationDate); + result.push({ + name, + creationDate + }); + }); + } + } + return result; +} // parse XML response for bucket notification function parseBucketNotification(xml) { @@ -82821,6 +86135,58 @@ function parseBucketNotification(xml) { return result; } +// parse XML response for bucket region +function parseBucketRegion(xml) { + // return region information + return (0, _helper.parseXml)(xml).LocationConstraint; +} + +// parse XML response for list parts of an in progress multipart upload +function parseListParts(xml) { + var xmlobj = (0, _helper.parseXml)(xml); + var result = { + isTruncated: false, + parts: [], + marker: undefined + }; + if (!xmlobj.ListPartsResult) { + throw new errors.InvalidXMLError('Missing tag: "ListPartsResult"'); + } + xmlobj = xmlobj.ListPartsResult; + if (xmlobj.IsTruncated) { + result.isTruncated = xmlobj.IsTruncated; + } + if (xmlobj.NextPartNumberMarker) { + result.marker = +(0, _helper.toArray)(xmlobj.NextPartNumberMarker)[0]; + } + if (xmlobj.Part) { + (0, _helper.toArray)(xmlobj.Part).forEach(p => { + var part = +(0, _helper.toArray)(p.PartNumber)[0]; + var lastModified = new Date(p.LastModified); + var etag = p.ETag.replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, '').replace(/^"/g, '').replace(/"$/g, ''); + result.parts.push({ + part, + lastModified, + etag + }); + }); + } + return result; +} + +// parse XML response when a new multipart upload is initiated +function parseInitiateMultipart(xml) { + var xmlobj = (0, _helper.parseXml)(xml); + if (!xmlobj.InitiateMultipartUploadResult) { + throw new errors.InvalidXMLError('Missing tag: "InitiateMultipartUploadResult"'); + } + xmlobj = xmlobj.InitiateMultipartUploadResult; + if (xmlobj.UploadId) { + return xmlobj.UploadId; + } + throw new errors.InvalidXMLError('Missing tag: "UploadId"'); +} + // parse XML response when a multipart upload is completed function parseCompleteMultipart(xml) { var xmlobj = (0, _helper.parseXml)(xml).CompleteMultipartUploadResult; @@ -82861,12 +86227,11 @@ const formatObjInfo = (content, opts = {}) => { const name = (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(Key)[0]); const lastModified = new Date((0, _helper.toArray)(LastModified)[0]); const etag = (0, _helper.sanitizeETag)((0, _helper.toArray)(ETag)[0]); - const size = (0, _helper.sanitizeSize)(Size); return { name, lastModified, etag, - size, + size: Size, versionId: VersionId, isLatest: IsLatest, isDeleteMarker: opts.IsDeleteMarker ? opts.IsDeleteMarker : false @@ -82881,7 +86246,7 @@ function parseListObjects(xml) { }; let isTruncated = false; let nextMarker, nextVersionKeyMarker; - const xmlobj = fxpWithoutNumParser.parse(xml); + const xmlobj = (0, _helper.parseXml)(xml); const parseCommonPrefixesEntity = responseEntity => { if (responseEntity) { (0, _helper.toArray)(responseEntity).forEach(commonPrefix => { @@ -82903,7 +86268,7 @@ function parseListObjects(xml) { const name = (0, _helper.sanitizeObjectKey)((0, _helper.toArray)(content.Key)[0]); const lastModified = new Date((0, _helper.toArray)(content.LastModified)[0]); const etag = (0, _helper.sanitizeETag)((0, _helper.toArray)(content.ETag)[0]); - const size = (0, _helper.sanitizeSize)(content.Size); + const size = content.Size; result.objects.push({ name, lastModified, @@ -83097,6 +86462,16 @@ function parseBucketEncryptionConfig(xml) { let encConfig = (0, _helper.parseXml)(xml); return encConfig; } +function parseReplicationConfig(xml) { + const xmlObj = (0, _helper.parseXml)(xml); + const replicationConfig = { + ReplicationConfiguration: { + role: xmlObj.ReplicationConfiguration.Role, + rules: (0, _helper.toArray)(xmlObj.ReplicationConfiguration.Rule) + } + }; + return replicationConfig; +} function parseObjectLegalHoldConfig(xml) { const xmlObj = (0, _helper.parseXml)(xml); return xmlObj.LegalHold; @@ -83246,7 +86621,222 @@ function parseSelectObjectContentResponse(res) { } // messageType End } // Top Level Stream End } -//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_bufferCrc","require","_fastXmlParser","errors","_interopRequireWildcard","_helpers","_helper","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","fxpWithoutNumParser","XMLParser","numberParseOptions","skipLike","parseCopyObject","xml","result","etag","lastModified","xmlobj","parseXml","CopyObjectResult","InvalidXMLError","ETag","replace","LastModified","Date","parseListMultipart","uploads","prefixes","isTruncated","ListMultipartUploadsResult","IsTruncated","NextKeyMarker","nextKeyMarker","NextUploadIdMarker","nextUploadIdMarker","CommonPrefixes","toArray","forEach","prefix","push","sanitizeObjectKey","Prefix","Upload","upload","Key","uploadId","UploadId","initiator","id","Initiator","ID","displayName","DisplayName","owner","Owner","storageClass","StorageClass","initiated","Initiated","parseBucketNotification","TopicConfiguration","QueueConfiguration","CloudFunctionConfiguration","genEvents","events","s3event","genFilterRules","filters","S3Key","FilterRule","rule","Name","Value","NotificationConfiguration","config","Id","Topic","Event","Filter","Queue","CloudFunction","parseCompleteMultipart","CompleteMultipartUploadResult","Location","location","bucket","Bucket","Code","Message","errCode","errMessage","formatObjInfo","content","opts","Size","VersionId","IsLatest","isObject","name","sanitizeETag","size","sanitizeSize","versionId","isLatest","isDeleteMarker","IsDeleteMarker","parseListObjects","objects","nextMarker","nextVersionKeyMarker","parse","parseCommonPrefixesEntity","responseEntity","commonPrefix","listBucketResult","ListBucketResult","listVersionsResult","ListVersionsResult","Contents","NextMarker","Version","DeleteMarker","NextVersionIdMarker","versionIdMarker","parseListObjectsV2","NextContinuationToken","nextContinuationToken","parseListObjectsV2WithMetadata","metadata","UserMetadata","parseBucketVersioningConfig","xmlObj","VersioningConfiguration","parseTagging","Tagging","TagSet","Tag","tagResult","parseLifecycleConfig","LifecycleConfiguration","parseObjectLockConfig","lockConfigResult","ObjectLockConfiguration","objectLockEnabled","ObjectLockEnabled","retentionResp","Rule","DefaultRetention","mode","Mode","isUnitYears","Years","validity","unit","RETENTION_VALIDITY_UNITS","YEARS","Days","DAYS","parseObjectRetentionConfig","retentionConfig","Retention","retainUntilDate","RetainUntilDate","parseBucketEncryptionConfig","encConfig","parseObjectLegalHoldConfig","LegalHold","uploadPartParser","respEl","CopyPartResult","removeObjectsParser","DeleteResult","Error","parseSelectObjectContentResponse","res","extractHeaderType","stream","headerNameLen","Buffer","from","read","readUInt8","headerNameWithSeparator","toString","splitBySeparator","split","headerName","length","extractHeaderValue","bodyLen","readUInt16BE","bodyName","selectResults","SelectResults","responseStream","readableStream","_readableState","msgCrcAccumulator","totalByteLengthBuffer","crc32","headerBytesBuffer","calculatedPreludeCrc","readInt32BE","preludeCrcBuffer","totalMsgLength","headerLength","preludeCrcByteValue","headers","headerBytes","headerReaderStream","headerTypeName","payloadStream","payLoadLength","payLoadBuffer","messageCrcByteValue","calculatedCrc","messageType","errorMessage","contentType","eventType","setResponse","readData","setRecords","progressData","setProgress","statsData","setStats","warningMessage","console","warn"],"sources":["xml-parsers.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport crc32 from 'buffer-crc32'\nimport { XMLParser } from 'fast-xml-parser'\n\nimport * as errors from './errors.ts'\nimport { SelectResults } from './helpers.ts'\nimport {\n  isObject,\n  parseXml,\n  readableStream,\n  sanitizeETag,\n  sanitizeObjectKey,\n  sanitizeSize,\n  toArray,\n} from './internal/helper.ts'\nimport { RETENTION_VALIDITY_UNITS } from './internal/type.ts'\n\nconst fxpWithoutNumParser = new XMLParser({\n  numberParseOptions: {\n    skipLike: /./,\n  },\n})\n\n// parse XML response for copy object\nexport function parseCopyObject(xml) {\n  var result = {\n    etag: '',\n    lastModified: '',\n  }\n\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.CopyObjectResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"CopyObjectResult\"')\n  }\n  xmlobj = xmlobj.CopyObjectResult\n  if (xmlobj.ETag) {\n    result.etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n  }\n  if (xmlobj.LastModified) {\n    result.lastModified = new Date(xmlobj.LastModified)\n  }\n\n  return result\n}\n\n// parse XML response for listing in-progress multipart uploads\nexport function parseListMultipart(xml) {\n  var result = {\n    uploads: [],\n    prefixes: [],\n    isTruncated: false,\n  }\n\n  var xmlobj = parseXml(xml)\n\n  if (!xmlobj.ListMultipartUploadsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListMultipartUploadsResult\"')\n  }\n  xmlobj = xmlobj.ListMultipartUploadsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextKeyMarker) {\n    result.nextKeyMarker = xmlobj.NextKeyMarker\n  }\n  if (xmlobj.NextUploadIdMarker) {\n    result.nextUploadIdMarker = xmlobj.nextUploadIdMarker || ''\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((prefix) => {\n      result.prefixes.push({ prefix: sanitizeObjectKey(toArray(prefix.Prefix)[0]) })\n    })\n  }\n\n  if (xmlobj.Upload) {\n    toArray(xmlobj.Upload).forEach((upload) => {\n      var key = upload.Key\n      var uploadId = upload.UploadId\n      var initiator = { id: upload.Initiator.ID, displayName: upload.Initiator.DisplayName }\n      var owner = { id: upload.Owner.ID, displayName: upload.Owner.DisplayName }\n      var storageClass = upload.StorageClass\n      var initiated = new Date(upload.Initiated)\n      result.uploads.push({ key, uploadId, initiator, owner, storageClass, initiated })\n    })\n  }\n  return result\n}\n\n// parse XML response to list all the owned buckets\n\n// parse XML response for bucket notification\nexport function parseBucketNotification(xml) {\n  var result = {\n    TopicConfiguration: [],\n    QueueConfiguration: [],\n    CloudFunctionConfiguration: [],\n  }\n  // Parse the events list\n  var genEvents = function (events) {\n    var result = []\n    if (events) {\n      toArray(events).forEach((s3event) => {\n        result.push(s3event)\n      })\n    }\n    return result\n  }\n  // Parse all filter rules\n  var genFilterRules = function (filters) {\n    var result = []\n    if (filters) {\n      filters = toArray(filters)\n      if (filters[0].S3Key) {\n        filters[0].S3Key = toArray(filters[0].S3Key)\n        if (filters[0].S3Key[0].FilterRule) {\n          toArray(filters[0].S3Key[0].FilterRule).forEach((rule) => {\n            var Name = toArray(rule.Name)[0]\n            var Value = toArray(rule.Value)[0]\n            result.push({ Name, Value })\n          })\n        }\n      }\n    }\n    return result\n  }\n\n  var xmlobj = parseXml(xml)\n  xmlobj = xmlobj.NotificationConfiguration\n\n  // Parse all topic configurations in the xml\n  if (xmlobj.TopicConfiguration) {\n    toArray(xmlobj.TopicConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var Topic = toArray(config.Topic)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.TopicConfiguration.push({ Id, Topic, Event, Filter })\n    })\n  }\n  // Parse all topic configurations in the xml\n  if (xmlobj.QueueConfiguration) {\n    toArray(xmlobj.QueueConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var Queue = toArray(config.Queue)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.QueueConfiguration.push({ Id, Queue, Event, Filter })\n    })\n  }\n  // Parse all QueueConfiguration arrays\n  if (xmlobj.CloudFunctionConfiguration) {\n    toArray(xmlobj.CloudFunctionConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var CloudFunction = toArray(config.CloudFunction)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.CloudFunctionConfiguration.push({ Id, CloudFunction, Event, Filter })\n    })\n  }\n\n  return result\n}\n\n// parse XML response when a multipart upload is completed\nexport function parseCompleteMultipart(xml) {\n  var xmlobj = parseXml(xml).CompleteMultipartUploadResult\n  if (xmlobj.Location) {\n    var location = toArray(xmlobj.Location)[0]\n    var bucket = toArray(xmlobj.Bucket)[0]\n    var key = xmlobj.Key\n    var etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n\n    return { location, bucket, key, etag }\n  }\n  // Complete Multipart can return XML Error after a 200 OK response\n  if (xmlobj.Code && xmlobj.Message) {\n    var errCode = toArray(xmlobj.Code)[0]\n    var errMessage = toArray(xmlobj.Message)[0]\n    return { errCode, errMessage }\n  }\n}\n\nconst formatObjInfo = (content, opts = {}) => {\n  let { Key, LastModified, ETag, Size, VersionId, IsLatest } = content\n\n  if (!isObject(opts)) {\n    opts = {}\n  }\n\n  const name = sanitizeObjectKey(toArray(Key)[0])\n  const lastModified = new Date(toArray(LastModified)[0])\n  const etag = sanitizeETag(toArray(ETag)[0])\n  const size = sanitizeSize(Size)\n\n  return {\n    name,\n    lastModified,\n    etag,\n    size,\n    versionId: VersionId,\n    isLatest: IsLatest,\n    isDeleteMarker: opts.IsDeleteMarker ? opts.IsDeleteMarker : false,\n  }\n}\n\n// parse XML response for list objects in a bucket\nexport function parseListObjects(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  let isTruncated = false\n  let nextMarker, nextVersionKeyMarker\n  const xmlobj = fxpWithoutNumParser.parse(xml)\n\n  const parseCommonPrefixesEntity = (responseEntity) => {\n    if (responseEntity) {\n      toArray(responseEntity).forEach((commonPrefix) => {\n        result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n      })\n    }\n  }\n\n  const listBucketResult = xmlobj.ListBucketResult\n  const listVersionsResult = xmlobj.ListVersionsResult\n\n  if (listBucketResult) {\n    if (listBucketResult.IsTruncated) {\n      isTruncated = listBucketResult.IsTruncated\n    }\n    if (listBucketResult.Contents) {\n      toArray(listBucketResult.Contents).forEach((content) => {\n        const name = sanitizeObjectKey(toArray(content.Key)[0])\n        const lastModified = new Date(toArray(content.LastModified)[0])\n        const etag = sanitizeETag(toArray(content.ETag)[0])\n        const size = sanitizeSize(content.Size)\n        result.objects.push({ name, lastModified, etag, size })\n      })\n    }\n\n    if (listBucketResult.NextMarker) {\n      nextMarker = listBucketResult.NextMarker\n    }\n    parseCommonPrefixesEntity(listBucketResult.CommonPrefixes)\n  }\n\n  if (listVersionsResult) {\n    if (listVersionsResult.IsTruncated) {\n      isTruncated = listVersionsResult.IsTruncated\n    }\n\n    if (listVersionsResult.Version) {\n      toArray(listVersionsResult.Version).forEach((content) => {\n        result.objects.push(formatObjInfo(content))\n      })\n    }\n    if (listVersionsResult.DeleteMarker) {\n      toArray(listVersionsResult.DeleteMarker).forEach((content) => {\n        result.objects.push(formatObjInfo(content, { IsDeleteMarker: true }))\n      })\n    }\n\n    if (listVersionsResult.NextKeyMarker) {\n      nextVersionKeyMarker = listVersionsResult.NextKeyMarker\n    }\n    if (listVersionsResult.NextVersionIdMarker) {\n      result.versionIdMarker = listVersionsResult.NextVersionIdMarker\n    }\n    parseCommonPrefixesEntity(listVersionsResult.CommonPrefixes)\n  }\n\n  result.isTruncated = isTruncated\n  if (isTruncated) {\n    result.nextMarker = nextVersionKeyMarker || nextMarker\n  }\n  return result\n}\n\n// parse XML response for list objects v2 in a bucket\nexport function parseListObjectsV2(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      var name = sanitizeObjectKey(toArray(content.Key)[0])\n      var lastModified = new Date(content.LastModified)\n      var etag = sanitizeETag(content.ETag)\n      var size = content.Size\n      result.objects.push({ name, lastModified, etag, size })\n    })\n  }\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\n// parse XML response for list objects v2 with metadata in a bucket\nexport function parseListObjectsV2WithMetadata(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      var name = sanitizeObjectKey(content.Key)\n      var lastModified = new Date(content.LastModified)\n      var etag = sanitizeETag(content.ETag)\n      var size = content.Size\n      var metadata\n      if (content.UserMetadata != null) {\n        metadata = toArray(content.UserMetadata)[0]\n      } else {\n        metadata = null\n      }\n      result.objects.push({ name, lastModified, etag, size, metadata })\n    })\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\nexport function parseBucketVersioningConfig(xml) {\n  var xmlObj = parseXml(xml)\n  return xmlObj.VersioningConfiguration\n}\n\nexport function parseTagging(xml) {\n  const xmlObj = parseXml(xml)\n  let result = []\n  if (xmlObj.Tagging && xmlObj.Tagging.TagSet && xmlObj.Tagging.TagSet.Tag) {\n    const tagResult = xmlObj.Tagging.TagSet.Tag\n    // if it is a single tag convert into an array so that the return value is always an array.\n    if (isObject(tagResult)) {\n      result.push(tagResult)\n    } else {\n      result = tagResult\n    }\n  }\n  return result\n}\n\nexport function parseLifecycleConfig(xml) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LifecycleConfiguration\n}\n\nexport function parseObjectLockConfig(xml) {\n  const xmlObj = parseXml(xml)\n  let lockConfigResult = {}\n  if (xmlObj.ObjectLockConfiguration) {\n    lockConfigResult = {\n      objectLockEnabled: xmlObj.ObjectLockConfiguration.ObjectLockEnabled,\n    }\n    let retentionResp\n    if (\n      xmlObj.ObjectLockConfiguration &&\n      xmlObj.ObjectLockConfiguration.Rule &&\n      xmlObj.ObjectLockConfiguration.Rule.DefaultRetention\n    ) {\n      retentionResp = xmlObj.ObjectLockConfiguration.Rule.DefaultRetention || {}\n      lockConfigResult.mode = retentionResp.Mode\n    }\n    if (retentionResp) {\n      const isUnitYears = retentionResp.Years\n      if (isUnitYears) {\n        lockConfigResult.validity = isUnitYears\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.YEARS\n      } else {\n        lockConfigResult.validity = retentionResp.Days\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.DAYS\n      }\n    }\n    return lockConfigResult\n  }\n}\n\nexport function parseObjectRetentionConfig(xml) {\n  const xmlObj = parseXml(xml)\n  const retentionConfig = xmlObj.Retention\n\n  return {\n    mode: retentionConfig.Mode,\n    retainUntilDate: retentionConfig.RetainUntilDate,\n  }\n}\n\nexport function parseBucketEncryptionConfig(xml) {\n  let encConfig = parseXml(xml)\n  return encConfig\n}\n\nexport function parseObjectLegalHoldConfig(xml) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LegalHold\n}\n\nexport function uploadPartParser(xml) {\n  const xmlObj = parseXml(xml)\n  const respEl = xmlObj.CopyPartResult\n  return respEl\n}\n\nexport function removeObjectsParser(xml) {\n  const xmlObj = parseXml(xml)\n  if (xmlObj.DeleteResult && xmlObj.DeleteResult.Error) {\n    // return errors as array always. as the response is object in case of single object passed in removeObjects\n    return toArray(xmlObj.DeleteResult.Error)\n  }\n  return []\n}\n\nexport function parseSelectObjectContentResponse(res) {\n  // extractHeaderType extracts the first half of the header message, the header type.\n  function extractHeaderType(stream) {\n    const headerNameLen = Buffer.from(stream.read(1)).readUInt8()\n    const headerNameWithSeparator = Buffer.from(stream.read(headerNameLen)).toString()\n    const splitBySeparator = (headerNameWithSeparator || '').split(':')\n    const headerName = splitBySeparator.length >= 1 ? splitBySeparator[1] : ''\n    return headerName\n  }\n\n  function extractHeaderValue(stream) {\n    const bodyLen = Buffer.from(stream.read(2)).readUInt16BE()\n    const bodyName = Buffer.from(stream.read(bodyLen)).toString()\n    return bodyName\n  }\n\n  const selectResults = new SelectResults({}) // will be returned\n\n  const responseStream = readableStream(res) // convert byte array to a readable responseStream\n  while (responseStream._readableState.length) {\n    // Top level responseStream read tracker.\n    let msgCrcAccumulator // accumulate from start of the message till the message crc start.\n\n    const totalByteLengthBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(totalByteLengthBuffer)\n\n    const headerBytesBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(headerBytesBuffer, msgCrcAccumulator)\n\n    const calculatedPreludeCrc = msgCrcAccumulator.readInt32BE() // use it to check if any CRC mismatch in header itself.\n\n    const preludeCrcBuffer = Buffer.from(responseStream.read(4)) // read 4 bytes    i.e 4+4 =8 + 4 = 12 ( prelude + prelude crc)\n    msgCrcAccumulator = crc32(preludeCrcBuffer, msgCrcAccumulator)\n\n    const totalMsgLength = totalByteLengthBuffer.readInt32BE()\n    const headerLength = headerBytesBuffer.readInt32BE()\n    const preludeCrcByteValue = preludeCrcBuffer.readInt32BE()\n\n    if (preludeCrcByteValue !== calculatedPreludeCrc) {\n      // Handle Header CRC mismatch Error\n      throw new Error(\n        `Header Checksum Mismatch, Prelude CRC of ${preludeCrcByteValue} does not equal expected CRC of ${calculatedPreludeCrc}`,\n      )\n    }\n\n    const headers = {}\n    if (headerLength > 0) {\n      const headerBytes = Buffer.from(responseStream.read(headerLength))\n      msgCrcAccumulator = crc32(headerBytes, msgCrcAccumulator)\n      const headerReaderStream = readableStream(headerBytes)\n      while (headerReaderStream._readableState.length) {\n        let headerTypeName = extractHeaderType(headerReaderStream)\n        headerReaderStream.read(1) // just read and ignore it.\n        headers[headerTypeName] = extractHeaderValue(headerReaderStream)\n      }\n    }\n\n    let payloadStream\n    const payLoadLength = totalMsgLength - headerLength - 16\n    if (payLoadLength > 0) {\n      const payLoadBuffer = Buffer.from(responseStream.read(payLoadLength))\n      msgCrcAccumulator = crc32(payLoadBuffer, msgCrcAccumulator)\n      // read the checksum early and detect any mismatch so we can avoid unnecessary further processing.\n      const messageCrcByteValue = Buffer.from(responseStream.read(4)).readInt32BE()\n      const calculatedCrc = msgCrcAccumulator.readInt32BE()\n      // Handle message CRC Error\n      if (messageCrcByteValue !== calculatedCrc) {\n        throw new Error(\n          `Message Checksum Mismatch, Message CRC of ${messageCrcByteValue} does not equal expected CRC of ${calculatedCrc}`,\n        )\n      }\n      payloadStream = readableStream(payLoadBuffer)\n    }\n\n    const messageType = headers['message-type']\n\n    switch (messageType) {\n      case 'error': {\n        const errorMessage = headers['error-code'] + ':\"' + headers['error-message'] + '\"'\n        throw new Error(errorMessage)\n      }\n      case 'event': {\n        const contentType = headers['content-type']\n        const eventType = headers['event-type']\n\n        switch (eventType) {\n          case 'End': {\n            selectResults.setResponse(res)\n            return selectResults\n          }\n\n          case 'Records': {\n            const readData = payloadStream.read(payLoadLength)\n            selectResults.setRecords(readData)\n            break\n          }\n\n          case 'Progress':\n            {\n              switch (contentType) {\n                case 'text/xml': {\n                  const progressData = payloadStream.read(payLoadLength)\n                  selectResults.setProgress(progressData.toString())\n                  break\n                }\n                default: {\n                  const errorMessage = `Unexpected content-type ${contentType} sent for event-type Progress`\n                  throw new Error(errorMessage)\n                }\n              }\n            }\n            break\n          case 'Stats':\n            {\n              switch (contentType) {\n                case 'text/xml': {\n                  const statsData = payloadStream.read(payLoadLength)\n                  selectResults.setStats(statsData.toString())\n                  break\n                }\n                default: {\n                  const errorMessage = `Unexpected content-type ${contentType} sent for event-type Stats`\n                  throw new Error(errorMessage)\n                }\n              }\n            }\n            break\n          default: {\n            // Continuation message: Not sure if it is supported. did not find a reference or any message in response.\n            // It does not have a payload.\n            const warningMessage = `Un implemented event detected  ${messageType}.`\n            // eslint-disable-next-line no-console\n            console.warn(warningMessage)\n          }\n        } // eventType End\n      } // Event End\n    } // messageType End\n  } // Top Level Stream End\n}\n"],"mappings":"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"} +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_bufferCrc","require","_fastXmlParser","_lodash","errors","_interopRequireWildcard","_helpers","_helper","_type","_getRequireWildcardCache","nodeInterop","WeakMap","cacheBabelInterop","cacheNodeInterop","obj","__esModule","default","cache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","fxp","XMLParser","parseError","xml","headerInfo","xmlErr","xmlObj","parse","Error","e","S3Error","_","each","value","toLowerCase","parseCopyObject","result","etag","lastModified","xmlobj","parseXml","CopyObjectResult","InvalidXMLError","ETag","replace","LastModified","Date","parseListMultipart","uploads","prefixes","isTruncated","ListMultipartUploadsResult","IsTruncated","NextKeyMarker","nextKeyMarker","NextUploadIdMarker","nextUploadIdMarker","CommonPrefixes","toArray","forEach","prefix","push","sanitizeObjectKey","Prefix","Upload","upload","Key","uploadId","UploadId","initiator","id","Initiator","ID","displayName","DisplayName","owner","Owner","storageClass","StorageClass","initiated","Initiated","parseListBucket","ListAllMyBucketsResult","Buckets","Bucket","bucket","name","Name","creationDate","CreationDate","parseBucketNotification","TopicConfiguration","QueueConfiguration","CloudFunctionConfiguration","genEvents","events","s3event","genFilterRules","filters","S3Key","FilterRule","rule","Value","NotificationConfiguration","config","Id","Topic","Event","Filter","Queue","CloudFunction","parseBucketRegion","LocationConstraint","parseListParts","parts","marker","undefined","ListPartsResult","NextPartNumberMarker","Part","p","part","PartNumber","parseInitiateMultipart","InitiateMultipartUploadResult","parseCompleteMultipart","CompleteMultipartUploadResult","Location","location","Code","Message","errCode","errMessage","formatObjInfo","content","opts","Size","VersionId","IsLatest","isObject","sanitizeETag","size","versionId","isLatest","isDeleteMarker","IsDeleteMarker","parseListObjects","objects","nextMarker","nextVersionKeyMarker","parseCommonPrefixesEntity","responseEntity","commonPrefix","listBucketResult","ListBucketResult","listVersionsResult","ListVersionsResult","Contents","NextMarker","Version","DeleteMarker","NextVersionIdMarker","versionIdMarker","parseListObjectsV2","NextContinuationToken","nextContinuationToken","parseListObjectsV2WithMetadata","metadata","UserMetadata","parseBucketVersioningConfig","VersioningConfiguration","parseTagging","Tagging","TagSet","Tag","tagResult","parseLifecycleConfig","LifecycleConfiguration","parseObjectLockConfig","lockConfigResult","ObjectLockConfiguration","objectLockEnabled","ObjectLockEnabled","retentionResp","Rule","DefaultRetention","mode","Mode","isUnitYears","Years","validity","unit","RETENTION_VALIDITY_UNITS","YEARS","Days","DAYS","parseObjectRetentionConfig","retentionConfig","Retention","retainUntilDate","RetainUntilDate","parseBucketEncryptionConfig","encConfig","parseReplicationConfig","replicationConfig","ReplicationConfiguration","role","Role","rules","parseObjectLegalHoldConfig","LegalHold","uploadPartParser","respEl","CopyPartResult","removeObjectsParser","DeleteResult","parseSelectObjectContentResponse","res","extractHeaderType","stream","headerNameLen","Buffer","from","read","readUInt8","headerNameWithSeparator","toString","splitBySeparator","split","headerName","length","extractHeaderValue","bodyLen","readUInt16BE","bodyName","selectResults","SelectResults","responseStream","readableStream","_readableState","msgCrcAccumulator","totalByteLengthBuffer","crc32","headerBytesBuffer","calculatedPreludeCrc","readInt32BE","preludeCrcBuffer","totalMsgLength","headerLength","preludeCrcByteValue","headers","headerBytes","headerReaderStream","headerTypeName","payloadStream","payLoadLength","payLoadBuffer","messageCrcByteValue","calculatedCrc","messageType","errorMessage","contentType","eventType","setResponse","readData","setRecords","progressData","setProgress","statsData","setStats","warningMessage","console","warn"],"sources":["xml-parsers.js"],"sourcesContent":["/*\n * MinIO Javascript Library for Amazon S3 Compatible Cloud Storage, (C) 2015 MinIO, Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport crc32 from 'buffer-crc32'\nimport { XMLParser } from 'fast-xml-parser'\nimport _ from 'lodash'\n\nimport * as errors from './errors.ts'\nimport { SelectResults } from './helpers.ts'\nimport { isObject, parseXml, readableStream, sanitizeETag, sanitizeObjectKey, toArray } from './internal/helper.ts'\nimport { RETENTION_VALIDITY_UNITS } from './internal/type.ts'\n\n// Parse XML and return information as Javascript types\nconst fxp = new XMLParser()\n\n// parse error XML response\nexport function parseError(xml, headerInfo) {\n  var xmlErr = {}\n  var xmlObj = fxp.parse(xml)\n  if (xmlObj.Error) {\n    xmlErr = xmlObj.Error\n  }\n\n  var e = new errors.S3Error()\n  _.each(xmlErr, (value, key) => {\n    e[key.toLowerCase()] = value\n  })\n\n  _.each(headerInfo, (value, key) => {\n    e[key] = value\n  })\n  return e\n}\n\n// parse XML response for copy object\nexport function parseCopyObject(xml) {\n  var result = {\n    etag: '',\n    lastModified: '',\n  }\n\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.CopyObjectResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"CopyObjectResult\"')\n  }\n  xmlobj = xmlobj.CopyObjectResult\n  if (xmlobj.ETag) {\n    result.etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n  }\n  if (xmlobj.LastModified) {\n    result.lastModified = new Date(xmlobj.LastModified)\n  }\n\n  return result\n}\n\n// parse XML response for listing in-progress multipart uploads\nexport function parseListMultipart(xml) {\n  var result = {\n    uploads: [],\n    prefixes: [],\n    isTruncated: false,\n  }\n\n  var xmlobj = parseXml(xml)\n\n  if (!xmlobj.ListMultipartUploadsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListMultipartUploadsResult\"')\n  }\n  xmlobj = xmlobj.ListMultipartUploadsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextKeyMarker) {\n    result.nextKeyMarker = xmlobj.NextKeyMarker\n  }\n  if (xmlobj.NextUploadIdMarker) {\n    result.nextUploadIdMarker = xmlobj.nextUploadIdMarker\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((prefix) => {\n      result.prefixes.push({ prefix: sanitizeObjectKey(toArray(prefix.Prefix)[0]) })\n    })\n  }\n\n  if (xmlobj.Upload) {\n    toArray(xmlobj.Upload).forEach((upload) => {\n      var key = upload.Key\n      var uploadId = upload.UploadId\n      var initiator = { id: upload.Initiator.ID, displayName: upload.Initiator.DisplayName }\n      var owner = { id: upload.Owner.ID, displayName: upload.Owner.DisplayName }\n      var storageClass = upload.StorageClass\n      var initiated = new Date(upload.Initiated)\n      result.uploads.push({ key, uploadId, initiator, owner, storageClass, initiated })\n    })\n  }\n  return result\n}\n\n// parse XML response to list all the owned buckets\nexport function parseListBucket(xml) {\n  var result = []\n  var xmlobj = parseXml(xml)\n\n  if (!xmlobj.ListAllMyBucketsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListAllMyBucketsResult\"')\n  }\n  xmlobj = xmlobj.ListAllMyBucketsResult\n\n  if (xmlobj.Buckets) {\n    if (xmlobj.Buckets.Bucket) {\n      toArray(xmlobj.Buckets.Bucket).forEach((bucket) => {\n        var name = bucket.Name\n        var creationDate = new Date(bucket.CreationDate)\n        result.push({ name, creationDate })\n      })\n    }\n  }\n  return result\n}\n\n// parse XML response for bucket notification\nexport function parseBucketNotification(xml) {\n  var result = {\n    TopicConfiguration: [],\n    QueueConfiguration: [],\n    CloudFunctionConfiguration: [],\n  }\n  // Parse the events list\n  var genEvents = function (events) {\n    var result = []\n    if (events) {\n      toArray(events).forEach((s3event) => {\n        result.push(s3event)\n      })\n    }\n    return result\n  }\n  // Parse all filter rules\n  var genFilterRules = function (filters) {\n    var result = []\n    if (filters) {\n      filters = toArray(filters)\n      if (filters[0].S3Key) {\n        filters[0].S3Key = toArray(filters[0].S3Key)\n        if (filters[0].S3Key[0].FilterRule) {\n          toArray(filters[0].S3Key[0].FilterRule).forEach((rule) => {\n            var Name = toArray(rule.Name)[0]\n            var Value = toArray(rule.Value)[0]\n            result.push({ Name, Value })\n          })\n        }\n      }\n    }\n    return result\n  }\n\n  var xmlobj = parseXml(xml)\n  xmlobj = xmlobj.NotificationConfiguration\n\n  // Parse all topic configurations in the xml\n  if (xmlobj.TopicConfiguration) {\n    toArray(xmlobj.TopicConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var Topic = toArray(config.Topic)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.TopicConfiguration.push({ Id, Topic, Event, Filter })\n    })\n  }\n  // Parse all topic configurations in the xml\n  if (xmlobj.QueueConfiguration) {\n    toArray(xmlobj.QueueConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var Queue = toArray(config.Queue)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.QueueConfiguration.push({ Id, Queue, Event, Filter })\n    })\n  }\n  // Parse all QueueConfiguration arrays\n  if (xmlobj.CloudFunctionConfiguration) {\n    toArray(xmlobj.CloudFunctionConfiguration).forEach((config) => {\n      var Id = toArray(config.Id)[0]\n      var CloudFunction = toArray(config.CloudFunction)[0]\n      var Event = genEvents(config.Event)\n      var Filter = genFilterRules(config.Filter)\n      result.CloudFunctionConfiguration.push({ Id, CloudFunction, Event, Filter })\n    })\n  }\n\n  return result\n}\n\n// parse XML response for bucket region\nexport function parseBucketRegion(xml) {\n  // return region information\n  return parseXml(xml).LocationConstraint\n}\n\n// parse XML response for list parts of an in progress multipart upload\nexport function parseListParts(xml) {\n  var xmlobj = parseXml(xml)\n  var result = {\n    isTruncated: false,\n    parts: [],\n    marker: undefined,\n  }\n  if (!xmlobj.ListPartsResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListPartsResult\"')\n  }\n  xmlobj = xmlobj.ListPartsResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextPartNumberMarker) {\n    result.marker = +toArray(xmlobj.NextPartNumberMarker)[0]\n  }\n  if (xmlobj.Part) {\n    toArray(xmlobj.Part).forEach((p) => {\n      var part = +toArray(p.PartNumber)[0]\n      var lastModified = new Date(p.LastModified)\n      var etag = p.ETag.replace(/^\"/g, '')\n        .replace(/\"$/g, '')\n        .replace(/^&quot;/g, '')\n        .replace(/&quot;$/g, '')\n        .replace(/^&#34;/g, '')\n        .replace(/&#34;$/g, '')\n      result.parts.push({ part, lastModified, etag })\n    })\n  }\n  return result\n}\n\n// parse XML response when a new multipart upload is initiated\nexport function parseInitiateMultipart(xml) {\n  var xmlobj = parseXml(xml)\n\n  if (!xmlobj.InitiateMultipartUploadResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"InitiateMultipartUploadResult\"')\n  }\n  xmlobj = xmlobj.InitiateMultipartUploadResult\n\n  if (xmlobj.UploadId) {\n    return xmlobj.UploadId\n  }\n  throw new errors.InvalidXMLError('Missing tag: \"UploadId\"')\n}\n\n// parse XML response when a multipart upload is completed\nexport function parseCompleteMultipart(xml) {\n  var xmlobj = parseXml(xml).CompleteMultipartUploadResult\n  if (xmlobj.Location) {\n    var location = toArray(xmlobj.Location)[0]\n    var bucket = toArray(xmlobj.Bucket)[0]\n    var key = xmlobj.Key\n    var etag = xmlobj.ETag.replace(/^\"/g, '')\n      .replace(/\"$/g, '')\n      .replace(/^&quot;/g, '')\n      .replace(/&quot;$/g, '')\n      .replace(/^&#34;/g, '')\n      .replace(/&#34;$/g, '')\n\n    return { location, bucket, key, etag }\n  }\n  // Complete Multipart can return XML Error after a 200 OK response\n  if (xmlobj.Code && xmlobj.Message) {\n    var errCode = toArray(xmlobj.Code)[0]\n    var errMessage = toArray(xmlobj.Message)[0]\n    return { errCode, errMessage }\n  }\n}\n\nconst formatObjInfo = (content, opts = {}) => {\n  let { Key, LastModified, ETag, Size, VersionId, IsLatest } = content\n\n  if (!isObject(opts)) {\n    opts = {}\n  }\n\n  const name = sanitizeObjectKey(toArray(Key)[0])\n  const lastModified = new Date(toArray(LastModified)[0])\n  const etag = sanitizeETag(toArray(ETag)[0])\n\n  return {\n    name,\n    lastModified,\n    etag,\n    size: Size,\n    versionId: VersionId,\n    isLatest: IsLatest,\n    isDeleteMarker: opts.IsDeleteMarker ? opts.IsDeleteMarker : false,\n  }\n}\n\n// parse XML response for list objects in a bucket\nexport function parseListObjects(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  let isTruncated = false\n  let nextMarker, nextVersionKeyMarker\n  const xmlobj = parseXml(xml)\n\n  const parseCommonPrefixesEntity = (responseEntity) => {\n    if (responseEntity) {\n      toArray(responseEntity).forEach((commonPrefix) => {\n        result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n      })\n    }\n  }\n\n  const listBucketResult = xmlobj.ListBucketResult\n  const listVersionsResult = xmlobj.ListVersionsResult\n\n  if (listBucketResult) {\n    if (listBucketResult.IsTruncated) {\n      isTruncated = listBucketResult.IsTruncated\n    }\n    if (listBucketResult.Contents) {\n      toArray(listBucketResult.Contents).forEach((content) => {\n        const name = sanitizeObjectKey(toArray(content.Key)[0])\n        const lastModified = new Date(toArray(content.LastModified)[0])\n        const etag = sanitizeETag(toArray(content.ETag)[0])\n        const size = content.Size\n        result.objects.push({ name, lastModified, etag, size })\n      })\n    }\n\n    if (listBucketResult.NextMarker) {\n      nextMarker = listBucketResult.NextMarker\n    }\n    parseCommonPrefixesEntity(listBucketResult.CommonPrefixes)\n  }\n\n  if (listVersionsResult) {\n    if (listVersionsResult.IsTruncated) {\n      isTruncated = listVersionsResult.IsTruncated\n    }\n\n    if (listVersionsResult.Version) {\n      toArray(listVersionsResult.Version).forEach((content) => {\n        result.objects.push(formatObjInfo(content))\n      })\n    }\n    if (listVersionsResult.DeleteMarker) {\n      toArray(listVersionsResult.DeleteMarker).forEach((content) => {\n        result.objects.push(formatObjInfo(content, { IsDeleteMarker: true }))\n      })\n    }\n\n    if (listVersionsResult.NextKeyMarker) {\n      nextVersionKeyMarker = listVersionsResult.NextKeyMarker\n    }\n    if (listVersionsResult.NextVersionIdMarker) {\n      result.versionIdMarker = listVersionsResult.NextVersionIdMarker\n    }\n    parseCommonPrefixesEntity(listVersionsResult.CommonPrefixes)\n  }\n\n  result.isTruncated = isTruncated\n  if (isTruncated) {\n    result.nextMarker = nextVersionKeyMarker || nextMarker\n  }\n  return result\n}\n\n// parse XML response for list objects v2 in a bucket\nexport function parseListObjectsV2(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      var name = sanitizeObjectKey(toArray(content.Key)[0])\n      var lastModified = new Date(content.LastModified)\n      var etag = sanitizeETag(content.ETag)\n      var size = content.Size\n      result.objects.push({ name, lastModified, etag, size })\n    })\n  }\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\n// parse XML response for list objects v2 with metadata in a bucket\nexport function parseListObjectsV2WithMetadata(xml) {\n  var result = {\n    objects: [],\n    isTruncated: false,\n  }\n  var xmlobj = parseXml(xml)\n  if (!xmlobj.ListBucketResult) {\n    throw new errors.InvalidXMLError('Missing tag: \"ListBucketResult\"')\n  }\n  xmlobj = xmlobj.ListBucketResult\n  if (xmlobj.IsTruncated) {\n    result.isTruncated = xmlobj.IsTruncated\n  }\n  if (xmlobj.NextContinuationToken) {\n    result.nextContinuationToken = xmlobj.NextContinuationToken\n  }\n\n  if (xmlobj.Contents) {\n    toArray(xmlobj.Contents).forEach((content) => {\n      var name = sanitizeObjectKey(content.Key)\n      var lastModified = new Date(content.LastModified)\n      var etag = sanitizeETag(content.ETag)\n      var size = content.Size\n      var metadata\n      if (content.UserMetadata != null) {\n        metadata = toArray(content.UserMetadata)[0]\n      } else {\n        metadata = null\n      }\n      result.objects.push({ name, lastModified, etag, size, metadata })\n    })\n  }\n\n  if (xmlobj.CommonPrefixes) {\n    toArray(xmlobj.CommonPrefixes).forEach((commonPrefix) => {\n      result.objects.push({ prefix: sanitizeObjectKey(toArray(commonPrefix.Prefix)[0]), size: 0 })\n    })\n  }\n  return result\n}\n\nexport function parseBucketVersioningConfig(xml) {\n  var xmlObj = parseXml(xml)\n  return xmlObj.VersioningConfiguration\n}\n\nexport function parseTagging(xml) {\n  const xmlObj = parseXml(xml)\n  let result = []\n  if (xmlObj.Tagging && xmlObj.Tagging.TagSet && xmlObj.Tagging.TagSet.Tag) {\n    const tagResult = xmlObj.Tagging.TagSet.Tag\n    // if it is a single tag convert into an array so that the return value is always an array.\n    if (isObject(tagResult)) {\n      result.push(tagResult)\n    } else {\n      result = tagResult\n    }\n  }\n  return result\n}\n\nexport function parseLifecycleConfig(xml) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LifecycleConfiguration\n}\n\nexport function parseObjectLockConfig(xml) {\n  const xmlObj = parseXml(xml)\n  let lockConfigResult = {}\n  if (xmlObj.ObjectLockConfiguration) {\n    lockConfigResult = {\n      objectLockEnabled: xmlObj.ObjectLockConfiguration.ObjectLockEnabled,\n    }\n    let retentionResp\n    if (\n      xmlObj.ObjectLockConfiguration &&\n      xmlObj.ObjectLockConfiguration.Rule &&\n      xmlObj.ObjectLockConfiguration.Rule.DefaultRetention\n    ) {\n      retentionResp = xmlObj.ObjectLockConfiguration.Rule.DefaultRetention || {}\n      lockConfigResult.mode = retentionResp.Mode\n    }\n    if (retentionResp) {\n      const isUnitYears = retentionResp.Years\n      if (isUnitYears) {\n        lockConfigResult.validity = isUnitYears\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.YEARS\n      } else {\n        lockConfigResult.validity = retentionResp.Days\n        lockConfigResult.unit = RETENTION_VALIDITY_UNITS.DAYS\n      }\n    }\n    return lockConfigResult\n  }\n}\n\nexport function parseObjectRetentionConfig(xml) {\n  const xmlObj = parseXml(xml)\n  const retentionConfig = xmlObj.Retention\n\n  return {\n    mode: retentionConfig.Mode,\n    retainUntilDate: retentionConfig.RetainUntilDate,\n  }\n}\n\nexport function parseBucketEncryptionConfig(xml) {\n  let encConfig = parseXml(xml)\n  return encConfig\n}\nexport function parseReplicationConfig(xml) {\n  const xmlObj = parseXml(xml)\n  const replicationConfig = {\n    ReplicationConfiguration: {\n      role: xmlObj.ReplicationConfiguration.Role,\n      rules: toArray(xmlObj.ReplicationConfiguration.Rule),\n    },\n  }\n  return replicationConfig\n}\n\nexport function parseObjectLegalHoldConfig(xml) {\n  const xmlObj = parseXml(xml)\n  return xmlObj.LegalHold\n}\n\nexport function uploadPartParser(xml) {\n  const xmlObj = parseXml(xml)\n  const respEl = xmlObj.CopyPartResult\n  return respEl\n}\n\nexport function removeObjectsParser(xml) {\n  const xmlObj = parseXml(xml)\n  if (xmlObj.DeleteResult && xmlObj.DeleteResult.Error) {\n    // return errors as array always. as the response is object in case of single object passed in removeObjects\n    return toArray(xmlObj.DeleteResult.Error)\n  }\n  return []\n}\n\nexport function parseSelectObjectContentResponse(res) {\n  // extractHeaderType extracts the first half of the header message, the header type.\n  function extractHeaderType(stream) {\n    const headerNameLen = Buffer.from(stream.read(1)).readUInt8()\n    const headerNameWithSeparator = Buffer.from(stream.read(headerNameLen)).toString()\n    const splitBySeparator = (headerNameWithSeparator || '').split(':')\n    const headerName = splitBySeparator.length >= 1 ? splitBySeparator[1] : ''\n    return headerName\n  }\n\n  function extractHeaderValue(stream) {\n    const bodyLen = Buffer.from(stream.read(2)).readUInt16BE()\n    const bodyName = Buffer.from(stream.read(bodyLen)).toString()\n    return bodyName\n  }\n\n  const selectResults = new SelectResults({}) // will be returned\n\n  const responseStream = readableStream(res) // convert byte array to a readable responseStream\n  while (responseStream._readableState.length) {\n    // Top level responseStream read tracker.\n    let msgCrcAccumulator // accumulate from start of the message till the message crc start.\n\n    const totalByteLengthBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(totalByteLengthBuffer)\n\n    const headerBytesBuffer = Buffer.from(responseStream.read(4))\n    msgCrcAccumulator = crc32(headerBytesBuffer, msgCrcAccumulator)\n\n    const calculatedPreludeCrc = msgCrcAccumulator.readInt32BE() // use it to check if any CRC mismatch in header itself.\n\n    const preludeCrcBuffer = Buffer.from(responseStream.read(4)) // read 4 bytes    i.e 4+4 =8 + 4 = 12 ( prelude + prelude crc)\n    msgCrcAccumulator = crc32(preludeCrcBuffer, msgCrcAccumulator)\n\n    const totalMsgLength = totalByteLengthBuffer.readInt32BE()\n    const headerLength = headerBytesBuffer.readInt32BE()\n    const preludeCrcByteValue = preludeCrcBuffer.readInt32BE()\n\n    if (preludeCrcByteValue !== calculatedPreludeCrc) {\n      // Handle Header CRC mismatch Error\n      throw new Error(\n        `Header Checksum Mismatch, Prelude CRC of ${preludeCrcByteValue} does not equal expected CRC of ${calculatedPreludeCrc}`,\n      )\n    }\n\n    const headers = {}\n    if (headerLength > 0) {\n      const headerBytes = Buffer.from(responseStream.read(headerLength))\n      msgCrcAccumulator = crc32(headerBytes, msgCrcAccumulator)\n      const headerReaderStream = readableStream(headerBytes)\n      while (headerReaderStream._readableState.length) {\n        let headerTypeName = extractHeaderType(headerReaderStream)\n        headerReaderStream.read(1) // just read and ignore it.\n        headers[headerTypeName] = extractHeaderValue(headerReaderStream)\n      }\n    }\n\n    let payloadStream\n    const payLoadLength = totalMsgLength - headerLength - 16\n    if (payLoadLength > 0) {\n      const payLoadBuffer = Buffer.from(responseStream.read(payLoadLength))\n      msgCrcAccumulator = crc32(payLoadBuffer, msgCrcAccumulator)\n      // read the checksum early and detect any mismatch so we can avoid unnecessary further processing.\n      const messageCrcByteValue = Buffer.from(responseStream.read(4)).readInt32BE()\n      const calculatedCrc = msgCrcAccumulator.readInt32BE()\n      // Handle message CRC Error\n      if (messageCrcByteValue !== calculatedCrc) {\n        throw new Error(\n          `Message Checksum Mismatch, Message CRC of ${messageCrcByteValue} does not equal expected CRC of ${calculatedCrc}`,\n        )\n      }\n      payloadStream = readableStream(payLoadBuffer)\n    }\n\n    const messageType = headers['message-type']\n\n    switch (messageType) {\n      case 'error': {\n        const errorMessage = headers['error-code'] + ':\"' + headers['error-message'] + '\"'\n        throw new Error(errorMessage)\n      }\n      case 'event': {\n        const contentType = headers['content-type']\n        const eventType = headers['event-type']\n\n        switch (eventType) {\n          case 'End': {\n            selectResults.setResponse(res)\n            return selectResults\n          }\n\n          case 'Records': {\n            const readData = payloadStream.read(payLoadLength)\n            selectResults.setRecords(readData)\n            break\n          }\n\n          case 'Progress':\n            {\n              switch (contentType) {\n                case 'text/xml': {\n                  const progressData = payloadStream.read(payLoadLength)\n                  selectResults.setProgress(progressData.toString())\n                  break\n                }\n                default: {\n                  const errorMessage = `Unexpected content-type ${contentType} sent for event-type Progress`\n                  throw new Error(errorMessage)\n                }\n              }\n            }\n            break\n          case 'Stats':\n            {\n              switch (contentType) {\n                case 'text/xml': {\n                  const statsData = payloadStream.read(payLoadLength)\n                  selectResults.setStats(statsData.toString())\n                  break\n                }\n                default: {\n                  const errorMessage = `Unexpected content-type ${contentType} sent for event-type Stats`\n                  throw new Error(errorMessage)\n                }\n              }\n            }\n            break\n          default: {\n            // Continuation message: Not sure if it is supported. did not find a reference or any message in response.\n            // It does not have a payload.\n            const warningMessage = `Un implemented event detected  ${messageType}.`\n            // eslint-disable-next-line no-console\n            console.warn(warningMessage)\n          }\n        } // eventType End\n      } // Event End\n    } // messageType End\n  } // Top Level Stream End\n}\n"],"mappings":"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"} + +/***/ }), + +/***/ 7962: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +/*! + * mime-db + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2015-2022 Douglas Christopher Wilson + * MIT Licensed + */ + +/** + * Module exports. + */ + +module.exports = __nccwpck_require__(2639) + + +/***/ }), + +/***/ 7920: +/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => { + +"use strict"; +/*! + * mime-types + * Copyright(c) 2014 Jonathan Ong + * Copyright(c) 2015 Douglas Christopher Wilson + * MIT Licensed + */ + + + +/** + * Module dependencies. + * @private + */ + +var db = __nccwpck_require__(7962) +var extname = (__nccwpck_require__(1017).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 + } + }) +} + /***/ }), @@ -88743,60 +92333,48 @@ module.exports.q = codes; // 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. -/**/ + +/**/ var objectKeys = Object.keys || function (obj) { var keys = []; - - for (var key in obj) { - keys.push(key); - } - + for (var key in obj) keys.push(key); return keys; }; /**/ - module.exports = Duplex; - var Readable = __nccwpck_require__(1433); - var Writable = __nccwpck_require__(2094); - __nccwpck_require__(4124)(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 @@ -88823,20 +92401,20 @@ Object.defineProperty(Duplex.prototype, 'writableLength', { get: function get() { return this._writableState.length; } -}); // the no-half-open enforcer +}); +// 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. + 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 @@ -88846,7 +92424,6 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { if (this._readableState === undefined || this._writableState === undefined) { return false; } - return this._readableState.destroyed && this._writableState.destroyed; }, set: function set(value) { @@ -88854,10 +92431,10 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { // has not been initialized yet if (this._readableState === undefined || this._writableState === undefined) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // backward compatibility, the user is explicitly + // managing destroyed this._readableState.destroyed = value; this._writableState.destroyed = value; } @@ -88889,22 +92466,20 @@ Object.defineProperty(Duplex.prototype, 'destroyed', { // 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; +module.exports = PassThrough; var Transform = __nccwpck_require__(4415); - __nccwpck_require__(4124)(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); }; @@ -88937,47 +92512,38 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) { // USE OR OTHER DEALINGS IN THE SOFTWARE. + module.exports = Readable; -/**/ +/**/ var Duplex; /**/ Readable.ReadableState = ReadableState; -/**/ +/**/ var EE = (__nccwpck_require__(2361).EventEmitter); - var EElistenerCount = function EElistenerCount(emitter, type) { return emitter.listeners(type).length; }; /**/ /**/ - - var Stream = __nccwpck_require__(2387); /**/ - var Buffer = (__nccwpck_require__(4300).Buffer); - -var OurUint8Array = global.Uint8Array || function () {}; - +var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } - function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } -/**/ - +/**/ var debugUtil = __nccwpck_require__(3837); - var debug; - if (debugUtil && debugUtil.debuglog) { debug = debugUtil.debuglog('stream'); } else { @@ -88985,60 +92551,57 @@ if (debugUtil && debugUtil.debuglog) { } /**/ - var BufferList = __nccwpck_require__(2746); - var destroyImpl = __nccwpck_require__(7049); - var _require = __nccwpck_require__(9948), - getHighWaterMark = _require.getHighWaterMark; - + getHighWaterMark = _require.getHighWaterMark; var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q), - 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. - + 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; - __nccwpck_require__(4124)(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 + 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 || __nccwpck_require__(1359); - options = options || {}; // Duplex streams are both readable and writable, but share + 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; - if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to + // 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 + 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); - this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the + // 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; @@ -89046,61 +92609,66 @@ function ReadableState(options, stream, isDuplex) { 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 + 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; - this.sync = true; // whenever we return null, then we set a flag to say + // 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.paused = true; - this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish') + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; - this.autoDestroy = !!options.autoDestroy; // has it been destroyed + // Should .destroy() be called after 'end' (and potentially 'finish') + this.autoDestroy = !!options.autoDestroy; - this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string + // 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'; - 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 + // 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 = (__nccwpck_require__(4841)/* .StringDecoder */ .s); this.decoder = new StringDecoder(options.encoding); this.encoding = options.encoding; } } - function Readable(options) { Duplex = Duplex || __nccwpck_require__(1359); - 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 + 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._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 @@ -89110,7 +92678,6 @@ Object.defineProperty(Readable.prototype, 'destroyed', { if (this._readableState === undefined) { return false; } - return this._readableState.destroyed; }, set: function set(value) { @@ -89118,69 +92685,60 @@ Object.defineProperty(Readable.prototype, 'destroyed', { // has not been initialized yet if (!this._readableState) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // 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. +}; + +// 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() - +}; +// 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) { @@ -89189,7 +92747,6 @@ function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { 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); @@ -89201,14 +92758,13 @@ function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { state.reading = false; maybeReadMore(stream, state); } - } // We can push more data if we are below the highWaterMark. + } + + // 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; @@ -89219,50 +92775,42 @@ function addChunk(stream, state, chunk, addToFront) { 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. - +}; +// backwards compatibility. Readable.prototype.setEncoding = function (enc) { if (!StringDecoder) StringDecoder = (__nccwpck_require__(4841)/* .StringDecoder */ .s); 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: + 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 - +}; +// 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. @@ -89278,55 +92826,54 @@ function computeNewHighWaterMark(n) { n |= n >>> 16; n++; } - return n; -} // This function is designed to be inlinable, so please take care when making -// changes to the function body. - +} +// 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 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 (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. - +} +// 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 + 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); - n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up. - + // 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 + } + + // 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 @@ -89347,40 +92894,37 @@ Readable.prototype.read = function (n) { // '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. - + // 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 + 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. - + } + // 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 - + 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, + 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; @@ -89388,34 +92932,28 @@ Readable.prototype.read = function (n) { 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 (!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() @@ -89424,61 +92962,56 @@ function onEofChunk(stream, state) { } 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 +} + +// 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 + } + + // 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, +} + +// 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. // @@ -89507,49 +93040,42 @@ function maybeReadMore_(stream, state) { var len = state.length; debug('maybeReadMore read 0'); stream.read(0); - if (len === state.length) // didn't get any data, stop spinning. + if (len === state.length) + // didn't get any data, stop spinning. break; } - state.readingMore = false; -} // abstract method. to be overridden in specific implementation classes. +} + +// 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; @@ -89557,23 +93083,21 @@ Readable.prototype.pipe = function (dest, pipeOpts) { } } } - function onend() { debug('onend'); dest.end(); - } // when the dest drains, it reduces the awaitDrain counter + } + + // 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 - + debug('cleanup'); + // cleanup event handlers once the pipe is broken dest.removeListener('close', onclose); dest.removeListener('finish', onfinish); dest.removeListener('drain', ondrain); @@ -89582,22 +93106,20 @@ Readable.prototype.pipe = function (dest, pipeOpts) { 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 + 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 @@ -89607,87 +93129,84 @@ Readable.prototype.pipe = function (dest, pipeOpts) { 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. - + } + // 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. + // 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. + // 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 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. + 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. + } + // slow case. multiple pipe destinations. if (!dest) { // remove all. @@ -89696,17 +93215,13 @@ Readable.prototype.unpipe = function (dest) { state.pipes = null; state.pipesCount = 0; state.flowing = false; - - for (var i = 0; i < len; i++) { - dests[i].emit('unpipe', this, { - hasUnpiped: false - }); - } - + for (var i = 0; i < len; i++) dests[i].emit('unpipe', this, { + hasUnpiped: false + }); return this; - } // try to find the right one. - + } + // try to find the right one. var index = indexOf(state.pipes, dest); if (index === -1) return this; state.pipes.splice(index, 1); @@ -89714,19 +93229,19 @@ Readable.prototype.unpipe = function (dest) { 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 - +}; +// 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 + 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) { @@ -89734,7 +93249,6 @@ Readable.prototype.on = function (ev, fn) { state.flowing = false; state.emittedReadable = false; debug('on readable', state.length, state.reading); - if (state.length) { emitReadable(this); } else if (!state.reading) { @@ -89742,15 +93256,11 @@ Readable.prototype.on = function (ev, fn) { } } } - 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 @@ -89760,13 +93270,10 @@ Readable.prototype.removeListener = function (ev, fn) { // 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 @@ -89776,121 +93283,103 @@ Readable.prototype.removeAllListeners = function (ev) { // 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 + 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. - +} +// 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 + 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); +} - while (state.flowing && stream.read() !== null) { - ; - } -} // wrap an old-style stream as the async data source. +// 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.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. + }); + // 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) { @@ -89899,37 +93388,32 @@ Readable.prototype.wrap = function (stream) { }; }(i); } - } // proxy certain important events. - + } + // 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. - + } + // 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 = __nccwpck_require__(3306); } - return createReadableStreamAsyncIterator(this); }; } - Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { // making it explicit this property is not enumerable // because otherwise some prototype manipulation in @@ -89961,8 +93445,9 @@ Object.defineProperty(Readable.prototype, 'readableFlowing', { this._readableState.flowing = state; } } -}); // exposed for testing purposes only. +}); +// exposed for testing purposes only. Readable._fromList = fromList; Object.defineProperty(Readable.prototype, 'readableLength', { // making it explicit this property is not enumerable @@ -89972,11 +93457,12 @@ Object.defineProperty(Readable.prototype, 'readableLength', { get: function get() { return this._readableState.length; } -}); // Pluck off n bytes from an array of buffers. +}); + +// 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; @@ -89991,52 +93477,44 @@ function fromList(n, state) { } 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. + 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 = __nccwpck_require__(9082); } - 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; } @@ -90066,6 +93544,7 @@ function indexOf(xs, x) { // 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 @@ -90109,40 +93588,34 @@ function indexOf(xs, x) { // the results of the previous transformed chunk were consumed. -module.exports = Transform; +module.exports = Transform; var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q), - 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; - + 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 = __nccwpck_require__(1359); - __nccwpck_require__(4124)(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` + 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); @@ -90153,26 +93626,25 @@ function Transform(options) { 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 + // 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. - + } + // 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); @@ -90181,11 +93653,12 @@ function prefinish() { 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! +}; + +// This is the part where you do stuff! // override this function in implementation classes. // 'chunk' is an input chunk. // @@ -90195,33 +93668,27 @@ Transform.prototype.push = function (chunk, encoding) { // 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. +}; + +// 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 @@ -90229,20 +93696,20 @@ Transform.prototype._read = function (n) { 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 (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); @@ -90274,29 +93741,29 @@ function done(stream, er, data) { // 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; -/* */ +/* */ 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 - +} +// 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); }; @@ -90304,155 +93771,159 @@ function CorkedRequest(state) { /* */ /**/ - - var Duplex; /**/ Writable.WritableState = WritableState; -/**/ +/**/ var internalUtil = { deprecate: __nccwpck_require__(7127) }; /**/ /**/ - var Stream = __nccwpck_require__(2387); /**/ - var Buffer = (__nccwpck_require__(4300).Buffer); - -var OurUint8Array = global.Uint8Array || function () {}; - +var OurUint8Array = (typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : typeof self !== 'undefined' ? self : {}).Uint8Array || function () {}; function _uint8ArrayToBuffer(chunk) { return Buffer.from(chunk); } - function _isUint8Array(obj) { return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; } - var destroyImpl = __nccwpck_require__(7049); - var _require = __nccwpck_require__(9948), - getHighWaterMark = _require.getHighWaterMark; - + getHighWaterMark = _require.getHighWaterMark; var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q), - 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; - + 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; - __nccwpck_require__(4124)(Writable, Stream); - function nop() {} - function WritableState(options, stream, isDuplex) { Duplex = Duplex || __nccwpck_require__(1359); - options = options || {}; // Duplex streams are both readable and writable, but share + 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; - if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream + // 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 + 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); - this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called - - this.finalCalled = false; // drain event flag. + // if _final has been called + this.finalCalled = false; - 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 + // drain event flag. + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; - this.finished = false; // has it been destroyed + // has it been destroyed + this.destroyed = false; - this.destroyed = false; // should we decode strings into buffers before passing to _write? + // 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 + 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'; - this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement + // 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; - this.length = 0; // a flag to see when we're in the middle of a write. + // a flag to see when we're in the middle of a write. + this.writing = false; - this.writing = false; // when true all writes will be buffered until .uncork() call + // when true all writes will be buffered until .uncork() call + this.corked = 0; - this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately, + // 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; - this.sync = true; // a flag to know if we're processing previously buffered items, which + // 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; - this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb) - + // 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. + // 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.lastBufferedRequest = null; + + // number of pending user-supplied write callbacks // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; - this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs + // emit prefinish if the only thing we're waiting for is _write cbs // This is relevant for synchronous Transform streams + this.prefinished = false; - this.prefinished = false; // True if the error was already emitted and should not be thrown again + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; - this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true. + // Should close be emitted on destroy. Defaults to true. + this.emitClose = options.emitClose !== false; - this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end') + // Should .destroy() be called after 'finish' (and potentially 'end') + this.autoDestroy = !!options.autoDestroy; - this.autoDestroy = !!options.autoDestroy; // count buffered requests + // count buffered requests + this.bufferedRequestCount = 0; - this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always + // 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', { @@ -90461,12 +93932,11 @@ WritableState.prototype.getBuffer = function 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. - +})(); +// 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, { @@ -90481,81 +93951,73 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot return object instanceof this; }; } - function Writable(options) { - Duplex = Duplex || __nccwpck_require__(1359); // Writable ctor is applied to Duplexes, too. + Duplex = Duplex || __nccwpck_require__(1359); + + // 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._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. - +} +// 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 - + 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 +} + +// 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)) { @@ -90564,20 +94026,16 @@ Writable.prototype.write = function (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(); @@ -90585,7 +94043,6 @@ Writable.prototype.setDefaultEncoding = function setDefaultEncoding(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 @@ -90595,15 +94052,12 @@ Object.defineProperty(Writable.prototype, 'writableBuffer', { 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 @@ -90612,27 +94066,25 @@ Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { get: function get() { return this._writableState.highWaterMark; } -}); // if we're already writing something, then just put this +}); + +// 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. - + 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 = { @@ -90642,21 +94094,17 @@ function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { 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; @@ -90665,16 +94113,14 @@ function doWrite(stream, state, writev, len, chunk, encoding, cb) { 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 + 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); @@ -90683,20 +94129,18 @@ function onwriteError(stream, state, sync, er, cb) { // it is async cb(er); stream._writableState.errorEmitted = true; - errorOrDestroy(stream, er); // this can emit finish, but finish must + 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; @@ -90706,11 +94150,9 @@ function onwrite(stream, er) { 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 { @@ -90718,29 +94160,27 @@ function onwrite(stream, er) { } } } - 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 +} + +// 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 - +} +// 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; @@ -90749,28 +94189,25 @@ function clearBuffer(stream, state) { 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 + 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 @@ -90781,32 +94218,26 @@ function clearBuffer(stream, state) { 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 + 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; @@ -90815,19 +94246,18 @@ Writable.prototype.end = function (chunk, encoding, cb) { cb = encoding; encoding = null; } + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); - if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks - + // .end() fully uncorks if (state.corked) { state.corked = 1; this.uncork(); - } // ignore unnecessary end() calls. - + } + // 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 @@ -90837,25 +94267,20 @@ Object.defineProperty(Writable.prototype, 'writableLength', { 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) { @@ -90868,59 +94293,47 @@ function prefinish(stream, state) { } } } - 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. - + } + // 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 @@ -90930,7 +94343,6 @@ Object.defineProperty(Writable.prototype, 'destroyed', { if (this._writableState === undefined) { return false; } - return this._writableState.destroyed; }, set: function set(value) { @@ -90938,16 +94350,15 @@ Object.defineProperty(Writable.prototype, 'destroyed', { // has not been initialized yet if (!this._writableState) { return; - } // backward compatibility, the user is explicitly - // managing destroyed - + } + // 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); }; @@ -90961,11 +94372,10 @@ Writable.prototype._destroy = function (err, cb) { 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; } - +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var finished = __nccwpck_require__(6080); - var kLastResolve = Symbol('lastResolve'); var kLastReject = Symbol('lastReject'); var kError = Symbol('error'); @@ -90973,22 +94383,19 @@ 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 + 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; @@ -90997,13 +94404,11 @@ function readAndResolve(iter) { } } } - 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 () { @@ -91011,33 +94416,26 @@ function wrapForNext(lastPromise, iter) { 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 @@ -91052,29 +94450,25 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro } }); }); - } // if we have multiple next() calls + } + + // 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; } @@ -91082,7 +94476,6 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro 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 @@ -91092,15 +94485,12 @@ var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPro 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 @@ -91119,7 +94509,6 @@ var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterat }), _defineProperty(_Object$create, kHandlePromise, { value: function value(resolve, reject) { var data = iterator[kStream].read(); - if (data) { iterator[kLastPromise] = null; iterator[kLastResolve] = null; @@ -91135,35 +94524,30 @@ var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterat 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 + 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; /***/ }), @@ -91174,41 +94558,29 @@ module.exports = createReadableStreamAsyncIterator; "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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); 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; } - +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, _toPropertyKey(descriptor.key), descriptor); } } +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var _require = __nccwpck_require__(4300), - Buffer = _require.Buffer; - + Buffer = _require.Buffer; var _require2 = __nccwpck_require__(3837), - inspect = _require2.inspect; - + 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 () { +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) { @@ -91252,11 +94624,7 @@ function () { if (this.length === 0) return ''; var p = this.head; var ret = '' + p.data; - - while (p = p.next) { - ret += s + p.data; - } - + while (p = p.next) ret += s + p.data; return ret; } }, { @@ -91266,21 +94634,19 @@ function () { 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. + } + // 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); @@ -91292,15 +94658,15 @@ function () { // 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. + } + // Consumes a specified amount of characters from the buffered data. }, { key: "_getString", value: function _getString(n) { @@ -91308,13 +94674,11 @@ function () { 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; @@ -91323,17 +94687,15 @@ function () { 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. + } + // Consumes a specified amount of bytes from the buffered data. }, { key: "_getBuffer", value: function _getBuffer(n) { @@ -91342,13 +94704,11 @@ function () { 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; @@ -91357,21 +94717,19 @@ function () { 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. + } + // Make sure the linked list only shows the minimal necessary information. }, { key: custom, value: function value(_, options) { - return inspect(this, _objectSpread({}, options, { + return inspect(this, _objectSpread(_objectSpread({}, options), {}, { // Only inspect one level. depth: 0, // It should not recurse. @@ -91379,7 +94737,6 @@ function () { })); } }]); - return BufferList; }(); @@ -91389,14 +94746,13 @@ function () { /***/ ((module) => { "use strict"; - // undocumented cb() API, needed for core, not for public API + +// 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); @@ -91408,21 +94764,20 @@ function destroy(err, cb) { 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 + } + // 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 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) { @@ -91440,21 +94795,17 @@ function destroy(err, cb) { 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; @@ -91462,7 +94813,6 @@ function undestroy() { this._readableState.ended = false; this._readableState.endEmitted = false; } - if (this._writableState) { this._writableState.destroyed = false; this._writableState.ended = false; @@ -91473,22 +94823,20 @@ function undestroy() { 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, @@ -91505,77 +94853,61 @@ module.exports = { // permission from the author, Mathias Buus (@mafintosh). -var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(7214)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE); +var ERR_STREAM_PREMATURE_CLOSE = (__nccwpck_require__(7214)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.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); @@ -91585,7 +94917,6 @@ function eos(stream, opts, callback) { stream.on('end', onlegacyfinish); stream.on('close', onlegacyfinish); } - stream.on('end', onend); stream.on('finish', onfinish); if (opts.error !== false) stream.on('error', onerror); @@ -91603,7 +94934,6 @@ function eos(stream, opts, callback) { stream.removeListener('close', onclose); }; } - module.exports = eos; /***/ }), @@ -91615,52 +94945,42 @@ module.exports = eos; 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; } - +function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; } +function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } +function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); } +function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } var ERR_INVALID_ARG_TYPE = (__nccwpck_require__(7214)/* .codes.ERR_INVALID_ARG_TYPE */ .q.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 + }, 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; - + var _yield$iterator$next = yield iterator.next(), + value = _yield$iterator$next.value, + done = _yield$iterator$next.done; if (done) { readable.push(null); - } else if (readable.push((yield value))) { + } else if (readable.push(yield value)) { next(); } else { reading = false; @@ -91671,12 +94991,11 @@ function from(Readable, iterable, opts) { }); return _next2.apply(this, arguments); } - return readable; } - module.exports = from; + /***/ }), /***/ 6989: @@ -91687,8 +95006,8 @@ module.exports = from; // permission from the author, Mathias Buus (@mafintosh). -var eos; +var eos; function once(callback) { var called = false; return function () { @@ -91697,20 +95016,16 @@ function once(callback) { callback.apply(void 0, arguments); }; } - var _require$codes = (__nccwpck_require__(7214)/* .codes */ .q), - ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS, - ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED; - + 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; @@ -91730,40 +95045,34 @@ function destroyer(stream, reading, writing, callback) { return function (err) { if (closed) return; if (destroyed) return; - destroyed = true; // request.destroy just do .end - .abort is what we want + 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; @@ -91778,7 +95087,6 @@ function pipeline() { }); return streams.reduce(pipe); } - module.exports = pipeline; /***/ }), @@ -91790,27 +95098,22 @@ module.exports = pipeline; var ERR_INVALID_OPT_VALUE = (__nccwpck_require__(7214)/* .codes.ERR_INVALID_OPT_VALUE */ .q.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 - + } + // Default value return state.objectMode ? 16 : 16 * 1024; } - module.exports = { getHighWaterMark: getHighWaterMark }; @@ -104178,7 +107481,7 @@ var State; State["SecretKey"] = "secret-key"; State["SessionToken"] = "session-token"; State["LocalHit"] = "local-hit"; -})(State || (exports.State = State = {})); +})(State = exports.State || (exports.State = {})); /***/ }), @@ -104534,6 +107837,14 @@ module.exports = require("zlib"); /***/ 3765: /***/ ((module) => { +"use strict"; +module.exports = JSON.parse('{"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/3gpphal+json":{"source":"iana","compressible":true},"application/3gpphalforms+json":{"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/captive+json":{"source":"iana","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/clr":{"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":["es","ecma"]},"application/edi-consent":{"source":"iana"},"application/edi-x12":{"source":"iana","compressible":false},"application/edifact":{"source":"iana","compressible":false},"application/efi":{"source":"iana"},"application/elm+json":{"source":"iana","charset":"UTF-8","compressible":true},"application/elm+xml":{"source":"iana","compressible":true},"application/emergencycalldata.cap+xml":{"source":"iana","charset":"UTF-8","compressible":true},"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/jscalendar+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},"application/mrb-publish+xml":{"source":"iana","compressible":true},"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/oauth-authz-req+jwt":{"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/opc-nodeset+xml":{"source":"iana","compressible":true},"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.cyn":{"source":"iana","charset":"7-BIT"},"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/sarif+json":{"source":"iana","compressible":true},"application/sarif-external-properties+json":{"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/ubjson":{"compressible":false,"extensions":["ubj"]},"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,"extensions":["td"]},"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.5gnas":{"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.gtpc":{"source":"iana"},"application/vnd.3gpp.interworking-data":{"source":"iana"},"application/vnd.3gpp.lpp":{"source":"iana"},"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.ngap":{"source":"iana"},"application/vnd.3gpp.pfcp":{"source":"iana"},"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.s1ap":{"source":"iana"},"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.cmoca-cmresource":{"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-cmtable":{"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":["key"]},"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.cryptomator.encrypted":{"source":"iana"},"application/vnd.cryptomator.vault":{"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.cyclonedx+json":{"source":"iana","compressible":true},"application/vnd.cyclonedx+xml":{"source":"iana","compressible":true},"application/vnd.d2l.coursepackage1p0+zip":{"source":"iana","compressible":false},"application/vnd.d3m-dataset":{"source":"iana"},"application/vnd.d3m-problem":{"source":"iana"},"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","extensions":["dbf"]},"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.fujifilm.fb.docuworks":{"source":"iana"},"application/vnd.fujifilm.fb.docuworks.binder":{"source":"iana"},"application/vnd.fujifilm.fb.docuworks.container":{"source":"iana"},"application/vnd.fujifilm.fb.jfi+xml":{"source":"iana","compressible":true},"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.slides":{"source":"iana"},"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","extensions":["mvt"]},"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.nebumind.line":{"source":"iana"},"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+cbor":{"source":"iana"},"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","extensions":["rar"]},"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.seis+json":{"source":"iana","compressible":true},"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.sycle+xml":{"source":"iana","compressible":true},"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.dpp":{"source":"iana"},"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":{"source":"iana","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},"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":["xsl","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","extensions":["amr"]},"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","opus"]},"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/scip":{"source":"iana"},"audio/silk":{"source":"apache","extensions":["sil"]},"audio/smv":{"source":"iana"},"audio/smv-qcp":{"source":"iana"},"audio/smv0":{"source":"iana"},"audio/sofa":{"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/tsvcis":{"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/avif":{"source":"iana","compressible":false,"extensions":["avif"]},"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/ktx2":{"source":"iana","extensions":["ktx2"]},"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.pco.b16":{"source":"iana","extensions":["b16"]},"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/e57":{"source":"iana"},"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.pytha.pyox":{"source":"iana"},"model/vnd.rosette.annotated-data-model":{"source":"iana"},"model/vnd.sap.vds":{"source":"iana","extensions":["vds"]},"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/cql":{"source":"iana"},"text/cql-expression":{"source":"iana"},"text/cql-identifier":{"source":"iana"},"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/fhirpath":{"source":"iana"},"text/flexfec":{"source":"iana"},"text/fwdred":{"source":"iana"},"text/gff3":{"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/shaclc":{"source":"iana"},"text/shex":{"source":"iana","extensions":["shex"]},"text/slim":{"extensions":["slim","slm"]},"text/spdx":{"source":"iana","extensions":["spdx"]},"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.hans":{"source":"iana"},"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":{"compressible":true,"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/av1":{"source":"iana"},"video/bmpeg":{"source":"iana"},"video/bt656":{"source":"iana"},"video/celb":{"source":"iana"},"video/dv":{"source":"iana"},"video/encaprtp":{"source":"iana"},"video/ffv1":{"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","extensions":["m4s"]},"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/scip":{"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}}'); + +/***/ }), + +/***/ 2639: +/***/ ((module) => { + "use strict"; module.exports = JSON.parse('{"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/3gpphal+json":{"source":"iana","compressible":true},"application/3gpphalforms+json":{"source":"iana","compressible":true},"application/a2l":{"source":"iana"},"application/ace+cbor":{"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/at+jwt":{"source":"iana"},"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/captive+json":{"source":"iana","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/city+json":{"source":"iana","compressible":true},"application/clr":{"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,"extensions":["cpl"]},"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/dash-patch+xml":{"source":"iana","compressible":true,"extensions":["mpp"]},"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":["es","ecma"]},"application/edi-consent":{"source":"iana"},"application/edi-x12":{"source":"iana","compressible":false},"application/edifact":{"source":"iana","compressible":false},"application/efi":{"source":"iana"},"application/elm+json":{"source":"iana","charset":"UTF-8","compressible":true},"application/elm+xml":{"source":"iana","compressible":true},"application/emergencycalldata.cap+xml":{"source":"iana","charset":"UTF-8","compressible":true},"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/express":{"source":"iana","extensions":["exp"]},"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/jscalendar+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":{"source":"iana","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,"extensions":["mpf"]},"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/missing-blocks+cbor-seq":{"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},"application/mrb-publish+xml":{"source":"iana","compressible":true},"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/oauth-authz-req+jwt":{"source":"iana"},"application/oblivious-dns-message":{"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/opc-nodeset+xml":{"source":"iana","compressible":true},"application/oscore":{"source":"iana"},"application/oxps":{"source":"iana","extensions":["oxps"]},"application/p21":{"source":"iana"},"application/p21+zip":{"source":"iana","compressible":false},"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","extensions":["asc"]},"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.cyn":{"source":"iana","charset":"7-BIT"},"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/sarif+json":{"source":"iana","compressible":true},"application/sarif-external-properties+json":{"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/spdx+json":{"source":"iana","compressible":true},"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/token-introspection+jwt":{"source":"iana"},"application/toml":{"compressible":true,"extensions":["toml"]},"application/trickle-ice-sdpfrag":{"source":"iana"},"application/trig":{"source":"iana","extensions":["trig"]},"application/ttml+xml":{"source":"iana","compressible":true,"extensions":["ttml"]},"application/tve-trigger":{"source":"iana"},"application/tzif":{"source":"iana"},"application/tzif-leap":{"source":"iana"},"application/ubjson":{"compressible":false,"extensions":["ubj"]},"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,"extensions":["td"]},"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.5gnas":{"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.gtpc":{"source":"iana"},"application/vnd.3gpp.interworking-data":{"source":"iana"},"application/vnd.3gpp.lpp":{"source":"iana"},"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.ngap":{"source":"iana"},"application/vnd.3gpp.pfcp":{"source":"iana"},"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.s1ap":{"source":"iana"},"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.cmoca-cmresource":{"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-cmtable":{"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.age":{"source":"iana","extensions":["age"]},"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.arrow.file":{"source":"iana"},"application/vnd.apache.arrow.stream":{"source":"iana"},"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":["key"]},"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.cryptomator.encrypted":{"source":"iana"},"application/vnd.cryptomator.vault":{"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.cyclonedx+json":{"source":"iana","compressible":true},"application/vnd.cyclonedx+xml":{"source":"iana","compressible":true},"application/vnd.d2l.coursepackage1p0+zip":{"source":"iana","compressible":false},"application/vnd.d3m-dataset":{"source":"iana"},"application/vnd.d3m-problem":{"source":"iana"},"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","extensions":["dbf"]},"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.eclipse.ditto+json":{"source":"iana","compressible":true},"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.eu.kasparian.car+json":{"source":"iana","compressible":true},"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.familysearch.gedcom+zip":{"source":"iana","compressible":false},"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.fujifilm.fb.docuworks":{"source":"iana"},"application/vnd.fujifilm.fb.docuworks.binder":{"source":"iana"},"application/vnd.fujifilm.fb.docuworks.container":{"source":"iana"},"application/vnd.fujifilm.fb.jfi+xml":{"source":"iana","compressible":true},"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.slides":{"source":"iana"},"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.hl7cda+xml":{"source":"iana","charset":"UTF-8","compressible":true},"application/vnd.hl7v2+xml":{"source":"iana","charset":"UTF-8","compressible":true},"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","extensions":["mvt"]},"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.maxar.archive.3tz+zip":{"source":"iana","compressible":false},"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.nacamar.ybrid+json":{"source":"iana","compressible":true},"application/vnd.ncd.control":{"source":"iana"},"application/vnd.ncd.reference":{"source":"iana"},"application/vnd.nearst.inv+json":{"source":"iana","compressible":true},"application/vnd.nebumind.line":{"source":"iana"},"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+cbor":{"source":"iana"},"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.opentimestamps.ots":{"source":"iana"},"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","extensions":["rar"]},"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.resilient.logic":{"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.seis+json":{"source":"iana","compressible":true},"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.sycle+xml":{"source":"iana","compressible":true},"application/vnd.syft+json":{"source":"iana","compressible":true},"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.veritone.aion+json":{"source":"iana","compressible":true},"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.dpp":{"source":"iana"},"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":{"source":"iana","compressible":true,"extensions":["wasm"]},"application/watcherinfo+xml":{"source":"iana","compressible":true,"extensions":["wif"]},"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-iwork-keynote-sffkey":{"extensions":["key"]},"application/x-iwork-numbers-sffnumbers":{"extensions":["numbers"]},"application/x-iwork-pages-sffpages":{"extensions":["pages"]},"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},"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":["xsl","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","extensions":["amr"]},"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","opus"]},"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/scip":{"source":"iana"},"audio/silk":{"source":"apache","extensions":["sil"]},"audio/smv":{"source":"iana"},"audio/smv-qcp":{"source":"iana"},"audio/smv0":{"source":"iana"},"audio/sofa":{"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/tsvcis":{"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","extensions":["avci"]},"image/avcs":{"source":"iana","extensions":["avcs"]},"image/avif":{"source":"iana","compressible":false,"extensions":["avif"]},"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/ktx2":{"source":"iana","extensions":["ktx2"]},"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","compressible":true,"extensions":["ico"]},"image/vnd.mix":{"source":"iana"},"image/vnd.mozilla.apng":{"source":"iana"},"image/vnd.ms-dds":{"compressible":true,"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.pco.b16":{"source":"iana","extensions":["b16"]},"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/e57":{"source":"iana"},"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/step":{"source":"iana"},"model/step+xml":{"source":"iana","compressible":true,"extensions":["stpx"]},"model/step+zip":{"source":"iana","compressible":false,"extensions":["stpz"]},"model/step-xml+zip":{"source":"iana","compressible":false,"extensions":["stpxz"]},"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.pytha.pyox":{"source":"iana"},"model/vnd.rosette.annotated-data-model":{"source":"iana"},"model/vnd.sap.vds":{"source":"iana","extensions":["vds"]},"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/cql":{"source":"iana"},"text/cql-expression":{"source":"iana"},"text/cql-identifier":{"source":"iana"},"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/fhirpath":{"source":"iana"},"text/flexfec":{"source":"iana"},"text/fwdred":{"source":"iana"},"text/gff3":{"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/shaclc":{"source":"iana"},"text/shex":{"source":"iana","extensions":["shex"]},"text/slim":{"extensions":["slim","slm"]},"text/spdx":{"source":"iana","extensions":["spdx"]},"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.familysearch.gedcom":{"source":"iana","extensions":["ged"]},"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.hans":{"source":"iana"},"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":{"compressible":true,"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/av1":{"source":"iana"},"video/bmpeg":{"source":"iana"},"video/bt656":{"source":"iana"},"video/celb":{"source":"iana"},"video/dv":{"source":"iana"},"video/encaprtp":{"source":"iana"},"video/ffv1":{"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","extensions":["m4s"]},"video/jpeg":{"source":"iana","extensions":["jpgv"]},"video/jpeg2000":{"source":"iana"},"video/jpm":{"source":"apache","extensions":["jpm","jpgm"]},"video/jxsv":{"source":"iana"},"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/scip":{"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/vp9":{"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}}'); diff --git a/src/restore.ts b/src/restore.ts index 3791cb7..763fda8 100644 --- a/src/restore.ts +++ b/src/restore.ts @@ -27,6 +27,7 @@ async function restoreCache() { const paths = getInputAsArray("path"); const restoreKeys = getInputAsArray("restore-keys"); const local = core.getInput("local"); + const errorOnS3Exception = getInputAsBoolean("error-on-s3-exception"); try { const compressionMethod = await utils.getCompressionMethod(); @@ -43,18 +44,18 @@ async function restoreCache() { core.saveState(State.SessionToken, core.getInput("sessionToken")); if (local) { - core.info('Local cache is enabled') + core.info("Local cache is enabled"); - const localKey = path.join(local, key, cacheFileName) + const localKey = path.join(local, key, cacheFileName); core.info(`Looking for exact match: ${localKey}`); if (fs.existsSync(localKey)) { - core.info('Local cache HIT! ✅') - await fs.copy(localKey, archivePath) - core.info('Local cache copied!') - - core.info('Extracting cache file...') + core.info("Local cache HIT! ✅"); + await fs.copy(localKey, archivePath); + core.info("Local cache copied!"); + + core.info("Extracting cache file..."); await extractTar(archivePath, compressionMethod); saveMatchedKey(key); @@ -62,10 +63,10 @@ async function restoreCache() { setCacheHitLocal(true); core.info("Cache restored from local successfully"); - return + return; } else { setCacheHitLocal(false); - core.info('Local cache MISS! ❌') + core.info("Local cache MISS! ❌"); } } @@ -98,8 +99,12 @@ async function restoreCache() { setCacheHitOutput(matchingKey === key); core.info("Cache restored from s3 successfully"); } catch (e: any) { - core.info("Restore s3 cache failed: " + e.message); setCacheHitOutput(false); + if (errorOnS3Exception) { + core.setFailed("Restore s3 cache failed: " + e.message); + } else { + core.info("Restore s3 cache failed: " + e.message); + } if (useFallback) { if (isGhes()) { core.warning("Cache fallback is not supported on Github Enterpise.");