Google Git
Sign in
pigweed/third_party/github/aspect-build/rules_js/3132410359bbf950c8df4dc4acd6c0edb4c10b81/./js/private/js_image_layer.mjs
blob: a87d81af66815726fedc7e2149d05277d95fbf49 [file]
import { createWriteStream, createReadStream } from 'node:fs';
import { readFile, stat, readdir, readlink } from 'node:fs/promises';
import * as path from 'node:path';
import { Readable as Readable$2 } from 'node:stream';
import { pathToFileURL } from 'node:url';
import { createGzip } from 'node:zlib';
import require$$0$1 from 'stream';
import require$$0 from 'buffer';
import require$$2 from 'events';
import require$$13 from 'string_decoder';
import require$$0$2 from 'fs';
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
function getAugmentedNamespace(n) {
var f = n.default;
if (typeof f == "function") {
var a = function () {
return f.apply(this, arguments);
};
a.prototype = f.prototype;
} else a = {};
Object.defineProperty(a, '__esModule', {value: true});
Object.keys(n).forEach(function (k) {
var d = Object.getOwnPropertyDescriptor(n, k);
Object.defineProperty(a, k, d.get ? d : {
enumerable: true,
get: function () {
return n[k];
}
});
});
return a;
}
var bl = {exports: {}};
var ours = {exports: {}};
var stream = {exports: {}};
var primordials;
var hasRequiredPrimordials;
function requirePrimordials () {
if (hasRequiredPrimordials) return primordials;
hasRequiredPrimordials = 1;
/*
This file is a reduced and adapted version of the main lib/internal/per_context/primordials.js file defined at
https://github.com/nodejs/node/blob/master/lib/internal/per_context/primordials.js
Don't try to replace with the original file and keep it up to date with the upstream file.
*/
primordials = {
ArrayIsArray(self) {
return Array.isArray(self)
},
ArrayPrototypeIncludes(self, el) {
return self.includes(el)
},
ArrayPrototypeIndexOf(self, el) {
return self.indexOf(el)
},
ArrayPrototypeJoin(self, sep) {
return self.join(sep)
},
ArrayPrototypeMap(self, fn) {
return self.map(fn)
},
ArrayPrototypePop(self, el) {
return self.pop(el)
},
ArrayPrototypePush(self, el) {
return self.push(el)
},
ArrayPrototypeSlice(self, start, end) {
return self.slice(start, end)
},
Error,
FunctionPrototypeCall(fn, thisArgs, ...args) {
return fn.call(thisArgs, ...args)
},
FunctionPrototypeSymbolHasInstance(self, instance) {
return Function.prototype[Symbol.hasInstance].call(self, instance)
},
MathFloor: Math.floor,
Number,
NumberIsInteger: Number.isInteger,
NumberIsNaN: Number.isNaN,
NumberMAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,
NumberMIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,
NumberParseInt: Number.parseInt,
ObjectDefineProperties(self, props) {
return Object.defineProperties(self, props)
},
ObjectDefineProperty(self, name, prop) {
return Object.defineProperty(self, name, prop)
},
ObjectGetOwnPropertyDescriptor(self, name) {
return Object.getOwnPropertyDescriptor(self, name)
},
ObjectKeys(obj) {
return Object.keys(obj)
},
ObjectSetPrototypeOf(target, proto) {
return Object.setPrototypeOf(target, proto)
},
Promise,
PromisePrototypeCatch(self, fn) {
return self.catch(fn)
},
PromisePrototypeThen(self, thenFn, catchFn) {
return self.then(thenFn, catchFn)
},
PromiseReject(err) {
return Promise.reject(err)
},
ReflectApply: Reflect.apply,
RegExpPrototypeTest(self, value) {
return self.test(value)
},
SafeSet: Set,
String,
StringPrototypeSlice(self, start, end) {
return self.slice(start, end)
},
StringPrototypeToLowerCase(self) {
return self.toLowerCase()
},
StringPrototypeToUpperCase(self) {
return self.toUpperCase()
},
StringPrototypeTrim(self) {
return self.trim()
},
Symbol,
SymbolAsyncIterator: Symbol.asyncIterator,
SymbolHasInstance: Symbol.hasInstance,
SymbolIterator: Symbol.iterator,
TypedArrayPrototypeSet(self, buf, len) {
return self.set(buf, len)
},
Uint8Array
};
return primordials;
}
var util = {exports: {}};
var hasRequiredUtil;
function requireUtil () {
if (hasRequiredUtil) return util.exports;
hasRequiredUtil = 1;
(function (module) {
const bufferModule = require$$0;
const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
const Blob = globalThis.Blob || bufferModule.Blob;
/* eslint-disable indent */
const isBlob =
typeof Blob !== 'undefined'
? function isBlob(b) {
// eslint-disable-next-line indent
return b instanceof Blob
}
: function isBlob(b) {
return false
};
/* eslint-enable indent */
// This is a simplified version of AggregateError
class AggregateError extends Error {
constructor(errors) {
if (!Array.isArray(errors)) {
throw new TypeError(`Expected input to be an Array, got ${typeof errors}`)
}
let message = '';
for (let i = 0; i < errors.length; i++) {
message += ` ${errors[i].stack}\n`;
}
super(message);
this.name = 'AggregateError';
this.errors = errors;
}
}
module.exports = {
AggregateError,
kEmptyObject: Object.freeze({}),
once(callback) {
let called = false;
return function (...args) {
if (called) {
return
}
called = true;
callback.apply(this, args);
}
},
createDeferredPromise: function () {
let resolve;
let reject;
// eslint-disable-next-line promise/param-names
const promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
return {
promise,
resolve,
reject
}
},
promisify(fn) {
return new Promise((resolve, reject) => {
fn((err, ...args) => {
if (err) {
return reject(err)
}
return resolve(...args)
});
})
},
debuglog() {
return function () {}
},
format(format, ...args) {
// Simplified version of https://nodejs.org/api/util.html#utilformatformat-args
return format.replace(/%([sdifj])/g, function (...[_unused, type]) {
const replacement = args.shift();
if (type === 'f') {
return replacement.toFixed(6)
} else if (type === 'j') {
return JSON.stringify(replacement)
} else if (type === 's' && typeof replacement === 'object') {
const ctor = replacement.constructor !== Object ? replacement.constructor.name : '';
return `${ctor} {}`.trim()
} else {
return replacement.toString()
}
})
},
inspect(value) {
// Vastly simplified version of https://nodejs.org/api/util.html#utilinspectobject-options
switch (typeof value) {
case 'string':
if (value.includes("'")) {
if (!value.includes('"')) {
return `"${value}"`
} else if (!value.includes('`') && !value.includes('${')) {
return `\`${value}\``
}
}
return `'${value}'`
case 'number':
if (isNaN(value)) {
return 'NaN'
} else if (Object.is(value, -0)) {
return String(value)
}
return value
case 'bigint':
return `${String(value)}n`
case 'boolean':
case 'undefined':
return String(value)
case 'object':
return '{}'
}
},
types: {
isAsyncFunction(fn) {
return fn instanceof AsyncFunction
},
isArrayBufferView(arr) {
return ArrayBuffer.isView(arr)
}
},
isBlob
};
module.exports.promisify.custom = Symbol.for('nodejs.util.promisify.custom');
} (util));
return util.exports;
}
var operators = {};
/**
* @author Toru Nagashima <https://github.com/mysticatea>
* @copyright 2015 Toru Nagashima. All rights reserved.
* See LICENSE file in root directory for full license.
*/
/**
* @typedef {object} PrivateData
* @property {EventTarget} eventTarget The event target.
* @property {{type:string}} event The original event object.
* @property {number} eventPhase The current event phase.
* @property {EventTarget|null} currentTarget The current event target.
* @property {boolean} canceled The flag to prevent default.
* @property {boolean} stopped The flag to stop propagation.
* @property {boolean} immediateStopped The flag to stop propagation immediately.
* @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.
* @property {number} timeStamp The unix time.
* @private
*/
/**
* Private data for event wrappers.
* @type {WeakMap<Event, PrivateData>}
* @private
*/
const privateData = new WeakMap();
/**
* Cache for wrapper classes.
* @type {WeakMap<Object, Function>}
* @private
*/
const wrappers = new WeakMap();
/**
* Get private data.
* @param {Event} event The event object to get private data.
* @returns {PrivateData} The private data of the event.
* @private
*/
function pd(event) {
const retv = privateData.get(event);
console.assert(
retv != null,
"'this' is expected an Event object, but got",
event
);
return retv
}
/**
* https://dom.spec.whatwg.org/#set-the-canceled-flag
* @param data {PrivateData} private data.
*/
function setCancelFlag(data) {
if (data.passiveListener != null) {
if (
typeof console !== "undefined" &&
typeof console.error === "function"
) {
console.error(
"Unable to preventDefault inside passive event listener invocation.",
data.passiveListener
);
}
return
}
if (!data.event.cancelable) {
return
}
data.canceled = true;
if (typeof data.event.preventDefault === "function") {
data.event.preventDefault();
}
}
/**
* @see https://dom.spec.whatwg.org/#interface-event
* @private
*/
/**
* The event wrapper.
* @constructor
* @param {EventTarget} eventTarget The event target of this dispatching.
* @param {Event|{type:string}} event The original event to wrap.
*/
function Event(eventTarget, event) {
privateData.set(this, {
eventTarget,
event,
eventPhase: 2,
currentTarget: eventTarget,
canceled: false,
stopped: false,
immediateStopped: false,
passiveListener: null,
timeStamp: event.timeStamp || Date.now(),
});
// https://heycam.github.io/webidl/#Unforgeable
Object.defineProperty(this, "isTrusted", { value: false, enumerable: true });
// Define accessors
const keys = Object.keys(event);
for (let i = 0; i < keys.length; ++i) {
const key = keys[i];
if (!(key in this)) {
Object.defineProperty(this, key, defineRedirectDescriptor(key));
}
}
}
// Should be enumerable, but class methods are not enumerable.
Event.prototype = {
/**
* The type of this event.
* @type {string}
*/
get type() {
return pd(this).event.type
},
/**
* The target of this event.
* @type {EventTarget}
*/
get target() {
return pd(this).eventTarget
},
/**
* The target of this event.
* @type {EventTarget}
*/
get currentTarget() {
return pd(this).currentTarget
},
/**
* @returns {EventTarget[]} The composed path of this event.
*/
composedPath() {
const currentTarget = pd(this).currentTarget;
if (currentTarget == null) {
return []
}
return [currentTarget]
},
/**
* Constant of NONE.
* @type {number}
*/
get NONE() {
return 0
},
/**
* Constant of CAPTURING_PHASE.
* @type {number}
*/
get CAPTURING_PHASE() {
return 1
},
/**
* Constant of AT_TARGET.
* @type {number}
*/
get AT_TARGET() {
return 2
},
/**
* Constant of BUBBLING_PHASE.
* @type {number}
*/
get BUBBLING_PHASE() {
return 3
},
/**
* The target of this event.
* @type {number}
*/
get eventPhase() {
return pd(this).eventPhase
},
/**
* Stop event bubbling.
* @returns {void}
*/
stopPropagation() {
const data = pd(this);
data.stopped = true;
if (typeof data.event.stopPropagation === "function") {
data.event.stopPropagation();
}
},
/**
* Stop event bubbling.
* @returns {void}
*/
stopImmediatePropagation() {
const data = pd(this);
data.stopped = true;
data.immediateStopped = true;
if (typeof data.event.stopImmediatePropagation === "function") {
data.event.stopImmediatePropagation();
}
},
/**
* The flag to be bubbling.
* @type {boolean}
*/
get bubbles() {
return Boolean(pd(this).event.bubbles)
},
/**
* The flag to be cancelable.
* @type {boolean}
*/
get cancelable() {
return Boolean(pd(this).event.cancelable)
},
/**
* Cancel this event.
* @returns {void}
*/
preventDefault() {
setCancelFlag(pd(this));
},
/**
* The flag to indicate cancellation state.
* @type {boolean}
*/
get defaultPrevented() {
return pd(this).canceled
},
/**
* The flag to be composed.
* @type {boolean}
*/
get composed() {
return Boolean(pd(this).event.composed)
},
/**
* The unix time of this event.
* @type {number}
*/
get timeStamp() {
return pd(this).timeStamp
},
/**
* The target of this event.
* @type {EventTarget}
* @deprecated
*/
get srcElement() {
return pd(this).eventTarget
},
/**
* The flag to stop event bubbling.
* @type {boolean}
* @deprecated
*/
get cancelBubble() {
return pd(this).stopped
},
set cancelBubble(value) {
if (!value) {
return
}
const data = pd(this);
data.stopped = true;
if (typeof data.event.cancelBubble === "boolean") {
data.event.cancelBubble = true;
}
},
/**
* The flag to indicate cancellation state.
* @type {boolean}
* @deprecated
*/
get returnValue() {
return !pd(this).canceled
},
set returnValue(value) {
if (!value) {
setCancelFlag(pd(this));
}
},
/**
* Initialize this event object. But do nothing under event dispatching.
* @param {string} type The event type.
* @param {boolean} [bubbles=false] The flag to be possible to bubble up.
* @param {boolean} [cancelable=false] The flag to be possible to cancel.
* @deprecated
*/
initEvent() {
// Do nothing.
},
};
// `constructor` is not enumerable.
Object.defineProperty(Event.prototype, "constructor", {
value: Event,
configurable: true,
writable: true,
});
// Ensure `event instanceof window.Event` is `true`.
if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
Object.setPrototypeOf(Event.prototype, window.Event.prototype);
// Make association for wrappers.
wrappers.set(window.Event.prototype, Event);
}
/**
* Get the property descriptor to redirect a given property.
* @param {string} key Property name to define property descriptor.
* @returns {PropertyDescriptor} The property descriptor to redirect the property.
* @private
*/
function defineRedirectDescriptor(key) {
return {
get() {
return pd(this).event[key]
},
set(value) {
pd(this).event[key] = value;
},
configurable: true,
enumerable: true,
}
}
/**
* Get the property descriptor to call a given method property.
* @param {string} key Property name to define property descriptor.
* @returns {PropertyDescriptor} The property descriptor to call the method property.
* @private
*/
function defineCallDescriptor(key) {
return {
value() {
const event = pd(this).event;
return event[key].apply(event, arguments)
},
configurable: true,
enumerable: true,
}
}
/**
* Define new wrapper class.
* @param {Function} BaseEvent The base wrapper class.
* @param {Object} proto The prototype of the original event.
* @returns {Function} The defined wrapper class.
* @private
*/
function defineWrapper(BaseEvent, proto) {
const keys = Object.keys(proto);
if (keys.length === 0) {
return BaseEvent
}
/** CustomEvent */
function CustomEvent(eventTarget, event) {
BaseEvent.call(this, eventTarget, event);
}
CustomEvent.prototype = Object.create(BaseEvent.prototype, {
constructor: { value: CustomEvent, configurable: true, writable: true },
});
// Define accessors.
for (let i = 0; i < keys.length; ++i) {
const key = keys[i];
if (!(key in BaseEvent.prototype)) {
const descriptor = Object.getOwnPropertyDescriptor(proto, key);
const isFunc = typeof descriptor.value === "function";
Object.defineProperty(
CustomEvent.prototype,
key,
isFunc
? defineCallDescriptor(key)
: defineRedirectDescriptor(key)
);
}
}
return CustomEvent
}
/**
* Get the wrapper class of a given prototype.
* @param {Object} proto The prototype of the original event to get its wrapper.
* @returns {Function} The wrapper class.
* @private
*/
function getWrapper(proto) {
if (proto == null || proto === Object.prototype) {
return Event
}
let wrapper = wrappers.get(proto);
if (wrapper == null) {
wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);
wrappers.set(proto, wrapper);
}
return wrapper
}
/**
* Wrap a given event to management a dispatching.
* @param {EventTarget} eventTarget The event target of this dispatching.
* @param {Object} event The event to wrap.
* @returns {Event} The wrapper instance.
* @private
*/
function wrapEvent(eventTarget, event) {
const Wrapper = getWrapper(Object.getPrototypeOf(event));
return new Wrapper(eventTarget, event)
}
/**
* Get the immediateStopped flag of a given event.
* @param {Event} event The event to get.
* @returns {boolean} The flag to stop propagation immediately.
* @private
*/
function isStopped(event) {
return pd(event).immediateStopped
}
/**
* Set the current event phase of a given event.
* @param {Event} event The event to set current target.
* @param {number} eventPhase New event phase.
* @returns {void}
* @private
*/
function setEventPhase(event, eventPhase) {
pd(event).eventPhase = eventPhase;
}
/**
* Set the current target of a given event.
* @param {Event} event The event to set current target.
* @param {EventTarget|null} currentTarget New current target.
* @returns {void}
* @private
*/
function setCurrentTarget(event, currentTarget) {
pd(event).currentTarget = currentTarget;
}
/**
* Set a passive listener of a given event.
* @param {Event} event The event to set current target.
* @param {Function|null} passiveListener New passive listener.
* @returns {void}
* @private
*/
function setPassiveListener(event, passiveListener) {
pd(event).passiveListener = passiveListener;
}
/**
* @typedef {object} ListenerNode
* @property {Function} listener
* @property {1|2|3} listenerType
* @property {boolean} passive
* @property {boolean} once
* @property {ListenerNode|null} next
* @private
*/
/**
* @type {WeakMap<object, Map<string, ListenerNode>>}
* @private
*/
const listenersMap = new WeakMap();
// Listener types
const CAPTURE = 1;
const BUBBLE = 2;
const ATTRIBUTE = 3;
/**
* Check whether a given value is an object or not.
* @param {any} x The value to check.
* @returns {boolean} `true` if the value is an object.
*/
function isObject(x) {
return x !== null && typeof x === "object" //eslint-disable-line no-restricted-syntax
}
/**
* Get listeners.
* @param {EventTarget} eventTarget The event target to get.
* @returns {Map<string, ListenerNode>} The listeners.
* @private
*/
function getListeners(eventTarget) {
const listeners = listenersMap.get(eventTarget);
if (listeners == null) {
throw new TypeError(
"'this' is expected an EventTarget object, but got another value."
)
}
return listeners
}
/**
* Get the property descriptor for the event attribute of a given event.
* @param {string} eventName The event name to get property descriptor.
* @returns {PropertyDescriptor} The property descriptor.
* @private
*/
function defineEventAttributeDescriptor(eventName) {
return {
get() {
const listeners = getListeners(this);
let node = listeners.get(eventName);
while (node != null) {
if (node.listenerType === ATTRIBUTE) {
return node.listener
}
node = node.next;
}
return null
},
set(listener) {
if (typeof listener !== "function" && !isObject(listener)) {
listener = null; // eslint-disable-line no-param-reassign
}
const listeners = getListeners(this);
// Traverse to the tail while removing old value.
let prev = null;
let node = listeners.get(eventName);
while (node != null) {
if (node.listenerType === ATTRIBUTE) {
// Remove old value.
if (prev !== null) {
prev.next = node.next;
} else if (node.next !== null) {
listeners.set(eventName, node.next);
} else {
listeners.delete(eventName);
}
} else {
prev = node;
}
node = node.next;
}
// Add new value.
if (listener !== null) {
const newNode = {
listener,
listenerType: ATTRIBUTE,
passive: false,
once: false,
next: null,
};
if (prev === null) {
listeners.set(eventName, newNode);
} else {
prev.next = newNode;
}
}
},
configurable: true,
enumerable: true,
}
}
/**
* Define an event attribute (e.g. `eventTarget.onclick`).
* @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.
* @param {string} eventName The event name to define.
* @returns {void}
*/
function defineEventAttribute(eventTargetPrototype, eventName) {
Object.defineProperty(
eventTargetPrototype,
`on${eventName}`,
defineEventAttributeDescriptor(eventName)
);
}
/**
* Define a custom EventTarget with event attributes.
* @param {string[]} eventNames Event names for event attributes.
* @returns {EventTarget} The custom EventTarget.
* @private
*/
function defineCustomEventTarget(eventNames) {
/** CustomEventTarget */
function CustomEventTarget() {
EventTarget.call(this);
}
CustomEventTarget.prototype = Object.create(EventTarget.prototype, {
constructor: {
value: CustomEventTarget,
configurable: true,
writable: true,
},
});
for (let i = 0; i < eventNames.length; ++i) {
defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);
}
return CustomEventTarget
}
/**
* EventTarget.
*
* - This is constructor if no arguments.
* - This is a function which returns a CustomEventTarget constructor if there are arguments.
*
* For example:
*
* class A extends EventTarget {}
* class B extends EventTarget("message") {}
* class C extends EventTarget("message", "error") {}
* class D extends EventTarget(["message", "error"]) {}
*/
function EventTarget() {
/*eslint-disable consistent-return */
if (this instanceof EventTarget) {
listenersMap.set(this, new Map());
return
}
if (arguments.length === 1 && Array.isArray(arguments[0])) {
return defineCustomEventTarget(arguments[0])
}
if (arguments.length > 0) {
const types = new Array(arguments.length);
for (let i = 0; i < arguments.length; ++i) {
types[i] = arguments[i];
}
return defineCustomEventTarget(types)
}
throw new TypeError("Cannot call a class as a function")
/*eslint-enable consistent-return */
}
// Should be enumerable, but class methods are not enumerable.
EventTarget.prototype = {
/**
* Add a given listener to this event target.
* @param {string} eventName The event name to add.
* @param {Function} listener The listener to add.
* @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
* @returns {void}
*/
addEventListener(eventName, listener, options) {
if (listener == null) {
return
}
if (typeof listener !== "function" && !isObject(listener)) {
throw new TypeError("'listener' should be a function or an object.")
}
const listeners = getListeners(this);
const optionsIsObj = isObject(options);
const capture = optionsIsObj
? Boolean(options.capture)
: Boolean(options);
const listenerType = capture ? CAPTURE : BUBBLE;
const newNode = {
listener,
listenerType,
passive: optionsIsObj && Boolean(options.passive),
once: optionsIsObj && Boolean(options.once),
next: null,
};
// Set it as the first node if the first node is null.
let node = listeners.get(eventName);
if (node === undefined) {
listeners.set(eventName, newNode);
return
}
// Traverse to the tail while checking duplication..
let prev = null;
while (node != null) {
if (
node.listener === listener &&
node.listenerType === listenerType
) {
// Should ignore duplication.
return
}
prev = node;
node = node.next;
}
// Add it.
prev.next = newNode;
},
/**
* Remove a given listener from this event target.
* @param {string} eventName The event name to remove.
* @param {Function} listener The listener to remove.
* @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.
* @returns {void}
*/
removeEventListener(eventName, listener, options) {
if (listener == null) {
return
}
const listeners = getListeners(this);
const capture = isObject(options)
? Boolean(options.capture)
: Boolean(options);
const listenerType = capture ? CAPTURE : BUBBLE;
let prev = null;
let node = listeners.get(eventName);
while (node != null) {
if (
node.listener === listener &&
node.listenerType === listenerType
) {
if (prev !== null) {
prev.next = node.next;
} else if (node.next !== null) {
listeners.set(eventName, node.next);
} else {
listeners.delete(eventName);
}
return
}
prev = node;
node = node.next;
}
},
/**
* Dispatch a given event.
* @param {Event|{type:string}} event The event to dispatch.
* @returns {boolean} `false` if canceled.
*/
dispatchEvent(event) {
if (event == null || typeof event.type !== "string") {
throw new TypeError('"event.type" should be a string.')
}
// If listeners aren't registered, terminate.
const listeners = getListeners(this);
const eventName = event.type;
let node = listeners.get(eventName);
if (node == null) {
return true
}
// Since we cannot rewrite several properties, so wrap object.
const wrappedEvent = wrapEvent(this, event);
// This doesn't process capturing phase and bubbling phase.
// This isn't participating in a tree.
let prev = null;
while (node != null) {
// Remove this listener if it's once
if (node.once) {
if (prev !== null) {
prev.next = node.next;
} else if (node.next !== null) {
listeners.set(eventName, node.next);
} else {
listeners.delete(eventName);
}
} else {
prev = node;
}
// Call this listener
setPassiveListener(
wrappedEvent,
node.passive ? node.listener : null
);
if (typeof node.listener === "function") {
try {
node.listener.call(this, wrappedEvent);
} catch (err) {
if (
typeof console !== "undefined" &&
typeof console.error === "function"
) {
console.error(err);
}
}
} else if (
node.listenerType !== ATTRIBUTE &&
typeof node.listener.handleEvent === "function"
) {
node.listener.handleEvent(wrappedEvent);
}
// Break if `event.stopImmediatePropagation` was called.
if (isStopped(wrappedEvent)) {
break
}
node = node.next;
}
setPassiveListener(wrappedEvent, null);
setEventPhase(wrappedEvent, 0);
setCurrentTarget(wrappedEvent, null);
return !wrappedEvent.defaultPrevented
},
};
// `constructor` is not enumerable.
Object.defineProperty(EventTarget.prototype, "constructor", {
value: EventTarget,
configurable: true,
writable: true,
});
// Ensure `eventTarget instanceof window.EventTarget` is `true`.
if (
typeof window !== "undefined" &&
typeof window.EventTarget !== "undefined"
) {
Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
}
/**
* @author Toru Nagashima <https://github.com/mysticatea>
* See LICENSE file in root directory for full license.
*/
/**
* The signal class.
* @see https://dom.spec.whatwg.org/#abortsignal
*/
class AbortSignal extends EventTarget {
/**
* AbortSignal cannot be constructed directly.
*/
constructor() {
super();
throw new TypeError("AbortSignal cannot be constructed directly");
}
/**
* Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
*/
get aborted() {
const aborted = abortedFlags.get(this);
if (typeof aborted !== "boolean") {
throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? "null" : typeof this}`);
}
return aborted;
}
}
defineEventAttribute(AbortSignal.prototype, "abort");
/**
* Create an AbortSignal object.
*/
function createAbortSignal() {
const signal = Object.create(AbortSignal.prototype);
EventTarget.call(signal);
abortedFlags.set(signal, false);
return signal;
}
/**
* Abort a given signal.
*/
function abortSignal(signal) {
if (abortedFlags.get(signal) !== false) {
return;
}
abortedFlags.set(signal, true);
signal.dispatchEvent({ type: "abort" });
}
/**
* Aborted flag for each instances.
*/
const abortedFlags = new WeakMap();
// Properties should be enumerable.
Object.defineProperties(AbortSignal.prototype, {
aborted: { enumerable: true },
});
// `toString()` should return `"[object AbortSignal]"`
if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {
configurable: true,
value: "AbortSignal",
});
}
/**
* The AbortController.
* @see https://dom.spec.whatwg.org/#abortcontroller
*/
class AbortController {
/**
* Initialize this controller.
*/
constructor() {
signals.set(this, createAbortSignal());
}
/**
* Returns the `AbortSignal` object associated with this object.
*/
get signal() {
return getSignal(this);
}
/**
* Abort and signal to any observers that the associated activity is to be aborted.
*/
abort() {
abortSignal(getSignal(this));
}
}
/**
* Associated signals.
*/
const signals = new WeakMap();
/**
* Get the associated signal of a given controller.
*/
function getSignal(controller) {
const signal = signals.get(controller);
if (signal == null) {
throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? "null" : typeof controller}`);
}
return signal;
}
// Properties should be enumerable.
Object.defineProperties(AbortController.prototype, {
signal: { enumerable: true },
abort: { enumerable: true },
});
if (typeof Symbol === "function" && typeof Symbol.toStringTag === "symbol") {
Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {
configurable: true,
value: "AbortController",
});
}
var abortController = /*#__PURE__*/Object.freeze({
__proto__: null,
'default': AbortController,
AbortController: AbortController,
AbortSignal: AbortSignal
});
var require$$9 = /*@__PURE__*/getAugmentedNamespace(abortController);
var errors;
var hasRequiredErrors;
function requireErrors () {
if (hasRequiredErrors) return errors;
hasRequiredErrors = 1;
const { format, inspect, AggregateError: CustomAggregateError } = requireUtil();
/*
This file is a reduced and adapted version of the main lib/internal/errors.js file defined at
https://github.com/nodejs/node/blob/master/lib/internal/errors.js
Don't try to replace with the original file and keep it up to date (starting from E(...) definitions)
with the upstream file.
*/
const AggregateError = globalThis.AggregateError || CustomAggregateError;
const kIsNodeError = Symbol('kIsNodeError');
const kTypes = [
'string',
'function',
'number',
'object',
// Accept 'Function' and 'Object' as alternative to the lower cased version.
'Function',
'Object',
'boolean',
'bigint',
'symbol'
];
const classRegExp = /^([A-Z][a-z0-9]*)+$/;
const nodeInternalPrefix = '__node_internal_';
const codes = {};
function assert(value, message) {
if (!value) {
throw new codes.ERR_INTERNAL_ASSERTION(message)
}
}
// Only use this for integers! Decimal numbers do not work with this function.
function addNumericalSeparator(val) {
let res = '';
let i = val.length;
const start = val[0] === '-' ? 1 : 0;
for (; i >= start + 4; i -= 3) {
res = `_${val.slice(i - 3, i)}${res}`;
}
return `${val.slice(0, i)}${res}`
}
function getMessage(key, msg, args) {
if (typeof msg === 'function') {
assert(
msg.length <= args.length,
// Default options do not count.
`Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).`
);
return msg(...args)
}
const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length;
assert(
expectedLength === args.length,
`Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
);
if (args.length === 0) {
return msg
}
return format(msg, ...args)
}
function E(code, message, Base) {
if (!Base) {
Base = Error;
}
class NodeError extends Base {
constructor(...args) {
super(getMessage(code, message, args));
}
toString() {
return `${this.name} [${code}]: ${this.message}`
}
}
Object.defineProperties(NodeError.prototype, {
name: {
value: Base.name,
writable: true,
enumerable: false,
configurable: true
},
toString: {
value() {
return `${this.name} [${code}]: ${this.message}`
},
writable: true,
enumerable: false,
configurable: true
}
});
NodeError.prototype.code = code;
NodeError.prototype[kIsNodeError] = true;
codes[code] = NodeError;
}
function hideStackFrames(fn) {
// We rename the functions that will be hidden to cut off the stacktrace
// at the outermost one
const hidden = nodeInternalPrefix + fn.name;
Object.defineProperty(fn, 'name', {
value: hidden
});
return fn
}
function aggregateTwoErrors(innerError, outerError) {
if (innerError && outerError && innerError !== outerError) {
if (Array.isArray(outerError.errors)) {
// If `outerError` is already an `AggregateError`.
outerError.errors.push(innerError);
return outerError
}
const err = new AggregateError([outerError, innerError], outerError.message);
err.code = outerError.code;
return err
}
return innerError || outerError
}
class AbortError extends Error {
constructor(message = 'The operation was aborted', options = undefined) {
if (options !== undefined && typeof options !== 'object') {
throw new codes.ERR_INVALID_ARG_TYPE('options', 'Object', options)
}
super(message, options);
this.code = 'ABORT_ERR';
this.name = 'AbortError';
}
}
E('ERR_ASSERTION', '%s', Error);
E(
'ERR_INVALID_ARG_TYPE',
(name, expected, actual) => {
assert(typeof name === 'string', "'name' must be a string");
if (!Array.isArray(expected)) {
expected = [expected];
}
let msg = 'The ';
if (name.endsWith(' argument')) {
// For cases like 'first argument'
msg += `${name} `;
} else {
msg += `"${name}" ${name.includes('.') ? 'property' : 'argument'} `;
}
msg += 'must be ';
const types = [];
const instances = [];
const other = [];
for (const value of expected) {
assert(typeof value === 'string', 'All expected entries have to be of type string');
if (kTypes.includes(value)) {
types.push(value.toLowerCase());
} else if (classRegExp.test(value)) {
instances.push(value);
} else {
assert(value !== 'object', 'The value "object" should be written as "Object"');
other.push(value);
}
}
// Special handle `object` in case other instances are allowed to outline
// the differences between each other.
if (instances.length > 0) {
const pos = types.indexOf('object');
if (pos !== -1) {
types.splice(types, pos, 1);
instances.push('Object');
}
}
if (types.length > 0) {
switch (types.length) {
case 1:
msg += `of type ${types[0]}`;
break
case 2:
msg += `one of type ${types[0]} or ${types[1]}`;
break
default: {
const last = types.pop();
msg += `one of type ${types.join(', ')}, or ${last}`;
}
}
if (instances.length > 0 || other.length > 0) {
msg += ' or ';
}
}
if (instances.length > 0) {
switch (instances.length) {
case 1:
msg += `an instance of ${instances[0]}`;
break
case 2:
msg += `an instance of ${instances[0]} or ${instances[1]}`;
break
default: {
const last = instances.pop();
msg += `an instance of ${instances.join(', ')}, or ${last}`;
}
}
if (other.length > 0) {
msg += ' or ';
}
}
switch (other.length) {
case 0:
break
case 1:
if (other[0].toLowerCase() !== other[0]) {
msg += 'an ';
}
msg += `${other[0]}`;
break
case 2:
msg += `one of ${other[0]} or ${other[1]}`;
break
default: {
const last = other.pop();
msg += `one of ${other.join(', ')}, or ${last}`;
}
}
if (actual == null) {
msg += `. Received ${actual}`;
} else if (typeof actual === 'function' && actual.name) {
msg += `. Received function ${actual.name}`;
} else if (typeof actual === 'object') {
var _actual$constructor;
if (
(_actual$constructor = actual.constructor) !== null &&
_actual$constructor !== undefined &&
_actual$constructor.name
) {
msg += `. Received an instance of ${actual.constructor.name}`;
} else {
const inspected = inspect(actual, {
depth: -1
});
msg += `. Received ${inspected}`;
}
} else {
let inspected = inspect(actual, {
colors: false
});
if (inspected.length > 25) {
inspected = `${inspected.slice(0, 25)}...`;
}
msg += `. Received type ${typeof actual} (${inspected})`;
}
return msg
},
TypeError
);
E(
'ERR_INVALID_ARG_VALUE',
(name, value, reason = 'is invalid') => {
let inspected = inspect(value);
if (inspected.length > 128) {
inspected = inspected.slice(0, 128) + '...';
}
const type = name.includes('.') ? 'property' : 'argument';
return `The ${type} '${name}' ${reason}. Received ${inspected}`
},
TypeError
);
E(
'ERR_INVALID_RETURN_VALUE',
(input, name, value) => {
var _value$constructor;
const type =
value !== null &&
value !== undefined &&
(_value$constructor = value.constructor) !== null &&
_value$constructor !== undefined &&
_value$constructor.name
? `instance of ${value.constructor.name}`
: `type ${typeof value}`;
return `Expected ${input} to be returned from the "${name}"` + ` function but got ${type}.`
},
TypeError
);
E(
'ERR_MISSING_ARGS',
(...args) => {
assert(args.length > 0, 'At least one arg needs to be specified');
let msg;
const len = args.length;
args = (Array.isArray(args) ? args : [args]).map((a) => `"${a}"`).join(' or ');
switch (len) {
case 1:
msg += `The ${args[0]} argument`;
break
case 2:
msg += `The ${args[0]} and ${args[1]} arguments`;
break
default:
{
const last = args.pop();
msg += `The ${args.join(', ')}, and ${last} arguments`;
}
break
}
return `${msg} must be specified`
},
TypeError
);
E(
'ERR_OUT_OF_RANGE',
(str, range, input) => {
assert(range, 'Missing "range" argument');
let received;
if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
received = addNumericalSeparator(String(input));
} else if (typeof input === 'bigint') {
received = String(input);
if (input > 2n ** 32n || input < -(2n ** 32n)) {
received = addNumericalSeparator(received);
}
received += 'n';
} else {
received = inspect(input);
}
return `The value of "${str}" is out of range. It must be ${range}. Received ${received}`
},
RangeError
);
E('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times', Error);
E('ERR_METHOD_NOT_IMPLEMENTED', 'The %s method is not implemented', Error);
E('ERR_STREAM_ALREADY_FINISHED', 'Cannot call %s after a stream was finished', Error);
E('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable', Error);
E('ERR_STREAM_DESTROYED', 'Cannot call %s after a stream was destroyed', Error);
E('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
E('ERR_STREAM_PREMATURE_CLOSE', 'Premature close', Error);
E('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF', Error);
E('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event', Error);
E('ERR_STREAM_WRITE_AFTER_END', 'write after end', Error);
E('ERR_UNKNOWN_ENCODING', 'Unknown encoding: %s', TypeError);
errors = {
AbortError,
aggregateTwoErrors: hideStackFrames(aggregateTwoErrors),
hideStackFrames,
codes
};
return errors;
}
var validators;
var hasRequiredValidators;
function requireValidators () {
if (hasRequiredValidators) return validators;
hasRequiredValidators = 1;
const {
ArrayIsArray,
ArrayPrototypeIncludes,
ArrayPrototypeJoin,
ArrayPrototypeMap,
NumberIsInteger,
NumberIsNaN,
NumberMAX_SAFE_INTEGER,
NumberMIN_SAFE_INTEGER,
NumberParseInt,
ObjectPrototypeHasOwnProperty,
RegExpPrototypeExec,
String,
StringPrototypeToUpperCase,
StringPrototypeTrim
} = requirePrimordials();
const {
hideStackFrames,
codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL }
} = requireErrors();
const { normalizeEncoding } = requireUtil();
const { isAsyncFunction, isArrayBufferView } = requireUtil().types;
const signals = {};
/**
* @param {*} value
* @returns {boolean}
*/
function isInt32(value) {
return value === (value | 0)
}
/**
* @param {*} value
* @returns {boolean}
*/
function isUint32(value) {
return value === value >>> 0
}
const octalReg = /^[0-7]+$/;
const modeDesc = 'must be a 32-bit unsigned integer or an octal string';
/**
* Parse and validate values that will be converted into mode_t (the S_*
* constants). Only valid numbers and octal strings are allowed. They could be
* converted to 32-bit unsigned integers or non-negative signed integers in the
* C++ land, but any value higher than 0o777 will result in platform-specific
* behaviors.
*
* @param {*} value Values to be validated
* @param {string} name Name of the argument
* @param {number} [def] If specified, will be returned for invalid values
* @returns {number}
*/
function parseFileMode(value, name, def) {
if (typeof value === 'undefined') {
value = def;
}
if (typeof value === 'string') {
if (RegExpPrototypeExec(octalReg, value) === null) {
throw new ERR_INVALID_ARG_VALUE(name, value, modeDesc)
}
value = NumberParseInt(value, 8);
}
validateUint32(value, name);
return value
}
/**
* @callback validateInteger
* @param {*} value
* @param {string} name
* @param {number} [min]
* @param {number} [max]
* @returns {asserts value is number}
*/
/** @type {validateInteger} */
const validateInteger = hideStackFrames((value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) => {
if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value)
if (!NumberIsInteger(value)) throw new ERR_OUT_OF_RANGE(name, 'an integer', value)
if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)
});
/**
* @callback validateInt32
* @param {*} value
* @param {string} name
* @param {number} [min]
* @param {number} [max]
* @returns {asserts value is number}
*/
/** @type {validateInt32} */
const validateInt32 = hideStackFrames((value, name, min = -2147483648, max = 2147483647) => {
// The defaults for min and max correspond to the limits of 32-bit integers.
if (typeof value !== 'number') {
throw new ERR_INVALID_ARG_TYPE(name, 'number', value)
}
if (!NumberIsInteger(value)) {
throw new ERR_OUT_OF_RANGE(name, 'an integer', value)
}
if (value < min || value > max) {
throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)
}
});
/**
* @callback validateUint32
* @param {*} value
* @param {string} name
* @param {number|boolean} [positive=false]
* @returns {asserts value is number}
*/
/** @type {validateUint32} */
const validateUint32 = hideStackFrames((value, name, positive = false) => {
if (typeof value !== 'number') {
throw new ERR_INVALID_ARG_TYPE(name, 'number', value)
}
if (!NumberIsInteger(value)) {
throw new ERR_OUT_OF_RANGE(name, 'an integer', value)
}
const min = positive ? 1 : 0;
// 2 ** 32 === 4294967296
const max = 4294967295;
if (value < min || value > max) {
throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)
}
});
/**
* @callback validateString
* @param {*} value
* @param {string} name
* @returns {asserts value is string}
*/
/** @type {validateString} */
function validateString(value, name) {
if (typeof value !== 'string') throw new ERR_INVALID_ARG_TYPE(name, 'string', value)
}
/**
* @callback validateNumber
* @param {*} value
* @param {string} name
* @param {number} [min]
* @param {number} [max]
* @returns {asserts value is number}
*/
/** @type {validateNumber} */
function validateNumber(value, name, min = undefined, max) {
if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value)
if (
(min != null && value < min) ||
(max != null && value > max) ||
((min != null || max != null) && NumberIsNaN(value))
) {
throw new ERR_OUT_OF_RANGE(
name,
`${min != null ? `>= ${min}` : ''}${min != null && max != null ? ' && ' : ''}${max != null ? `<= ${max}` : ''}`,
value
)
}
}
/**
* @callback validateOneOf
* @template T
* @param {T} value
* @param {string} name
* @param {T[]} oneOf
*/
/** @type {validateOneOf} */
const validateOneOf = hideStackFrames((value, name, oneOf) => {
if (!ArrayPrototypeIncludes(oneOf, value)) {
const allowed = ArrayPrototypeJoin(
ArrayPrototypeMap(oneOf, (v) => (typeof v === 'string' ? `'${v}'` : String(v))),
', '
);
const reason = 'must be one of: ' + allowed;
throw new ERR_INVALID_ARG_VALUE(name, value, reason)
}
});
/**
* @callback validateBoolean
* @param {*} value
* @param {string} name
* @returns {asserts value is boolean}
*/
/** @type {validateBoolean} */
function validateBoolean(value, name) {
if (typeof value !== 'boolean') throw new ERR_INVALID_ARG_TYPE(name, 'boolean', value)
}
function getOwnPropertyValueOrDefault(options, key, defaultValue) {
return options == null || !ObjectPrototypeHasOwnProperty(options, key) ? defaultValue : options[key]
}
/**
* @callback validateObject
* @param {*} value
* @param {string} name
* @param {{
* allowArray?: boolean,
* allowFunction?: boolean,
* nullable?: boolean
* }} [options]
*/
/** @type {validateObject} */
const validateObject = hideStackFrames((value, name, options = null) => {
const allowArray = getOwnPropertyValueOrDefault(options, 'allowArray', false);
const allowFunction = getOwnPropertyValueOrDefault(options, 'allowFunction', false);
const nullable = getOwnPropertyValueOrDefault(options, 'nullable', false);
if (
(!nullable && value === null) ||
(!allowArray && ArrayIsArray(value)) ||
(typeof value !== 'object' && (!allowFunction || typeof value !== 'function'))
) {
throw new ERR_INVALID_ARG_TYPE(name, 'Object', value)
}
});
/**
* @callback validateArray
* @param {*} value
* @param {string} name
* @param {number} [minLength]
* @returns {asserts value is any[]}
*/
/** @type {validateArray} */
const validateArray = hideStackFrames((value, name, minLength = 0) => {
if (!ArrayIsArray(value)) {
throw new ERR_INVALID_ARG_TYPE(name, 'Array', value)
}
if (value.length < minLength) {
const reason = `must be longer than ${minLength}`;
throw new ERR_INVALID_ARG_VALUE(name, value, reason)
}
});
// eslint-disable-next-line jsdoc/require-returns-check
/**
* @param {*} signal
* @param {string} [name='signal']
* @returns {asserts signal is keyof signals}
*/
function validateSignalName(signal, name = 'signal') {
validateString(signal, name);
if (signals[signal] === undefined) {
if (signals[StringPrototypeToUpperCase(signal)] !== undefined) {
throw new ERR_UNKNOWN_SIGNAL(signal + ' (signals must use all capital letters)')
}
throw new ERR_UNKNOWN_SIGNAL(signal)
}
}
/**
* @callback validateBuffer
* @param {*} buffer
* @param {string} [name='buffer']
* @returns {asserts buffer is ArrayBufferView}
*/
/** @type {validateBuffer} */
const validateBuffer = hideStackFrames((buffer, name = 'buffer') => {
if (!isArrayBufferView(buffer)) {
throw new ERR_INVALID_ARG_TYPE(name, ['Buffer', 'TypedArray', 'DataView'], buffer)
}
});
/**
* @param {string} data
* @param {string} encoding
*/
function validateEncoding(data, encoding) {
const normalizedEncoding = normalizeEncoding(encoding);
const length = data.length;
if (normalizedEncoding === 'hex' && length % 2 !== 0) {
throw new ERR_INVALID_ARG_VALUE('encoding', encoding, `is invalid for data of length ${length}`)
}
}
/**
* Check that the port number is not NaN when coerced to a number,
* is an integer and that it falls within the legal range of port numbers.
* @param {*} port
* @param {string} [name='Port']
* @param {boolean} [allowZero=true]
* @returns {number}
*/
function validatePort(port, name = 'Port', allowZero = true) {
if (
(typeof port !== 'number' && typeof port !== 'string') ||
(typeof port === 'string' && StringPrototypeTrim(port).length === 0) ||
+port !== +port >>> 0 ||
port > 0xffff ||
(port === 0 && !allowZero)
) {
throw new ERR_SOCKET_BAD_PORT(name, port, allowZero)
}
return port | 0
}
/**
* @callback validateAbortSignal
* @param {*} signal
* @param {string} name
*/
/** @type {validateAbortSignal} */
const validateAbortSignal = hideStackFrames((signal, name) => {
if (signal !== undefined && (signal === null || typeof signal !== 'object' || !('aborted' in signal))) {
throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal)
}
});
/**
* @callback validateFunction
* @param {*} value
* @param {string} name
* @returns {asserts value is Function}
*/
/** @type {validateFunction} */
const validateFunction = hideStackFrames((value, name) => {
if (typeof value !== 'function') throw new ERR_INVALID_ARG_TYPE(name, 'Function', value)
});
/**
* @callback validatePlainFunction
* @param {*} value
* @param {string} name
* @returns {asserts value is Function}
*/
/** @type {validatePlainFunction} */
const validatePlainFunction = hideStackFrames((value, name) => {
if (typeof value !== 'function' || isAsyncFunction(value)) throw new ERR_INVALID_ARG_TYPE(name, 'Function', value)
});
/**
* @callback validateUndefined
* @param {*} value
* @param {string} name
* @returns {asserts value is undefined}
*/
/** @type {validateUndefined} */
const validateUndefined = hideStackFrames((value, name) => {
if (value !== undefined) throw new ERR_INVALID_ARG_TYPE(name, 'undefined', value)
});
/**
* @template T
* @param {T} value
* @param {string} name
* @param {T[]} union
*/
function validateUnion(value, name, union) {
if (!ArrayPrototypeIncludes(union, value)) {
throw new ERR_INVALID_ARG_TYPE(name, `('${ArrayPrototypeJoin(union, '|')}')`, value)
}
}
validators = {
isInt32,
isUint32,
parseFileMode,
validateArray,
validateBoolean,
validateBuffer,
validateEncoding,
validateFunction,
validateInt32,
validateInteger,
validateNumber,
validateObject,
validateOneOf,
validatePlainFunction,
validatePort,
validateSignalName,
validateString,
validateUint32,
validateUndefined,
validateUnion,
validateAbortSignal
};
return validators;
}
var endOfStream = {exports: {}};
var process$1;
var hasRequiredProcess;
function requireProcess () {
if (hasRequiredProcess) return process$1;
hasRequiredProcess = 1;
// for now just expose the builtin process global from node.js
process$1 = commonjsGlobal.process;
return process$1;
}
var utils;
var hasRequiredUtils;
function requireUtils () {
if (hasRequiredUtils) return utils;
hasRequiredUtils = 1;
const { Symbol, SymbolAsyncIterator, SymbolIterator } = requirePrimordials();
const kDestroyed = Symbol('kDestroyed');
const kIsErrored = Symbol('kIsErrored');
const kIsReadable = Symbol('kIsReadable');
const kIsDisturbed = Symbol('kIsDisturbed');
function isReadableNodeStream(obj, strict = false) {
var _obj$_readableState;
return !!(
(
obj &&
typeof obj.pipe === 'function' &&
typeof obj.on === 'function' &&
(!strict || (typeof obj.pause === 'function' && typeof obj.resume === 'function')) &&
(!obj._writableState ||
((_obj$_readableState = obj._readableState) === null || _obj$_readableState === undefined
? undefined
: _obj$_readableState.readable) !== false) &&
// Duplex
(!obj._writableState || obj._readableState)
) // Writable has .pipe.
)
}
function isWritableNodeStream(obj) {
var _obj$_writableState;
return !!(
(
obj &&
typeof obj.write === 'function' &&
typeof obj.on === 'function' &&
(!obj._readableState ||
((_obj$_writableState = obj._writableState) === null || _obj$_writableState === undefined
? undefined
: _obj$_writableState.writable) !== false)
) // Duplex
)
}
function isDuplexNodeStream(obj) {
return !!(
obj &&
typeof obj.pipe === 'function' &&
obj._readableState &&
typeof obj.on === 'function' &&
typeof obj.write === 'function'
)
}
function isNodeStream(obj) {
return (
obj &&
(obj._readableState ||
obj._writableState ||
(typeof obj.write === 'function' && typeof obj.on === 'function') ||
(typeof obj.pipe === 'function' && typeof obj.on === 'function'))
)
}
function isIterable(obj, isAsync) {
if (obj == null) return false
if (isAsync === true) return typeof obj[SymbolAsyncIterator] === 'function'
if (isAsync === false) return typeof obj[SymbolIterator] === 'function'
return typeof obj[SymbolAsyncIterator] === 'function' || typeof obj[SymbolIterator] === 'function'
}
function isDestroyed(stream) {
if (!isNodeStream(stream)) return null
const wState = stream._writableState;
const rState = stream._readableState;
const state = wState || rState;
return !!(stream.destroyed || stream[kDestroyed] || (state !== null && state !== undefined && state.destroyed))
}
// Have been end():d.
function isWritableEnded(stream) {
if (!isWritableNodeStream(stream)) return null
if (stream.writableEnded === true) return true
const wState = stream._writableState;
if (wState !== null && wState !== undefined && wState.errored) return false
if (typeof (wState === null || wState === undefined ? undefined : wState.ended) !== 'boolean') return null
return wState.ended
}
// Have emitted 'finish'.
function isWritableFinished(stream, strict) {
if (!isWritableNodeStream(stream)) return null
if (stream.writableFinished === true) return true
const wState = stream._writableState;
if (wState !== null && wState !== undefined && wState.errored) return false
if (typeof (wState === null || wState === undefined ? undefined : wState.finished) !== 'boolean') return null
return !!(wState.finished || (strict === false && wState.ended === true && wState.length === 0))
}
// Have been push(null):d.
function isReadableEnded(stream) {
if (!isReadableNodeStream(stream)) return null
if (stream.readableEnded === true) return true
const rState = stream._readableState;
if (!rState || rState.errored) return false
if (typeof (rState === null || rState === undefined ? undefined : rState.ended) !== 'boolean') return null
return rState.ended
}
// Have emitted 'end'.
function isReadableFinished(stream, strict) {
if (!isReadableNodeStream(stream)) return null
const rState = stream._readableState;
if (rState !== null && rState !== undefined && rState.errored) return false
if (typeof (rState === null || rState === undefined ? undefined : rState.endEmitted) !== 'boolean') return null
return !!(rState.endEmitted || (strict === false && rState.ended === true && rState.length === 0))
}
function isReadable(stream) {
if (stream && stream[kIsReadable] != null) return stream[kIsReadable]
if (typeof (stream === null || stream === undefined ? undefined : stream.readable) !== 'boolean') return null
if (isDestroyed(stream)) return false
return isReadableNodeStream(stream) && stream.readable && !isReadableFinished(stream)
}
function isWritable(stream) {
if (typeof (stream === null || stream === undefined ? undefined : stream.writable) !== 'boolean') return null
if (isDestroyed(stream)) return false
return isWritableNodeStream(stream) && stream.writable && !isWritableEnded(stream)
}
function isFinished(stream, opts) {
if (!isNodeStream(stream)) {
return null
}
if (isDestroyed(stream)) {
return true
}
if ((opts === null || opts === undefined ? undefined : opts.readable) !== false && isReadable(stream)) {
return false
}
if ((opts === null || opts === undefined ? undefined : opts.writable) !== false && isWritable(stream)) {
return false
}
return true
}
function isWritableErrored(stream) {
var _stream$_writableStat, _stream$_writableStat2;
if (!isNodeStream(stream)) {
return null
}
if (stream.writableErrored) {
return stream.writableErrored
}
return (_stream$_writableStat =
(_stream$_writableStat2 = stream._writableState) === null || _stream$_writableStat2 === undefined
? undefined
: _stream$_writableStat2.errored) !== null && _stream$_writableStat !== undefined
? _stream$_writableStat
: null
}
function isReadableErrored(stream) {
var _stream$_readableStat, _stream$_readableStat2;
if (!isNodeStream(stream)) {
return null
}
if (stream.readableErrored) {
return stream.readableErrored
}
return (_stream$_readableStat =
(_stream$_readableStat2 = stream._readableState) === null || _stream$_readableStat2 === undefined
? undefined
: _stream$_readableStat2.errored) !== null && _stream$_readableStat !== undefined
? _stream$_readableStat
: null
}
function isClosed(stream) {
if (!isNodeStream(stream)) {
return null
}
if (typeof stream.closed === 'boolean') {
return stream.closed
}
const wState = stream._writableState;
const rState = stream._readableState;
if (
typeof (wState === null || wState === undefined ? undefined : wState.closed) === 'boolean' ||
typeof (rState === null || rState === undefined ? undefined : rState.closed) === 'boolean'
) {
return (
(wState === null || wState === undefined ? undefined : wState.closed) ||
(rState === null || rState === undefined ? undefined : rState.closed)
)
}
if (typeof stream._closed === 'boolean' && isOutgoingMessage(stream)) {
return stream._closed
}
return null
}
function isOutgoingMessage(stream) {
return (
typeof stream._closed === 'boolean' &&
typeof stream._defaultKeepAlive === 'boolean' &&
typeof stream._removedConnection === 'boolean' &&
typeof stream._removedContLen === 'boolean'
)
}
function isServerResponse(stream) {
return typeof stream._sent100 === 'boolean' && isOutgoingMessage(stream)
}
function isServerRequest(stream) {
var _stream$req;
return (
typeof stream._consuming === 'boolean' &&
typeof stream._dumped === 'boolean' &&
((_stream$req = stream.req) === null || _stream$req === undefined ? undefined : _stream$req.upgradeOrConnect) ===
undefined
)
}
function willEmitClose(stream) {
if (!isNodeStream(stream)) return null
const wState = stream._writableState;
const rState = stream._readableState;
const state = wState || rState;
return (
(!state && isServerResponse(stream)) || !!(state && state.autoDestroy && state.emitClose && state.closed === false)
)
}
function isDisturbed(stream) {
var _stream$kIsDisturbed;
return !!(
stream &&
((_stream$kIsDisturbed = stream[kIsDisturbed]) !== null && _stream$kIsDisturbed !== undefined
? _stream$kIsDisturbed
: stream.readableDidRead || stream.readableAborted)
)
}
function isErrored(stream) {
var _ref,
_ref2,
_ref3,
_ref4,
_ref5,
_stream$kIsErrored,
_stream$_readableStat3,
_stream$_writableStat3,
_stream$_readableStat4,
_stream$_writableStat4;
return !!(
stream &&
((_ref =
(_ref2 =
(_ref3 =
(_ref4 =
(_ref5 =
(_stream$kIsErrored = stream[kIsErrored]) !== null && _stream$kIsErrored !== undefined
? _stream$kIsErrored
: stream.readableErrored) !== null && _ref5 !== undefined
? _ref5
: stream.writableErrored) !== null && _ref4 !== undefined
? _ref4
: (_stream$_readableStat3 = stream._readableState) === null || _stream$_readableStat3 === undefined
? undefined
: _stream$_readableStat3.errorEmitted) !== null && _ref3 !== undefined
? _ref3
: (_stream$_writableStat3 = stream._writableState) === null || _stream$_writableStat3 === undefined
? undefined
: _stream$_writableStat3.errorEmitted) !== null && _ref2 !== undefined
? _ref2
: (_stream$_readableStat4 = stream._readableState) === null || _stream$_readableStat4 === undefined
? undefined
: _stream$_readableStat4.errored) !== null && _ref !== undefined
? _ref
: (_stream$_writableStat4 = stream._writableState) === null || _stream$_writableStat4 === undefined
? undefined
: _stream$_writableStat4.errored)
)
}
utils = {
kDestroyed,
isDisturbed,
kIsDisturbed,
isErrored,
kIsErrored,
isReadable,
kIsReadable,
isClosed,
isDestroyed,
isDuplexNodeStream,
isFinished,
isIterable,
isReadableNodeStream,
isReadableEnded,
isReadableFinished,
isReadableErrored,
isNodeStream,
isWritable,
isWritableNodeStream,
isWritableEnded,
isWritableFinished,
isWritableErrored,
isServerRequest,
isServerResponse,
willEmitClose
};
return utils;
}
/* replacement start */
var hasRequiredEndOfStream;
function requireEndOfStream () {
if (hasRequiredEndOfStream) return endOfStream.exports;
hasRequiredEndOfStream = 1;
const process = requireProcess()
/* replacement end */
// Ported from https://github.com/mafintosh/end-of-stream with
// permission from the author, Mathias Buus (@mafintosh).
; const { AbortError, codes } = requireErrors();
const { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes;
const { kEmptyObject, once } = requireUtil();
const { validateAbortSignal, validateFunction, validateObject } = requireValidators();
const { Promise } = requirePrimordials();
const {
isClosed,
isReadable,
isReadableNodeStream,
isReadableFinished,
isReadableErrored,
isWritable,
isWritableNodeStream,
isWritableFinished,
isWritableErrored,
isNodeStream,
willEmitClose: _willEmitClose
} = requireUtils();
function isRequest(stream) {
return stream.setHeader && typeof stream.abort === 'function'
}
const nop = () => {};
function eos(stream, options, callback) {
var _options$readable, _options$writable;
if (arguments.length === 2) {
callback = options;
options = kEmptyObject;
} else if (options == null) {
options = kEmptyObject;
} else {
validateObject(options, 'options');
}
validateFunction(callback, 'callback');
validateAbortSignal(options.signal, 'options.signal');
callback = once(callback);
const readable =
(_options$readable = options.readable) !== null && _options$readable !== undefined
? _options$readable
: isReadableNodeStream(stream);
const writable =
(_options$writable = options.writable) !== null && _options$writable !== undefined
? _options$writable
: isWritableNodeStream(stream);
if (!isNodeStream(stream)) {
// TODO: Webstreams.
throw new ERR_INVALID_ARG_TYPE('stream', 'Stream', stream)
}
const wState = stream._writableState;
const rState = stream._readableState;
const onlegacyfinish = () => {
if (!stream.writable) {
onfinish();
}
};
// TODO (ronag): Improve soft detection to include core modules and
// common ecosystem modules that do properly emit 'close' but fail
// this generic check.
let willEmitClose =
_willEmitClose(stream) && isReadableNodeStream(stream) === readable && isWritableNodeStream(stream) === writable;
let writableFinished = isWritableFinished(stream, false);
const onfinish = () => {
writableFinished = true;
// Stream should not be destroyed here. If it is that
// means that user space is doing something differently and
// we cannot trust willEmitClose.
if (stream.destroyed) {
willEmitClose = false;
}
if (willEmitClose && (!stream.readable || readable)) {
return
}
if (!readable || readableFinished) {
callback.call(stream);
}
};
let readableFinished = isReadableFinished(stream, false);
const onend = () => {
readableFinished = true;
// Stream should not be destroyed here. If it is that
// means that user space is doing something differently and
// we cannot trust willEmitClose.
if (stream.destroyed) {
willEmitClose = false;
}
if (willEmitClose && (!stream.writable || writable)) {
return
}
if (!writable || writableFinished) {
callback.call(stream);
}
};
const onerror = (err) => {
callback.call(stream, err);
};
let closed = isClosed(stream);
const onclose = () => {
closed = true;
const errored = isWritableErrored(stream) || isReadableErrored(stream);
if (errored && typeof errored !== 'boolean') {
return callback.call(stream, errored)
}
if (readable && !readableFinished && isReadableNodeStream(stream, true)) {
if (!isReadableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE())
}
if (writable && !writableFinished) {
if (!isWritableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE())
}
callback.call(stream);
};
const onrequest = () => {
stream.req.on('finish', onfinish);
};
if (isRequest(stream)) {
stream.on('complete', onfinish);
if (!willEmitClose) {
stream.on('abort', onclose);
}
if (stream.req) {
onrequest();
} else {
stream.on('request', onrequest);
}
} else if (writable && !wState) {
// legacy streams
stream.on('end', onlegacyfinish);
stream.on('close', onlegacyfinish);
}
// Not all streams will emit 'close' after 'aborted'.
if (!willEmitClose && typeof stream.aborted === 'boolean') {
stream.on('aborted', onclose);
}
stream.on('end', onend);
stream.on('finish', onfinish);
if (options.error !== false) {
stream.on('error', onerror);
}
stream.on('close', onclose);
if (closed) {
process.nextTick(onclose);
} else if (
(wState !== null && wState !== undefined && wState.errorEmitted) ||
(rState !== null && rState !== undefined && rState.errorEmitted)
) {
if (!willEmitClose) {
process.nextTick(onclose);
}
} else if (
!readable &&
(!willEmitClose || isReadable(stream)) &&
(writableFinished || isWritable(stream) === false)
) {
process.nextTick(onclose);
} else if (
!writable &&
(!willEmitClose || isWritable(stream)) &&
(readableFinished || isReadable(stream) === false)
) {
process.nextTick(onclose);
} else if (rState && stream.req && stream.aborted) {
process.nextTick(onclose);
}
const cleanup = () => {
callback = nop;
stream.removeListener('aborted', onclose);
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);
};
if (options.signal && !closed) {
const abort = () => {
// Keep it because cleanup removes it.
const endCallback = callback;
cleanup();
endCallback.call(
stream,
new AbortError(undefined, {
cause: options.signal.reason
})
);
};
if (options.signal.aborted) {
process.nextTick(abort);
} else {
const originalCallback = callback;
callback = once((...args) => {
options.signal.removeEventListener('abort', abort);
originalCallback.apply(stream, args);
});
options.signal.addEventListener('abort', abort);
}
}
return cleanup
}
function finished(stream, opts) {
return new Promise((resolve, reject) => {
eos(stream, opts, (err) => {
if (err) {
reject(err);
} else {
resolve();
}
});
})
}
endOfStream.exports = eos;
endOfStream.exports.finished = finished;
return endOfStream.exports;
}
var hasRequiredOperators;
function requireOperators () {
if (hasRequiredOperators) return operators;
hasRequiredOperators = 1;
const AbortController = globalThis.AbortController || require$$9.AbortController;
const {
codes: { ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },
AbortError
} = requireErrors();
const { validateAbortSignal, validateInteger, validateObject } = requireValidators();
const kWeakHandler = requirePrimordials().Symbol('kWeak');
const { finished } = requireEndOfStream();
const {
ArrayPrototypePush,
MathFloor,
Number,
NumberIsNaN,
Promise,
PromiseReject,
PromisePrototypeThen,
Symbol
} = requirePrimordials();
const kEmpty = Symbol('kEmpty');
const kEof = Symbol('kEof');
function map(fn, options) {
if (typeof fn !== 'function') {
throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)
}
if (options != null) {
validateObject(options, 'options');
}
if ((options === null || options === undefined ? undefined : options.signal) != null) {
validateAbortSignal(options.signal, 'options.signal');
}
let concurrency = 1;
if ((options === null || options === undefined ? undefined : options.concurrency) != null) {
concurrency = MathFloor(options.concurrency);
}
validateInteger(concurrency, 'concurrency', 1);
return async function* map() {
var _options$signal, _options$signal2;
const ac = new AbortController();
const stream = this;
const queue = [];
const signal = ac.signal;
const signalOpt = {
signal
};
const abort = () => ac.abort();
if (
options !== null &&
options !== undefined &&
(_options$signal = options.signal) !== null &&
_options$signal !== undefined &&
_options$signal.aborted
) {
abort();
}
options === null || options === undefined
? undefined
: (_options$signal2 = options.signal) === null || _options$signal2 === undefined
? undefined
: _options$signal2.addEventListener('abort', abort);
let next;
let resume;
let done = false;
function onDone() {
done = true;
}
async function pump() {
try {
for await (let val of stream) {
var _val;
if (done) {
return
}
if (signal.aborted) {
throw new AbortError()
}
try {
val = fn(val, signalOpt);
} catch (err) {
val = PromiseReject(err);
}
if (val === kEmpty) {
continue
}
if (typeof ((_val = val) === null || _val === undefined ? undefined : _val.catch) === 'function') {
val.catch(onDone);
}
queue.push(val);
if (next) {
next();
next = null;
}
if (!done && queue.length && queue.length >= concurrency) {
await new Promise((resolve) => {
resume = resolve;
});
}
}
queue.push(kEof);
} catch (err) {
const val = PromiseReject(err);
PromisePrototypeThen(val, undefined, onDone);
queue.push(val);
} finally {
var _options$signal3;
done = true;
if (next) {
next();
next = null;
}
options === null || options === undefined
? undefined
: (_options$signal3 = options.signal) === null || _options$signal3 === undefined
? undefined
: _options$signal3.removeEventListener('abort', abort);
}
}
pump();
try {
while (true) {
while (queue.length > 0) {
const val = await queue[0];
if (val === kEof) {
return
}
if (signal.aborted) {
throw new AbortError()
}
if (val !== kEmpty) {
yield val;
}
queue.shift();
if (resume) {
resume();
resume = null;
}
}
await new Promise((resolve) => {
next = resolve;
});
}
} finally {
ac.abort();
done = true;
if (resume) {
resume();
resume = null;
}
}
}.call(this)
}
function asIndexedPairs(options = undefined) {
if (options != null) {
validateObject(options, 'options');
}
if ((options === null || options === undefined ? undefined : options.signal) != null) {
validateAbortSignal(options.signal, 'options.signal');
}
return async function* asIndexedPairs() {
let index = 0;
for await (const val of this) {
var _options$signal4;
if (
options !== null &&
options !== undefined &&
(_options$signal4 = options.signal) !== null &&
_options$signal4 !== undefined &&
_options$signal4.aborted
) {
throw new AbortError({
cause: options.signal.reason
})
}
yield [index++, val];
}
}.call(this)
}
async function some(fn, options = undefined) {
for await (const unused of filter.call(this, fn, options)) {
return true
}
return false
}
async function every(fn, options = undefined) {
if (typeof fn !== 'function') {
throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)
}
// https://en.wikipedia.org/wiki/De_Morgan%27s_laws
return !(await some.call(
this,
async (...args) => {
return !(await fn(...args))
},
options
))
}
async function find(fn, options) {
for await (const result of filter.call(this, fn, options)) {
return result
}
return undefined
}
async function forEach(fn, options) {
if (typeof fn !== 'function') {
throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)
}
async function forEachFn(value, options) {
await fn(value, options);
return kEmpty
}
// eslint-disable-next-line no-unused-vars
for await (const unused of map.call(this, forEachFn, options));
}
function filter(fn, options) {
if (typeof fn !== 'function') {
throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)
}
async function filterFn(value, options) {
if (await fn(value, options)) {
return value
}
return kEmpty
}
return map.call(this, filterFn, options)
}
// Specific to provide better error to reduce since the argument is only
// missing if the stream has no items in it - but the code is still appropriate
class ReduceAwareErrMissingArgs extends ERR_MISSING_ARGS {
constructor() {
super('reduce');
this.message = 'Reduce of an empty stream requires an initial value';
}
}
async function reduce(reducer, initialValue, options) {
var _options$signal5;
if (typeof reducer !== 'function') {
throw new ERR_INVALID_ARG_TYPE('reducer', ['Function', 'AsyncFunction'], reducer)
}
if (options != null) {
validateObject(options, 'options');
}
if ((options === null || options === undefined ? undefined : options.signal) != null) {
validateAbortSignal(options.signal, 'options.signal');
}
let hasInitialValue = arguments.length > 1;
if (
options !== null &&
options !== undefined &&
(_options$signal5 = options.signal) !== null &&
_options$signal5 !== undefined &&
_options$signal5.aborted
) {
const err = new AbortError(undefined, {
cause: options.signal.reason
});
this.once('error', () => {}); // The error is already propagated
await finished(this.destroy(err));
throw err
}
const ac = new AbortController();
const signal = ac.signal;
if (options !== null && options !== undefined && options.signal) {
const opts = {
once: true,
[kWeakHandler]: this
};
options.signal.addEventListener('abort', () => ac.abort(), opts);
}
let gotAnyItemFromStream = false;
try {
for await (const value of this) {
var _options$signal6;
gotAnyItemFromStream = true;
if (
options !== null &&
options !== undefined &&
(_options$signal6 = options.signal) !== null &&
_options$signal6 !== undefined &&
_options$signal6.aborted
) {
throw new AbortError()
}
if (!hasInitialValue) {
initialValue = value;
hasInitialValue = true;
} else {
initialValue = await reducer(initialValue, value, {
signal
});
}
}
if (!gotAnyItemFromStream && !hasInitialValue) {
throw new ReduceAwareErrMissingArgs()
}
} finally {
ac.abort();
}
return initialValue
}
async function toArray(options) {
if (options != null) {
validateObject(options, 'options');
}
if ((options === null || options === undefined ? undefined : options.signal) != null) {
validateAbortSignal(options.signal, 'options.signal');
}
const result = [];
for await (const val of this) {
var _options$signal7;
if (
options !== null &&
options !== undefined &&
(_options$signal7 = options.signal) !== null &&
_options$signal7 !== undefined &&
_options$signal7.aborted
) {
throw new AbortError(undefined, {
cause: options.signal.reason
})
}
ArrayPrototypePush(result, val);
}
return result
}
function flatMap(fn, options) {
const values = map.call(this, fn, options);
return async function* flatMap() {
for await (const val of values) {
yield* val;
}
}.call(this)
}
function toIntegerOrInfinity(number) {
// We coerce here to align with the spec
// https://github.com/tc39/proposal-iterator-helpers/issues/169
number = Number(number);
if (NumberIsNaN(number)) {
return 0
}
if (number < 0) {
throw new ERR_OUT_OF_RANGE('number', '>= 0', number)
}
return number
}
function drop(number, options = undefined) {
if (options != null) {
validateObject(options, 'options');
}
if ((options === null || options === undefined ? undefined : options.signal) != null) {
validateAbortSignal(options.signal, 'options.signal');
}
number = toIntegerOrInfinity(number);
return async function* drop() {
var _options$signal8;
if (
options !== null &&
options !== undefined &&
(_options$signal8 = options.signal) !== null &&
_options$signal8 !== undefined &&
_options$signal8.aborted
) {
throw new AbortError()
}
for await (const val of this) {
var _options$signal9;
if (
options !== null &&
options !== undefined &&
(_options$signal9 = options.signal) !== null &&
_options$signal9 !== undefined &&
_options$signal9.aborted
) {
throw new AbortError()
}
if (number-- <= 0) {
yield val;
}
}
}.call(this)
}
function take(number, options = undefined) {
if (options != null) {
validateObject(options, 'options');
}
if ((options === null || options === undefined ? undefined : options.signal) != null) {
validateAbortSignal(options.signal, 'options.signal');
}
number = toIntegerOrInfinity(number);
return async function* take() {
var _options$signal10;
if (
options !== null &&
options !== undefined &&
(_options$signal10 = options.signal) !== null &&
_options$signal10 !== undefined &&
_options$signal10.aborted
) {
throw new AbortError()
}
for await (const val of this) {
var _options$signal11;
if (
options !== null &&
options !== undefined &&
(_options$signal11 = options.signal) !== null &&
_options$signal11 !== undefined &&
_options$signal11.aborted
) {
throw new AbortError()
}
if (number-- > 0) {
yield val;
} else {
return
}
}
}.call(this)
}
operators.streamReturningOperators = {
asIndexedPairs,
drop,
filter,
flatMap,
map,
take
};
operators.promiseReturningOperators = {
every,
forEach,
reduce,
toArray,
some,
find
};
return operators;
}
var destroy_1;
var hasRequiredDestroy;
function requireDestroy () {
if (hasRequiredDestroy) return destroy_1;
hasRequiredDestroy = 1;
/* replacement start */
const process = requireProcess();
/* replacement end */
const {
aggregateTwoErrors,
codes: { ERR_MULTIPLE_CALLBACK },
AbortError
} = requireErrors();
const { Symbol } = requirePrimordials();
const { kDestroyed, isDestroyed, isFinished, isServerRequest } = requireUtils();
const kDestroy = Symbol('kDestroy');
const kConstruct = Symbol('kConstruct');
function checkError(err, w, r) {
if (err) {
// Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
err.stack; // eslint-disable-line no-unused-expressions
if (w && !w.errored) {
w.errored = err;
}
if (r && !r.errored) {
r.errored = err;
}
}
}
// Backwards compat. cb() is undocumented and unused in core but
// unfortunately might be used by modules.
function destroy(err, cb) {
const r = this._readableState;
const w = this._writableState;
// With duplex streams we use the writable side for state.
const s = w || r;
if ((w && w.destroyed) || (r && r.destroyed)) {
if (typeof cb === 'function') {
cb();
}
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
checkError(err, w, r);
if (w) {
w.destroyed = true;
}
if (r) {
r.destroyed = true;
}
// If still constructing then defer calling _destroy.
if (!s.constructed) {
this.once(kDestroy, function (er) {
_destroy(this, aggregateTwoErrors(er, err), cb);
});
} else {
_destroy(this, err, cb);
}
return this
}
function _destroy(self, err, cb) {
let called = false;
function onDestroy(err) {
if (called) {
return
}
called = true;
const r = self._readableState;
const w = self._writableState;
checkError(err, w, r);
if (w) {
w.closed = true;
}
if (r) {
r.closed = true;
}
if (typeof cb === 'function') {
cb(err);
}
if (err) {
process.nextTick(emitErrorCloseNT, self, err);
} else {
process.nextTick(emitCloseNT, self);
}
}
try {
self._destroy(err || null, onDestroy);
} catch (err) {
onDestroy(err);
}
}
function emitErrorCloseNT(self, err) {
emitErrorNT(self, err);
emitCloseNT(self);
}
function emitCloseNT(self) {
const r = self._readableState;
const w = self._writableState;
if (w) {
w.closeEmitted = true;
}
if (r) {
r.closeEmitted = true;
}
if ((w && w.emitClose) || (r && r.emitClose)) {
self.emit('close');
}
}
function emitErrorNT(self, err) {
const r = self._readableState;
const w = self._writableState;
if ((w && w.errorEmitted) || (r && r.errorEmitted)) {
return
}
if (w) {
w.errorEmitted = true;
}
if (r) {
r.errorEmitted = true;
}
self.emit('error', err);
}
function undestroy() {
const r = this._readableState;
const w = this._writableState;
if (r) {
r.constructed = true;
r.closed = false;
r.closeEmitted = false;
r.destroyed = false;
r.errored = null;
r.errorEmitted = false;
r.reading = false;
r.ended = r.readable === false;
r.endEmitted = r.readable === false;
}
if (w) {
w.constructed = true;
w.destroyed = false;
w.closed = false;
w.closeEmitted = false;
w.errored = null;
w.errorEmitted = false;
w.finalCalled = false;
w.prefinished = false;
w.ended = w.writable === false;
w.ending = w.writable === false;
w.finished = w.writable === false;
}
}
function errorOrDestroy(stream, err, sync) {
// 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.
const r = stream._readableState;
const w = stream._writableState;
if ((w && w.destroyed) || (r && r.destroyed)) {
return this
}
if ((r && r.autoDestroy) || (w && w.autoDestroy)) stream.destroy(err);
else if (err) {
// Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
err.stack; // eslint-disable-line no-unused-expressions
if (w && !w.errored) {
w.errored = err;
}
if (r && !r.errored) {
r.errored = err;
}
if (sync) {
process.nextTick(emitErrorNT, stream, err);
} else {
emitErrorNT(stream, err);
}
}
}
function construct(stream, cb) {
if (typeof stream._construct !== 'function') {
return
}
const r = stream._readableState;
const w = stream._writableState;
if (r) {
r.constructed = false;
}
if (w) {
w.constructed = false;
}
stream.once(kConstruct, cb);
if (stream.listenerCount(kConstruct) > 1) {
// Duplex
return
}
process.nextTick(constructNT, stream);
}
function constructNT(stream) {
let called = false;
function onConstruct(err) {
if (called) {
errorOrDestroy(stream, err !== null && err !== undefined ? err : new ERR_MULTIPLE_CALLBACK());
return
}
called = true;
const r = stream._readableState;
const w = stream._writableState;
const s = w || r;
if (r) {
r.constructed = true;
}
if (w) {
w.constructed = true;
}
if (s.destroyed) {
stream.emit(kDestroy, err);
} else if (err) {
errorOrDestroy(stream, err, true);
} else {
process.nextTick(emitConstructNT, stream);
}
}
try {
stream._construct(onConstruct);
} catch (err) {
onConstruct(err);
}
}
function emitConstructNT(stream) {
stream.emit(kConstruct);
}
function isRequest(stream) {
return stream && stream.setHeader && typeof stream.abort === 'function'
}
function emitCloseLegacy(stream) {
stream.emit('close');
}
function emitErrorCloseLegacy(stream, err) {
stream.emit('error', err);
process.nextTick(emitCloseLegacy, stream);
}
// Normalize destroy for legacy.
function destroyer(stream, err) {
if (!stream || isDestroyed(stream)) {
return
}
if (!err && !isFinished(stream)) {
err = new AbortError();
}
// TODO: Remove isRequest branches.
if (isServerRequest(stream)) {
stream.socket = null;
stream.destroy(err);
} else if (isRequest(stream)) {
stream.abort();
} else if (isRequest(stream.req)) {
stream.req.abort();
} else if (typeof stream.destroy === 'function') {
stream.destroy(err);
} else if (typeof stream.close === 'function') {
// TODO: Don't lose err?
stream.close();
} else if (err) {
process.nextTick(emitErrorCloseLegacy, stream, err);
} else {
process.nextTick(emitCloseLegacy, stream);
}
if (!stream.destroyed) {
stream[kDestroyed] = true;
}
}
destroy_1 = {
construct,
destroyer,
destroy,
undestroy,
errorOrDestroy
};
return destroy_1;
}
var legacy;
var hasRequiredLegacy;
function requireLegacy () {
if (hasRequiredLegacy) return legacy;
hasRequiredLegacy = 1;
const { ArrayIsArray, ObjectSetPrototypeOf } = requirePrimordials();
const { EventEmitter: EE } = require$$2;
function Stream(opts) {
EE.call(this, opts);
}
ObjectSetPrototypeOf(Stream.prototype, EE.prototype);
ObjectSetPrototypeOf(Stream, EE);
Stream.prototype.pipe = function (dest, options) {
const source = this;
function ondata(chunk) {
if (dest.writable && dest.write(chunk) === false && source.pause) {
source.pause();
}
}
source.on('data', ondata);
function ondrain() {
if (source.readable && source.resume) {
source.resume();
}
}
dest.on('drain', ondrain);
// If the 'end' option is not supplied, dest.end() will be called when
// source gets the 'end' or 'close' events. Only dest.end() once.
if (!dest._isStdio && (!options || options.end !== false)) {
source.on('end', onend);
source.on('close', onclose);
}
let didOnEnd = false;
function onend() {
if (didOnEnd) return
didOnEnd = true;
dest.end();
}
function onclose() {
if (didOnEnd) return
didOnEnd = true;
if (typeof dest.destroy === 'function') dest.destroy();
}
// Don't leave dangling pipes when there are errors.
function onerror(er) {
cleanup();
if (EE.listenerCount(this, 'error') === 0) {
this.emit('error', er);
}
}
prependListener(source, 'error', onerror);
prependListener(dest, 'error', onerror);
// Remove all the event listeners that were added.
function cleanup() {
source.removeListener('data', ondata);
dest.removeListener('drain', ondrain);
source.removeListener('end', onend);
source.removeListener('close', onclose);
source.removeListener('error', onerror);
dest.removeListener('error', onerror);
source.removeListener('end', cleanup);
source.removeListener('close', cleanup);
dest.removeListener('close', cleanup);
}
source.on('end', cleanup);
source.on('close', cleanup);
dest.on('close', cleanup);
dest.emit('pipe', source);
// Allow for unix-like usage: A.pipe(B).pipe(C)
return dest
};
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 (ArrayIsArray(emitter._events[event])) emitter._events[event].unshift(fn);
else emitter._events[event] = [fn, emitter._events[event]];
}
legacy = {
Stream,
prependListener
};
return legacy;
}
var addAbortSignal = {exports: {}};
var hasRequiredAddAbortSignal;
function requireAddAbortSignal () {
if (hasRequiredAddAbortSignal) return addAbortSignal.exports;
hasRequiredAddAbortSignal = 1;
(function (module) {
const { AbortError, codes } = requireErrors();
const eos = requireEndOfStream();
const { ERR_INVALID_ARG_TYPE } = codes;
// This method is inlined here for readable-stream
// It also does not allow for signal to not exist on the stream
// https://github.com/nodejs/node/pull/36061#discussion_r533718029
const validateAbortSignal = (signal, name) => {
if (typeof signal !== 'object' || !('aborted' in signal)) {
throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal)
}
};
function isNodeStream(obj) {
return !!(obj && typeof obj.pipe === 'function')
}
module.exports.addAbortSignal = function addAbortSignal(signal, stream) {
validateAbortSignal(signal, 'signal');
if (!isNodeStream(stream)) {
throw new ERR_INVALID_ARG_TYPE('stream', 'stream.Stream', stream)
}
return module.exports.addAbortSignalNoValidate(signal, stream)
};
module.exports.addAbortSignalNoValidate = function (signal, stream) {
if (typeof signal !== 'object' || !('aborted' in signal)) {
return stream
}
const onAbort = () => {
stream.destroy(
new AbortError(undefined, {
cause: signal.reason
})
);
};
if (signal.aborted) {
onAbort();
} else {
signal.addEventListener('abort', onAbort);
eos(stream, () => signal.removeEventListener('abort', onAbort));
}
return stream
};
} (addAbortSignal));
return addAbortSignal.exports;
}
var buffer_list;
var hasRequiredBuffer_list;
function requireBuffer_list () {
if (hasRequiredBuffer_list) return buffer_list;
hasRequiredBuffer_list = 1;
const { StringPrototypeSlice, SymbolIterator, TypedArrayPrototypeSet, Uint8Array } = requirePrimordials();
const { Buffer } = require$$0;
const { inspect } = requireUtil();
buffer_list = class BufferList {
constructor() {
this.head = null;
this.tail = null;
this.length = 0;
}
push(v) {
const entry = {
data: v,
next: null
};
if (this.length > 0) this.tail.next = entry;
else this.head = entry;
this.tail = entry;
++this.length;
}
unshift(v) {
const entry = {
data: v,
next: this.head
};
if (this.length === 0) this.tail = entry;
this.head = entry;
++this.length;
}
shift() {
if (this.length === 0) return
const ret = this.head.data;
if (this.length === 1) this.head = this.tail = null;
else this.head = this.head.next;
--this.length;
return ret
}
clear() {
this.head = this.tail = null;
this.length = 0;
}
join(s) {
if (this.length === 0) return ''
let p = this.head;
let ret = '' + p.data;
while ((p = p.next) !== null) ret += s + p.data;
return ret
}
concat(n) {
if (this.length === 0) return Buffer.alloc(0)
const ret = Buffer.allocUnsafe(n >>> 0);
let p = this.head;
let i = 0;
while (p) {
TypedArrayPrototypeSet(ret, p.data, i);
i += p.data.length;
p = p.next;
}
return ret
}
// Consumes a specified amount of bytes or characters from the buffered data.
consume(n, hasStrings) {
const data = this.head.data;
if (n < data.length) {
// `slice` is the same for buffers and strings.
const slice = data.slice(0, n);
this.head.data = data.slice(n);
return slice
}
if (n === data.length) {
// First chunk is a perfect match.
return this.shift()
}
// Result spans more than one buffer.
return hasStrings ? this._getString(n) : this._getBuffer(n)
}
first() {
return this.head.data
}
*[SymbolIterator]() {
for (let p = this.head; p; p = p.next) {
yield p.data;
}
}
// Consumes a specified amount of characters from the buffered data.
_getString(n) {
let ret = '';
let p = this.head;
let c = 0;
do {
const str = p.data;
if (n > str.length) {
ret += str;
n -= str.length;
} else {
if (n === str.length) {
ret += str;
++c;
if (p.next) this.head = p.next;
else this.head = this.tail = null;
} else {
ret += StringPrototypeSlice(str, 0, n);
this.head = p;
p.data = StringPrototypeSlice(str, n);
}
break
}
++c;
} while ((p = p.next) !== null)
this.length -= c;
return ret
}
// Consumes a specified amount of bytes from the buffered data.
_getBuffer(n) {
const ret = Buffer.allocUnsafe(n);
const retLen = n;
let p = this.head;
let c = 0;
do {
const buf = p.data;
if (n > buf.length) {
TypedArrayPrototypeSet(ret, buf, retLen - n);
n -= buf.length;
} else {
if (n === buf.length) {
TypedArrayPrototypeSet(ret, buf, retLen - n);
++c;
if (p.next) this.head = p.next;
else this.head = this.tail = null;
} else {
TypedArrayPrototypeSet(ret, new Uint8Array(buf.buffer, buf.byteOffset, n), retLen - n);
this.head = p;
p.data = buf.slice(n);
}
break
}
++c;
} while ((p = p.next) !== null)
this.length -= c;
return ret
}
// Make sure the linked list only shows the minimal necessary information.
[Symbol.for('nodejs.util.inspect.custom')](_, options) {
return inspect(this, {
...options,
// Only inspect one level.
depth: 0,
// It should not recurse.
customInspect: false
})
}
};
return buffer_list;
}
var state;
var hasRequiredState;
function requireState () {
if (hasRequiredState) return state;
hasRequiredState = 1;
const { MathFloor, NumberIsInteger } = requirePrimordials();
const { ERR_INVALID_ARG_VALUE } = requireErrors().codes;
function highWaterMarkFrom(options, isDuplex, duplexKey) {
return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null
}
function getDefaultHighWaterMark(objectMode) {
return objectMode ? 16 : 16 * 1024
}
function getHighWaterMark(state, options, duplexKey, isDuplex) {
const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
if (hwm != null) {
if (!NumberIsInteger(hwm) || hwm < 0) {
const name = isDuplex ? `options.${duplexKey}` : 'options.highWaterMark';
throw new ERR_INVALID_ARG_VALUE(name, hwm)
}
return MathFloor(hwm)
}
// Default value
return getDefaultHighWaterMark(state.objectMode)
}
state = {
getHighWaterMark,
getDefaultHighWaterMark
};
return state;
}
var from_1;
var hasRequiredFrom;
function requireFrom () {
if (hasRequiredFrom) return from_1;
hasRequiredFrom = 1;
/* replacement start */
const process = requireProcess();
/* replacement end */
const { PromisePrototypeThen, SymbolAsyncIterator, SymbolIterator } = requirePrimordials();
const { Buffer } = require$$0;
const { ERR_INVALID_ARG_TYPE, ERR_STREAM_NULL_VALUES } = requireErrors().codes;
function from(Readable, iterable, opts) {
let iterator;
if (typeof iterable === 'string' || iterable instanceof Buffer) {
return new Readable({
objectMode: true,
...opts,
read() {
this.push(iterable);
this.push(null);
}
})
}
let isAsync;
if (iterable && iterable[SymbolAsyncIterator]) {
isAsync = true;
iterator = iterable[SymbolAsyncIterator]();
} else if (iterable && iterable[SymbolIterator]) {
isAsync = false;
iterator = iterable[SymbolIterator]();
} else {
throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable)
}
const readable = new Readable({
objectMode: true,
highWaterMark: 1,
// TODO(ronag): What options should be allowed?
...opts
});
// Flag to protect against _read
// being called before last iteration completion.
let reading = false;
readable._read = function () {
if (!reading) {
reading = true;
next();
}
};
readable._destroy = function (error, cb) {
PromisePrototypeThen(
close(error),
() => process.nextTick(cb, error),
// nextTick is here in case cb throws
(e) => process.nextTick(cb, e || error)
);
};
async function close(error) {
const hadError = error !== undefined && error !== null;
const hasThrow = typeof iterator.throw === 'function';
if (hadError && hasThrow) {
const { value, done } = await iterator.throw(error);
await value;
if (done) {
return
}
}
if (typeof iterator.return === 'function') {
const { value } = await iterator.return();
await value;
}
}
async function next() {
for (;;) {
try {
const { value, done } = isAsync ? await iterator.next() : iterator.next();
if (done) {
readable.push(null);
} else {
const res = value && typeof value.then === 'function' ? await value : value;
if (res === null) {
reading = false;
throw new ERR_STREAM_NULL_VALUES()
} else if (readable.push(res)) {
continue
} else {
reading = false;
}
}
} catch (err) {
readable.destroy(err);
}
break
}
}
return readable
}
from_1 = from;
return from_1;
}
/* replacement start */
var readable;
var hasRequiredReadable;
function requireReadable () {
if (hasRequiredReadable) return readable;
hasRequiredReadable = 1;
const process = requireProcess()
/* replacement end */
// 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.
; const {
ArrayPrototypeIndexOf,
NumberIsInteger,
NumberIsNaN,
NumberParseInt,
ObjectDefineProperties,
ObjectKeys,
ObjectSetPrototypeOf,
Promise,
SafeSet,
SymbolAsyncIterator,
Symbol
} = requirePrimordials();
readable = Readable;
Readable.ReadableState = ReadableState;
const { EventEmitter: EE } = require$$2;
const { Stream, prependListener } = requireLegacy();
const { Buffer } = require$$0;
const { addAbortSignal } = requireAddAbortSignal();
const eos = requireEndOfStream();
let debug = requireUtil().debuglog('stream', (fn) => {
debug = fn;
});
const BufferList = requireBuffer_list();
const destroyImpl = requireDestroy();
const { getHighWaterMark, getDefaultHighWaterMark } = requireState();
const {
aggregateTwoErrors,
codes: {
ERR_INVALID_ARG_TYPE,
ERR_METHOD_NOT_IMPLEMENTED,
ERR_OUT_OF_RANGE,
ERR_STREAM_PUSH_AFTER_EOF,
ERR_STREAM_UNSHIFT_AFTER_END_EVENT
}
} = requireErrors();
const { validateObject } = requireValidators();
const kPaused = Symbol('kPaused');
const { StringDecoder } = require$$13;
const from = requireFrom();
ObjectSetPrototypeOf(Readable.prototype, Stream.prototype);
ObjectSetPrototypeOf(Readable, Stream);
const nop = () => {};
const { errorOrDestroy } = destroyImpl;
function ReadableState(options, stream, isDuplex) {
// 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 requireDuplex();
// 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 && options.objectMode);
if (isDuplex) this.objectMode = this.objectMode || !!(options && 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 = options
? getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex)
: getDefaultHighWaterMark(false);
// 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 = [];
this.flowing = null;
this.ended = false;
this.endEmitted = false;
this.reading = false;
// Stream is still being constructed and cannot be
// destroyed until construction finished or failed.
// Async construction is opt in, therefore we start as
// constructed.
this.constructed = true;
// 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[kPaused] = null;
// 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 || options.emitClose !== false;
// Should .destroy() be called after 'end' (and potentially 'finish').
this.autoDestroy = !options || options.autoDestroy !== false;
// Has it been destroyed.
this.destroyed = false;
// Indicates whether the stream has errored. When true no further
// _read calls, 'data' or 'readable' events should occur. This is needed
// since when autoDestroy is disabled we need a way to tell whether the
// stream has failed.
this.errored = null;
// Indicates whether the stream has finished destroying.
this.closed = false;
// True if close has been emitted or would have been emitted
// depending on emitClose.
this.closeEmitted = 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 && options.defaultEncoding) || 'utf8';
// Ref the piped dest which we need a drain event on it
// type: null | Writable | Set<Writable>.
this.awaitDrainWriters = null;
this.multiAwaitDrain = false;
// If true, a maybeReadMore has been scheduled.
this.readingMore = false;
this.dataEmitted = false;
this.decoder = null;
this.encoding = null;
if (options && options.encoding) {
this.decoder = new StringDecoder(options.encoding);
this.encoding = options.encoding;
}
}
function Readable(options) {
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.
const isDuplex = this instanceof requireDuplex();
this._readableState = new ReadableState(options, this, isDuplex);
if (options) {
if (typeof options.read === 'function') this._read = options.read;
if (typeof options.destroy === 'function') this._destroy = options.destroy;
if (typeof options.construct === 'function') this._construct = options.construct;
if (options.signal && !isDuplex) addAbortSignal(options.signal, this);
}
Stream.call(this, options);
destroyImpl.construct(this, () => {
if (this._readableState.needReadable) {
maybeReadMore(this, this._readableState);
}
});
}
Readable.prototype.destroy = destroyImpl.destroy;
Readable.prototype._undestroy = destroyImpl.undestroy;
Readable.prototype._destroy = function (err, cb) {
cb(err);
};
Readable.prototype[EE.captureRejectionSymbol] = function (err) {
this.destroy(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) {
return readableAddChunk(this, chunk, encoding, false)
};
// Unshift should *always* be something directly out of read().
Readable.prototype.unshift = function (chunk, encoding) {
return readableAddChunk(this, chunk, encoding, true)
};
function readableAddChunk(stream, chunk, encoding, addToFront) {
debug('readableAddChunk', chunk);
const state = stream._readableState;
let err;
if (!state.objectMode) {
if (typeof chunk === 'string') {
encoding = encoding || state.defaultEncoding;
if (state.encoding !== encoding) {
if (addToFront && state.encoding) {
// When unshifting, if state.encoding is set, we have to save
// the string in the BufferList with the state encoding.
chunk = Buffer.from(chunk, encoding).toString(state.encoding);
} else {
chunk = Buffer.from(chunk, encoding);
encoding = '';
}
}
} else if (chunk instanceof Buffer) {
encoding = '';
} else if (Stream._isUint8Array(chunk)) {
chunk = Stream._uint8ArrayToBuffer(chunk);
encoding = '';
} else if (chunk != null) {
err = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
}
}
if (err) {
errorOrDestroy(stream, err);
} else if (chunk === null) {
state.reading = false;
onEofChunk(stream, state);
} else if (state.objectMode || (chunk && chunk.length > 0)) {
if (addToFront) {
if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
else if (state.destroyed || state.errored) return false
else addChunk(stream, state, chunk, true);
} else if (state.ended) {
errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
} else if (state.destroyed || state.errored) {
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 && stream.listenerCount('data') > 0) {
// Use the guard to avoid creating `Set()` repeatedly
// when we have multiple pipes.
if (state.multiAwaitDrain) {
state.awaitDrainWriters.clear();
} else {
state.awaitDrainWriters = null;
}
state.dataEmitted = true;
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);
}
Readable.prototype.isPaused = function () {
const state = this._readableState;
return state[kPaused] === true || state.flowing === false
};
// Backwards compatibility.
Readable.prototype.setEncoding = function (enc) {
const decoder = new StringDecoder(enc);
this._readableState.decoder = decoder;
// If setEncoding(null), decoder.encoding equals utf8.
this._readableState.encoding = this._readableState.decoder.encoding;
const buffer = this._readableState.buffer;
// Iterate over current buffer to convert already stored Buffers:
let content = '';
for (const data of buffer) {
content += decoder.write(data);
}
buffer.clear();
if (content !== '') buffer.push(content);
this._readableState.length = content.length;
return this
};
// Don't raise the hwm > 1GB.
const MAX_HWM = 0x40000000;
function computeNewHighWaterMark(n) {
if (n > MAX_HWM) {
throw new ERR_OUT_OF_RANGE('size', '<= 1GiB', n)
} 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 (NumberIsNaN(n)) {
// Only flow one buffer at a time.
if (state.flowing && state.length) return state.buffer.first().length
return state.length
}
if (n <= state.length) return n
return state.ended ? state.length : 0
}
// You can override either this method, or the async _read(n) below.
Readable.prototype.read = function (n) {
debug('read', n);
// Same as parseInt(undefined, 10), however V8 7.3 performance regressed
// in this scenario, so we are doing it manually.
if (n === undefined) {
n = NaN;
} else if (!NumberIsInteger(n)) {
n = NumberParseInt(n, 10);
}
const state = this._readableState;
const nOrig = n;
// If we're asking for more than the current hwm, then raise the hwm.
if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(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.
let 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, if we're already
// reading, then it's unnecessary, if we're constructing we have to wait,
// and if we're destroyed or errored, then it's not allowed,
if (state.ended || state.reading || state.destroyed || state.errored || !state.constructed) {
doRead = false;
debug('reading, ended or constructing', 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
try {
this._read(state.highWaterMark);
} catch (err) {
errorOrDestroy(this, err);
}
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);
}
let 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;
if (state.multiAwaitDrain) {
state.awaitDrainWriters.clear();
} else {
state.awaitDrainWriters = null;
}
}
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 && !state.errorEmitted && !state.closeEmitted) {
state.dataEmitted = true;
this.emit('data', ret);
}
return ret
};
function onEofChunk(stream, state) {
debug('onEofChunk');
if (state.ended) return
if (state.decoder) {
const 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;
state.emittedReadable = true;
// We have to emit readable now that we are EOF. Modules
// in the ecosystem (e.g. dicer) rely on this event being sync.
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) {
const 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) {
const state = stream._readableState;
debug('emitReadable_', state.destroyed, state.length, state.ended);
if (!state.destroyed && !state.errored && (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.constructed) {
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 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))
) {
const 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) {
throw new ERR_METHOD_NOT_IMPLEMENTED('_read()')
};
Readable.prototype.pipe = function (dest, pipeOpts) {
const src = this;
const state = this._readableState;
if (state.pipes.length === 1) {
if (!state.multiAwaitDrain) {
state.multiAwaitDrain = true;
state.awaitDrainWriters = new SafeSet(state.awaitDrainWriters ? [state.awaitDrainWriters] : []);
}
}
state.pipes.push(dest);
debug('pipe count=%d opts=%j', state.pipes.length, pipeOpts);
const doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
const 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();
}
let ondrain;
let cleanedUp = false;
function cleanup() {
debug('cleanup');
// Cleanup event handlers once the pipe is broken.
dest.removeListener('close', onclose);
dest.removeListener('finish', onfinish);
if (ondrain) {
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 (ondrain && state.awaitDrainWriters && (!dest._writableState || dest._writableState.needDrain)) ondrain();
}
function pause() {
// 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 (!cleanedUp) {
if (state.pipes.length === 1 && state.pipes[0] === dest) {
debug('false write response, pause', 0);
state.awaitDrainWriters = dest;
state.multiAwaitDrain = false;
} else if (state.pipes.length > 1 && state.pipes.includes(dest)) {
debug('false write response, pause', state.awaitDrainWriters.size);
state.awaitDrainWriters.add(dest);
}
src.pause();
}
if (!ondrain) {
// 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.
ondrain = pipeOnDrain(src, dest);
dest.on('drain', ondrain);
}
}
src.on('data', ondata);
function ondata(chunk) {
debug('ondata');
const ret = dest.write(chunk);
debug('dest.write', ret);
if (ret === false) {
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 (dest.listenerCount('error') === 0) {
const s = dest._writableState || dest._readableState;
if (s && !s.errorEmitted) {
// User incorrectly emitted 'error' directly on the stream.
errorOrDestroy(dest, er);
} else {
dest.emit('error', er);
}
}
}
// Make sure our error handler is attached before userland ones.
prependListener(dest, 'error', onerror);
// Both close and finish should trigger unpipe, but only once.
function onclose() {
dest.removeListener('finish', onfinish);
unpipe();
}
dest.once('close', onclose);
function onfinish() {
debug('onfinish');
dest.removeListener('close', onclose);
unpipe();
}
dest.once('finish', onfinish);
function unpipe() {
debug('unpipe');
src.unpipe(dest);
}
// Tell the dest that it's being piped to.
dest.emit('pipe', src);
// Start the flow if it hasn't been started already.
if (dest.writableNeedDrain === true) {
if (state.flowing) {
pause();
}
} else if (!state.flowing) {
debug('pipe resume');
src.resume();
}
return dest
};
function pipeOnDrain(src, dest) {
return function pipeOnDrainFunctionResult() {
const state = src._readableState;
// `ondrain` will call directly,
// `this` maybe not a reference to dest,
// so we use the real dest here.
if (state.awaitDrainWriters === dest) {
debug('pipeOnDrain', 1);
state.awaitDrainWriters = null;
} else if (state.multiAwaitDrain) {
debug('pipeOnDrain', state.awaitDrainWriters.size);
state.awaitDrainWriters.delete(dest);
}
if ((!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) && src.listenerCount('data')) {
src.resume();
}
}
}
Readable.prototype.unpipe = function (dest) {
const state = this._readableState;
const unpipeInfo = {
hasUnpiped: false
};
// If we're not piping anywhere, then do nothing.
if (state.pipes.length === 0) return this
if (!dest) {
// remove all.
const dests = state.pipes;
state.pipes = [];
this.pause();
for (let i = 0; i < dests.length; i++)
dests[i].emit('unpipe', this, {
hasUnpiped: false
});
return this
}
// Try to find the right one.
const index = ArrayPrototypeIndexOf(state.pipes, dest);
if (index === -1) return this
state.pipes.splice(index, 1);
if (state.pipes.length === 0) this.pause();
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) {
const res = Stream.prototype.on.call(this, ev, fn);
const 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) {
const 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.off = Readable.prototype.removeListener;
Readable.prototype.removeAllListeners = function (ev) {
const 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) {
const state = self._readableState;
state.readableListening = self.listenerCount('readable') > 0;
if (state.resumeScheduled && state[kPaused] === false) {
// 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();
} else if (!state.readableListening) {
state.flowing = null;
}
}
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 () {
const 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[kPaused] = 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[kPaused] = true;
return this
};
function flow(stream) {
const 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) {
let paused = false;
// TODO (ronag): Should this.destroy(err) emit
// 'error' on the wrapped stream? Would require
// a static factory method, e.g. Readable.wrap(stream).
stream.on('data', (chunk) => {
if (!this.push(chunk) && stream.pause) {
paused = true;
stream.pause();
}
});
stream.on('end', () => {
this.push(null);
});
stream.on('error', (err) => {
errorOrDestroy(this, err);
});
stream.on('close', () => {
this.destroy();
});
stream.on('destroy', () => {
this.destroy();
});
this._read = () => {
if (paused && stream.resume) {
paused = false;
stream.resume();
}
};
// Proxy all the other methods. Important when wrapping filters and duplexes.
const streamKeys = ObjectKeys(stream);
for (let j = 1; j < streamKeys.length; j++) {
const i = streamKeys[j];
if (this[i] === undefined && typeof stream[i] === 'function') {
this[i] = stream[i].bind(stream);
}
}
return this
};
Readable.prototype[SymbolAsyncIterator] = function () {
return streamToAsyncIterator(this)
};
Readable.prototype.iterator = function (options) {
if (options !== undefined) {
validateObject(options, 'options');
}
return streamToAsyncIterator(this, options)
};
function streamToAsyncIterator(stream, options) {
if (typeof stream.read !== 'function') {
stream = Readable.wrap(stream, {
objectMode: true
});
}
const iter = createAsyncIterator(stream, options);
iter.stream = stream;
return iter
}
async function* createAsyncIterator(stream, options) {
let callback = nop;
function next(resolve) {
if (this === stream) {
callback();
callback = nop;
} else {
callback = resolve;
}
}
stream.on('readable', next);
let error;
const cleanup = eos(
stream,
{
writable: false
},
(err) => {
error = err ? aggregateTwoErrors(error, err) : null;
callback();
callback = nop;
}
);
try {
while (true) {
const chunk = stream.destroyed ? null : stream.read();
if (chunk !== null) {
yield chunk;
} else if (error) {
throw error
} else if (error === null) {
return
} else {
await new Promise(next);
}
}
} catch (err) {
error = aggregateTwoErrors(error, err);
throw error
} finally {
if (
(error || (options === null || options === undefined ? undefined : options.destroyOnReturn) !== false) &&
(error === undefined || stream._readableState.autoDestroy)
) {
destroyImpl.destroyer(stream, null);
} else {
stream.off('readable', next);
cleanup();
}
}
}
// Making it explicit these properties are not enumerable
// because otherwise some prototype manipulation in
// userland will fail.
ObjectDefineProperties(Readable.prototype, {
readable: {
__proto__: null,
get() {
const r = this._readableState;
// r.readable === false means that this is part of a Duplex stream
// where the readable side was disabled upon construction.
// Compat. The user might manually disable readable side through
// deprecated setter.
return !!r && r.readable !== false && !r.destroyed && !r.errorEmitted && !r.endEmitted
},
set(val) {
// Backwards compat.
if (this._readableState) {
this._readableState.readable = !!val;
}
}
},
readableDidRead: {
__proto__: null,
enumerable: false,
get: function () {
return this._readableState.dataEmitted
}
},
readableAborted: {
__proto__: null,
enumerable: false,
get: function () {
return !!(
this._readableState.readable !== false &&
(this._readableState.destroyed || this._readableState.errored) &&
!this._readableState.endEmitted
)
}
},
readableHighWaterMark: {
__proto__: null,
enumerable: false,
get: function () {
return this._readableState.highWaterMark
}
},
readableBuffer: {
__proto__: null,
enumerable: false,
get: function () {
return this._readableState && this._readableState.buffer
}
},
readableFlowing: {
__proto__: null,
enumerable: false,
get: function () {
return this._readableState.flowing
},
set: function (state) {
if (this._readableState) {
this._readableState.flowing = state;
}
}
},
readableLength: {
__proto__: null,
enumerable: false,
get() {
return this._readableState.length
}
},
readableObjectMode: {
__proto__: null,
enumerable: false,
get() {
return this._readableState ? this._readableState.objectMode : false
}
},
readableEncoding: {
__proto__: null,
enumerable: false,
get() {
return this._readableState ? this._readableState.encoding : null
}
},
errored: {
__proto__: null,
enumerable: false,
get() {
return this._readableState ? this._readableState.errored : null
}
},
closed: {
__proto__: null,
get() {
return this._readableState ? this._readableState.closed : false
}
},
destroyed: {
__proto__: null,
enumerable: false,
get() {
return this._readableState ? this._readableState.destroyed : false
},
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;
}
},
readableEnded: {
__proto__: null,
enumerable: false,
get() {
return this._readableState ? this._readableState.endEmitted : false
}
}
});
ObjectDefineProperties(ReadableState.prototype, {
// Legacy getter for `pipesCount`.
pipesCount: {
__proto__: null,
get() {
return this.pipes.length
}
},
// Legacy property for `paused`.
paused: {
__proto__: null,
get() {
return this[kPaused] !== false
},
set(value) {
this[kPaused] = !!value;
}
}
});
// Exposed for testing purposes only.
Readable._fromList = fromList;
// Pluck off n bytes from an array of buffers.
// Length is the combined lengths of all the buffers in the list.
// This function is designed to be inlinable, so please take care when making
// changes to the function body.
function fromList(n, state) {
// nothing buffered.
if (state.length === 0) return null
let 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) {
const 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.errored && !state.closeEmitted && !state.endEmitted && state.length === 0) {
state.endEmitted = true;
stream.emit('end');
if (stream.writable && stream.allowHalfOpen === false) {
process.nextTick(endWritableNT, stream);
} else if (state.autoDestroy) {
// In case of duplex streams we need a way to detect
// if the writable side is ready for autoDestroy as well.
const wState = stream._writableState;
const autoDestroy =
!wState ||
(wState.autoDestroy &&
// We don't expect the writable to ever 'finish'
// if writable is explicitly set to false.
(wState.finished || wState.writable === false));
if (autoDestroy) {
stream.destroy();
}
}
}
}
function endWritableNT(stream) {
const writable = stream.writable && !stream.writableEnded && !stream.destroyed;
if (writable) {
stream.end();
}
}
Readable.from = function (iterable, opts) {
return from(Readable, iterable, opts)
};
let webStreamsAdapters;
// Lazy to avoid circular references
function lazyWebStreams() {
if (webStreamsAdapters === undefined) webStreamsAdapters = {};
return webStreamsAdapters
}
Readable.fromWeb = function (readableStream, options) {
return lazyWebStreams().newStreamReadableFromReadableStream(readableStream, options)
};
Readable.toWeb = function (streamReadable, options) {
return lazyWebStreams().newReadableStreamFromStreamReadable(streamReadable, options)
};
Readable.wrap = function (src, options) {
var _ref, _src$readableObjectMo;
return new Readable({
objectMode:
(_ref =
(_src$readableObjectMo = src.readableObjectMode) !== null && _src$readableObjectMo !== undefined
? _src$readableObjectMo
: src.objectMode) !== null && _ref !== undefined
? _ref
: true,
...options,
destroy(err, callback) {
destroyImpl.destroyer(src, err);
callback(err);
}
}).wrap(src)
};
return readable;
}
/* replacement start */
var writable;
var hasRequiredWritable;
function requireWritable () {
if (hasRequiredWritable) return writable;
hasRequiredWritable = 1;
const process = requireProcess()
/* replacement end */
// 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.
; const {
ArrayPrototypeSlice,
Error,
FunctionPrototypeSymbolHasInstance,
ObjectDefineProperty,
ObjectDefineProperties,
ObjectSetPrototypeOf,
StringPrototypeToLowerCase,
Symbol,
SymbolHasInstance
} = requirePrimordials();
writable = Writable;
Writable.WritableState = WritableState;
const { EventEmitter: EE } = require$$2;
const Stream = requireLegacy().Stream;
const { Buffer } = require$$0;
const destroyImpl = requireDestroy();
const { addAbortSignal } = requireAddAbortSignal();
const { getHighWaterMark, getDefaultHighWaterMark } = requireState();
const {
ERR_INVALID_ARG_TYPE,
ERR_METHOD_NOT_IMPLEMENTED,
ERR_MULTIPLE_CALLBACK,
ERR_STREAM_CANNOT_PIPE,
ERR_STREAM_DESTROYED,
ERR_STREAM_ALREADY_FINISHED,
ERR_STREAM_NULL_VALUES,
ERR_STREAM_WRITE_AFTER_END,
ERR_UNKNOWN_ENCODING
} = requireErrors().codes;
const { errorOrDestroy } = destroyImpl;
ObjectSetPrototypeOf(Writable.prototype, Stream.prototype);
ObjectSetPrototypeOf(Writable, Stream);
function nop() {}
const kOnFinished = Symbol('kOnFinished');
function WritableState(options, stream, isDuplex) {
// 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 requireDuplex();
// Object stream flag to indicate whether or not this stream
// contains buffers or objects.
this.objectMode = !!(options && options.objectMode);
if (isDuplex) this.objectMode = this.objectMode || !!(options && 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 = options
? getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex)
: getDefaultHighWaterMark(false);
// 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.
const noDecode = !!(options && 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 && 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 = onwrite.bind(undefined, stream);
// 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;
// Storage for data passed to the afterWrite() callback in case of
// synchronous _write() completion.
this.afterWriteTickInfo = null;
resetBuffer(this);
// Number of pending user-supplied write callbacks
// this must be 0 before 'finish' can be emitted.
this.pendingcb = 0;
// Stream is still being constructed and cannot be
// destroyed until construction finished or failed.
// Async construction is opt in, therefore we start as
// constructed.
this.constructed = true;
// 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 || options.emitClose !== false;
// Should .destroy() be called after 'finish' (and potentially 'end').
this.autoDestroy = !options || options.autoDestroy !== false;
// Indicates whether the stream has errored. When true all write() calls
// should return false. This is needed since when autoDestroy
// is disabled we need a way to tell whether the stream has failed.
this.errored = null;
// Indicates whether the stream has finished destroying.
this.closed = false;
// True if close has been emitted or would have been emitted
// depending on emitClose.
this.closeEmitted = false;
this[kOnFinished] = [];
}
function resetBuffer(state) {
state.buffered = [];
state.bufferedIndex = 0;
state.allBuffers = true;
state.allNoop = true;
}
WritableState.prototype.getBuffer = function getBuffer() {
return ArrayPrototypeSlice(this.buffered, this.bufferedIndex)
};
ObjectDefineProperty(WritableState.prototype, 'bufferedRequestCount', {
__proto__: null,
get() {
return this.buffered.length - this.bufferedIndex
}
});
function Writable(options) {
// 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.
const isDuplex = this instanceof requireDuplex();
if (!isDuplex && !FunctionPrototypeSymbolHasInstance(Writable, this)) return new Writable(options)
this._writableState = new WritableState(options, this, isDuplex);
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;
if (typeof options.construct === 'function') this._construct = options.construct;
if (options.signal) addAbortSignal(options.signal, this);
}
Stream.call(this, options);
destroyImpl.construct(this, () => {
const state = this._writableState;
if (!state.writing) {
clearBuffer(this, state);
}
finishMaybe(this, state);
});
}
ObjectDefineProperty(Writable, SymbolHasInstance, {
__proto__: null,
value: function (object) {
if (FunctionPrototypeSymbolHasInstance(this, object)) return true
if (this !== Writable) return false
return object && object._writableState instanceof WritableState
}
});
// Otherwise people can pipe Writable streams, which is just wrong.
Writable.prototype.pipe = function () {
errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
};
function _write(stream, chunk, encoding, cb) {
const state = stream._writableState;
if (typeof encoding === 'function') {
cb = encoding;
encoding = state.defaultEncoding;
} else {
if (!encoding) encoding = state.defaultEncoding;
else if (encoding !== 'buffer' && !Buffer.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding)
if (typeof cb !== 'function') cb = nop;
}
if (chunk === null) {
throw new ERR_STREAM_NULL_VALUES()
} else if (!state.objectMode) {
if (typeof chunk === 'string') {
if (state.decodeStrings !== false) {
chunk = Buffer.from(chunk, encoding);
encoding = 'buffer';
}
} else if (chunk instanceof Buffer) {
encoding = 'buffer';
} else if (Stream._isUint8Array(chunk)) {
chunk = Stream._uint8ArrayToBuffer(chunk);
encoding = 'buffer';
} else {
throw new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk)
}
}
let err;
if (state.ending) {
err = new ERR_STREAM_WRITE_AFTER_END();
} else if (state.destroyed) {
err = new ERR_STREAM_DESTROYED('write');
}
if (err) {
process.nextTick(cb, err);
errorOrDestroy(stream, err, true);
return err
}
state.pendingcb++;
return writeOrBuffer(stream, state, chunk, encoding, cb)
}
Writable.prototype.write = function (chunk, encoding, cb) {
return _write(this, chunk, encoding, cb) === true
};
Writable.prototype.cork = function () {
this._writableState.corked++;
};
Writable.prototype.uncork = function () {
const state = this._writableState;
if (state.corked) {
state.corked--;
if (!state.writing) clearBuffer(this, state);
}
};
Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
// node::ParseEncoding() requires lower case.
if (typeof encoding === 'string') encoding = StringPrototypeToLowerCase(encoding);
if (!Buffer.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding)
this._writableState.defaultEncoding = encoding;
return 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, chunk, encoding, callback) {
const len = state.objectMode ? 1 : chunk.length;
state.length += len;
// stream._write resets state.length
const 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 || state.errored || !state.constructed) {
state.buffered.push({
chunk,
encoding,
callback
});
if (state.allBuffers && encoding !== 'buffer') {
state.allBuffers = false;
}
if (state.allNoop && callback !== nop) {
state.allNoop = false;
}
} else {
state.writelen = len;
state.writecb = callback;
state.writing = true;
state.sync = true;
stream._write(chunk, encoding, state.onwrite);
state.sync = false;
}
// Return false if errored or destroyed in order to break
// any synchronous while(stream.write(data)) loops.
return ret && !state.errored && !state.destroyed
}
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, er, cb) {
--state.pendingcb;
cb(er);
// Ensure callbacks are invoked even when autoDestroy is
// not enabled. Passing `er` here doesn't make sense since
// it's related to one specific write, not to the buffered
// writes.
errorBuffer(state);
// This can emit error, but error must always follow cb.
errorOrDestroy(stream, er);
}
function onwrite(stream, er) {
const state = stream._writableState;
const sync = state.sync;
const cb = state.writecb;
if (typeof cb !== 'function') {
errorOrDestroy(stream, new ERR_MULTIPLE_CALLBACK());
return
}
state.writing = false;
state.writecb = null;
state.length -= state.writelen;
state.writelen = 0;
if (er) {
// Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
er.stack; // eslint-disable-line no-unused-expressions
if (!state.errored) {
state.errored = er;
}
// In case of duplex streams we need to notify the readable side of the
// error.
if (stream._readableState && !stream._readableState.errored) {
stream._readableState.errored = er;
}
if (sync) {
process.nextTick(onwriteError, stream, state, er, cb);
} else {
onwriteError(stream, state, er, cb);
}
} else {
if (state.buffered.length > state.bufferedIndex) {
clearBuffer(stream, state);
}
if (sync) {
// It is a common case that the callback passed to .write() is always
// the same. In that case, we do not schedule a new nextTick(), but
// rather just increase a counter, to improve performance and avoid
// memory allocations.
if (state.afterWriteTickInfo !== null && state.afterWriteTickInfo.cb === cb) {
state.afterWriteTickInfo.count++;
} else {
state.afterWriteTickInfo = {
count: 1,
cb,
stream,
state
};
process.nextTick(afterWriteTick, state.afterWriteTickInfo);
}
} else {
afterWrite(stream, state, 1, cb);
}
}
}
function afterWriteTick({ stream, state, count, cb }) {
state.afterWriteTickInfo = null;
return afterWrite(stream, state, count, cb)
}
function afterWrite(stream, state, count, cb) {
const needDrain = !state.ending && !stream.destroyed && state.length === 0 && state.needDrain;
if (needDrain) {
state.needDrain = false;
stream.emit('drain');
}
while (count-- > 0) {
state.pendingcb--;
cb();
}
if (state.destroyed) {
errorBuffer(state);
}
finishMaybe(stream, state);
}
// If there's something in the buffer waiting, then invoke callbacks.
function errorBuffer(state) {
if (state.writing) {
return
}
for (let n = state.bufferedIndex; n < state.buffered.length; ++n) {
var _state$errored;
const { chunk, callback } = state.buffered[n];
const len = state.objectMode ? 1 : chunk.length;
state.length -= len;
callback(
(_state$errored = state.errored) !== null && _state$errored !== undefined
? _state$errored
: new ERR_STREAM_DESTROYED('write')
);
}
const onfinishCallbacks = state[kOnFinished].splice(0);
for (let i = 0; i < onfinishCallbacks.length; i++) {
var _state$errored2;
onfinishCallbacks[i](
(_state$errored2 = state.errored) !== null && _state$errored2 !== undefined
? _state$errored2
: new ERR_STREAM_DESTROYED('end')
);
}
resetBuffer(state);
}
// If there's something in the buffer waiting, then process it.
function clearBuffer(stream, state) {
if (state.corked || state.bufferProcessing || state.destroyed || !state.constructed) {
return
}
const { buffered, bufferedIndex, objectMode } = state;
const bufferedLength = buffered.length - bufferedIndex;
if (!bufferedLength) {
return
}
let i = bufferedIndex;
state.bufferProcessing = true;
if (bufferedLength > 1 && stream._writev) {
state.pendingcb -= bufferedLength - 1;
const callback = state.allNoop
? nop
: (err) => {
for (let n = i; n < buffered.length; ++n) {
buffered[n].callback(err);
}
};
// Make a copy of `buffered` if it's going to be used by `callback` above,
// since `doWrite` will mutate the array.
const chunks = state.allNoop && i === 0 ? buffered : ArrayPrototypeSlice(buffered, i);
chunks.allBuffers = state.allBuffers;
doWrite(stream, state, true, state.length, chunks, '', callback);
resetBuffer(state);
} else {
do {
const { chunk, encoding, callback } = buffered[i];
buffered[i++] = null;
const len = objectMode ? 1 : chunk.length;
doWrite(stream, state, false, len, chunk, encoding, callback);
} while (i < buffered.length && !state.writing)
if (i === buffered.length) {
resetBuffer(state);
} else if (i > 256) {
buffered.splice(0, i);
state.bufferedIndex = 0;
} else {
state.bufferedIndex = i;
}
}
state.bufferProcessing = false;
}
Writable.prototype._write = function (chunk, encoding, cb) {
if (this._writev) {
this._writev(
[
{
chunk,
encoding
}
],
cb
);
} else {
throw new ERR_METHOD_NOT_IMPLEMENTED('_write()')
}
};
Writable.prototype._writev = null;
Writable.prototype.end = function (chunk, encoding, cb) {
const state = this._writableState;
if (typeof chunk === 'function') {
cb = chunk;
chunk = null;
encoding = null;
} else if (typeof encoding === 'function') {
cb = encoding;
encoding = null;
}
let err;
if (chunk !== null && chunk !== undefined) {
const ret = _write(this, chunk, encoding);
if (ret instanceof Error) {
err = ret;
}
}
// .end() fully uncorks.
if (state.corked) {
state.corked = 1;
this.uncork();
}
if (err) ; else if (!state.errored && !state.ending) {
// This is forgiving in terms of unnecessary calls to end() and can hide
// logic errors. However, usually such errors are harmless and causing a
// hard error can be disproportionately destructive. It is not always
// trivial for the user to determine whether end() needs to be called
// or not.
state.ending = true;
finishMaybe(this, state, true);
state.ended = true;
} else if (state.finished) {
err = new ERR_STREAM_ALREADY_FINISHED('end');
} else if (state.destroyed) {
err = new ERR_STREAM_DESTROYED('end');
}
if (typeof cb === 'function') {
if (err || state.finished) {
process.nextTick(cb, err);
} else {
state[kOnFinished].push(cb);
}
}
return this
};
function needFinish(state) {
return (
state.ending &&
!state.destroyed &&
state.constructed &&
state.length === 0 &&
!state.errored &&
state.buffered.length === 0 &&
!state.finished &&
!state.writing &&
!state.errorEmitted &&
!state.closeEmitted
)
}
function callFinal(stream, state) {
let called = false;
function onFinish(err) {
if (called) {
errorOrDestroy(stream, err !== null && err !== undefined ? err : ERR_MULTIPLE_CALLBACK());
return
}
called = true;
state.pendingcb--;
if (err) {
const onfinishCallbacks = state[kOnFinished].splice(0);
for (let i = 0; i < onfinishCallbacks.length; i++) {
onfinishCallbacks[i](err);
}
errorOrDestroy(stream, err, state.sync);
} else if (needFinish(state)) {
state.prefinished = true;
stream.emit('prefinish');
// Backwards compat. Don't check state.sync here.
// Some streams assume 'finish' will be emitted
// asynchronously relative to _final callback.
state.pendingcb++;
process.nextTick(finish, stream, state);
}
}
state.sync = true;
state.pendingcb++;
try {
stream._final(onFinish);
} catch (err) {
onFinish(err);
}
state.sync = false;
}
function prefinish(stream, state) {
if (!state.prefinished && !state.finalCalled) {
if (typeof stream._final === 'function' && !state.destroyed) {
state.finalCalled = true;
callFinal(stream, state);
} else {
state.prefinished = true;
stream.emit('prefinish');
}
}
}
function finishMaybe(stream, state, sync) {
if (needFinish(state)) {
prefinish(stream, state);
if (state.pendingcb === 0) {
if (sync) {
state.pendingcb++;
process.nextTick(
(stream, state) => {
if (needFinish(state)) {
finish(stream, state);
} else {
state.pendingcb--;
}
},
stream,
state
);
} else if (needFinish(state)) {
state.pendingcb++;
finish(stream, state);
}
}
}
}
function finish(stream, state) {
state.pendingcb--;
state.finished = true;
const onfinishCallbacks = state[kOnFinished].splice(0);
for (let i = 0; i < onfinishCallbacks.length; i++) {
onfinishCallbacks[i]();
}
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.
const rState = stream._readableState;
const autoDestroy =
!rState ||
(rState.autoDestroy &&
// We don't expect the readable to ever 'end'
// if readable is explicitly set to false.
(rState.endEmitted || rState.readable === false));
if (autoDestroy) {
stream.destroy();
}
}
}
ObjectDefineProperties(Writable.prototype, {
closed: {
__proto__: null,
get() {
return this._writableState ? this._writableState.closed : false
}
},
destroyed: {
__proto__: null,
get() {
return this._writableState ? this._writableState.destroyed : false
},
set(value) {
// Backward compatibility, the user is explicitly managing destroyed.
if (this._writableState) {
this._writableState.destroyed = value;
}
}
},
writable: {
__proto__: null,
get() {
const w = this._writableState;
// w.writable === false means that this is part of a Duplex stream
// where the writable side was disabled upon construction.
// Compat. The user might manually disable writable side through
// deprecated setter.
return !!w && w.writable !== false && !w.destroyed && !w.errored && !w.ending && !w.ended
},
set(val) {
// Backwards compatible.
if (this._writableState) {
this._writableState.writable = !!val;
}
}
},
writableFinished: {
__proto__: null,
get() {
return this._writableState ? this._writableState.finished : false
}
},
writableObjectMode: {
__proto__: null,
get() {
return this._writableState ? this._writableState.objectMode : false
}
},
writableBuffer: {
__proto__: null,
get() {
return this._writableState && this._writableState.getBuffer()
}
},
writableEnded: {
__proto__: null,
get() {
return this._writableState ? this._writableState.ending : false
}
},
writableNeedDrain: {
__proto__: null,
get() {
const wState = this._writableState;
if (!wState) return false
return !wState.destroyed && !wState.ending && wState.needDrain
}
},
writableHighWaterMark: {
__proto__: null,
get() {
return this._writableState && this._writableState.highWaterMark
}
},
writableCorked: {
__proto__: null,
get() {
return this._writableState ? this._writableState.corked : 0
}
},
writableLength: {
__proto__: null,
get() {
return this._writableState && this._writableState.length
}
},
errored: {
__proto__: null,
enumerable: false,
get() {
return this._writableState ? this._writableState.errored : null
}
},
writableAborted: {
__proto__: null,
enumerable: false,
get: function () {
return !!(
this._writableState.writable !== false &&
(this._writableState.destroyed || this._writableState.errored) &&
!this._writableState.finished
)
}
}
});
const destroy = destroyImpl.destroy;
Writable.prototype.destroy = function (err, cb) {
const state = this._writableState;
// Invoke pending callbacks.
if (!state.destroyed && (state.bufferedIndex < state.buffered.length || state[kOnFinished].length)) {
process.nextTick(errorBuffer, state);
}
destroy.call(this, err, cb);
return this
};
Writable.prototype._undestroy = destroyImpl.undestroy;
Writable.prototype._destroy = function (err, cb) {
cb(err);
};
Writable.prototype[EE.captureRejectionSymbol] = function (err) {
this.destroy(err);
};
let webStreamsAdapters;
// Lazy to avoid circular references
function lazyWebStreams() {
if (webStreamsAdapters === undefined) webStreamsAdapters = {};
return webStreamsAdapters
}
Writable.fromWeb = function (writableStream, options) {
return lazyWebStreams().newStreamWritableFromWritableStream(writableStream, options)
};
Writable.toWeb = function (streamWritable) {
return lazyWebStreams().newWritableStreamFromStreamWritable(streamWritable)
};
return writable;
}
/* replacement start */
var duplexify;
var hasRequiredDuplexify;
function requireDuplexify () {
if (hasRequiredDuplexify) return duplexify;
hasRequiredDuplexify = 1;
const process = requireProcess()
/* replacement end */
; const bufferModule = require$$0;
const {
isReadable,
isWritable,
isIterable,
isNodeStream,
isReadableNodeStream,
isWritableNodeStream,
isDuplexNodeStream
} = requireUtils();
const eos = requireEndOfStream();
const {
AbortError,
codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE }
} = requireErrors();
const { destroyer } = requireDestroy();
const Duplex = requireDuplex();
const Readable = requireReadable();
const { createDeferredPromise } = requireUtil();
const from = requireFrom();
const Blob = globalThis.Blob || bufferModule.Blob;
const isBlob =
typeof Blob !== 'undefined'
? function isBlob(b) {
return b instanceof Blob
}
: function isBlob(b) {
return false
};
const AbortController = globalThis.AbortController || require$$9.AbortController;
const { FunctionPrototypeCall } = requirePrimordials();
// This is needed for pre node 17.
class Duplexify extends Duplex {
constructor(options) {
super(options);
// https://github.com/nodejs/node/pull/34385
if ((options === null || options === undefined ? undefined : options.readable) === false) {
this._readableState.readable = false;
this._readableState.ended = true;
this._readableState.endEmitted = true;
}
if ((options === null || options === undefined ? undefined : options.writable) === false) {
this._writableState.writable = false;
this._writableState.ending = true;
this._writableState.ended = true;
this._writableState.finished = true;
}
}
}
duplexify = function duplexify(body, name) {
if (isDuplexNodeStream(body)) {
return body
}
if (isReadableNodeStream(body)) {
return _duplexify({
readable: body
})
}
if (isWritableNodeStream(body)) {
return _duplexify({
writable: body
})
}
if (isNodeStream(body)) {
return _duplexify({
writable: false,
readable: false
})
}
// TODO: Webstreams
// if (isReadableStream(body)) {
// return _duplexify({ readable: Readable.fromWeb(body) });
// }
// TODO: Webstreams
// if (isWritableStream(body)) {
// return _duplexify({ writable: Writable.fromWeb(body) });
// }
if (typeof body === 'function') {
const { value, write, final, destroy } = fromAsyncGen(body);
if (isIterable(value)) {
return from(Duplexify, value, {
// TODO (ronag): highWaterMark?
objectMode: true,
write,
final,
destroy
})
}
const then = value === null || value === undefined ? undefined : value.then;
if (typeof then === 'function') {
let d;
const promise = FunctionPrototypeCall(
then,
value,
(val) => {
if (val != null) {
throw new ERR_INVALID_RETURN_VALUE('nully', 'body', val)
}
},
(err) => {
destroyer(d, err);
}
);
return (d = new Duplexify({
// TODO (ronag): highWaterMark?
objectMode: true,
readable: false,
write,
final(cb) {
final(async () => {
try {
await promise;
process.nextTick(cb, null);
} catch (err) {
process.nextTick(cb, err);
}
});
},
destroy
}))
}
throw new ERR_INVALID_RETURN_VALUE('Iterable, AsyncIterable or AsyncFunction', name, value)
}
if (isBlob(body)) {
return duplexify(body.arrayBuffer())
}
if (isIterable(body)) {
return from(Duplexify, body, {
// TODO (ronag): highWaterMark?
objectMode: true,
writable: false
})
}
// TODO: Webstreams.
// if (
// isReadableStream(body?.readable) &&
// isWritableStream(body?.writable)
// ) {
// return Duplexify.fromWeb(body);
// }
if (
typeof (body === null || body === undefined ? undefined : body.writable) === 'object' ||
typeof (body === null || body === undefined ? undefined : body.readable) === 'object'
) {
const readable =
body !== null && body !== undefined && body.readable
? isReadableNodeStream(body === null || body === undefined ? undefined : body.readable)
? body === null || body === undefined
? undefined
: body.readable
: duplexify(body.readable)
: undefined;
const writable =
body !== null && body !== undefined && body.writable
? isWritableNodeStream(body === null || body === undefined ? undefined : body.writable)
? body === null || body === undefined
? undefined
: body.writable
: duplexify(body.writable)
: undefined;
return _duplexify({
readable,
writable
})
}
const then = body === null || body === undefined ? undefined : body.then;
if (typeof then === 'function') {
let d;
FunctionPrototypeCall(
then,
body,
(val) => {
if (val != null) {
d.push(val);
}
d.push(null);
},
(err) => {
destroyer(d, err);
}
);
return (d = new Duplexify({
objectMode: true,
writable: false,
read() {}
}))
}
throw new ERR_INVALID_ARG_TYPE(
name,
[
'Blob',
'ReadableStream',
'WritableStream',
'Stream',
'Iterable',
'AsyncIterable',
'Function',
'{ readable, writable } pair',
'Promise'
],
body
)
};
function fromAsyncGen(fn) {
let { promise, resolve } = createDeferredPromise();
const ac = new AbortController();
const signal = ac.signal;
const value = fn(
(async function* () {
while (true) {
const _promise = promise;
promise = null;
const { chunk, done, cb } = await _promise;
process.nextTick(cb);
if (done) return
if (signal.aborted)
throw new AbortError(undefined, {
cause: signal.reason
})
;({ promise, resolve } = createDeferredPromise());
yield chunk;
}
})(),
{
signal
}
);
return {
value,
write(chunk, encoding, cb) {
const _resolve = resolve;
resolve = null;
_resolve({
chunk,
done: false,
cb
});
},
final(cb) {
const _resolve = resolve;
resolve = null;
_resolve({
done: true,
cb
});
},
destroy(err, cb) {
ac.abort();
cb(err);
}
}
}
function _duplexify(pair) {
const r = pair.readable && typeof pair.readable.read !== 'function' ? Readable.wrap(pair.readable) : pair.readable;
const w = pair.writable;
let readable = !!isReadable(r);
let writable = !!isWritable(w);
let ondrain;
let onfinish;
let onreadable;
let onclose;
let d;
function onfinished(err) {
const cb = onclose;
onclose = null;
if (cb) {
cb(err);
} else if (err) {
d.destroy(err);
} else if (!readable && !writable) {
d.destroy();
}
}
// TODO(ronag): Avoid double buffering.
// Implement Writable/Readable/Duplex traits.
// See, https://github.com/nodejs/node/pull/33515.
d = new Duplexify({
// TODO (ronag): highWaterMark?
readableObjectMode: !!(r !== null && r !== undefined && r.readableObjectMode),
writableObjectMode: !!(w !== null && w !== undefined && w.writableObjectMode),
readable,
writable
});
if (writable) {
eos(w, (err) => {
writable = false;
if (err) {
destroyer(r, err);
}
onfinished(err);
});
d._write = function (chunk, encoding, callback) {
if (w.write(chunk, encoding)) {
callback();
} else {
ondrain = callback;
}
};
d._final = function (callback) {
w.end();
onfinish = callback;
};
w.on('drain', function () {
if (ondrain) {
const cb = ondrain;
ondrain = null;
cb();
}
});
w.on('finish', function () {
if (onfinish) {
const cb = onfinish;
onfinish = null;
cb();
}
});
}
if (readable) {
eos(r, (err) => {
readable = false;
if (err) {
destroyer(r, err);
}
onfinished(err);
});
r.on('readable', function () {
if (onreadable) {
const cb = onreadable;
onreadable = null;
cb();
}
});
r.on('end', function () {
d.push(null);
});
d._read = function () {
while (true) {
const buf = r.read();
if (buf === null) {
onreadable = d._read;
return
}
if (!d.push(buf)) {
return
}
}
};
}
d._destroy = function (err, callback) {
if (!err && onclose !== null) {
err = new AbortError();
}
onreadable = null;
ondrain = null;
onfinish = null;
if (onclose === null) {
callback(err);
} else {
onclose = callback;
destroyer(w, err);
destroyer(r, err);
}
};
return d
}
return duplexify;
}
var duplex;
var hasRequiredDuplex;
function requireDuplex () {
if (hasRequiredDuplex) return duplex;
hasRequiredDuplex = 1;
const {
ObjectDefineProperties,
ObjectGetOwnPropertyDescriptor,
ObjectKeys,
ObjectSetPrototypeOf
} = requirePrimordials();
duplex = Duplex;
const Readable = requireReadable();
const Writable = requireWritable();
ObjectSetPrototypeOf(Duplex.prototype, Readable.prototype);
ObjectSetPrototypeOf(Duplex, Readable);
{
const keys = ObjectKeys(Writable.prototype);
// Allow the keys array to be GC'ed.
for (let i = 0; i < keys.length; i++) {
const method = keys[i];
if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
}
}
function Duplex(options) {
if (!(this instanceof Duplex)) return new Duplex(options)
Readable.call(this, options);
Writable.call(this, options);
if (options) {
this.allowHalfOpen = options.allowHalfOpen !== false;
if (options.readable === false) {
this._readableState.readable = false;
this._readableState.ended = true;
this._readableState.endEmitted = true;
}
if (options.writable === false) {
this._writableState.writable = false;
this._writableState.ending = true;
this._writableState.ended = true;
this._writableState.finished = true;
}
} else {
this.allowHalfOpen = true;
}
}
ObjectDefineProperties(Duplex.prototype, {
writable: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writable')
},
writableHighWaterMark: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableHighWaterMark')
},
writableObjectMode: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableObjectMode')
},
writableBuffer: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableBuffer')
},
writableLength: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableLength')
},
writableFinished: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableFinished')
},
writableCorked: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableCorked')
},
writableEnded: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableEnded')
},
writableNeedDrain: {
__proto__: null,
...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableNeedDrain')
},
destroyed: {
__proto__: null,
get() {
if (this._readableState === undefined || this._writableState === undefined) {
return false
}
return this._readableState.destroyed && this._writableState.destroyed
},
set(value) {
// Backward compatibility, the user is explicitly
// managing destroyed.
if (this._readableState && this._writableState) {
this._readableState.destroyed = value;
this._writableState.destroyed = value;
}
}
}
});
let webStreamsAdapters;
// Lazy to avoid circular references
function lazyWebStreams() {
if (webStreamsAdapters === undefined) webStreamsAdapters = {};
return webStreamsAdapters
}
Duplex.fromWeb = function (pair, options) {
return lazyWebStreams().newStreamDuplexFromReadableWritablePair(pair, options)
};
Duplex.toWeb = function (duplex) {
return lazyWebStreams().newReadableWritablePairFromDuplex(duplex)
};
let duplexify;
Duplex.from = function (body) {
if (!duplexify) {
duplexify = requireDuplexify();
}
return duplexify(body, 'body')
};
return duplex;
}
var transform;
var hasRequiredTransform;
function requireTransform () {
if (hasRequiredTransform) return transform;
hasRequiredTransform = 1;
const { ObjectSetPrototypeOf, Symbol } = requirePrimordials();
transform = Transform;
const { ERR_METHOD_NOT_IMPLEMENTED } = requireErrors().codes;
const Duplex = requireDuplex();
const { getHighWaterMark } = requireState();
ObjectSetPrototypeOf(Transform.prototype, Duplex.prototype);
ObjectSetPrototypeOf(Transform, Duplex);
const kCallback = Symbol('kCallback');
function Transform(options) {
if (!(this instanceof Transform)) return new Transform(options)
// TODO (ronag): This should preferably always be
// applied but would be semver-major. Or even better;
// make Transform a Readable with the Writable interface.
const readableHighWaterMark = options ? getHighWaterMark(this, options, 'readableHighWaterMark', true) : null;
if (readableHighWaterMark === 0) {
// A Duplex will buffer both on the writable and readable side while
// a Transform just wants to buffer hwm number of elements. To avoid
// buffering twice we disable buffering on the writable side.
options = {
...options,
highWaterMark: null,
readableHighWaterMark,
// TODO (ronag): 0 is not optimal since we have
// a "bug" where we check needDrain before calling _write and not after.
// Refs: https://github.com/nodejs/node/pull/32887
// Refs: https://github.com/nodejs/node/pull/35941
writableHighWaterMark: options.writableHighWaterMark || 0
};
}
Duplex.call(this, options);
// 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;
this[kCallback] = null;
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.
// Backwards compat. Some Transform streams incorrectly implement _final
// instead of or in addition to _flush. By using 'prefinish' instead of
// implementing _final we continue supporting this unfortunate use case.
this.on('prefinish', prefinish);
}
function final(cb) {
if (typeof this._flush === 'function' && !this.destroyed) {
this._flush((er, data) => {
if (er) {
if (cb) {
cb(er);
} else {
this.destroy(er);
}
return
}
if (data != null) {
this.push(data);
}
this.push(null);
if (cb) {
cb();
}
});
} else {
this.push(null);
if (cb) {
cb();
}
}
}
function prefinish() {
if (this._final !== final) {
final.call(this);
}
}
Transform.prototype._final = final;
Transform.prototype._transform = function (chunk, encoding, callback) {
throw new ERR_METHOD_NOT_IMPLEMENTED('_transform()')
};
Transform.prototype._write = function (chunk, encoding, callback) {
const rState = this._readableState;
const wState = this._writableState;
const length = rState.length;
this._transform(chunk, encoding, (err, val) => {
if (err) {
callback(err);
return
}
if (val != null) {
this.push(val);
}
if (
wState.ended ||
// Backwards compat.
length === rState.length ||
// Backwards compat.
rState.length < rState.highWaterMark
) {
callback();
} else {
this[kCallback] = callback;
}
});
};
Transform.prototype._read = function () {
if (this[kCallback]) {
const callback = this[kCallback];
this[kCallback] = null;
callback();
}
};
return transform;
}
var passthrough;
var hasRequiredPassthrough;
function requirePassthrough () {
if (hasRequiredPassthrough) return passthrough;
hasRequiredPassthrough = 1;
const { ObjectSetPrototypeOf } = requirePrimordials();
passthrough = PassThrough;
const Transform = requireTransform();
ObjectSetPrototypeOf(PassThrough.prototype, Transform.prototype);
ObjectSetPrototypeOf(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);
};
return passthrough;
}
/* replacement start */
var pipeline_1;
var hasRequiredPipeline;
function requirePipeline () {
if (hasRequiredPipeline) return pipeline_1;
hasRequiredPipeline = 1;
const process = requireProcess()
/* replacement end */
// Ported from https://github.com/mafintosh/pump with
// permission from the author, Mathias Buus (@mafintosh).
; const { ArrayIsArray, Promise, SymbolAsyncIterator } = requirePrimordials();
const eos = requireEndOfStream();
const { once } = requireUtil();
const destroyImpl = requireDestroy();
const Duplex = requireDuplex();
const {
aggregateTwoErrors,
codes: {
ERR_INVALID_ARG_TYPE,
ERR_INVALID_RETURN_VALUE,
ERR_MISSING_ARGS,
ERR_STREAM_DESTROYED,
ERR_STREAM_PREMATURE_CLOSE
},
AbortError
} = requireErrors();
const { validateFunction, validateAbortSignal } = requireValidators();
const { isIterable, isReadable, isReadableNodeStream, isNodeStream } = requireUtils();
const AbortController = globalThis.AbortController || require$$9.AbortController;
let PassThrough;
let Readable;
function destroyer(stream, reading, writing) {
let finished = false;
stream.on('close', () => {
finished = true;
});
const cleanup = eos(
stream,
{
readable: reading,
writable: writing
},
(err) => {
finished = !err;
}
);
return {
destroy: (err) => {
if (finished) return
finished = true;
destroyImpl.destroyer(stream, err || new ERR_STREAM_DESTROYED('pipe'));
},
cleanup
}
}
function popCallback(streams) {
// Streams should never be an empty array. It should always contain at least
// a single stream. Therefore optimize for the average case instead of
// checking for length === 0 as well.
validateFunction(streams[streams.length - 1], 'streams[stream.length - 1]');
return streams.pop()
}
function makeAsyncIterable(val) {
if (isIterable(val)) {
return val
} else if (isReadableNodeStream(val)) {
// Legacy streams are not Iterable.
return fromReadable(val)
}
throw new ERR_INVALID_ARG_TYPE('val', ['Readable', 'Iterable', 'AsyncIterable'], val)
}
async function* fromReadable(val) {
if (!Readable) {
Readable = requireReadable();
}
yield* Readable.prototype[SymbolAsyncIterator].call(val);
}
async function pump(iterable, writable, finish, { end }) {
let error;
let onresolve = null;
const resume = (err) => {
if (err) {
error = err;
}
if (onresolve) {
const callback = onresolve;
onresolve = null;
callback();
}
};
const wait = () =>
new Promise((resolve, reject) => {
if (error) {
reject(error);
} else {
onresolve = () => {
if (error) {
reject(error);
} else {
resolve();
}
};
}
});
writable.on('drain', resume);
const cleanup = eos(
writable,
{
readable: false
},
resume
);
try {
if (writable.writableNeedDrain) {
await wait();
}
for await (const chunk of iterable) {
if (!writable.write(chunk)) {
await wait();
}
}
if (end) {
writable.end();
}
await wait();
finish();
} catch (err) {
finish(error !== err ? aggregateTwoErrors(error, err) : err);
} finally {
cleanup();
writable.off('drain', resume);
}
}
function pipeline(...streams) {
return pipelineImpl(streams, once(popCallback(streams)))
}
function pipelineImpl(streams, callback, opts) {
if (streams.length === 1 && ArrayIsArray(streams[0])) {
streams = streams[0];
}
if (streams.length < 2) {
throw new ERR_MISSING_ARGS('streams')
}
const ac = new AbortController();
const signal = ac.signal;
const outerSignal = opts === null || opts === undefined ? undefined : opts.signal;
// Need to cleanup event listeners if last stream is readable
// https://github.com/nodejs/node/issues/35452
const lastStreamCleanup = [];
validateAbortSignal(outerSignal, 'options.signal');
function abort() {
finishImpl(new AbortError());
}
outerSignal === null || outerSignal === undefined ? undefined : outerSignal.addEventListener('abort', abort);
let error;
let value;
const destroys = [];
let finishCount = 0;
function finish(err) {
finishImpl(err, --finishCount === 0);
}
function finishImpl(err, final) {
if (err && (!error || error.code === 'ERR_STREAM_PREMATURE_CLOSE')) {
error = err;
}
if (!error && !final) {
return
}
while (destroys.length) {
destroys.shift()(error);
}
outerSignal === null || outerSignal === undefined ? undefined : outerSignal.removeEventListener('abort', abort);
ac.abort();
if (final) {
if (!error) {
lastStreamCleanup.forEach((fn) => fn());
}
process.nextTick(callback, error, value);
}
}
let ret;
for (let i = 0; i < streams.length; i++) {
const stream = streams[i];
const reading = i < streams.length - 1;
const writing = i > 0;
const end = reading || (opts === null || opts === undefined ? undefined : opts.end) !== false;
const isLastStream = i === streams.length - 1;
if (isNodeStream(stream)) {
if (end) {
const { destroy, cleanup } = destroyer(stream, reading, writing);
destroys.push(destroy);
if (isReadable(stream) && isLastStream) {
lastStreamCleanup.push(cleanup);
}
}
// Catch stream errors that occur after pipe/pump has completed.
function onError(err) {
if (err && err.name !== 'AbortError' && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
finish(err);
}
}
stream.on('error', onError);
if (isReadable(stream) && isLastStream) {
lastStreamCleanup.push(() => {
stream.removeListener('error', onError);
});
}
}
if (i === 0) {
if (typeof stream === 'function') {
ret = stream({
signal
});
if (!isIterable(ret)) {
throw new ERR_INVALID_RETURN_VALUE('Iterable, AsyncIterable or Stream', 'source', ret)
}
} else if (isIterable(stream) || isReadableNodeStream(stream)) {
ret = stream;
} else {
ret = Duplex.from(stream);
}
} else if (typeof stream === 'function') {
ret = makeAsyncIterable(ret);
ret = stream(ret, {
signal
});
if (reading) {
if (!isIterable(ret, true)) {
throw new ERR_INVALID_RETURN_VALUE('AsyncIterable', `transform[${i - 1}]`, ret)
}
} else {
var _ret;
if (!PassThrough) {
PassThrough = requirePassthrough();
}
// If the last argument to pipeline is not a stream
// we must create a proxy stream so that pipeline(...)
// always returns a stream which can be further
// composed through `.pipe(stream)`.
const pt = new PassThrough({
objectMode: true
});
// Handle Promises/A+ spec, `then` could be a getter that throws on
// second use.
const then = (_ret = ret) === null || _ret === undefined ? undefined : _ret.then;
if (typeof then === 'function') {
finishCount++;
then.call(
ret,
(val) => {
value = val;
if (val != null) {
pt.write(val);
}
if (end) {
pt.end();
}
process.nextTick(finish);
},
(err) => {
pt.destroy(err);
process.nextTick(finish, err);
}
);
} else if (isIterable(ret, true)) {
finishCount++;
pump(ret, pt, finish, {
end
});
} else {
throw new ERR_INVALID_RETURN_VALUE('AsyncIterable or Promise', 'destination', ret)
}
ret = pt;
const { destroy, cleanup } = destroyer(ret, false, true);
destroys.push(destroy);
if (isLastStream) {
lastStreamCleanup.push(cleanup);
}
}
} else if (isNodeStream(stream)) {
if (isReadableNodeStream(ret)) {
finishCount += 2;
const cleanup = pipe(ret, stream, finish, {
end
});
if (isReadable(stream) && isLastStream) {
lastStreamCleanup.push(cleanup);
}
} else if (isIterable(ret)) {
finishCount++;
pump(ret, stream, finish, {
end
});
} else {
throw new ERR_INVALID_ARG_TYPE('val', ['Readable', 'Iterable', 'AsyncIterable'], ret)
}
ret = stream;
} else {
ret = Duplex.from(stream);
}
}
if (
(signal !== null && signal !== undefined && signal.aborted) ||
(outerSignal !== null && outerSignal !== undefined && outerSignal.aborted)
) {
process.nextTick(abort);
}
return ret
}
function pipe(src, dst, finish, { end }) {
let ended = false;
dst.on('close', () => {
if (!ended) {
// Finish if the destination closes before the source has completed.
finish(new ERR_STREAM_PREMATURE_CLOSE());
}
});
src.pipe(dst, {
end
});
if (end) {
// Compat. Before node v10.12.0 stdio used to throw an error so
// pipe() did/does not end() stdio destinations.
// Now they allow it but "secretly" don't close the underlying fd.
src.once('end', () => {
ended = true;
dst.end();
});
} else {
finish();
}
eos(
src,
{
readable: true,
writable: false
},
(err) => {
const rState = src._readableState;
if (
err &&
err.code === 'ERR_STREAM_PREMATURE_CLOSE' &&
rState &&
rState.ended &&
!rState.errored &&
!rState.errorEmitted
) {
// Some readable streams will emit 'close' before 'end'. However, since
// this is on the readable side 'end' should still be emitted if the
// stream has been ended and no error emitted. This should be allowed in
// favor of backwards compatibility. Since the stream is piped to a
// destination this should not result in any observable difference.
// We don't need to check if this is a writable premature close since
// eos will only fail with premature close on the reading side for
// duplex streams.
src.once('end', finish).once('error', finish);
} else {
finish(err);
}
}
);
return eos(
dst,
{
readable: false,
writable: true
},
finish
)
}
pipeline_1 = {
pipelineImpl,
pipeline
};
return pipeline_1;
}
var compose;
var hasRequiredCompose;
function requireCompose () {
if (hasRequiredCompose) return compose;
hasRequiredCompose = 1;
const { pipeline } = requirePipeline();
const Duplex = requireDuplex();
const { destroyer } = requireDestroy();
const { isNodeStream, isReadable, isWritable } = requireUtils();
const {
AbortError,
codes: { ERR_INVALID_ARG_VALUE, ERR_MISSING_ARGS }
} = requireErrors();
compose = function compose(...streams) {
if (streams.length === 0) {
throw new ERR_MISSING_ARGS('streams')
}
if (streams.length === 1) {
return Duplex.from(streams[0])
}
const orgStreams = [...streams];
if (typeof streams[0] === 'function') {
streams[0] = Duplex.from(streams[0]);
}
if (typeof streams[streams.length - 1] === 'function') {
const idx = streams.length - 1;
streams[idx] = Duplex.from(streams[idx]);
}
for (let n = 0; n < streams.length; ++n) {
if (!isNodeStream(streams[n])) {
// TODO(ronag): Add checks for non streams.
continue
}
if (n < streams.length - 1 && !isReadable(streams[n])) {
throw new ERR_INVALID_ARG_VALUE(`streams[${n}]`, orgStreams[n], 'must be readable')
}
if (n > 0 && !isWritable(streams[n])) {
throw new ERR_INVALID_ARG_VALUE(`streams[${n}]`, orgStreams[n], 'must be writable')
}
}
let ondrain;
let onfinish;
let onreadable;
let onclose;
let d;
function onfinished(err) {
const cb = onclose;
onclose = null;
if (cb) {
cb(err);
} else if (err) {
d.destroy(err);
} else if (!readable && !writable) {
d.destroy();
}
}
const head = streams[0];
const tail = pipeline(streams, onfinished);
const writable = !!isWritable(head);
const readable = !!isReadable(tail);
// TODO(ronag): Avoid double buffering.
// Implement Writable/Readable/Duplex traits.
// See, https://github.com/nodejs/node/pull/33515.
d = new Duplex({
// TODO (ronag): highWaterMark?
writableObjectMode: !!(head !== null && head !== undefined && head.writableObjectMode),
readableObjectMode: !!(tail !== null && tail !== undefined && tail.writableObjectMode),
writable,
readable
});
if (writable) {
d._write = function (chunk, encoding, callback) {
if (head.write(chunk, encoding)) {
callback();
} else {
ondrain = callback;
}
};
d._final = function (callback) {
head.end();
onfinish = callback;
};
head.on('drain', function () {
if (ondrain) {
const cb = ondrain;
ondrain = null;
cb();
}
});
tail.on('finish', function () {
if (onfinish) {
const cb = onfinish;
onfinish = null;
cb();
}
});
}
if (readable) {
tail.on('readable', function () {
if (onreadable) {
const cb = onreadable;
onreadable = null;
cb();
}
});
tail.on('end', function () {
d.push(null);
});
d._read = function () {
while (true) {
const buf = tail.read();
if (buf === null) {
onreadable = d._read;
return
}
if (!d.push(buf)) {
return
}
}
};
}
d._destroy = function (err, callback) {
if (!err && onclose !== null) {
err = new AbortError();
}
onreadable = null;
ondrain = null;
onfinish = null;
if (onclose === null) {
callback(err);
} else {
onclose = callback;
destroyer(tail, err);
}
};
return d
};
return compose;
}
var promises;
var hasRequiredPromises;
function requirePromises () {
if (hasRequiredPromises) return promises;
hasRequiredPromises = 1;
const { ArrayPrototypePop, Promise } = requirePrimordials();
const { isIterable, isNodeStream } = requireUtils();
const { pipelineImpl: pl } = requirePipeline();
const { finished } = requireEndOfStream();
function pipeline(...streams) {
return new Promise((resolve, reject) => {
let signal;
let end;
const lastArg = streams[streams.length - 1];
if (lastArg && typeof lastArg === 'object' && !isNodeStream(lastArg) && !isIterable(lastArg)) {
const options = ArrayPrototypePop(streams);
signal = options.signal;
end = options.end;
}
pl(
streams,
(err, value) => {
if (err) {
reject(err);
} else {
resolve(value);
}
},
{
signal,
end
}
);
})
}
promises = {
finished,
pipeline
};
return promises;
}
/* replacement start */
var hasRequiredStream;
function requireStream () {
if (hasRequiredStream) return stream.exports;
hasRequiredStream = 1;
const { Buffer } = require$$0
/* replacement end */
// 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.
; const { ObjectDefineProperty, ObjectKeys, ReflectApply } = requirePrimordials();
const {
promisify: { custom: customPromisify }
} = requireUtil();
const { streamReturningOperators, promiseReturningOperators } = requireOperators();
const {
codes: { ERR_ILLEGAL_CONSTRUCTOR }
} = requireErrors();
const compose = requireCompose();
const { pipeline } = requirePipeline();
const { destroyer } = requireDestroy();
const eos = requireEndOfStream();
const promises = requirePromises();
const utils = requireUtils();
const Stream = (stream.exports = requireLegacy().Stream);
Stream.isDisturbed = utils.isDisturbed;
Stream.isErrored = utils.isErrored;
Stream.isReadable = utils.isReadable;
Stream.Readable = requireReadable();
for (const key of ObjectKeys(streamReturningOperators)) {
const op = streamReturningOperators[key];
function fn(...args) {
if (new.target) {
throw ERR_ILLEGAL_CONSTRUCTOR()
}
return Stream.Readable.from(ReflectApply(op, this, args))
}
ObjectDefineProperty(fn, 'name', {
__proto__: null,
value: op.name
});
ObjectDefineProperty(fn, 'length', {
__proto__: null,
value: op.length
});
ObjectDefineProperty(Stream.Readable.prototype, key, {
__proto__: null,
value: fn,
enumerable: false,
configurable: true,
writable: true
});
}
for (const key of ObjectKeys(promiseReturningOperators)) {
const op = promiseReturningOperators[key];
function fn(...args) {
if (new.target) {
throw ERR_ILLEGAL_CONSTRUCTOR()
}
return ReflectApply(op, this, args)
}
ObjectDefineProperty(fn, 'name', {
__proto__: null,
value: op.name
});
ObjectDefineProperty(fn, 'length', {
__proto__: null,
value: op.length
});
ObjectDefineProperty(Stream.Readable.prototype, key, {
__proto__: null,
value: fn,
enumerable: false,
configurable: true,
writable: true
});
}
Stream.Writable = requireWritable();
Stream.Duplex = requireDuplex();
Stream.Transform = requireTransform();
Stream.PassThrough = requirePassthrough();
Stream.pipeline = pipeline;
const { addAbortSignal } = requireAddAbortSignal();
Stream.addAbortSignal = addAbortSignal;
Stream.finished = eos;
Stream.destroy = destroyer;
Stream.compose = compose;
ObjectDefineProperty(Stream, 'promises', {
__proto__: null,
configurable: true,
enumerable: true,
get() {
return promises
}
});
ObjectDefineProperty(pipeline, customPromisify, {
__proto__: null,
enumerable: true,
get() {
return promises.pipeline
}
});
ObjectDefineProperty(eos, customPromisify, {
__proto__: null,
enumerable: true,
get() {
return promises.finished
}
});
// Backwards-compat with node 0.4.x
Stream.Stream = Stream;
Stream._isUint8Array = function isUint8Array(value) {
return value instanceof Uint8Array
};
Stream._uint8ArrayToBuffer = function _uint8ArrayToBuffer(chunk) {
return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)
};
return stream.exports;
}
(function (module) {
const Stream = require$$0$1;
if (Stream && process.env.READABLE_STREAM === 'disable') {
const promises = Stream.promises;
// Explicit export naming is needed for ESM
module.exports._uint8ArrayToBuffer = Stream._uint8ArrayToBuffer;
module.exports._isUint8Array = Stream._isUint8Array;
module.exports.isDisturbed = Stream.isDisturbed;
module.exports.isErrored = Stream.isErrored;
module.exports.isReadable = Stream.isReadable;
module.exports.Readable = Stream.Readable;
module.exports.Writable = Stream.Writable;
module.exports.Duplex = Stream.Duplex;
module.exports.Transform = Stream.Transform;
module.exports.PassThrough = Stream.PassThrough;
module.exports.addAbortSignal = Stream.addAbortSignal;
module.exports.finished = Stream.finished;
module.exports.destroy = Stream.destroy;
module.exports.pipeline = Stream.pipeline;
module.exports.compose = Stream.compose;
Object.defineProperty(Stream, 'promises', {
configurable: true,
enumerable: true,
get() {
return promises
}
});
module.exports.Stream = Stream.Stream;
} else {
const CustomStream = requireStream();
const promises = requirePromises();
const originalDestroy = CustomStream.Readable.destroy;
module.exports = CustomStream.Readable;
// Explicit export naming is needed for ESM
module.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer;
module.exports._isUint8Array = CustomStream._isUint8Array;
module.exports.isDisturbed = CustomStream.isDisturbed;
module.exports.isErrored = CustomStream.isErrored;
module.exports.isReadable = CustomStream.isReadable;
module.exports.Readable = CustomStream.Readable;
module.exports.Writable = CustomStream.Writable;
module.exports.Duplex = CustomStream.Duplex;
module.exports.Transform = CustomStream.Transform;
module.exports.PassThrough = CustomStream.PassThrough;
module.exports.addAbortSignal = CustomStream.addAbortSignal;
module.exports.finished = CustomStream.finished;
module.exports.destroy = CustomStream.destroy;
module.exports.destroy = originalDestroy;
module.exports.pipeline = CustomStream.pipeline;
module.exports.compose = CustomStream.compose;
Object.defineProperty(CustomStream, 'promises', {
configurable: true,
enumerable: true,
get() {
return promises
}
});
module.exports.Stream = CustomStream.Stream;
}
// Allow default importing
module.exports.default = module.exports;
} (ours));
var inherits$1 = {exports: {}};
var inherits_browser = {exports: {}};
var hasRequiredInherits_browser;
function requireInherits_browser () {
if (hasRequiredInherits_browser) return inherits_browser.exports;
hasRequiredInherits_browser = 1;
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
inherits_browser.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
}
};
} else {
// old school shim for old browsers
inherits_browser.exports = function inherits(ctor, superCtor) {
if (superCtor) {
ctor.super_ = superCtor;
var TempCtor = function () {};
TempCtor.prototype = superCtor.prototype;
ctor.prototype = new TempCtor();
ctor.prototype.constructor = ctor;
}
};
}
return inherits_browser.exports;
}
(function (module) {
try {
var util = require('util');
/* istanbul ignore next */
if (typeof util.inherits !== 'function') throw '';
module.exports = util.inherits;
} catch (e) {
/* istanbul ignore next */
module.exports = requireInherits_browser();
}
} (inherits$1));
const { Buffer: Buffer$1 } = require$$0;
const symbol = Symbol.for('BufferList');
function BufferList$1 (buf) {
if (!(this instanceof BufferList$1)) {
return new BufferList$1(buf)
}
BufferList$1._init.call(this, buf);
}
BufferList$1._init = function _init (buf) {
Object.defineProperty(this, symbol, { value: true });
this._bufs = [];
this.length = 0;
if (buf) {
this.append(buf);
}
};
BufferList$1.prototype._new = function _new (buf) {
return new BufferList$1(buf)
};
BufferList$1.prototype._offset = function _offset (offset) {
if (offset === 0) {
return [0, 0]
}
let tot = 0;
for (let i = 0; i < this._bufs.length; i++) {
const _t = tot + this._bufs[i].length;
if (offset < _t || i === this._bufs.length - 1) {
return [i, offset - tot]
}
tot = _t;
}
};
BufferList$1.prototype._reverseOffset = function (blOffset) {
const bufferId = blOffset[0];
let offset = blOffset[1];
for (let i = 0; i < bufferId; i++) {
offset += this._bufs[i].length;
}
return offset
};
BufferList$1.prototype.get = function get (index) {
if (index > this.length || index < 0) {
return undefined
}
const offset = this._offset(index);
return this._bufs[offset[0]][offset[1]]
};
BufferList$1.prototype.slice = function slice (start, end) {
if (typeof start === 'number' && start < 0) {
start += this.length;
}
if (typeof end === 'number' && end < 0) {
end += this.length;
}
return this.copy(null, 0, start, end)
};
BufferList$1.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {
if (typeof srcStart !== 'number' || srcStart < 0) {
srcStart = 0;
}
if (typeof srcEnd !== 'number' || srcEnd > this.length) {
srcEnd = this.length;
}
if (srcStart >= this.length) {
return dst || Buffer$1.alloc(0)
}
if (srcEnd <= 0) {
return dst || Buffer$1.alloc(0)
}
const copy = !!dst;
const off = this._offset(srcStart);
const len = srcEnd - srcStart;
let bytes = len;
let bufoff = (copy && dstStart) || 0;
let start = off[1];
// copy/slice everything
if (srcStart === 0 && srcEnd === this.length) {
if (!copy) {
// slice, but full concat if multiple buffers
return this._bufs.length === 1
? this._bufs[0]
: Buffer$1.concat(this._bufs, this.length)
}
// copy, need to copy individual buffers
for (let i = 0; i < this._bufs.length; i++) {
this._bufs[i].copy(dst, bufoff);
bufoff += this._bufs[i].length;
}
return dst
}
// easy, cheap case where it's a subset of one of the buffers
if (bytes <= this._bufs[off[0]].length - start) {
return copy
? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)
: this._bufs[off[0]].slice(start, start + bytes)
}
if (!copy) {
// a slice, we need something to copy in to
dst = Buffer$1.allocUnsafe(len);
}
for (let i = off[0]; i < this._bufs.length; i++) {
const l = this._bufs[i].length - start;
if (bytes > l) {
this._bufs[i].copy(dst, bufoff, start);
bufoff += l;
} else {
this._bufs[i].copy(dst, bufoff, start, start + bytes);
bufoff += l;
break
}
bytes -= l;
if (start) {
start = 0;
}
}
// safeguard so that we don't return uninitialized memory
if (dst.length > bufoff) return dst.slice(0, bufoff)
return dst
};
BufferList$1.prototype.shallowSlice = function shallowSlice (start, end) {
start = start || 0;
end = typeof end !== 'number' ? this.length : end;
if (start < 0) {
start += this.length;
}
if (end < 0) {
end += this.length;
}
if (start === end) {
return this._new()
}
const startOffset = this._offset(start);
const endOffset = this._offset(end);
const buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1);
if (endOffset[1] === 0) {
buffers.pop();
} else {
buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1]);
}
if (startOffset[1] !== 0) {
buffers[0] = buffers[0].slice(startOffset[1]);
}
return this._new(buffers)
};
BufferList$1.prototype.toString = function toString (encoding, start, end) {
return this.slice(start, end).toString(encoding)
};
BufferList$1.prototype.consume = function consume (bytes) {
// first, normalize the argument, in accordance with how Buffer does it
bytes = Math.trunc(bytes);
// do nothing if not a positive number
if (Number.isNaN(bytes) || bytes <= 0) return this
while (this._bufs.length) {
if (bytes >= this._bufs[0].length) {
bytes -= this._bufs[0].length;
this.length -= this._bufs[0].length;
this._bufs.shift();
} else {
this._bufs[0] = this._bufs[0].slice(bytes);
this.length -= bytes;
break
}
}
return this
};
BufferList$1.prototype.duplicate = function duplicate () {
const copy = this._new();
for (let i = 0; i < this._bufs.length; i++) {
copy.append(this._bufs[i]);
}
return copy
};
BufferList$1.prototype.append = function append (buf) {
if (buf == null) {
return this
}
if (buf.buffer) {
// append a view of the underlying ArrayBuffer
this._appendBuffer(Buffer$1.from(buf.buffer, buf.byteOffset, buf.byteLength));
} else if (Array.isArray(buf)) {
for (let i = 0; i < buf.length; i++) {
this.append(buf[i]);
}
} else if (this._isBufferList(buf)) {
// unwrap argument into individual BufferLists
for (let i = 0; i < buf._bufs.length; i++) {
this.append(buf._bufs[i]);
}
} else {
// coerce number arguments to strings, since Buffer(number) does
// uninitialized memory allocation
if (typeof buf === 'number') {
buf = buf.toString();
}
this._appendBuffer(Buffer$1.from(buf));
}
return this
};
BufferList$1.prototype._appendBuffer = function appendBuffer (buf) {
this._bufs.push(buf);
this.length += buf.length;
};
BufferList$1.prototype.indexOf = function (search, offset, encoding) {
if (encoding === undefined && typeof offset === 'string') {
encoding = offset;
offset = undefined;
}
if (typeof search === 'function' || Array.isArray(search)) {
throw new TypeError('The "value" argument must be one of type string, Buffer, BufferList, or Uint8Array.')
} else if (typeof search === 'number') {
search = Buffer$1.from([search]);
} else if (typeof search === 'string') {
search = Buffer$1.from(search, encoding);
} else if (this._isBufferList(search)) {
search = search.slice();
} else if (Array.isArray(search.buffer)) {
search = Buffer$1.from(search.buffer, search.byteOffset, search.byteLength);
} else if (!Buffer$1.isBuffer(search)) {
search = Buffer$1.from(search);
}
offset = Number(offset || 0);
if (isNaN(offset)) {
offset = 0;
}
if (offset < 0) {
offset = this.length + offset;
}
if (offset < 0) {
offset = 0;
}
if (search.length === 0) {
return offset > this.length ? this.length : offset
}
const blOffset = this._offset(offset);
let blIndex = blOffset[0]; // index of which internal buffer we're working on
let buffOffset = blOffset[1]; // offset of the internal buffer we're working on
// scan over each buffer
for (; blIndex < this._bufs.length; blIndex++) {
const buff = this._bufs[blIndex];
while (buffOffset < buff.length) {
const availableWindow = buff.length - buffOffset;
if (availableWindow >= search.length) {
const nativeSearchResult = buff.indexOf(search, buffOffset);
if (nativeSearchResult !== -1) {
return this._reverseOffset([blIndex, nativeSearchResult])
}
buffOffset = buff.length - search.length + 1; // end of native search window
} else {
const revOffset = this._reverseOffset([blIndex, buffOffset]);
if (this._match(revOffset, search)) {
return revOffset
}
buffOffset++;
}
}
buffOffset = 0;
}
return -1
};
BufferList$1.prototype._match = function (offset, search) {
if (this.length - offset < search.length) {
return false
}
for (let searchOffset = 0; searchOffset < search.length; searchOffset++) {
if (this.get(offset + searchOffset) !== search[searchOffset]) {
return false
}
}
return true
}
;(function () {
const methods = {
readDoubleBE: 8,
readDoubleLE: 8,
readFloatBE: 4,
readFloatLE: 4,
readBigInt64BE: 8,
readBigInt64LE: 8,
readBigUInt64BE: 8,
readBigUInt64LE: 8,
readInt32BE: 4,
readInt32LE: 4,
readUInt32BE: 4,
readUInt32LE: 4,
readInt16BE: 2,
readInt16LE: 2,
readUInt16BE: 2,
readUInt16LE: 2,
readInt8: 1,
readUInt8: 1,
readIntBE: null,
readIntLE: null,
readUIntBE: null,
readUIntLE: null
};
for (const m in methods) {
(function (m) {
if (methods[m] === null) {
BufferList$1.prototype[m] = function (offset, byteLength) {
return this.slice(offset, offset + byteLength)[m](0, byteLength)
};
} else {
BufferList$1.prototype[m] = function (offset = 0) {
return this.slice(offset, offset + methods[m])[m](0)
};
}
}(m));
}
}());
// Used internally by the class and also as an indicator of this object being
// a `BufferList`. It's not possible to use `instanceof BufferList` in a browser
// environment because there could be multiple different copies of the
// BufferList class and some `BufferList`s might be `BufferList`s.
BufferList$1.prototype._isBufferList = function _isBufferList (b) {
return b instanceof BufferList$1 || BufferList$1.isBufferList(b)
};
BufferList$1.isBufferList = function isBufferList (b) {
return b != null && b[symbol]
};
var BufferList_1 = BufferList$1;
const DuplexStream = ours.exports.Duplex;
const inherits = inherits$1.exports;
const BufferList = BufferList_1;
function BufferListStream (callback) {
if (!(this instanceof BufferListStream)) {
return new BufferListStream(callback)
}
if (typeof callback === 'function') {
this._callback = callback;
const piper = function piper (err) {
if (this._callback) {
this._callback(err);
this._callback = null;
}
}.bind(this);
this.on('pipe', function onPipe (src) {
src.on('error', piper);
});
this.on('unpipe', function onUnpipe (src) {
src.removeListener('error', piper);
});
callback = null;
}
BufferList._init.call(this, callback);
DuplexStream.call(this);
}
inherits(BufferListStream, DuplexStream);
Object.assign(BufferListStream.prototype, BufferList.prototype);
BufferListStream.prototype._new = function _new (callback) {
return new BufferListStream(callback)
};
BufferListStream.prototype._write = function _write (buf, encoding, callback) {
this._appendBuffer(buf);
if (typeof callback === 'function') {
callback();
}
};
BufferListStream.prototype._read = function _read (size) {
if (!this.length) {
return this.push(null)
}
size = Math.min(size, this.length);
this.push(this.slice(0, size));
this.consume(size);
};
BufferListStream.prototype.end = function end (chunk) {
DuplexStream.prototype.end.call(this, chunk);
if (this._callback) {
this._callback(null, this.slice());
this._callback = null;
}
};
BufferListStream.prototype._destroy = function _destroy (err, cb) {
this._bufs.length = 0;
this.length = 0;
cb(err);
};
BufferListStream.prototype._isBufferList = function _isBufferList (b) {
return b instanceof BufferListStream || b instanceof BufferList || BufferListStream.isBufferList(b)
};
BufferListStream.isBufferList = BufferList.isBufferList;
bl.exports = BufferListStream;
bl.exports.BufferListStream = BufferListStream;
bl.exports.BufferList = BufferList;
var queueMicrotask_1;
var hasRequiredQueueMicrotask;
function requireQueueMicrotask () {
if (hasRequiredQueueMicrotask) return queueMicrotask_1;
hasRequiredQueueMicrotask = 1;
queueMicrotask_1 = typeof queueMicrotask === 'function' ? queueMicrotask : (fn) => Promise.resolve().then(fn);
return queueMicrotask_1;
}
var processNextTick = (typeof process !== 'undefined' && typeof process.nextTick === 'function')
? process.nextTick.bind(process)
: requireQueueMicrotask();
var fixedSize = class FixedFIFO {
constructor (hwm) {
if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two')
this.buffer = new Array(hwm);
this.mask = hwm - 1;
this.top = 0;
this.btm = 0;
this.next = null;
}
push (data) {
if (this.buffer[this.top] !== undefined) return false
this.buffer[this.top] = data;
this.top = (this.top + 1) & this.mask;
return true
}
shift () {
const last = this.buffer[this.btm];
if (last === undefined) return undefined
this.buffer[this.btm] = undefined;
this.btm = (this.btm + 1) & this.mask;
return last
}
peek () {
return this.buffer[this.btm]
}
isEmpty () {
return this.buffer[this.btm] === undefined
}
};
const FixedFIFO = fixedSize;
var fastFifo = class FastFIFO {
constructor (hwm) {
this.hwm = hwm || 16;
this.head = new FixedFIFO(this.hwm);
this.tail = this.head;
}
push (val) {
if (!this.head.push(val)) {
const prev = this.head;
this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
this.head.push(val);
}
}
shift () {
const val = this.tail.shift();
if (val === undefined && this.tail.next) {
const next = this.tail.next;
this.tail.next = null;
this.tail = next;
return this.tail.shift()
}
return val
}
peek () {
return this.tail.peek()
}
isEmpty () {
return this.head.isEmpty()
}
};
const { EventEmitter } = require$$2;
const STREAM_DESTROYED = new Error('Stream was destroyed');
const PREMATURE_CLOSE = new Error('Premature close');
const queueTick = processNextTick;
const FIFO = fastFifo;
/* eslint-disable no-multi-spaces */
// 26 bits used total (4 from shared, 13 from read, and 9 from write)
const MAX = ((1 << 26) - 1);
// Shared state
const OPENING = 0b0001;
const PREDESTROYING = 0b0010;
const DESTROYING = 0b0100;
const DESTROYED = 0b1000;
const NOT_OPENING = MAX ^ OPENING;
const NOT_PREDESTROYING = MAX ^ PREDESTROYING;
// Read state (4 bit offset from shared state)
const READ_ACTIVE = 0b0000000000001 << 4;
const READ_PRIMARY = 0b0000000000010 << 4;
const READ_SYNC = 0b0000000000100 << 4;
const READ_QUEUED = 0b0000000001000 << 4;
const READ_RESUMED = 0b0000000010000 << 4;
const READ_PIPE_DRAINED = 0b0000000100000 << 4;
const READ_ENDING = 0b0000001000000 << 4;
const READ_EMIT_DATA = 0b0000010000000 << 4;
const READ_EMIT_READABLE = 0b0000100000000 << 4;
const READ_EMITTED_READABLE = 0b0001000000000 << 4;
const READ_DONE = 0b0010000000000 << 4;
const READ_NEXT_TICK = 0b0100000000001 << 4; // also active
const READ_NEEDS_PUSH = 0b1000000000000 << 4;
// Combined read state
const READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED;
const READ_ACTIVE_AND_SYNC = READ_ACTIVE | READ_SYNC;
const READ_ACTIVE_AND_SYNC_AND_NEEDS_PUSH = READ_ACTIVE | READ_SYNC | READ_NEEDS_PUSH;
const READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE;
const READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED;
const READ_NOT_ACTIVE = MAX ^ READ_ACTIVE;
const READ_NON_PRIMARY = MAX ^ READ_PRIMARY;
const READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH);
const READ_NOT_SYNC = MAX ^ READ_SYNC;
const READ_PUSHED = MAX ^ READ_NEEDS_PUSH;
const READ_PAUSED = MAX ^ READ_RESUMED;
const READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE);
const READ_NOT_ENDING = MAX ^ READ_ENDING;
const READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING;
const READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK;
// Write state (17 bit offset, 4 bit offset from shared state and 13 from read state)
const WRITE_ACTIVE = 0b000000001 << 17;
const WRITE_PRIMARY = 0b000000010 << 17;
const WRITE_SYNC = 0b000000100 << 17;
const WRITE_QUEUED = 0b000001000 << 17;
const WRITE_UNDRAINED = 0b000010000 << 17;
const WRITE_DONE = 0b000100000 << 17;
const WRITE_EMIT_DRAIN = 0b001000000 << 17;
const WRITE_NEXT_TICK = 0b010000001 << 17; // also active
const WRITE_FINISHING = 0b100000000 << 17;
const WRITE_NOT_ACTIVE = MAX ^ WRITE_ACTIVE;
const WRITE_NOT_SYNC = MAX ^ WRITE_SYNC;
const WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY;
const WRITE_NOT_FINISHING = MAX ^ WRITE_FINISHING;
const WRITE_DRAINED = MAX ^ WRITE_UNDRAINED;
const WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED;
const WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK;
// Combined shared state
const ACTIVE = READ_ACTIVE | WRITE_ACTIVE;
const NOT_ACTIVE = MAX ^ ACTIVE;
const DONE = READ_DONE | WRITE_DONE;
const DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING;
const OPEN_STATUS = DESTROY_STATUS | OPENING;
const AUTO_DESTROY = DESTROY_STATUS | DONE;
const NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY;
const ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK;
const TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE;
const IS_OPENING = OPEN_STATUS | TICKING;
// Combined shared state and read state
const READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE;
const READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED;
const READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED;
const READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE;
const SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH;
const READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE;
// Combined write state
const WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE;
const WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED;
const WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE;
const WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE;
const WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED;
const WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE;
const WRITE_ACTIVE_AND_SYNC = WRITE_ACTIVE | WRITE_SYNC;
const WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE;
const WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE;
const asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator');
class WritableState {
constructor (stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
this.stream = stream;
this.queue = new FIFO();
this.highWaterMark = highWaterMark;
this.buffered = 0;
this.error = null;
this.pipeline = null;
this.byteLength = byteLengthWritable || byteLength || defaultByteLength;
this.map = mapWritable || map;
this.afterWrite = afterWrite.bind(this);
this.afterUpdateNextTick = updateWriteNT.bind(this);
}
get ended () {
return (this.stream._duplexState & WRITE_DONE) !== 0
}
push (data) {
if (this.map !== null) data = this.map(data);
this.buffered += this.byteLength(data);
this.queue.push(data);
if (this.buffered < this.highWaterMark) {
this.stream._duplexState |= WRITE_QUEUED;
return true
}
this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED;
return false
}
shift () {
const data = this.queue.shift();
const stream = this.stream;
this.buffered -= this.byteLength(data);
if (this.buffered === 0) stream._duplexState &= WRITE_NOT_QUEUED;
return data
}
end (data) {
if (typeof data === 'function') this.stream.once('finish', data);
else if (data !== undefined && data !== null) this.push(data);
this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY;
}
autoBatch (data, cb) {
const buffer = [];
const stream = this.stream;
buffer.push(data);
while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {
buffer.push(stream._writableState.shift());
}
if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null)
stream._writev(buffer, cb);
}
update () {
const stream = this.stream;
while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
const data = this.shift();
stream._duplexState |= WRITE_ACTIVE_AND_SYNC;
stream._write(data, this.afterWrite);
stream._duplexState &= WRITE_NOT_SYNC;
}
if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
}
updateNonPrimary () {
const stream = this.stream;
if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
stream._duplexState = (stream._duplexState | WRITE_ACTIVE) & WRITE_NOT_FINISHING;
stream._final(afterFinal.bind(this));
return
}
if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
stream._duplexState |= ACTIVE;
stream._destroy(afterDestroy.bind(this));
}
return
}
if ((stream._duplexState & IS_OPENING) === OPENING) {
stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
stream._open(afterOpen.bind(this));
}
}
updateNextTick () {
if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return
this.stream._duplexState |= WRITE_NEXT_TICK;
queueTick(this.afterUpdateNextTick);
}
}
class ReadableState {
constructor (stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
this.stream = stream;
this.queue = new FIFO();
this.highWaterMark = highWaterMark;
this.buffered = 0;
this.error = null;
this.pipeline = null;
this.byteLength = byteLengthReadable || byteLength || defaultByteLength;
this.map = mapReadable || map;
this.pipeTo = null;
this.afterRead = afterRead.bind(this);
this.afterUpdateNextTick = updateReadNT.bind(this);
}
get ended () {
return (this.stream._duplexState & READ_DONE) !== 0
}
pipe (pipeTo, cb) {
if (this.pipeTo !== null) throw new Error('Can only pipe to one destination')
if (typeof cb !== 'function') cb = null;
this.stream._duplexState |= READ_PIPE_DRAINED;
this.pipeTo = pipeTo;
this.pipeline = new Pipeline(this.stream, pipeTo, cb);
if (cb) this.stream.on('error', noop$1); // We already error handle this so supress crashes
if (isStreamx(pipeTo)) {
pipeTo._writableState.pipeline = this.pipeline;
if (cb) pipeTo.on('error', noop$1); // We already error handle this so supress crashes
pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)); // TODO: just call finished from pipeTo itself
} else {
const onerror = this.pipeline.done.bind(this.pipeline, pipeTo);
const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null); // onclose has a weird bool arg
pipeTo.on('error', onerror);
pipeTo.on('close', onclose);
pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline));
}
pipeTo.on('drain', afterDrain.bind(this));
this.stream.emit('piping', pipeTo);
pipeTo.emit('pipe', this.stream);
}
push (data) {
const stream = this.stream;
if (data === null) {
this.highWaterMark = 0;
stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED;
return false
}
if (this.map !== null) data = this.map(data);
this.buffered += this.byteLength(data);
this.queue.push(data);
stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED;
return this.buffered < this.highWaterMark
}
shift () {
const data = this.queue.shift();
this.buffered -= this.byteLength(data);
if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED;
return data
}
unshift (data) {
let tail;
const pending = [];
while ((tail = this.queue.shift()) !== undefined) {
pending.push(tail);
}
this.push(data);
for (let i = 0; i < pending.length; i++) {
this.queue.push(pending[i]);
}
}
read () {
const stream = this.stream;
if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {
const data = this.shift();
if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED;
if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data);
return data
}
return null
}
drain () {
const stream = this.stream;
while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {
const data = this.shift();
if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED;
if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data);
}
}
update () {
const stream = this.stream;
this.drain();
while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === 0) {
stream._duplexState |= READ_ACTIVE_AND_SYNC_AND_NEEDS_PUSH;
stream._read(this.afterRead);
stream._duplexState &= READ_NOT_SYNC;
if ((stream._duplexState & READ_ACTIVE) === 0) this.drain();
}
if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {
stream._duplexState |= READ_EMITTED_READABLE;
stream.emit('readable');
}
if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
}
updateNonPrimary () {
const stream = this.stream;
if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {
stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING;
stream.emit('end');
if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING;
if (this.pipeTo !== null) this.pipeTo.end();
}
if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
stream._duplexState |= ACTIVE;
stream._destroy(afterDestroy.bind(this));
}
return
}
if ((stream._duplexState & IS_OPENING) === OPENING) {
stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
stream._open(afterOpen.bind(this));
}
}
updateNextTick () {
if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return
this.stream._duplexState |= READ_NEXT_TICK;
queueTick(this.afterUpdateNextTick);
}
}
class TransformState {
constructor (stream) {
this.data = null;
this.afterTransform = afterTransform.bind(stream);
this.afterFinal = null;
}
}
class Pipeline {
constructor (src, dst, cb) {
this.from = src;
this.to = dst;
this.afterPipe = cb;
this.error = null;
this.pipeToFinished = false;
}
finished () {
this.pipeToFinished = true;
}
done (stream, err) {
if (err) this.error = err;
if (stream === this.to) {
this.to = null;
if (this.from !== null) {
if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {
this.from.destroy(this.error || new Error('Writable stream closed prematurely'));
}
return
}
}
if (stream === this.from) {
this.from = null;
if (this.to !== null) {
if ((stream._duplexState & READ_DONE) === 0) {
this.to.destroy(this.error || new Error('Readable stream closed before ending'));
}
return
}
}
if (this.afterPipe !== null) this.afterPipe(this.error);
this.to = this.from = this.afterPipe = null;
}
}
function afterDrain () {
this.stream._duplexState |= READ_PIPE_DRAINED;
if ((this.stream._duplexState & READ_ACTIVE_AND_SYNC) === 0) this.updateNextTick();
else this.drain();
}
function afterFinal (err) {
const stream = this.stream;
if (err) stream.destroy(err);
if ((stream._duplexState & DESTROY_STATUS) === 0) {
stream._duplexState |= WRITE_DONE;
stream.emit('finish');
}
if ((stream._duplexState & AUTO_DESTROY) === DONE) {
stream._duplexState |= DESTROYING;
}
stream._duplexState &= WRITE_NOT_ACTIVE;
this.update();
}
function afterDestroy (err) {
const stream = this.stream;
if (!err && this.error !== STREAM_DESTROYED) err = this.error;
if (err) stream.emit('error', err);
stream._duplexState |= DESTROYED;
stream.emit('close');
const rs = stream._readableState;
const ws = stream._writableState;
if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err);
if (ws !== null && ws.pipeline !== null) ws.pipeline.done(stream, err);
}
function afterWrite (err) {
const stream = this.stream;
if (err) stream.destroy(err);
stream._duplexState &= WRITE_NOT_ACTIVE;
if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {
stream._duplexState &= WRITE_DRAINED;
if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {
stream.emit('drain');
}
}
if ((stream._duplexState & WRITE_SYNC) === 0) this.update();
}
function afterRead (err) {
if (err) this.stream.destroy(err);
this.stream._duplexState &= READ_NOT_ACTIVE;
if ((this.stream._duplexState & READ_SYNC) === 0) this.update();
}
function updateReadNT () {
this.stream._duplexState &= READ_NOT_NEXT_TICK;
this.update();
}
function updateWriteNT () {
this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
this.update();
}
function afterOpen (err) {
const stream = this.stream;
if (err) stream.destroy(err);
if ((stream._duplexState & DESTROYING) === 0) {
if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY;
if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY;
stream.emit('open');
}
stream._duplexState &= NOT_ACTIVE;
if (stream._writableState !== null) {
stream._writableState.update();
}
if (stream._readableState !== null) {
stream._readableState.update();
}
}
function afterTransform (err, data) {
if (data !== undefined && data !== null) this.push(data);
this._writableState.afterWrite(err);
}
class Stream extends EventEmitter {
constructor (opts) {
super();
this._duplexState = 0;
this._readableState = null;
this._writableState = null;
if (opts) {
if (opts.open) this._open = opts.open;
if (opts.destroy) this._destroy = opts.destroy;
if (opts.predestroy) this._predestroy = opts.predestroy;
if (opts.signal) {
opts.signal.addEventListener('abort', abort.bind(this));
}
}
}
_open (cb) {
cb(null);
}
_destroy (cb) {
cb(null);
}
_predestroy () {
// does nothing
}
get readable () {
return this._readableState !== null ? true : undefined
}
get writable () {
return this._writableState !== null ? true : undefined
}
get destroyed () {
return (this._duplexState & DESTROYED) !== 0
}
get destroying () {
return (this._duplexState & DESTROY_STATUS) !== 0
}
destroy (err) {
if ((this._duplexState & DESTROY_STATUS) === 0) {
if (!err) err = STREAM_DESTROYED;
this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY;
if (this._readableState !== null) this._readableState.error = err;
if (this._writableState !== null) this._writableState.error = err;
this._duplexState |= PREDESTROYING;
this._predestroy();
this._duplexState &= NOT_PREDESTROYING;
if (this._readableState !== null) this._readableState.updateNextTick();
if (this._writableState !== null) this._writableState.updateNextTick();
}
}
on (name, fn) {
if (this._readableState !== null) {
if (name === 'data') {
this._duplexState |= (READ_EMIT_DATA | READ_RESUMED);
this._readableState.updateNextTick();
}
if (name === 'readable') {
this._duplexState |= READ_EMIT_READABLE;
this._readableState.updateNextTick();
}
}
if (this._writableState !== null) {
if (name === 'drain') {
this._duplexState |= WRITE_EMIT_DRAIN;
this._writableState.updateNextTick();
}
}
return super.on(name, fn)
}
}
class Readable$1 extends Stream {
constructor (opts) {
super(opts);
this._duplexState |= OPENING | WRITE_DONE;
this._readableState = new ReadableState(this, opts);
if (opts) {
if (opts.read) this._read = opts.read;
if (opts.eagerOpen) this.resume().pause();
}
}
_read (cb) {
cb(null);
}
pipe (dest, cb) {
this._readableState.pipe(dest, cb);
this._readableState.updateNextTick();
return dest
}
read () {
this._readableState.updateNextTick();
return this._readableState.read()
}
push (data) {
this._readableState.updateNextTick();
return this._readableState.push(data)
}
unshift (data) {
this._readableState.updateNextTick();
return this._readableState.unshift(data)
}
resume () {
this._duplexState |= READ_RESUMED;
this._readableState.updateNextTick();
return this
}
pause () {
this._duplexState &= READ_PAUSED;
return this
}
static _fromAsyncIterator (ite, opts) {
let destroy;
const rs = new Readable$1({
...opts,
read (cb) {
ite.next().then(push).then(cb.bind(null, null)).catch(cb);
},
predestroy () {
destroy = ite.return();
},
destroy (cb) {
if (!destroy) return cb(null)
destroy.then(cb.bind(null, null)).catch(cb);
}
});
return rs
function push (data) {
if (data.done) rs.push(null);
else rs.push(data.value);
}
}
static from (data, opts) {
if (isReadStreamx(data)) return data
if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts)
if (!Array.isArray(data)) data = data === undefined ? [] : [data];
let i = 0;
return new Readable$1({
...opts,
read (cb) {
this.push(i === data.length ? null : data[i++]);
cb(null);
}
})
}
static isBackpressured (rs) {
return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark
}
static isPaused (rs) {
return (rs._duplexState & READ_RESUMED) === 0
}
[asyncIterator] () {
const stream = this;
let error = null;
let promiseResolve = null;
let promiseReject = null;
this.on('error', (err) => { error = err; });
this.on('readable', onreadable);
this.on('close', onclose);
return {
[asyncIterator] () {
return this
},
next () {
return new Promise(function (resolve, reject) {
promiseResolve = resolve;
promiseReject = reject;
const data = stream.read();
if (data !== null) ondata(data);
else if ((stream._duplexState & DESTROYED) !== 0) ondata(null);
})
},
return () {
return destroy(null)
},
throw (err) {
return destroy(err)
}
}
function onreadable () {
if (promiseResolve !== null) ondata(stream.read());
}
function onclose () {
if (promiseResolve !== null) ondata(null);
}
function ondata (data) {
if (promiseReject === null) return
if (error) promiseReject(error);
else if (data === null && (stream._duplexState & READ_DONE) === 0) promiseReject(STREAM_DESTROYED);
else promiseResolve({ value: data, done: data === null });
promiseReject = promiseResolve = null;
}
function destroy (err) {
stream.destroy(err);
return new Promise((resolve, reject) => {
if (stream._duplexState & DESTROYED) return resolve({ value: undefined, done: true })
stream.once('close', function () {
if (err) reject(err);
else resolve({ value: undefined, done: true });
});
})
}
}
}
class Writable$1 extends Stream {
constructor (opts) {
super(opts);
this._duplexState |= OPENING | READ_DONE;
this._writableState = new WritableState(this, opts);
if (opts) {
if (opts.writev) this._writev = opts.writev;
if (opts.write) this._write = opts.write;
if (opts.final) this._final = opts.final;
}
}
_writev (batch, cb) {
cb(null);
}
_write (data, cb) {
this._writableState.autoBatch(data, cb);
}
_final (cb) {
cb(null);
}
static isBackpressured (ws) {
return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0
}
write (data) {
this._writableState.updateNextTick();
return this._writableState.push(data)
}
end (data) {
this._writableState.updateNextTick();
this._writableState.end(data);
return this
}
}
class Duplex extends Readable$1 { // and Writable
constructor (opts) {
super(opts);
this._duplexState = OPENING;
this._writableState = new WritableState(this, opts);
if (opts) {
if (opts.writev) this._writev = opts.writev;
if (opts.write) this._write = opts.write;
if (opts.final) this._final = opts.final;
}
}
_writev (batch, cb) {
cb(null);
}
_write (data, cb) {
this._writableState.autoBatch(data, cb);
}
_final (cb) {
cb(null);
}
write (data) {
this._writableState.updateNextTick();
return this._writableState.push(data)
}
end (data) {
this._writableState.updateNextTick();
this._writableState.end(data);
return this
}
}
class Transform extends Duplex {
constructor (opts) {
super(opts);
this._transformState = new TransformState(this);
if (opts) {
if (opts.transform) this._transform = opts.transform;
if (opts.flush) this._flush = opts.flush;
}
}
_write (data, cb) {
if (this._readableState.buffered >= this._readableState.highWaterMark) {
this._transformState.data = data;
} else {
this._transform(data, this._transformState.afterTransform);
}
}
_read (cb) {
if (this._transformState.data !== null) {
const data = this._transformState.data;
this._transformState.data = null;
cb(null);
this._transform(data, this._transformState.afterTransform);
} else {
cb(null);
}
}
_transform (data, cb) {
cb(null, data);
}
_flush (cb) {
cb(null);
}
_final (cb) {
this._transformState.afterFinal = cb;
this._flush(transformAfterFlush.bind(this));
}
}
class PassThrough extends Transform {}
function transformAfterFlush (err, data) {
const cb = this._transformState.afterFinal;
if (err) return cb(err)
if (data !== null && data !== undefined) this.push(data);
this.push(null);
cb(null);
}
function pipelinePromise (...streams) {
return new Promise((resolve, reject) => {
return pipeline(...streams, (err) => {
if (err) return reject(err)
resolve();
})
})
}
function pipeline (stream, ...streams) {
const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams];
const done = (all.length && typeof all[all.length - 1] === 'function') ? all.pop() : null;
if (all.length < 2) throw new Error('Pipeline requires at least 2 streams')
let src = all[0];
let dest = null;
let error = null;
for (let i = 1; i < all.length; i++) {
dest = all[i];
if (isStreamx(src)) {
src.pipe(dest, onerror);
} else {
errorHandle(src, true, i > 1, onerror);
src.pipe(dest);
}
src = dest;
}
if (done) {
let fin = false;
dest.on('finish', () => { fin = true; });
dest.on('error', err => { error = error || err; });
dest.on('close', () => done(error || (fin ? null : PREMATURE_CLOSE)));
}
return dest
function errorHandle (s, rd, wr, onerror) {
s.on('error', onerror);
s.on('close', onclose);
function onclose () {
if (rd && s._readableState && !s._readableState.ended) return onerror(PREMATURE_CLOSE)
if (wr && s._writableState && !s._writableState.ended) return onerror(PREMATURE_CLOSE)
}
}
function onerror (err) {
if (!err || error) return
error = err;
for (const s of all) {
s.destroy(err);
}
}
}
function isStream (stream) {
return !!stream._readableState || !!stream._writableState
}
function isStreamx (stream) {
return typeof stream._duplexState === 'number' && isStream(stream)
}
function getStreamError (stream) {
return (stream._readableState && stream._readableState.error) || (stream._writableState && stream._writableState.error)
}
function isReadStreamx (stream) {
return isStreamx(stream) && stream.readable
}
function isTypedArray (data) {
return typeof data === 'object' && data !== null && typeof data.byteLength === 'number'
}
function defaultByteLength (data) {
return isTypedArray(data) ? data.byteLength : 1024
}
function noop$1 () {}
function abort () {
this.destroy(new Error('Stream aborted.'));
}
var streamx = {
pipeline,
pipelinePromise,
isStream,
isStreamx,
getStreamError,
Stream,
Writable: Writable$1,
Readable: Readable$1,
Duplex,
Transform,
// Export PassThrough for compatibility with Node.js core's stream module
PassThrough
};
var headers$1 = {};
function isBuffer (value) {
return Buffer.isBuffer(value) || value instanceof Uint8Array
}
function isEncoding (encoding) {
return Buffer.isEncoding(encoding)
}
function alloc (size, fill, encoding) {
return Buffer.alloc(size, fill, encoding)
}
function allocUnsafe (size) {
return Buffer.allocUnsafe(size)
}
function allocUnsafeSlow (size) {
return Buffer.allocUnsafeSlow(size)
}
function byteLength (string, encoding) {
return Buffer.byteLength(string, encoding)
}
function compare (a, b) {
return Buffer.compare(a, b)
}
function concat (buffers, totalLength) {
return Buffer.concat(buffers, totalLength)
}
function copy (source, target, targetStart, start, end) {
return toBuffer(source).copy(target, targetStart, start, end)
}
function equals (a, b) {
return toBuffer(a).equals(b)
}
function fill (buffer, value, offset, end, encoding) {
return toBuffer(buffer).fill(value, offset, end, encoding)
}
function from (value, encodingOrOffset, length) {
return Buffer.from(value, encodingOrOffset, length)
}
function includes (buffer, value, byteOffset, encoding) {
return toBuffer(buffer).includes(value, byteOffset, encoding)
}
function indexOf$1 (buffer, value, byfeOffset, encoding) {
return toBuffer(buffer).indexOf(value, byfeOffset, encoding)
}
function lastIndexOf (buffer, value, byteOffset, encoding) {
return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding)
}
function swap16 (buffer) {
return toBuffer(buffer).swap16()
}
function swap32 (buffer) {
return toBuffer(buffer).swap32()
}
function swap64 (buffer) {
return toBuffer(buffer).swap64()
}
function toBuffer (buffer) {
if (Buffer.isBuffer(buffer)) return buffer
return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength)
}
function toString (buffer, encoding, start, end) {
return toBuffer(buffer).toString(encoding, start, end)
}
function write (buffer, string, offset, length, encoding) {
return toBuffer(buffer).write(string, offset, length, encoding)
}
function writeDoubleLE (buffer, value, offset) {
return toBuffer(buffer).writeDoubleLE(value, offset)
}
function writeFloatLE (buffer, value, offset) {
return toBuffer(buffer).writeFloatLE(value, offset)
}
function writeUInt32LE (buffer, value, offset) {
return toBuffer(buffer).writeUInt32LE(value, offset)
}
function writeInt32LE (buffer, value, offset) {
return toBuffer(buffer).writeInt32LE(value, offset)
}
function readDoubleLE (buffer, offset) {
return toBuffer(buffer).readDoubleLE(offset)
}
function readFloatLE (buffer, offset) {
return toBuffer(buffer).readFloatLE(offset)
}
function readUInt32LE (buffer, offset) {
return toBuffer(buffer).readUInt32LE(offset)
}
function readInt32LE (buffer, offset) {
return toBuffer(buffer).readInt32LE(offset)
}
var b4a$2 = {
isBuffer,
isEncoding,
alloc,
allocUnsafe,
allocUnsafeSlow,
byteLength,
compare,
concat,
copy,
equals,
fill,
from,
includes,
indexOf: indexOf$1,
lastIndexOf,
swap16,
swap32,
swap64,
toBuffer,
toString,
write,
writeDoubleLE,
writeFloatLE,
writeUInt32LE,
writeInt32LE,
readDoubleLE,
readFloatLE,
readUInt32LE,
readInt32LE
};
const b4a$1 = b4a$2;
const ZEROS = '0000000000000000000';
const SEVENS = '7777777777777777777';
const ZERO_OFFSET = '0'.charCodeAt(0);
const USTAR_MAGIC = b4a$1.from('ustar\x00', 'binary');
const USTAR_VER = b4a$1.from('00', 'binary');
const GNU_MAGIC = b4a$1.from('ustar\x20', 'binary');
const GNU_VER = b4a$1.from('\x20\x00', 'binary');
const MASK = 0o7777;
const MAGIC_OFFSET = 257;
const VERSION_OFFSET = 263;
const clamp = function (index, len, defaultValue) {
if (typeof index !== 'number') return defaultValue
index = ~~index; // Coerce to integer.
if (index >= len) return len
if (index >= 0) return index
index += len;
if (index >= 0) return index
return 0
};
const toType = function (flag) {
switch (flag) {
case 0:
return 'file'
case 1:
return 'link'
case 2:
return 'symlink'
case 3:
return 'character-device'
case 4:
return 'block-device'
case 5:
return 'directory'
case 6:
return 'fifo'
case 7:
return 'contiguous-file'
case 72:
return 'pax-header'
case 55:
return 'pax-global-header'
case 27:
return 'gnu-long-link-path'
case 28:
case 30:
return 'gnu-long-path'
}
return null
};
const toTypeflag = function (flag) {
switch (flag) {
case 'file':
return 0
case 'link':
return 1
case 'symlink':
return 2
case 'character-device':
return 3
case 'block-device':
return 4
case 'directory':
return 5
case 'fifo':
return 6
case 'contiguous-file':
return 7
case 'pax-header':
return 72
}
return 0
};
const indexOf = function (block, num, offset, end) {
for (; offset < end; offset++) {
if (block[offset] === num) return offset
}
return end
};
const cksum = function (block) {
let sum = 8 * 32;
for (let i = 0; i < 148; i++) sum += block[i];
for (let j = 156; j < 512; j++) sum += block[j];
return sum
};
const encodeOct = function (val, n) {
val = val.toString(8);
if (val.length > n) return SEVENS.slice(0, n) + ' '
else return ZEROS.slice(0, n - val.length) + val + ' '
};
/* Copied from the node-tar repo and modified to meet
* tar-stream coding standard.
*
* Source: https://github.com/npm/node-tar/blob/51b6627a1f357d2eb433e7378e5f05e83b7aa6cd/lib/header.js#L349
*/
function parse256 (buf) {
// first byte MUST be either 80 or FF
// 80 for positive, FF for 2's comp
let positive;
if (buf[0] === 0x80) positive = true;
else if (buf[0] === 0xFF) positive = false;
else return null
// build up a base-256 tuple from the least sig to the highest
const tuple = [];
let i;
for (i = buf.length - 1; i > 0; i--) {
const byte = buf[i];
if (positive) tuple.push(byte);
else tuple.push(0xFF - byte);
}
let sum = 0;
const l = tuple.length;
for (i = 0; i < l; i++) {
sum += tuple[i] * Math.pow(256, i);
}
return positive ? sum : -1 * sum
}
const decodeOct = function (val, offset, length) {
val = val.slice(offset, offset + length);
offset = 0;
// If prefixed with 0x80 then parse as a base-256 integer
if (val[offset] & 0x80) {
return parse256(val)
} else {
// Older versions of tar can prefix with spaces
while (offset < val.length && val[offset] === 32) offset++;
const end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length);
while (offset < end && val[offset] === 0) offset++;
if (end === offset) return 0
return parseInt(val.slice(offset, end).toString(), 8)
}
};
const decodeStr = function (val, offset, length, encoding) {
return val.slice(offset, indexOf(val, 0, offset, offset + length)).toString(encoding)
};
const addLength = function (str) {
const len = b4a$1.byteLength(str);
let digits = Math.floor(Math.log(len) / Math.log(10)) + 1;
if (len + digits >= Math.pow(10, digits)) digits++;
return (len + digits) + str
};
headers$1.decodeLongPath = function (buf, encoding) {
return decodeStr(buf, 0, buf.length, encoding)
};
headers$1.encodePax = function (opts) { // TODO: encode more stuff in pax
let result = '';
if (opts.name) result += addLength(' path=' + opts.name + '\n');
if (opts.linkname) result += addLength(' linkpath=' + opts.linkname + '\n');
const pax = opts.pax;
if (pax) {
for (const key in pax) {
result += addLength(' ' + key + '=' + pax[key] + '\n');
}
}
return b4a$1.from(result)
};
headers$1.decodePax = function (buf) {
const result = {};
while (buf.length) {
let i = 0;
while (i < buf.length && buf[i] !== 32) i++;
const len = parseInt(buf.slice(0, i).toString(), 10);
if (!len) return result
const b = buf.slice(i + 1, len - 1).toString();
const keyIndex = b.indexOf('=');
if (keyIndex === -1) return result
result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1);
buf = buf.slice(len);
}
return result
};
headers$1.encode = function (opts) {
const buf = b4a$1.alloc(512);
let name = opts.name;
let prefix = '';
if (opts.typeflag === 5 && name[name.length - 1] !== '/') name += '/';
if (b4a$1.byteLength(name) !== name.length) return null // utf-8
while (b4a$1.byteLength(name) > 100) {
const i = name.indexOf('/');
if (i === -1) return null
prefix += prefix ? '/' + name.slice(0, i) : name.slice(0, i);
name = name.slice(i + 1);
}
if (b4a$1.byteLength(name) > 100 || b4a$1.byteLength(prefix) > 155) return null
if (opts.linkname && b4a$1.byteLength(opts.linkname) > 100) return null
b4a$1.write(buf, name);
b4a$1.write(buf, encodeOct(opts.mode & MASK, 6), 100);
b4a$1.write(buf, encodeOct(opts.uid, 6), 108);
b4a$1.write(buf, encodeOct(opts.gid, 6), 116);
b4a$1.write(buf, encodeOct(opts.size, 11), 124);
b4a$1.write(buf, encodeOct((opts.mtime.getTime() / 1000) | 0, 11), 136);
buf[156] = ZERO_OFFSET + toTypeflag(opts.type);
if (opts.linkname) b4a$1.write(buf, opts.linkname, 157);
b4a$1.copy(USTAR_MAGIC, buf, MAGIC_OFFSET);
b4a$1.copy(USTAR_VER, buf, VERSION_OFFSET);
if (opts.uname) b4a$1.write(buf, opts.uname, 265);
if (opts.gname) b4a$1.write(buf, opts.gname, 297);
b4a$1.write(buf, encodeOct(opts.devmajor || 0, 6), 329);
b4a$1.write(buf, encodeOct(opts.devminor || 0, 6), 337);
if (prefix) b4a$1.write(buf, prefix, 345);
b4a$1.write(buf, encodeOct(cksum(buf), 6), 148);
return buf
};
headers$1.decode = function (buf, filenameEncoding, allowUnknownFormat) {
let typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET;
let name = decodeStr(buf, 0, 100, filenameEncoding);
const mode = decodeOct(buf, 100, 8);
const uid = decodeOct(buf, 108, 8);
const gid = decodeOct(buf, 116, 8);
const size = decodeOct(buf, 124, 12);
const mtime = decodeOct(buf, 136, 12);
const type = toType(typeflag);
const linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding);
const uname = decodeStr(buf, 265, 32);
const gname = decodeStr(buf, 297, 32);
const devmajor = decodeOct(buf, 329, 8);
const devminor = decodeOct(buf, 337, 8);
const c = cksum(buf);
// checksum is still initial value if header was null.
if (c === 8 * 32) return null
// valid checksum
if (c !== decodeOct(buf, 148, 8)) throw new Error('Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?')
if (USTAR_MAGIC.compare(buf, MAGIC_OFFSET, MAGIC_OFFSET + 6) === 0) {
// ustar (posix) format.
// prepend prefix, if present.
if (buf[345]) name = decodeStr(buf, 345, 155, filenameEncoding) + '/' + name;
} else if (GNU_MAGIC.compare(buf, MAGIC_OFFSET, MAGIC_OFFSET + 6) === 0 &&
GNU_VER.compare(buf, VERSION_OFFSET, VERSION_OFFSET + 2) === 0) ; else {
if (!allowUnknownFormat) {
throw new Error('Invalid tar header: unknown format.')
}
}
// to support old tar versions that use trailing / to indicate dirs
if (typeflag === 0 && name && name[name.length - 1] === '/') typeflag = 5;
return {
name,
mode,
uid,
gid,
size,
mtime: new Date(1000 * mtime),
type,
linkname,
uname,
gname,
devmajor,
devminor
}
};
const { constants } = require$$0$2;
const { Readable, Writable } = streamx;
const { StringDecoder } = require$$13;
const b4a = b4a$2;
const headers = headers$1;
const DMODE = 0o755;
const FMODE = 0o644;
const END_OF_TAR = b4a.alloc(1024);
const noop = function () {};
const overflow = function (self, size) {
size &= 511;
if (size) self.push(END_OF_TAR.subarray(0, 512 - size));
};
function modeToType (mode) {
switch (mode & constants.S_IFMT) {
case constants.S_IFBLK: return 'block-device'
case constants.S_IFCHR: return 'character-device'
case constants.S_IFDIR: return 'directory'
case constants.S_IFIFO: return 'fifo'
case constants.S_IFLNK: return 'symlink'
}
return 'file'
}
class Sink extends Writable {
constructor (to) {
super();
this.written = 0;
this._to = to;
}
_write (data, cb) {
this.written += data.byteLength;
if (this._to.push(data)) return cb()
this._to._drain = cb;
}
}
class LinkSink extends Writable {
constructor () {
super();
this.linkname = '';
this._decoder = new StringDecoder('utf-8');
}
_write (data, cb) {
this.linkname += this._decoder.write(data);
cb();
}
}
class Void extends Writable {
_write (data, cb) {
cb(new Error('No body allowed for this entry'));
}
}
class Pack extends Readable {
constructor (opts) {
super(opts);
this._drain = noop;
this._finalized = false;
this._finalizing = false;
this._stream = null;
}
entry (header, buffer, callback) {
if (this._stream) throw new Error('already piping an entry')
if (this._finalized || this.destroyed) return
if (typeof buffer === 'function') {
callback = buffer;
buffer = null;
}
if (!callback) callback = noop;
const self = this;
if (!header.size || header.type === 'symlink') header.size = 0;
if (!header.type) header.type = modeToType(header.mode);
if (!header.mode) header.mode = header.type === 'directory' ? DMODE : FMODE;
if (!header.uid) header.uid = 0;
if (!header.gid) header.gid = 0;
if (!header.mtime) header.mtime = new Date();
if (typeof buffer === 'string') buffer = b4a.from(buffer);
if (b4a.isBuffer(buffer)) {
header.size = buffer.byteLength;
this._encode(header);
const ok = this.push(buffer);
overflow(self, header.size);
if (ok) process.nextTick(callback);
else this._drain = callback;
return new Void()
}
if (header.type === 'symlink' && !header.linkname) {
const linkSink = new LinkSink();
linkSink
.on('error', function (err) {
self.destroy();
callback(err);
})
.on('close', function () {
header.linkname = linkSink.linkname;
self._encode(header);
callback();
});
return linkSink
}
this._encode(header);
if (header.type !== 'file' && header.type !== 'contiguous-file') {
process.nextTick(callback);
return new Void()
}
const sink = new Sink(this);
sink
.on('error', function (err) {
self._stream = null;
self.destroy();
callback(err);
})
.on('close', function () {
self._stream = null;
if (sink.written !== header.size) ;
overflow(self, header.size);
if (self._finalizing) { self.finalize(); }
callback();
});
this._stream = sink;
return sink
}
finalize () {
if (this._stream) {
this._finalizing = true;
return
}
if (this._finalized) return
this._finalized = true;
this.push(END_OF_TAR);
this.push(null);
}
_encode (header) {
if (!header.pax) {
const buf = headers.encode(header);
if (buf) {
this.push(buf);
return
}
}
this._encodePax(header);
}
_encodePax (header) {
const paxHeader = headers.encodePax({
name: header.name,
linkname: header.linkname,
pax: header.pax
});
const newHeader = {
name: 'PaxHeader',
mode: header.mode,
uid: header.uid,
gid: header.gid,
size: paxHeader.byteLength,
mtime: header.mtime,
type: 'pax-header',
linkname: header.linkname && 'PaxHeader',
uname: header.uname,
gname: header.gname,
devmajor: header.devmajor,
devminor: header.devminor
};
this.push(headers.encode(newHeader));
this.push(paxHeader);
overflow(this, paxHeader.byteLength);
newHeader.size = header.size;
newHeader.type = header.type;
this.push(headers.encode(newHeader));
}
_read (cb) {
const drain = this._drain;
this._drain = noop;
drain();
cb();
}
}
var pack$1 = function pack (opts) {
return new Pack(opts)
};
var pack = pack$1;
const MTIME = new Date(0);
const MODE_FOR_DIR = 0o755;
const MODE_FOR_FILE = 0o555;
const MODE_FOR_SYMLINK = 0o775;
function findKeyByValue(entries, value) {
for (const [key, { dest: val }] of Object.entries(entries)) {
if (val == value) {
return key;
}
}
return undefined;
}
async function readlinkSafe(p) {
try {
const link = await readlink(p);
return path.resolve(path.dirname(p), link);
}
catch (e) {
if (e.code == 'EINVAL') {
return p;
}
throw e;
}
}
async function resolveSymlink(p) {
let prevHop = path.resolve(p);
let hopped = false;
while (true) {
// /output-base/sandbox/4/execroot/wksp/bazel-out
// /output-base/execroot/wksp/bazel-out
let nextHop = await readlinkSafe(prevHop);
if (!nextHop.startsWith(process.env.JS_BINARY__EXECROOT)) {
return hopped ? prevHop : undefined;
}
if (nextHop != prevHop) {
prevHop = nextHop;
hopped = true;
}
else if (!hopped) {
return undefined;
}
else {
return nextHop;
}
}
}
async function* walk(dir, accumulate = '') {
const dirents = await readdir(dir, { withFileTypes: true });
for (const dirent of dirents) {
let isDirectory = dirent.isDirectory();
if (dirent.isSymbolicLink() &&
!dirent.isDirectory() &&
!dirent.isFile()) {
// On OSX we sometimes encounter this bug: https://github.com/nodejs/node/issues/30646
// The entry is apparently a symlink, but it's ambiguous whether it's a symlink to a
// file or to a directory, and lstat doesn't tell us either. Determine the type by
// attempting to read it as a directory.
try {
await readdir(path.join(dir, dirent.name));
isDirectory = true;
}
catch (error) {
if (error.code === 'ENOTDIR') {
isDirectory = false;
}
else {
throw error;
}
}
}
if (isDirectory) {
yield* walk(path.join(dir, dirent.name), path.join(accumulate, dirent.name));
}
else {
yield path.join(accumulate, dirent.name);
}
}
}
function add_parents(name, pkg, existing_paths, owner) {
const segments = path.dirname(name).split('/');
let prev = '';
const stats = {
// this is an intermediate directory and bazel does not allow specifying
// modes for intermediate directories.
mode: MODE_FOR_DIR,
mtime: MTIME,
};
for (const part of segments) {
if (!part) {
continue;
}
prev = path.join(prev, part);
// check if the directory has been has been created before.
if (existing_paths.has(prev)) {
continue;
}
existing_paths.add(prev);
add_directory(prev, pkg, owner, stats);
}
}
function add_directory(name, pkg, owner, stats) {
pkg.entry({
type: 'directory',
name: name.replace(/^\//, ''),
mode: stats.mode,
mtime: MTIME,
gid: owner.gid,
uid: owner.uid,
}).end();
}
function add_symlink(name, linkname, pkg, owner, stats) {
const link_parent = path.dirname(name);
pkg.entry({
type: 'symlink',
name: name.replace(/^\//, ''),
linkname: path.relative(link_parent, linkname),
mode: stats.mode,
mtime: MTIME,
uid: owner.uid,
gid: owner.gid,
}).end();
}
function add_file(name, content, pkg, owner, stats) {
return new Promise((resolve, reject) => {
const entry = pkg.entry({
type: 'file',
name: name.replace(/^\//, ''),
mode: stats.mode,
size: stats.size,
mtime: MTIME,
uid: owner.uid,
gid: owner.gid,
}, (err) => {
if (err) {
reject(err);
}
else {
resolve(undefined);
}
});
content.pipe(entry);
});
}
async function build(entries, outputPath, compression, owner) {
const output = pack();
const existing_paths = new Set();
let write = output;
if (compression == 'gzip') {
write = write.pipe(createGzip());
}
write.pipe(createWriteStream(outputPath));
for (const key of Object.keys(entries).sort()) {
const { dest, is_directory, is_source, is_external, root, remove_non_hermetic_lines, } = entries[key];
// its a treeartifact. expand it and add individual entries.
if (is_directory) {
for await (const sub_key of walk(dest)) {
const new_key = path.join(key, sub_key);
const new_dest = path.join(dest, sub_key);
add_parents(new_key, output, existing_paths, owner);
const stats = await stat(new_dest);
await add_file(new_key, createReadStream(new_dest), output, owner, stats);
}
continue;
}
// create parents of current path.
add_parents(key, output, existing_paths, owner);
// A source file from workspace, not an output of a target.
if (is_source) {
const originalStat = await stat(dest);
// use stable mode bits instead of preserving the one from file.
const stats = {
mode: MODE_FOR_FILE,
mtime: MTIME,
size: originalStat.size,
};
await add_file(key, createReadStream(dest), output, owner, stats);
continue;
}
// root indicates where the generated source comes from. it looks like
// `bazel-out/darwin_arm64-fastbuild` when there's no transition.
if (!root) {
// everything except sources should have
throw new Error(`unexpected entry format. ${JSON.stringify(entries[key])}. please file a bug at https://github.com/aspect-build/rules_js/issues/new/choose`);
}
const realp = await resolveSymlink(dest);
// it's important that we don't treat any symlink pointing out of execroot since
// bazel symlinks external files into sandbox to make them available to us.
if (realp && !is_external) {
const output_path = realp.slice(realp.indexOf(root));
// interestingly, bazel 5 and 6 sets different mode bits on symlinks.
// well use `0o755` to allow owner&group to `rwx` and others `rx`
// see: https://chmodcommand.com/chmod-775/
// const stats = await stat(dest)
const stats = { mode: MODE_FOR_SYMLINK, mtime: MTIME };
const linkname = findKeyByValue(entries, output_path);
if (linkname == undefined) {
throw new Error(`Couldn't map symbolic link ${output_path} to a path. please file a bug at https://github.com/aspect-build/rules_js/issues/new/choose\n\n` +
`dest: ${dest}\n` +
`realpath: ${realp}\n` +
`outputpath: ${output_path}\n` +
`root: ${root}\n` +
`runfiles: ${key}\n\n`);
}
add_symlink(key, linkname, output, owner, stats);
}
else {
// Due to filesystems setting different bits depending on the os we have to opt-in
// to use a stable mode for files.
// In the future, we might want to hand off fine-grained control of these to users
// see: https://chmodcommand.com/chmod-0555/
const originalStat = await stat(dest);
const stats = {
mode: MODE_FOR_FILE,
mtime: MTIME,
size: originalStat.size,
};
let stream = createReadStream(dest);
if (remove_non_hermetic_lines) {
const content = await readFile(dest);
const replaced = Buffer.from(content
.toString()
.replace(/.*JS_BINARY__TARGET_CPU=".*?"/g, `export JS_BINARY__TARGET_CPU="$(uname -m)"`)
.replace(/.*JS_BINARY__BINDIR=".*"/g, `export JS_BINARY__BINDIR="$(pwd)"`));
stream = Readable$2.from(replaced);
stats.size = replaced.byteLength;
}
await add_file(key, stream, output, owner, stats);
}
}
output.finalize();
}
if (import.meta.url === pathToFileURL(process.argv[1]).href) {
const [entriesPath, outputPath, compression, owner,] = process.argv.slice(2);
const raw_entries = await readFile(entriesPath);
const entries = JSON.parse(raw_entries.toString());
const [uid, gid] = owner.split(':').map(Number);
build(entries, outputPath, compression, { uid, gid });
}
export { build };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"image.mjs","sources":["../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/ours/primordials.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/ours/util.js","../../../node_modules/.aspect_rules_js/event-target-shim@5.0.1/node_modules/event-target-shim/dist/event-target-shim.mjs","../../../node_modules/.aspect_rules_js/abort-controller@3.0.0/node_modules/abort-controller/dist/abort-controller.mjs","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/ours/errors.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/validators.js","../../../node_modules/.aspect_rules_js/process@0.11.10/node_modules/process/index.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/utils.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/end-of-stream.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/operators.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/destroy.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/legacy.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/add-abort-signal.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/buffer_list.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/state.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/from.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/readable.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/writable.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/duplexify.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/duplex.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/transform.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/passthrough.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/pipeline.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/internal/streams/compose.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/stream/promises.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/stream.js","../../../node_modules/.aspect_rules_js/readable-stream@4.3.0/node_modules/readable-stream/lib/ours/index.js","../../../node_modules/.aspect_rules_js/inherits@2.0.4/node_modules/inherits/inherits_browser.js","../../../node_modules/.aspect_rules_js/inherits@2.0.4/node_modules/inherits/inherits.js","../../../node_modules/.aspect_rules_js/bl@6.0.0/node_modules/bl/BufferList.js","../../../node_modules/.aspect_rules_js/bl@6.0.0/node_modules/bl/bl.js","../../../node_modules/.aspect_rules_js/queue-tick@1.0.1/node_modules/queue-tick/queue-microtask.js","../../../node_modules/.aspect_rules_js/queue-tick@1.0.1/node_modules/queue-tick/process-next-tick.js","../../../node_modules/.aspect_rules_js/fast-fifo@1.1.0/node_modules/fast-fifo/fixed-size.js","../../../node_modules/.aspect_rules_js/fast-fifo@1.1.0/node_modules/fast-fifo/index.js","../../../node_modules/.aspect_rules_js/streamx@2.13.2/node_modules/streamx/index.js","../../../node_modules/.aspect_rules_js/b4a@1.6.1/node_modules/b4a/index.js","../../../node_modules/.aspect_rules_js/tar-stream@3.0.0/node_modules/tar-stream/headers.js","../../../node_modules/.aspect_rules_js/tar-stream@3.0.0/node_modules/tar-stream/pack.js","../../../node_modules/.aspect_rules_js/tar-stream@3.0.0/node_modules/tar-stream/index.js","index.ts"],"sourcesContent":["'use strict'\n\n/*\n  This file is a reduced and adapted version of the main lib/internal/per_context/primordials.js file defined at\n\n  https://github.com/nodejs/node/blob/master/lib/internal/per_context/primordials.js\n\n  Don't try to replace with the original file and keep it up to date with the upstream file.\n*/\nmodule.exports = {\n  ArrayIsArray(self) {\n    return Array.isArray(self)\n  },\n  ArrayPrototypeIncludes(self, el) {\n    return self.includes(el)\n  },\n  ArrayPrototypeIndexOf(self, el) {\n    return self.indexOf(el)\n  },\n  ArrayPrototypeJoin(self, sep) {\n    return self.join(sep)\n  },\n  ArrayPrototypeMap(self, fn) {\n    return self.map(fn)\n  },\n  ArrayPrototypePop(self, el) {\n    return self.pop(el)\n  },\n  ArrayPrototypePush(self, el) {\n    return self.push(el)\n  },\n  ArrayPrototypeSlice(self, start, end) {\n    return self.slice(start, end)\n  },\n  Error,\n  FunctionPrototypeCall(fn, thisArgs, ...args) {\n    return fn.call(thisArgs, ...args)\n  },\n  FunctionPrototypeSymbolHasInstance(self, instance) {\n    return Function.prototype[Symbol.hasInstance].call(self, instance)\n  },\n  MathFloor: Math.floor,\n  Number,\n  NumberIsInteger: Number.isInteger,\n  NumberIsNaN: Number.isNaN,\n  NumberMAX_SAFE_INTEGER: Number.MAX_SAFE_INTEGER,\n  NumberMIN_SAFE_INTEGER: Number.MIN_SAFE_INTEGER,\n  NumberParseInt: Number.parseInt,\n  ObjectDefineProperties(self, props) {\n    return Object.defineProperties(self, props)\n  },\n  ObjectDefineProperty(self, name, prop) {\n    return Object.defineProperty(self, name, prop)\n  },\n  ObjectGetOwnPropertyDescriptor(self, name) {\n    return Object.getOwnPropertyDescriptor(self, name)\n  },\n  ObjectKeys(obj) {\n    return Object.keys(obj)\n  },\n  ObjectSetPrototypeOf(target, proto) {\n    return Object.setPrototypeOf(target, proto)\n  },\n  Promise,\n  PromisePrototypeCatch(self, fn) {\n    return self.catch(fn)\n  },\n  PromisePrototypeThen(self, thenFn, catchFn) {\n    return self.then(thenFn, catchFn)\n  },\n  PromiseReject(err) {\n    return Promise.reject(err)\n  },\n  ReflectApply: Reflect.apply,\n  RegExpPrototypeTest(self, value) {\n    return self.test(value)\n  },\n  SafeSet: Set,\n  String,\n  StringPrototypeSlice(self, start, end) {\n    return self.slice(start, end)\n  },\n  StringPrototypeToLowerCase(self) {\n    return self.toLowerCase()\n  },\n  StringPrototypeToUpperCase(self) {\n    return self.toUpperCase()\n  },\n  StringPrototypeTrim(self) {\n    return self.trim()\n  },\n  Symbol,\n  SymbolAsyncIterator: Symbol.asyncIterator,\n  SymbolHasInstance: Symbol.hasInstance,\n  SymbolIterator: Symbol.iterator,\n  TypedArrayPrototypeSet(self, buf, len) {\n    return self.set(buf, len)\n  },\n  Uint8Array\n}\n","'use strict'\n\nconst bufferModule = require('buffer')\nconst AsyncFunction = Object.getPrototypeOf(async function () {}).constructor\nconst Blob = globalThis.Blob || bufferModule.Blob\n/* eslint-disable indent */\nconst isBlob =\n  typeof Blob !== 'undefined'\n    ? function isBlob(b) {\n        // eslint-disable-next-line indent\n        return b instanceof Blob\n      }\n    : function isBlob(b) {\n        return false\n      }\n/* eslint-enable indent */\n\n// This is a simplified version of AggregateError\nclass AggregateError extends Error {\n  constructor(errors) {\n    if (!Array.isArray(errors)) {\n      throw new TypeError(`Expected input to be an Array, got ${typeof errors}`)\n    }\n    let message = ''\n    for (let i = 0; i < errors.length; i++) {\n      message += `    ${errors[i].stack}\\n`\n    }\n    super(message)\n    this.name = 'AggregateError'\n    this.errors = errors\n  }\n}\nmodule.exports = {\n  AggregateError,\n  kEmptyObject: Object.freeze({}),\n  once(callback) {\n    let called = false\n    return function (...args) {\n      if (called) {\n        return\n      }\n      called = true\n      callback.apply(this, args)\n    }\n  },\n  createDeferredPromise: function () {\n    let resolve\n    let reject\n\n    // eslint-disable-next-line promise/param-names\n    const promise = new Promise((res, rej) => {\n      resolve = res\n      reject = rej\n    })\n    return {\n      promise,\n      resolve,\n      reject\n    }\n  },\n  promisify(fn) {\n    return new Promise((resolve, reject) => {\n      fn((err, ...args) => {\n        if (err) {\n          return reject(err)\n        }\n        return resolve(...args)\n      })\n    })\n  },\n  debuglog() {\n    return function () {}\n  },\n  format(format, ...args) {\n    // Simplified version of https://nodejs.org/api/util.html#utilformatformat-args\n    return format.replace(/%([sdifj])/g, function (...[_unused, type]) {\n      const replacement = args.shift()\n      if (type === 'f') {\n        return replacement.toFixed(6)\n      } else if (type === 'j') {\n        return JSON.stringify(replacement)\n      } else if (type === 's' && typeof replacement === 'object') {\n        const ctor = replacement.constructor !== Object ? replacement.constructor.name : ''\n        return `${ctor} {}`.trim()\n      } else {\n        return replacement.toString()\n      }\n    })\n  },\n  inspect(value) {\n    // Vastly simplified version of https://nodejs.org/api/util.html#utilinspectobject-options\n    switch (typeof value) {\n      case 'string':\n        if (value.includes(\"'\")) {\n          if (!value.includes('\"')) {\n            return `\"${value}\"`\n          } else if (!value.includes('`') && !value.includes('${')) {\n            return `\\`${value}\\``\n          }\n        }\n        return `'${value}'`\n      case 'number':\n        if (isNaN(value)) {\n          return 'NaN'\n        } else if (Object.is(value, -0)) {\n          return String(value)\n        }\n        return value\n      case 'bigint':\n        return `${String(value)}n`\n      case 'boolean':\n      case 'undefined':\n        return String(value)\n      case 'object':\n        return '{}'\n    }\n  },\n  types: {\n    isAsyncFunction(fn) {\n      return fn instanceof AsyncFunction\n    },\n    isArrayBufferView(arr) {\n      return ArrayBuffer.isView(arr)\n    }\n  },\n  isBlob\n}\nmodule.exports.promisify.custom = Symbol.for('nodejs.util.promisify.custom')\n","/**\n * @author Toru Nagashima <https://github.com/mysticatea>\n * @copyright 2015 Toru Nagashima. All rights reserved.\n * See LICENSE file in root directory for full license.\n */\n/**\n * @typedef {object} PrivateData\n * @property {EventTarget} eventTarget The event target.\n * @property {{type:string}} event The original event object.\n * @property {number} eventPhase The current event phase.\n * @property {EventTarget|null} currentTarget The current event target.\n * @property {boolean} canceled The flag to prevent default.\n * @property {boolean} stopped The flag to stop propagation.\n * @property {boolean} immediateStopped The flag to stop propagation immediately.\n * @property {Function|null} passiveListener The listener if the current listener is passive. Otherwise this is null.\n * @property {number} timeStamp The unix time.\n * @private\n */\n\n/**\n * Private data for event wrappers.\n * @type {WeakMap<Event, PrivateData>}\n * @private\n */\nconst privateData = new WeakMap();\n\n/**\n * Cache for wrapper classes.\n * @type {WeakMap<Object, Function>}\n * @private\n */\nconst wrappers = new WeakMap();\n\n/**\n * Get private data.\n * @param {Event} event The event object to get private data.\n * @returns {PrivateData} The private data of the event.\n * @private\n */\nfunction pd(event) {\n    const retv = privateData.get(event);\n    console.assert(\n        retv != null,\n        \"'this' is expected an Event object, but got\",\n        event\n    );\n    return retv\n}\n\n/**\n * https://dom.spec.whatwg.org/#set-the-canceled-flag\n * @param data {PrivateData} private data.\n */\nfunction setCancelFlag(data) {\n    if (data.passiveListener != null) {\n        if (\n            typeof console !== \"undefined\" &&\n            typeof console.error === \"function\"\n        ) {\n            console.error(\n                \"Unable to preventDefault inside passive event listener invocation.\",\n                data.passiveListener\n            );\n        }\n        return\n    }\n    if (!data.event.cancelable) {\n        return\n    }\n\n    data.canceled = true;\n    if (typeof data.event.preventDefault === \"function\") {\n        data.event.preventDefault();\n    }\n}\n\n/**\n * @see https://dom.spec.whatwg.org/#interface-event\n * @private\n */\n/**\n * The event wrapper.\n * @constructor\n * @param {EventTarget} eventTarget The event target of this dispatching.\n * @param {Event|{type:string}} event The original event to wrap.\n */\nfunction Event(eventTarget, event) {\n    privateData.set(this, {\n        eventTarget,\n        event,\n        eventPhase: 2,\n        currentTarget: eventTarget,\n        canceled: false,\n        stopped: false,\n        immediateStopped: false,\n        passiveListener: null,\n        timeStamp: event.timeStamp || Date.now(),\n    });\n\n    // https://heycam.github.io/webidl/#Unforgeable\n    Object.defineProperty(this, \"isTrusted\", { value: false, enumerable: true });\n\n    // Define accessors\n    const keys = Object.keys(event);\n    for (let i = 0; i < keys.length; ++i) {\n        const key = keys[i];\n        if (!(key in this)) {\n            Object.defineProperty(this, key, defineRedirectDescriptor(key));\n        }\n    }\n}\n\n// Should be enumerable, but class methods are not enumerable.\nEvent.prototype = {\n    /**\n     * The type of this event.\n     * @type {string}\n     */\n    get type() {\n        return pd(this).event.type\n    },\n\n    /**\n     * The target of this event.\n     * @type {EventTarget}\n     */\n    get target() {\n        return pd(this).eventTarget\n    },\n\n    /**\n     * The target of this event.\n     * @type {EventTarget}\n     */\n    get currentTarget() {\n        return pd(this).currentTarget\n    },\n\n    /**\n     * @returns {EventTarget[]} The composed path of this event.\n     */\n    composedPath() {\n        const currentTarget = pd(this).currentTarget;\n        if (currentTarget == null) {\n            return []\n        }\n        return [currentTarget]\n    },\n\n    /**\n     * Constant of NONE.\n     * @type {number}\n     */\n    get NONE() {\n        return 0\n    },\n\n    /**\n     * Constant of CAPTURING_PHASE.\n     * @type {number}\n     */\n    get CAPTURING_PHASE() {\n        return 1\n    },\n\n    /**\n     * Constant of AT_TARGET.\n     * @type {number}\n     */\n    get AT_TARGET() {\n        return 2\n    },\n\n    /**\n     * Constant of BUBBLING_PHASE.\n     * @type {number}\n     */\n    get BUBBLING_PHASE() {\n        return 3\n    },\n\n    /**\n     * The target of this event.\n     * @type {number}\n     */\n    get eventPhase() {\n        return pd(this).eventPhase\n    },\n\n    /**\n     * Stop event bubbling.\n     * @returns {void}\n     */\n    stopPropagation() {\n        const data = pd(this);\n\n        data.stopped = true;\n        if (typeof data.event.stopPropagation === \"function\") {\n            data.event.stopPropagation();\n        }\n    },\n\n    /**\n     * Stop event bubbling.\n     * @returns {void}\n     */\n    stopImmediatePropagation() {\n        const data = pd(this);\n\n        data.stopped = true;\n        data.immediateStopped = true;\n        if (typeof data.event.stopImmediatePropagation === \"function\") {\n            data.event.stopImmediatePropagation();\n        }\n    },\n\n    /**\n     * The flag to be bubbling.\n     * @type {boolean}\n     */\n    get bubbles() {\n        return Boolean(pd(this).event.bubbles)\n    },\n\n    /**\n     * The flag to be cancelable.\n     * @type {boolean}\n     */\n    get cancelable() {\n        return Boolean(pd(this).event.cancelable)\n    },\n\n    /**\n     * Cancel this event.\n     * @returns {void}\n     */\n    preventDefault() {\n        setCancelFlag(pd(this));\n    },\n\n    /**\n     * The flag to indicate cancellation state.\n     * @type {boolean}\n     */\n    get defaultPrevented() {\n        return pd(this).canceled\n    },\n\n    /**\n     * The flag to be composed.\n     * @type {boolean}\n     */\n    get composed() {\n        return Boolean(pd(this).event.composed)\n    },\n\n    /**\n     * The unix time of this event.\n     * @type {number}\n     */\n    get timeStamp() {\n        return pd(this).timeStamp\n    },\n\n    /**\n     * The target of this event.\n     * @type {EventTarget}\n     * @deprecated\n     */\n    get srcElement() {\n        return pd(this).eventTarget\n    },\n\n    /**\n     * The flag to stop event bubbling.\n     * @type {boolean}\n     * @deprecated\n     */\n    get cancelBubble() {\n        return pd(this).stopped\n    },\n    set cancelBubble(value) {\n        if (!value) {\n            return\n        }\n        const data = pd(this);\n\n        data.stopped = true;\n        if (typeof data.event.cancelBubble === \"boolean\") {\n            data.event.cancelBubble = true;\n        }\n    },\n\n    /**\n     * The flag to indicate cancellation state.\n     * @type {boolean}\n     * @deprecated\n     */\n    get returnValue() {\n        return !pd(this).canceled\n    },\n    set returnValue(value) {\n        if (!value) {\n            setCancelFlag(pd(this));\n        }\n    },\n\n    /**\n     * Initialize this event object. But do nothing under event dispatching.\n     * @param {string} type The event type.\n     * @param {boolean} [bubbles=false] The flag to be possible to bubble up.\n     * @param {boolean} [cancelable=false] The flag to be possible to cancel.\n     * @deprecated\n     */\n    initEvent() {\n        // Do nothing.\n    },\n};\n\n// `constructor` is not enumerable.\nObject.defineProperty(Event.prototype, \"constructor\", {\n    value: Event,\n    configurable: true,\n    writable: true,\n});\n\n// Ensure `event instanceof window.Event` is `true`.\nif (typeof window !== \"undefined\" && typeof window.Event !== \"undefined\") {\n    Object.setPrototypeOf(Event.prototype, window.Event.prototype);\n\n    // Make association for wrappers.\n    wrappers.set(window.Event.prototype, Event);\n}\n\n/**\n * Get the property descriptor to redirect a given property.\n * @param {string} key Property name to define property descriptor.\n * @returns {PropertyDescriptor} The property descriptor to redirect the property.\n * @private\n */\nfunction defineRedirectDescriptor(key) {\n    return {\n        get() {\n            return pd(this).event[key]\n        },\n        set(value) {\n            pd(this).event[key] = value;\n        },\n        configurable: true,\n        enumerable: true,\n    }\n}\n\n/**\n * Get the property descriptor to call a given method property.\n * @param {string} key Property name to define property descriptor.\n * @returns {PropertyDescriptor} The property descriptor to call the method property.\n * @private\n */\nfunction defineCallDescriptor(key) {\n    return {\n        value() {\n            const event = pd(this).event;\n            return event[key].apply(event, arguments)\n        },\n        configurable: true,\n        enumerable: true,\n    }\n}\n\n/**\n * Define new wrapper class.\n * @param {Function} BaseEvent The base wrapper class.\n * @param {Object} proto The prototype of the original event.\n * @returns {Function} The defined wrapper class.\n * @private\n */\nfunction defineWrapper(BaseEvent, proto) {\n    const keys = Object.keys(proto);\n    if (keys.length === 0) {\n        return BaseEvent\n    }\n\n    /** CustomEvent */\n    function CustomEvent(eventTarget, event) {\n        BaseEvent.call(this, eventTarget, event);\n    }\n\n    CustomEvent.prototype = Object.create(BaseEvent.prototype, {\n        constructor: { value: CustomEvent, configurable: true, writable: true },\n    });\n\n    // Define accessors.\n    for (let i = 0; i < keys.length; ++i) {\n        const key = keys[i];\n        if (!(key in BaseEvent.prototype)) {\n            const descriptor = Object.getOwnPropertyDescriptor(proto, key);\n            const isFunc = typeof descriptor.value === \"function\";\n            Object.defineProperty(\n                CustomEvent.prototype,\n                key,\n                isFunc\n                    ? defineCallDescriptor(key)\n                    : defineRedirectDescriptor(key)\n            );\n        }\n    }\n\n    return CustomEvent\n}\n\n/**\n * Get the wrapper class of a given prototype.\n * @param {Object} proto The prototype of the original event to get its wrapper.\n * @returns {Function} The wrapper class.\n * @private\n */\nfunction getWrapper(proto) {\n    if (proto == null || proto === Object.prototype) {\n        return Event\n    }\n\n    let wrapper = wrappers.get(proto);\n    if (wrapper == null) {\n        wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);\n        wrappers.set(proto, wrapper);\n    }\n    return wrapper\n}\n\n/**\n * Wrap a given event to management a dispatching.\n * @param {EventTarget} eventTarget The event target of this dispatching.\n * @param {Object} event The event to wrap.\n * @returns {Event} The wrapper instance.\n * @private\n */\nfunction wrapEvent(eventTarget, event) {\n    const Wrapper = getWrapper(Object.getPrototypeOf(event));\n    return new Wrapper(eventTarget, event)\n}\n\n/**\n * Get the immediateStopped flag of a given event.\n * @param {Event} event The event to get.\n * @returns {boolean} The flag to stop propagation immediately.\n * @private\n */\nfunction isStopped(event) {\n    return pd(event).immediateStopped\n}\n\n/**\n * Set the current event phase of a given event.\n * @param {Event} event The event to set current target.\n * @param {number} eventPhase New event phase.\n * @returns {void}\n * @private\n */\nfunction setEventPhase(event, eventPhase) {\n    pd(event).eventPhase = eventPhase;\n}\n\n/**\n * Set the current target of a given event.\n * @param {Event} event The event to set current target.\n * @param {EventTarget|null} currentTarget New current target.\n * @returns {void}\n * @private\n */\nfunction setCurrentTarget(event, currentTarget) {\n    pd(event).currentTarget = currentTarget;\n}\n\n/**\n * Set a passive listener of a given event.\n * @param {Event} event The event to set current target.\n * @param {Function|null} passiveListener New passive listener.\n * @returns {void}\n * @private\n */\nfunction setPassiveListener(event, passiveListener) {\n    pd(event).passiveListener = passiveListener;\n}\n\n/**\n * @typedef {object} ListenerNode\n * @property {Function} listener\n * @property {1|2|3} listenerType\n * @property {boolean} passive\n * @property {boolean} once\n * @property {ListenerNode|null} next\n * @private\n */\n\n/**\n * @type {WeakMap<object, Map<string, ListenerNode>>}\n * @private\n */\nconst listenersMap = new WeakMap();\n\n// Listener types\nconst CAPTURE = 1;\nconst BUBBLE = 2;\nconst ATTRIBUTE = 3;\n\n/**\n * Check whether a given value is an object or not.\n * @param {any} x The value to check.\n * @returns {boolean} `true` if the value is an object.\n */\nfunction isObject(x) {\n    return x !== null && typeof x === \"object\" //eslint-disable-line no-restricted-syntax\n}\n\n/**\n * Get listeners.\n * @param {EventTarget} eventTarget The event target to get.\n * @returns {Map<string, ListenerNode>} The listeners.\n * @private\n */\nfunction getListeners(eventTarget) {\n    const listeners = listenersMap.get(eventTarget);\n    if (listeners == null) {\n        throw new TypeError(\n            \"'this' is expected an EventTarget object, but got another value.\"\n        )\n    }\n    return listeners\n}\n\n/**\n * Get the property descriptor for the event attribute of a given event.\n * @param {string} eventName The event name to get property descriptor.\n * @returns {PropertyDescriptor} The property descriptor.\n * @private\n */\nfunction defineEventAttributeDescriptor(eventName) {\n    return {\n        get() {\n            const listeners = getListeners(this);\n            let node = listeners.get(eventName);\n            while (node != null) {\n                if (node.listenerType === ATTRIBUTE) {\n                    return node.listener\n                }\n                node = node.next;\n            }\n            return null\n        },\n\n        set(listener) {\n            if (typeof listener !== \"function\" && !isObject(listener)) {\n                listener = null; // eslint-disable-line no-param-reassign\n            }\n            const listeners = getListeners(this);\n\n            // Traverse to the tail while removing old value.\n            let prev = null;\n            let node = listeners.get(eventName);\n            while (node != null) {\n                if (node.listenerType === ATTRIBUTE) {\n                    // Remove old value.\n                    if (prev !== null) {\n                        prev.next = node.next;\n                    } else if (node.next !== null) {\n                        listeners.set(eventName, node.next);\n                    } else {\n                        listeners.delete(eventName);\n                    }\n                } else {\n                    prev = node;\n                }\n\n                node = node.next;\n            }\n\n            // Add new value.\n            if (listener !== null) {\n                const newNode = {\n                    listener,\n                    listenerType: ATTRIBUTE,\n                    passive: false,\n                    once: false,\n                    next: null,\n                };\n                if (prev === null) {\n                    listeners.set(eventName, newNode);\n                } else {\n                    prev.next = newNode;\n                }\n            }\n        },\n        configurable: true,\n        enumerable: true,\n    }\n}\n\n/**\n * Define an event attribute (e.g. `eventTarget.onclick`).\n * @param {Object} eventTargetPrototype The event target prototype to define an event attrbite.\n * @param {string} eventName The event name to define.\n * @returns {void}\n */\nfunction defineEventAttribute(eventTargetPrototype, eventName) {\n    Object.defineProperty(\n        eventTargetPrototype,\n        `on${eventName}`,\n        defineEventAttributeDescriptor(eventName)\n    );\n}\n\n/**\n * Define a custom EventTarget with event attributes.\n * @param {string[]} eventNames Event names for event attributes.\n * @returns {EventTarget} The custom EventTarget.\n * @private\n */\nfunction defineCustomEventTarget(eventNames) {\n    /** CustomEventTarget */\n    function CustomEventTarget() {\n        EventTarget.call(this);\n    }\n\n    CustomEventTarget.prototype = Object.create(EventTarget.prototype, {\n        constructor: {\n            value: CustomEventTarget,\n            configurable: true,\n            writable: true,\n        },\n    });\n\n    for (let i = 0; i < eventNames.length; ++i) {\n        defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);\n    }\n\n    return CustomEventTarget\n}\n\n/**\n * EventTarget.\n *\n * - This is constructor if no arguments.\n * - This is a function which returns a CustomEventTarget constructor if there are arguments.\n *\n * For example:\n *\n *     class A extends EventTarget {}\n *     class B extends EventTarget(\"message\") {}\n *     class C extends EventTarget(\"message\", \"error\") {}\n *     class D extends EventTarget([\"message\", \"error\"]) {}\n */\nfunction EventTarget() {\n    /*eslint-disable consistent-return */\n    if (this instanceof EventTarget) {\n        listenersMap.set(this, new Map());\n        return\n    }\n    if (arguments.length === 1 && Array.isArray(arguments[0])) {\n        return defineCustomEventTarget(arguments[0])\n    }\n    if (arguments.length > 0) {\n        const types = new Array(arguments.length);\n        for (let i = 0; i < arguments.length; ++i) {\n            types[i] = arguments[i];\n        }\n        return defineCustomEventTarget(types)\n    }\n    throw new TypeError(\"Cannot call a class as a function\")\n    /*eslint-enable consistent-return */\n}\n\n// Should be enumerable, but class methods are not enumerable.\nEventTarget.prototype = {\n    /**\n     * Add a given listener to this event target.\n     * @param {string} eventName The event name to add.\n     * @param {Function} listener The listener to add.\n     * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.\n     * @returns {void}\n     */\n    addEventListener(eventName, listener, options) {\n        if (listener == null) {\n            return\n        }\n        if (typeof listener !== \"function\" && !isObject(listener)) {\n            throw new TypeError(\"'listener' should be a function or an object.\")\n        }\n\n        const listeners = getListeners(this);\n        const optionsIsObj = isObject(options);\n        const capture = optionsIsObj\n            ? Boolean(options.capture)\n            : Boolean(options);\n        const listenerType = capture ? CAPTURE : BUBBLE;\n        const newNode = {\n            listener,\n            listenerType,\n            passive: optionsIsObj && Boolean(options.passive),\n            once: optionsIsObj && Boolean(options.once),\n            next: null,\n        };\n\n        // Set it as the first node if the first node is null.\n        let node = listeners.get(eventName);\n        if (node === undefined) {\n            listeners.set(eventName, newNode);\n            return\n        }\n\n        // Traverse to the tail while checking duplication..\n        let prev = null;\n        while (node != null) {\n            if (\n                node.listener === listener &&\n                node.listenerType === listenerType\n            ) {\n                // Should ignore duplication.\n                return\n            }\n            prev = node;\n            node = node.next;\n        }\n\n        // Add it.\n        prev.next = newNode;\n    },\n\n    /**\n     * Remove a given listener from this event target.\n     * @param {string} eventName The event name to remove.\n     * @param {Function} listener The listener to remove.\n     * @param {boolean|{capture?:boolean,passive?:boolean,once?:boolean}} [options] The options for this listener.\n     * @returns {void}\n     */\n    removeEventListener(eventName, listener, options) {\n        if (listener == null) {\n            return\n        }\n\n        const listeners = getListeners(this);\n        const capture = isObject(options)\n            ? Boolean(options.capture)\n            : Boolean(options);\n        const listenerType = capture ? CAPTURE : BUBBLE;\n\n        let prev = null;\n        let node = listeners.get(eventName);\n        while (node != null) {\n            if (\n                node.listener === listener &&\n                node.listenerType === listenerType\n            ) {\n                if (prev !== null) {\n                    prev.next = node.next;\n                } else if (node.next !== null) {\n                    listeners.set(eventName, node.next);\n                } else {\n                    listeners.delete(eventName);\n                }\n                return\n            }\n\n            prev = node;\n            node = node.next;\n        }\n    },\n\n    /**\n     * Dispatch a given event.\n     * @param {Event|{type:string}} event The event to dispatch.\n     * @returns {boolean} `false` if canceled.\n     */\n    dispatchEvent(event) {\n        if (event == null || typeof event.type !== \"string\") {\n            throw new TypeError('\"event.type\" should be a string.')\n        }\n\n        // If listeners aren't registered, terminate.\n        const listeners = getListeners(this);\n        const eventName = event.type;\n        let node = listeners.get(eventName);\n        if (node == null) {\n            return true\n        }\n\n        // Since we cannot rewrite several properties, so wrap object.\n        const wrappedEvent = wrapEvent(this, event);\n\n        // This doesn't process capturing phase and bubbling phase.\n        // This isn't participating in a tree.\n        let prev = null;\n        while (node != null) {\n            // Remove this listener if it's once\n            if (node.once) {\n                if (prev !== null) {\n                    prev.next = node.next;\n                } else if (node.next !== null) {\n                    listeners.set(eventName, node.next);\n                } else {\n                    listeners.delete(eventName);\n                }\n            } else {\n                prev = node;\n            }\n\n            // Call this listener\n            setPassiveListener(\n                wrappedEvent,\n                node.passive ? node.listener : null\n            );\n            if (typeof node.listener === \"function\") {\n                try {\n                    node.listener.call(this, wrappedEvent);\n                } catch (err) {\n                    if (\n                        typeof console !== \"undefined\" &&\n                        typeof console.error === \"function\"\n                    ) {\n                        console.error(err);\n                    }\n                }\n            } else if (\n                node.listenerType !== ATTRIBUTE &&\n                typeof node.listener.handleEvent === \"function\"\n            ) {\n                node.listener.handleEvent(wrappedEvent);\n            }\n\n            // Break if `event.stopImmediatePropagation` was called.\n            if (isStopped(wrappedEvent)) {\n                break\n            }\n\n            node = node.next;\n        }\n        setPassiveListener(wrappedEvent, null);\n        setEventPhase(wrappedEvent, 0);\n        setCurrentTarget(wrappedEvent, null);\n\n        return !wrappedEvent.defaultPrevented\n    },\n};\n\n// `constructor` is not enumerable.\nObject.defineProperty(EventTarget.prototype, \"constructor\", {\n    value: EventTarget,\n    configurable: true,\n    writable: true,\n});\n\n// Ensure `eventTarget instanceof window.EventTarget` is `true`.\nif (\n    typeof window !== \"undefined\" &&\n    typeof window.EventTarget !== \"undefined\"\n) {\n    Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);\n}\n\nexport default EventTarget;\nexport { defineEventAttribute, EventTarget };\n//# sourceMappingURL=event-target-shim.mjs.map\n","/**\n * @author Toru Nagashima <https://github.com/mysticatea>\n * See LICENSE file in root directory for full license.\n */\nimport { EventTarget, defineEventAttribute } from 'event-target-shim';\n\n/**\n * The signal class.\n * @see https://dom.spec.whatwg.org/#abortsignal\n */\nclass AbortSignal extends EventTarget {\n    /**\n     * AbortSignal cannot be constructed directly.\n     */\n    constructor() {\n        super();\n        throw new TypeError(\"AbortSignal cannot be constructed directly\");\n    }\n    /**\n     * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.\n     */\n    get aborted() {\n        const aborted = abortedFlags.get(this);\n        if (typeof aborted !== \"boolean\") {\n            throw new TypeError(`Expected 'this' to be an 'AbortSignal' object, but got ${this === null ? \"null\" : typeof this}`);\n        }\n        return aborted;\n    }\n}\ndefineEventAttribute(AbortSignal.prototype, \"abort\");\n/**\n * Create an AbortSignal object.\n */\nfunction createAbortSignal() {\n    const signal = Object.create(AbortSignal.prototype);\n    EventTarget.call(signal);\n    abortedFlags.set(signal, false);\n    return signal;\n}\n/**\n * Abort a given signal.\n */\nfunction abortSignal(signal) {\n    if (abortedFlags.get(signal) !== false) {\n        return;\n    }\n    abortedFlags.set(signal, true);\n    signal.dispatchEvent({ type: \"abort\" });\n}\n/**\n * Aborted flag for each instances.\n */\nconst abortedFlags = new WeakMap();\n// Properties should be enumerable.\nObject.defineProperties(AbortSignal.prototype, {\n    aborted: { enumerable: true },\n});\n// `toString()` should return `\"[object AbortSignal]\"`\nif (typeof Symbol === \"function\" && typeof Symbol.toStringTag === \"symbol\") {\n    Object.defineProperty(AbortSignal.prototype, Symbol.toStringTag, {\n        configurable: true,\n        value: \"AbortSignal\",\n    });\n}\n\n/**\n * The AbortController.\n * @see https://dom.spec.whatwg.org/#abortcontroller\n */\nclass AbortController {\n    /**\n     * Initialize this controller.\n     */\n    constructor() {\n        signals.set(this, createAbortSignal());\n    }\n    /**\n     * Returns the `AbortSignal` object associated with this object.\n     */\n    get signal() {\n        return getSignal(this);\n    }\n    /**\n     * Abort and signal to any observers that the associated activity is to be aborted.\n     */\n    abort() {\n        abortSignal(getSignal(this));\n    }\n}\n/**\n * Associated signals.\n */\nconst signals = new WeakMap();\n/**\n * Get the associated signal of a given controller.\n */\nfunction getSignal(controller) {\n    const signal = signals.get(controller);\n    if (signal == null) {\n        throw new TypeError(`Expected 'this' to be an 'AbortController' object, but got ${controller === null ? \"null\" : typeof controller}`);\n    }\n    return signal;\n}\n// Properties should be enumerable.\nObject.defineProperties(AbortController.prototype, {\n    signal: { enumerable: true },\n    abort: { enumerable: true },\n});\nif (typeof Symbol === \"function\" && typeof Symbol.toStringTag === \"symbol\") {\n    Object.defineProperty(AbortController.prototype, Symbol.toStringTag, {\n        configurable: true,\n        value: \"AbortController\",\n    });\n}\n\nexport default AbortController;\nexport { AbortController, AbortSignal };\n//# sourceMappingURL=abort-controller.mjs.map\n","'use strict'\n\nconst { format, inspect, AggregateError: CustomAggregateError } = require('./util')\n\n/*\n  This file is a reduced and adapted version of the main lib/internal/errors.js file defined at\n\n  https://github.com/nodejs/node/blob/master/lib/internal/errors.js\n\n  Don't try to replace with the original file and keep it up to date (starting from E(...) definitions)\n  with the upstream file.\n*/\n\nconst AggregateError = globalThis.AggregateError || CustomAggregateError\nconst kIsNodeError = Symbol('kIsNodeError')\nconst kTypes = [\n  'string',\n  'function',\n  'number',\n  'object',\n  // Accept 'Function' and 'Object' as alternative to the lower cased version.\n  'Function',\n  'Object',\n  'boolean',\n  'bigint',\n  'symbol'\n]\nconst classRegExp = /^([A-Z][a-z0-9]*)+$/\nconst nodeInternalPrefix = '__node_internal_'\nconst codes = {}\nfunction assert(value, message) {\n  if (!value) {\n    throw new codes.ERR_INTERNAL_ASSERTION(message)\n  }\n}\n\n// Only use this for integers! Decimal numbers do not work with this function.\nfunction addNumericalSeparator(val) {\n  let res = ''\n  let i = val.length\n  const start = val[0] === '-' ? 1 : 0\n  for (; i >= start + 4; i -= 3) {\n    res = `_${val.slice(i - 3, i)}${res}`\n  }\n  return `${val.slice(0, i)}${res}`\n}\nfunction getMessage(key, msg, args) {\n  if (typeof msg === 'function') {\n    assert(\n      msg.length <= args.length,\n      // Default options do not count.\n      `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).`\n    )\n    return msg(...args)\n  }\n  const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length\n  assert(\n    expectedLength === args.length,\n    `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`\n  )\n  if (args.length === 0) {\n    return msg\n  }\n  return format(msg, ...args)\n}\nfunction E(code, message, Base) {\n  if (!Base) {\n    Base = Error\n  }\n  class NodeError extends Base {\n    constructor(...args) {\n      super(getMessage(code, message, args))\n    }\n    toString() {\n      return `${this.name} [${code}]: ${this.message}`\n    }\n  }\n  Object.defineProperties(NodeError.prototype, {\n    name: {\n      value: Base.name,\n      writable: true,\n      enumerable: false,\n      configurable: true\n    },\n    toString: {\n      value() {\n        return `${this.name} [${code}]: ${this.message}`\n      },\n      writable: true,\n      enumerable: false,\n      configurable: true\n    }\n  })\n  NodeError.prototype.code = code\n  NodeError.prototype[kIsNodeError] = true\n  codes[code] = NodeError\n}\nfunction hideStackFrames(fn) {\n  // We rename the functions that will be hidden to cut off the stacktrace\n  // at the outermost one\n  const hidden = nodeInternalPrefix + fn.name\n  Object.defineProperty(fn, 'name', {\n    value: hidden\n  })\n  return fn\n}\nfunction aggregateTwoErrors(innerError, outerError) {\n  if (innerError && outerError && innerError !== outerError) {\n    if (Array.isArray(outerError.errors)) {\n      // If `outerError` is already an `AggregateError`.\n      outerError.errors.push(innerError)\n      return outerError\n    }\n    const err = new AggregateError([outerError, innerError], outerError.message)\n    err.code = outerError.code\n    return err\n  }\n  return innerError || outerError\n}\nclass AbortError extends Error {\n  constructor(message = 'The operation was aborted', options = undefined) {\n    if (options !== undefined && typeof options !== 'object') {\n      throw new codes.ERR_INVALID_ARG_TYPE('options', 'Object', options)\n    }\n    super(message, options)\n    this.code = 'ABORT_ERR'\n    this.name = 'AbortError'\n  }\n}\nE('ERR_ASSERTION', '%s', Error)\nE(\n  'ERR_INVALID_ARG_TYPE',\n  (name, expected, actual) => {\n    assert(typeof name === 'string', \"'name' must be a string\")\n    if (!Array.isArray(expected)) {\n      expected = [expected]\n    }\n    let msg = 'The '\n    if (name.endsWith(' argument')) {\n      // For cases like 'first argument'\n      msg += `${name} `\n    } else {\n      msg += `\"${name}\" ${name.includes('.') ? 'property' : 'argument'} `\n    }\n    msg += 'must be '\n    const types = []\n    const instances = []\n    const other = []\n    for (const value of expected) {\n      assert(typeof value === 'string', 'All expected entries have to be of type string')\n      if (kTypes.includes(value)) {\n        types.push(value.toLowerCase())\n      } else if (classRegExp.test(value)) {\n        instances.push(value)\n      } else {\n        assert(value !== 'object', 'The value \"object\" should be written as \"Object\"')\n        other.push(value)\n      }\n    }\n\n    // Special handle `object` in case other instances are allowed to outline\n    // the differences between each other.\n    if (instances.length > 0) {\n      const pos = types.indexOf('object')\n      if (pos !== -1) {\n        types.splice(types, pos, 1)\n        instances.push('Object')\n      }\n    }\n    if (types.length > 0) {\n      switch (types.length) {\n        case 1:\n          msg += `of type ${types[0]}`\n          break\n        case 2:\n          msg += `one of type ${types[0]} or ${types[1]}`\n          break\n        default: {\n          const last = types.pop()\n          msg += `one of type ${types.join(', ')}, or ${last}`\n        }\n      }\n      if (instances.length > 0 || other.length > 0) {\n        msg += ' or '\n      }\n    }\n    if (instances.length > 0) {\n      switch (instances.length) {\n        case 1:\n          msg += `an instance of ${instances[0]}`\n          break\n        case 2:\n          msg += `an instance of ${instances[0]} or ${instances[1]}`\n          break\n        default: {\n          const last = instances.pop()\n          msg += `an instance of ${instances.join(', ')}, or ${last}`\n        }\n      }\n      if (other.length > 0) {\n        msg += ' or '\n      }\n    }\n    switch (other.length) {\n      case 0:\n        break\n      case 1:\n        if (other[0].toLowerCase() !== other[0]) {\n          msg += 'an '\n        }\n        msg += `${other[0]}`\n        break\n      case 2:\n        msg += `one of ${other[0]} or ${other[1]}`\n        break\n      default: {\n        const last = other.pop()\n        msg += `one of ${other.join(', ')}, or ${last}`\n      }\n    }\n    if (actual == null) {\n      msg += `. Received ${actual}`\n    } else if (typeof actual === 'function' && actual.name) {\n      msg += `. Received function ${actual.name}`\n    } else if (typeof actual === 'object') {\n      var _actual$constructor\n      if (\n        (_actual$constructor = actual.constructor) !== null &&\n        _actual$constructor !== undefined &&\n        _actual$constructor.name\n      ) {\n        msg += `. Received an instance of ${actual.constructor.name}`\n      } else {\n        const inspected = inspect(actual, {\n          depth: -1\n        })\n        msg += `. Received ${inspected}`\n      }\n    } else {\n      let inspected = inspect(actual, {\n        colors: false\n      })\n      if (inspected.length > 25) {\n        inspected = `${inspected.slice(0, 25)}...`\n      }\n      msg += `. Received type ${typeof actual} (${inspected})`\n    }\n    return msg\n  },\n  TypeError\n)\nE(\n  'ERR_INVALID_ARG_VALUE',\n  (name, value, reason = 'is invalid') => {\n    let inspected = inspect(value)\n    if (inspected.length > 128) {\n      inspected = inspected.slice(0, 128) + '...'\n    }\n    const type = name.includes('.') ? 'property' : 'argument'\n    return `The ${type} '${name}' ${reason}. Received ${inspected}`\n  },\n  TypeError\n)\nE(\n  'ERR_INVALID_RETURN_VALUE',\n  (input, name, value) => {\n    var _value$constructor\n    const type =\n      value !== null &&\n      value !== undefined &&\n      (_value$constructor = value.constructor) !== null &&\n      _value$constructor !== undefined &&\n      _value$constructor.name\n        ? `instance of ${value.constructor.name}`\n        : `type ${typeof value}`\n    return `Expected ${input} to be returned from the \"${name}\"` + ` function but got ${type}.`\n  },\n  TypeError\n)\nE(\n  'ERR_MISSING_ARGS',\n  (...args) => {\n    assert(args.length > 0, 'At least one arg needs to be specified')\n    let msg\n    const len = args.length\n    args = (Array.isArray(args) ? args : [args]).map((a) => `\"${a}\"`).join(' or ')\n    switch (len) {\n      case 1:\n        msg += `The ${args[0]} argument`\n        break\n      case 2:\n        msg += `The ${args[0]} and ${args[1]} arguments`\n        break\n      default:\n        {\n          const last = args.pop()\n          msg += `The ${args.join(', ')}, and ${last} arguments`\n        }\n        break\n    }\n    return `${msg} must be specified`\n  },\n  TypeError\n)\nE(\n  'ERR_OUT_OF_RANGE',\n  (str, range, input) => {\n    assert(range, 'Missing \"range\" argument')\n    let received\n    if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n      received = addNumericalSeparator(String(input))\n    } else if (typeof input === 'bigint') {\n      received = String(input)\n      if (input > 2n ** 32n || input < -(2n ** 32n)) {\n        received = addNumericalSeparator(received)\n      }\n      received += 'n'\n    } else {\n      received = inspect(input)\n    }\n    return `The value of \"${str}\" is out of range. It must be ${range}. Received ${received}`\n  },\n  RangeError\n)\nE('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times', Error)\nE('ERR_METHOD_NOT_IMPLEMENTED', 'The %s method is not implemented', Error)\nE('ERR_STREAM_ALREADY_FINISHED', 'Cannot call %s after a stream was finished', Error)\nE('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable', Error)\nE('ERR_STREAM_DESTROYED', 'Cannot call %s after a stream was destroyed', Error)\nE('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError)\nE('ERR_STREAM_PREMATURE_CLOSE', 'Premature close', Error)\nE('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF', Error)\nE('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event', Error)\nE('ERR_STREAM_WRITE_AFTER_END', 'write after end', Error)\nE('ERR_UNKNOWN_ENCODING', 'Unknown encoding: %s', TypeError)\nmodule.exports = {\n  AbortError,\n  aggregateTwoErrors: hideStackFrames(aggregateTwoErrors),\n  hideStackFrames,\n  codes\n}\n","'use strict'\n\nconst {\n  ArrayIsArray,\n  ArrayPrototypeIncludes,\n  ArrayPrototypeJoin,\n  ArrayPrototypeMap,\n  NumberIsInteger,\n  NumberIsNaN,\n  NumberMAX_SAFE_INTEGER,\n  NumberMIN_SAFE_INTEGER,\n  NumberParseInt,\n  ObjectPrototypeHasOwnProperty,\n  RegExpPrototypeExec,\n  String,\n  StringPrototypeToUpperCase,\n  StringPrototypeTrim\n} = require('../ours/primordials')\nconst {\n  hideStackFrames,\n  codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL }\n} = require('../ours/errors')\nconst { normalizeEncoding } = require('../ours/util')\nconst { isAsyncFunction, isArrayBufferView } = require('../ours/util').types\nconst signals = {}\n\n/**\n * @param {*} value\n * @returns {boolean}\n */\nfunction isInt32(value) {\n  return value === (value | 0)\n}\n\n/**\n * @param {*} value\n * @returns {boolean}\n */\nfunction isUint32(value) {\n  return value === value >>> 0\n}\nconst octalReg = /^[0-7]+$/\nconst modeDesc = 'must be a 32-bit unsigned integer or an octal string'\n\n/**\n * Parse and validate values that will be converted into mode_t (the S_*\n * constants). Only valid numbers and octal strings are allowed. They could be\n * converted to 32-bit unsigned integers or non-negative signed integers in the\n * C++ land, but any value higher than 0o777 will result in platform-specific\n * behaviors.\n *\n * @param {*} value Values to be validated\n * @param {string} name Name of the argument\n * @param {number} [def] If specified, will be returned for invalid values\n * @returns {number}\n */\nfunction parseFileMode(value, name, def) {\n  if (typeof value === 'undefined') {\n    value = def\n  }\n  if (typeof value === 'string') {\n    if (RegExpPrototypeExec(octalReg, value) === null) {\n      throw new ERR_INVALID_ARG_VALUE(name, value, modeDesc)\n    }\n    value = NumberParseInt(value, 8)\n  }\n  validateUint32(value, name)\n  return value\n}\n\n/**\n * @callback validateInteger\n * @param {*} value\n * @param {string} name\n * @param {number} [min]\n * @param {number} [max]\n * @returns {asserts value is number}\n */\n\n/** @type {validateInteger} */\nconst validateInteger = hideStackFrames((value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) => {\n  if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value)\n  if (!NumberIsInteger(value)) throw new ERR_OUT_OF_RANGE(name, 'an integer', value)\n  if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)\n})\n\n/**\n * @callback validateInt32\n * @param {*} value\n * @param {string} name\n * @param {number} [min]\n * @param {number} [max]\n * @returns {asserts value is number}\n */\n\n/** @type {validateInt32} */\nconst validateInt32 = hideStackFrames((value, name, min = -2147483648, max = 2147483647) => {\n  // The defaults for min and max correspond to the limits of 32-bit integers.\n  if (typeof value !== 'number') {\n    throw new ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n  if (!NumberIsInteger(value)) {\n    throw new ERR_OUT_OF_RANGE(name, 'an integer', value)\n  }\n  if (value < min || value > max) {\n    throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)\n  }\n})\n\n/**\n * @callback validateUint32\n * @param {*} value\n * @param {string} name\n * @param {number|boolean} [positive=false]\n * @returns {asserts value is number}\n */\n\n/** @type {validateUint32} */\nconst validateUint32 = hideStackFrames((value, name, positive = false) => {\n  if (typeof value !== 'number') {\n    throw new ERR_INVALID_ARG_TYPE(name, 'number', value)\n  }\n  if (!NumberIsInteger(value)) {\n    throw new ERR_OUT_OF_RANGE(name, 'an integer', value)\n  }\n  const min = positive ? 1 : 0\n  // 2 ** 32 === 4294967296\n  const max = 4294967295\n  if (value < min || value > max) {\n    throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value)\n  }\n})\n\n/**\n * @callback validateString\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is string}\n */\n\n/** @type {validateString} */\nfunction validateString(value, name) {\n  if (typeof value !== 'string') throw new ERR_INVALID_ARG_TYPE(name, 'string', value)\n}\n\n/**\n * @callback validateNumber\n * @param {*} value\n * @param {string} name\n * @param {number} [min]\n * @param {number} [max]\n * @returns {asserts value is number}\n */\n\n/** @type {validateNumber} */\nfunction validateNumber(value, name, min = undefined, max) {\n  if (typeof value !== 'number') throw new ERR_INVALID_ARG_TYPE(name, 'number', value)\n  if (\n    (min != null && value < min) ||\n    (max != null && value > max) ||\n    ((min != null || max != null) && NumberIsNaN(value))\n  ) {\n    throw new ERR_OUT_OF_RANGE(\n      name,\n      `${min != null ? `>= ${min}` : ''}${min != null && max != null ? ' && ' : ''}${max != null ? `<= ${max}` : ''}`,\n      value\n    )\n  }\n}\n\n/**\n * @callback validateOneOf\n * @template T\n * @param {T} value\n * @param {string} name\n * @param {T[]} oneOf\n */\n\n/** @type {validateOneOf} */\nconst validateOneOf = hideStackFrames((value, name, oneOf) => {\n  if (!ArrayPrototypeIncludes(oneOf, value)) {\n    const allowed = ArrayPrototypeJoin(\n      ArrayPrototypeMap(oneOf, (v) => (typeof v === 'string' ? `'${v}'` : String(v))),\n      ', '\n    )\n    const reason = 'must be one of: ' + allowed\n    throw new ERR_INVALID_ARG_VALUE(name, value, reason)\n  }\n})\n\n/**\n * @callback validateBoolean\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is boolean}\n */\n\n/** @type {validateBoolean} */\nfunction validateBoolean(value, name) {\n  if (typeof value !== 'boolean') throw new ERR_INVALID_ARG_TYPE(name, 'boolean', value)\n}\nfunction getOwnPropertyValueOrDefault(options, key, defaultValue) {\n  return options == null || !ObjectPrototypeHasOwnProperty(options, key) ? defaultValue : options[key]\n}\n\n/**\n * @callback validateObject\n * @param {*} value\n * @param {string} name\n * @param {{\n *   allowArray?: boolean,\n *   allowFunction?: boolean,\n *   nullable?: boolean\n * }} [options]\n */\n\n/** @type {validateObject} */\nconst validateObject = hideStackFrames((value, name, options = null) => {\n  const allowArray = getOwnPropertyValueOrDefault(options, 'allowArray', false)\n  const allowFunction = getOwnPropertyValueOrDefault(options, 'allowFunction', false)\n  const nullable = getOwnPropertyValueOrDefault(options, 'nullable', false)\n  if (\n    (!nullable && value === null) ||\n    (!allowArray && ArrayIsArray(value)) ||\n    (typeof value !== 'object' && (!allowFunction || typeof value !== 'function'))\n  ) {\n    throw new ERR_INVALID_ARG_TYPE(name, 'Object', value)\n  }\n})\n\n/**\n * @callback validateArray\n * @param {*} value\n * @param {string} name\n * @param {number} [minLength]\n * @returns {asserts value is any[]}\n */\n\n/** @type {validateArray} */\nconst validateArray = hideStackFrames((value, name, minLength = 0) => {\n  if (!ArrayIsArray(value)) {\n    throw new ERR_INVALID_ARG_TYPE(name, 'Array', value)\n  }\n  if (value.length < minLength) {\n    const reason = `must be longer than ${minLength}`\n    throw new ERR_INVALID_ARG_VALUE(name, value, reason)\n  }\n})\n\n// eslint-disable-next-line jsdoc/require-returns-check\n/**\n * @param {*} signal\n * @param {string} [name='signal']\n * @returns {asserts signal is keyof signals}\n */\nfunction validateSignalName(signal, name = 'signal') {\n  validateString(signal, name)\n  if (signals[signal] === undefined) {\n    if (signals[StringPrototypeToUpperCase(signal)] !== undefined) {\n      throw new ERR_UNKNOWN_SIGNAL(signal + ' (signals must use all capital letters)')\n    }\n    throw new ERR_UNKNOWN_SIGNAL(signal)\n  }\n}\n\n/**\n * @callback validateBuffer\n * @param {*} buffer\n * @param {string} [name='buffer']\n * @returns {asserts buffer is ArrayBufferView}\n */\n\n/** @type {validateBuffer} */\nconst validateBuffer = hideStackFrames((buffer, name = 'buffer') => {\n  if (!isArrayBufferView(buffer)) {\n    throw new ERR_INVALID_ARG_TYPE(name, ['Buffer', 'TypedArray', 'DataView'], buffer)\n  }\n})\n\n/**\n * @param {string} data\n * @param {string} encoding\n */\nfunction validateEncoding(data, encoding) {\n  const normalizedEncoding = normalizeEncoding(encoding)\n  const length = data.length\n  if (normalizedEncoding === 'hex' && length % 2 !== 0) {\n    throw new ERR_INVALID_ARG_VALUE('encoding', encoding, `is invalid for data of length ${length}`)\n  }\n}\n\n/**\n * Check that the port number is not NaN when coerced to a number,\n * is an integer and that it falls within the legal range of port numbers.\n * @param {*} port\n * @param {string} [name='Port']\n * @param {boolean} [allowZero=true]\n * @returns {number}\n */\nfunction validatePort(port, name = 'Port', allowZero = true) {\n  if (\n    (typeof port !== 'number' && typeof port !== 'string') ||\n    (typeof port === 'string' && StringPrototypeTrim(port).length === 0) ||\n    +port !== +port >>> 0 ||\n    port > 0xffff ||\n    (port === 0 && !allowZero)\n  ) {\n    throw new ERR_SOCKET_BAD_PORT(name, port, allowZero)\n  }\n  return port | 0\n}\n\n/**\n * @callback validateAbortSignal\n * @param {*} signal\n * @param {string} name\n */\n\n/** @type {validateAbortSignal} */\nconst validateAbortSignal = hideStackFrames((signal, name) => {\n  if (signal !== undefined && (signal === null || typeof signal !== 'object' || !('aborted' in signal))) {\n    throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal)\n  }\n})\n\n/**\n * @callback validateFunction\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is Function}\n */\n\n/** @type {validateFunction} */\nconst validateFunction = hideStackFrames((value, name) => {\n  if (typeof value !== 'function') throw new ERR_INVALID_ARG_TYPE(name, 'Function', value)\n})\n\n/**\n * @callback validatePlainFunction\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is Function}\n */\n\n/** @type {validatePlainFunction} */\nconst validatePlainFunction = hideStackFrames((value, name) => {\n  if (typeof value !== 'function' || isAsyncFunction(value)) throw new ERR_INVALID_ARG_TYPE(name, 'Function', value)\n})\n\n/**\n * @callback validateUndefined\n * @param {*} value\n * @param {string} name\n * @returns {asserts value is undefined}\n */\n\n/** @type {validateUndefined} */\nconst validateUndefined = hideStackFrames((value, name) => {\n  if (value !== undefined) throw new ERR_INVALID_ARG_TYPE(name, 'undefined', value)\n})\n\n/**\n * @template T\n * @param {T} value\n * @param {string} name\n * @param {T[]} union\n */\nfunction validateUnion(value, name, union) {\n  if (!ArrayPrototypeIncludes(union, value)) {\n    throw new ERR_INVALID_ARG_TYPE(name, `('${ArrayPrototypeJoin(union, '|')}')`, value)\n  }\n}\nmodule.exports = {\n  isInt32,\n  isUint32,\n  parseFileMode,\n  validateArray,\n  validateBoolean,\n  validateBuffer,\n  validateEncoding,\n  validateFunction,\n  validateInt32,\n  validateInteger,\n  validateNumber,\n  validateObject,\n  validateOneOf,\n  validatePlainFunction,\n  validatePort,\n  validateSignalName,\n  validateString,\n  validateUint32,\n  validateUndefined,\n  validateUnion,\n  validateAbortSignal\n}\n","// for now just expose the builtin process global from node.js\nmodule.exports = global.process;\n","'use strict'\n\nconst { Symbol, SymbolAsyncIterator, SymbolIterator } = require('../../ours/primordials')\nconst kDestroyed = Symbol('kDestroyed')\nconst kIsErrored = Symbol('kIsErrored')\nconst kIsReadable = Symbol('kIsReadable')\nconst kIsDisturbed = Symbol('kIsDisturbed')\nfunction isReadableNodeStream(obj, strict = false) {\n  var _obj$_readableState\n  return !!(\n    (\n      obj &&\n      typeof obj.pipe === 'function' &&\n      typeof obj.on === 'function' &&\n      (!strict || (typeof obj.pause === 'function' && typeof obj.resume === 'function')) &&\n      (!obj._writableState ||\n        ((_obj$_readableState = obj._readableState) === null || _obj$_readableState === undefined\n          ? undefined\n          : _obj$_readableState.readable) !== false) &&\n      // Duplex\n      (!obj._writableState || obj._readableState)\n    ) // Writable has .pipe.\n  )\n}\n\nfunction isWritableNodeStream(obj) {\n  var _obj$_writableState\n  return !!(\n    (\n      obj &&\n      typeof obj.write === 'function' &&\n      typeof obj.on === 'function' &&\n      (!obj._readableState ||\n        ((_obj$_writableState = obj._writableState) === null || _obj$_writableState === undefined\n          ? undefined\n          : _obj$_writableState.writable) !== false)\n    ) // Duplex\n  )\n}\n\nfunction isDuplexNodeStream(obj) {\n  return !!(\n    obj &&\n    typeof obj.pipe === 'function' &&\n    obj._readableState &&\n    typeof obj.on === 'function' &&\n    typeof obj.write === 'function'\n  )\n}\nfunction isNodeStream(obj) {\n  return (\n    obj &&\n    (obj._readableState ||\n      obj._writableState ||\n      (typeof obj.write === 'function' && typeof obj.on === 'function') ||\n      (typeof obj.pipe === 'function' && typeof obj.on === 'function'))\n  )\n}\nfunction isIterable(obj, isAsync) {\n  if (obj == null) return false\n  if (isAsync === true) return typeof obj[SymbolAsyncIterator] === 'function'\n  if (isAsync === false) return typeof obj[SymbolIterator] === 'function'\n  return typeof obj[SymbolAsyncIterator] === 'function' || typeof obj[SymbolIterator] === 'function'\n}\nfunction isDestroyed(stream) {\n  if (!isNodeStream(stream)) return null\n  const wState = stream._writableState\n  const rState = stream._readableState\n  const state = wState || rState\n  return !!(stream.destroyed || stream[kDestroyed] || (state !== null && state !== undefined && state.destroyed))\n}\n\n// Have been end():d.\nfunction isWritableEnded(stream) {\n  if (!isWritableNodeStream(stream)) return null\n  if (stream.writableEnded === true) return true\n  const wState = stream._writableState\n  if (wState !== null && wState !== undefined && wState.errored) return false\n  if (typeof (wState === null || wState === undefined ? undefined : wState.ended) !== 'boolean') return null\n  return wState.ended\n}\n\n// Have emitted 'finish'.\nfunction isWritableFinished(stream, strict) {\n  if (!isWritableNodeStream(stream)) return null\n  if (stream.writableFinished === true) return true\n  const wState = stream._writableState\n  if (wState !== null && wState !== undefined && wState.errored) return false\n  if (typeof (wState === null || wState === undefined ? undefined : wState.finished) !== 'boolean') return null\n  return !!(wState.finished || (strict === false && wState.ended === true && wState.length === 0))\n}\n\n// Have been push(null):d.\nfunction isReadableEnded(stream) {\n  if (!isReadableNodeStream(stream)) return null\n  if (stream.readableEnded === true) return true\n  const rState = stream._readableState\n  if (!rState || rState.errored) return false\n  if (typeof (rState === null || rState === undefined ? undefined : rState.ended) !== 'boolean') return null\n  return rState.ended\n}\n\n// Have emitted 'end'.\nfunction isReadableFinished(stream, strict) {\n  if (!isReadableNodeStream(stream)) return null\n  const rState = stream._readableState\n  if (rState !== null && rState !== undefined && rState.errored) return false\n  if (typeof (rState === null || rState === undefined ? undefined : rState.endEmitted) !== 'boolean') return null\n  return !!(rState.endEmitted || (strict === false && rState.ended === true && rState.length === 0))\n}\nfunction isReadable(stream) {\n  if (stream && stream[kIsReadable] != null) return stream[kIsReadable]\n  if (typeof (stream === null || stream === undefined ? undefined : stream.readable) !== 'boolean') return null\n  if (isDestroyed(stream)) return false\n  return isReadableNodeStream(stream) && stream.readable && !isReadableFinished(stream)\n}\nfunction isWritable(stream) {\n  if (typeof (stream === null || stream === undefined ? undefined : stream.writable) !== 'boolean') return null\n  if (isDestroyed(stream)) return false\n  return isWritableNodeStream(stream) && stream.writable && !isWritableEnded(stream)\n}\nfunction isFinished(stream, opts) {\n  if (!isNodeStream(stream)) {\n    return null\n  }\n  if (isDestroyed(stream)) {\n    return true\n  }\n  if ((opts === null || opts === undefined ? undefined : opts.readable) !== false && isReadable(stream)) {\n    return false\n  }\n  if ((opts === null || opts === undefined ? undefined : opts.writable) !== false && isWritable(stream)) {\n    return false\n  }\n  return true\n}\nfunction isWritableErrored(stream) {\n  var _stream$_writableStat, _stream$_writableStat2\n  if (!isNodeStream(stream)) {\n    return null\n  }\n  if (stream.writableErrored) {\n    return stream.writableErrored\n  }\n  return (_stream$_writableStat =\n    (_stream$_writableStat2 = stream._writableState) === null || _stream$_writableStat2 === undefined\n      ? undefined\n      : _stream$_writableStat2.errored) !== null && _stream$_writableStat !== undefined\n    ? _stream$_writableStat\n    : null\n}\nfunction isReadableErrored(stream) {\n  var _stream$_readableStat, _stream$_readableStat2\n  if (!isNodeStream(stream)) {\n    return null\n  }\n  if (stream.readableErrored) {\n    return stream.readableErrored\n  }\n  return (_stream$_readableStat =\n    (_stream$_readableStat2 = stream._readableState) === null || _stream$_readableStat2 === undefined\n      ? undefined\n      : _stream$_readableStat2.errored) !== null && _stream$_readableStat !== undefined\n    ? _stream$_readableStat\n    : null\n}\nfunction isClosed(stream) {\n  if (!isNodeStream(stream)) {\n    return null\n  }\n  if (typeof stream.closed === 'boolean') {\n    return stream.closed\n  }\n  const wState = stream._writableState\n  const rState = stream._readableState\n  if (\n    typeof (wState === null || wState === undefined ? undefined : wState.closed) === 'boolean' ||\n    typeof (rState === null || rState === undefined ? undefined : rState.closed) === 'boolean'\n  ) {\n    return (\n      (wState === null || wState === undefined ? undefined : wState.closed) ||\n      (rState === null || rState === undefined ? undefined : rState.closed)\n    )\n  }\n  if (typeof stream._closed === 'boolean' && isOutgoingMessage(stream)) {\n    return stream._closed\n  }\n  return null\n}\nfunction isOutgoingMessage(stream) {\n  return (\n    typeof stream._closed === 'boolean' &&\n    typeof stream._defaultKeepAlive === 'boolean' &&\n    typeof stream._removedConnection === 'boolean' &&\n    typeof stream._removedContLen === 'boolean'\n  )\n}\nfunction isServerResponse(stream) {\n  return typeof stream._sent100 === 'boolean' && isOutgoingMessage(stream)\n}\nfunction isServerRequest(stream) {\n  var _stream$req\n  return (\n    typeof stream._consuming === 'boolean' &&\n    typeof stream._dumped === 'boolean' &&\n    ((_stream$req = stream.req) === null || _stream$req === undefined ? undefined : _stream$req.upgradeOrConnect) ===\n      undefined\n  )\n}\nfunction willEmitClose(stream) {\n  if (!isNodeStream(stream)) return null\n  const wState = stream._writableState\n  const rState = stream._readableState\n  const state = wState || rState\n  return (\n    (!state && isServerResponse(stream)) || !!(state && state.autoDestroy && state.emitClose && state.closed === false)\n  )\n}\nfunction isDisturbed(stream) {\n  var _stream$kIsDisturbed\n  return !!(\n    stream &&\n    ((_stream$kIsDisturbed = stream[kIsDisturbed]) !== null && _stream$kIsDisturbed !== undefined\n      ? _stream$kIsDisturbed\n      : stream.readableDidRead || stream.readableAborted)\n  )\n}\nfunction isErrored(stream) {\n  var _ref,\n    _ref2,\n    _ref3,\n    _ref4,\n    _ref5,\n    _stream$kIsErrored,\n    _stream$_readableStat3,\n    _stream$_writableStat3,\n    _stream$_readableStat4,\n    _stream$_writableStat4\n  return !!(\n    stream &&\n    ((_ref =\n      (_ref2 =\n        (_ref3 =\n          (_ref4 =\n            (_ref5 =\n              (_stream$kIsErrored = stream[kIsErrored]) !== null && _stream$kIsErrored !== undefined\n                ? _stream$kIsErrored\n                : stream.readableErrored) !== null && _ref5 !== undefined\n              ? _ref5\n              : stream.writableErrored) !== null && _ref4 !== undefined\n            ? _ref4\n            : (_stream$_readableStat3 = stream._readableState) === null || _stream$_readableStat3 === undefined\n            ? undefined\n            : _stream$_readableStat3.errorEmitted) !== null && _ref3 !== undefined\n          ? _ref3\n          : (_stream$_writableStat3 = stream._writableState) === null || _stream$_writableStat3 === undefined\n          ? undefined\n          : _stream$_writableStat3.errorEmitted) !== null && _ref2 !== undefined\n        ? _ref2\n        : (_stream$_readableStat4 = stream._readableState) === null || _stream$_readableStat4 === undefined\n        ? undefined\n        : _stream$_readableStat4.errored) !== null && _ref !== undefined\n      ? _ref\n      : (_stream$_writableStat4 = stream._writableState) === null || _stream$_writableStat4 === undefined\n      ? undefined\n      : _stream$_writableStat4.errored)\n  )\n}\nmodule.exports = {\n  kDestroyed,\n  isDisturbed,\n  kIsDisturbed,\n  isErrored,\n  kIsErrored,\n  isReadable,\n  kIsReadable,\n  isClosed,\n  isDestroyed,\n  isDuplexNodeStream,\n  isFinished,\n  isIterable,\n  isReadableNodeStream,\n  isReadableEnded,\n  isReadableFinished,\n  isReadableErrored,\n  isNodeStream,\n  isWritable,\n  isWritableNodeStream,\n  isWritableEnded,\n  isWritableFinished,\n  isWritableErrored,\n  isServerRequest,\n  isServerResponse,\n  willEmitClose\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n\n;('use strict')\nconst { AbortError, codes } = require('../../ours/errors')\nconst { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes\nconst { kEmptyObject, once } = require('../../ours/util')\nconst { validateAbortSignal, validateFunction, validateObject } = require('../validators')\nconst { Promise } = require('../../ours/primordials')\nconst {\n  isClosed,\n  isReadable,\n  isReadableNodeStream,\n  isReadableFinished,\n  isReadableErrored,\n  isWritable,\n  isWritableNodeStream,\n  isWritableFinished,\n  isWritableErrored,\n  isNodeStream,\n  willEmitClose: _willEmitClose\n} = require('./utils')\nfunction isRequest(stream) {\n  return stream.setHeader && typeof stream.abort === 'function'\n}\nconst nop = () => {}\nfunction eos(stream, options, callback) {\n  var _options$readable, _options$writable\n  if (arguments.length === 2) {\n    callback = options\n    options = kEmptyObject\n  } else if (options == null) {\n    options = kEmptyObject\n  } else {\n    validateObject(options, 'options')\n  }\n  validateFunction(callback, 'callback')\n  validateAbortSignal(options.signal, 'options.signal')\n  callback = once(callback)\n  const readable =\n    (_options$readable = options.readable) !== null && _options$readable !== undefined\n      ? _options$readable\n      : isReadableNodeStream(stream)\n  const writable =\n    (_options$writable = options.writable) !== null && _options$writable !== undefined\n      ? _options$writable\n      : isWritableNodeStream(stream)\n  if (!isNodeStream(stream)) {\n    // TODO: Webstreams.\n    throw new ERR_INVALID_ARG_TYPE('stream', 'Stream', stream)\n  }\n  const wState = stream._writableState\n  const rState = stream._readableState\n  const onlegacyfinish = () => {\n    if (!stream.writable) {\n      onfinish()\n    }\n  }\n\n  // TODO (ronag): Improve soft detection to include core modules and\n  // common ecosystem modules that do properly emit 'close' but fail\n  // this generic check.\n  let willEmitClose =\n    _willEmitClose(stream) && isReadableNodeStream(stream) === readable && isWritableNodeStream(stream) === writable\n  let writableFinished = isWritableFinished(stream, false)\n  const onfinish = () => {\n    writableFinished = true\n    // Stream should not be destroyed here. If it is that\n    // means that user space is doing something differently and\n    // we cannot trust willEmitClose.\n    if (stream.destroyed) {\n      willEmitClose = false\n    }\n    if (willEmitClose && (!stream.readable || readable)) {\n      return\n    }\n    if (!readable || readableFinished) {\n      callback.call(stream)\n    }\n  }\n  let readableFinished = isReadableFinished(stream, false)\n  const onend = () => {\n    readableFinished = true\n    // Stream should not be destroyed here. If it is that\n    // means that user space is doing something differently and\n    // we cannot trust willEmitClose.\n    if (stream.destroyed) {\n      willEmitClose = false\n    }\n    if (willEmitClose && (!stream.writable || writable)) {\n      return\n    }\n    if (!writable || writableFinished) {\n      callback.call(stream)\n    }\n  }\n  const onerror = (err) => {\n    callback.call(stream, err)\n  }\n  let closed = isClosed(stream)\n  const onclose = () => {\n    closed = true\n    const errored = isWritableErrored(stream) || isReadableErrored(stream)\n    if (errored && typeof errored !== 'boolean') {\n      return callback.call(stream, errored)\n    }\n    if (readable && !readableFinished && isReadableNodeStream(stream, true)) {\n      if (!isReadableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE())\n    }\n    if (writable && !writableFinished) {\n      if (!isWritableFinished(stream, false)) return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE())\n    }\n    callback.call(stream)\n  }\n  const onrequest = () => {\n    stream.req.on('finish', onfinish)\n  }\n  if (isRequest(stream)) {\n    stream.on('complete', onfinish)\n    if (!willEmitClose) {\n      stream.on('abort', onclose)\n    }\n    if (stream.req) {\n      onrequest()\n    } else {\n      stream.on('request', onrequest)\n    }\n  } else if (writable && !wState) {\n    // legacy streams\n    stream.on('end', onlegacyfinish)\n    stream.on('close', onlegacyfinish)\n  }\n\n  // Not all streams will emit 'close' after 'aborted'.\n  if (!willEmitClose && typeof stream.aborted === 'boolean') {\n    stream.on('aborted', onclose)\n  }\n  stream.on('end', onend)\n  stream.on('finish', onfinish)\n  if (options.error !== false) {\n    stream.on('error', onerror)\n  }\n  stream.on('close', onclose)\n  if (closed) {\n    process.nextTick(onclose)\n  } else if (\n    (wState !== null && wState !== undefined && wState.errorEmitted) ||\n    (rState !== null && rState !== undefined && rState.errorEmitted)\n  ) {\n    if (!willEmitClose) {\n      process.nextTick(onclose)\n    }\n  } else if (\n    !readable &&\n    (!willEmitClose || isReadable(stream)) &&\n    (writableFinished || isWritable(stream) === false)\n  ) {\n    process.nextTick(onclose)\n  } else if (\n    !writable &&\n    (!willEmitClose || isWritable(stream)) &&\n    (readableFinished || isReadable(stream) === false)\n  ) {\n    process.nextTick(onclose)\n  } else if (rState && stream.req && stream.aborted) {\n    process.nextTick(onclose)\n  }\n  const cleanup = () => {\n    callback = nop\n    stream.removeListener('aborted', onclose)\n    stream.removeListener('complete', onfinish)\n    stream.removeListener('abort', onclose)\n    stream.removeListener('request', onrequest)\n    if (stream.req) stream.req.removeListener('finish', onfinish)\n    stream.removeListener('end', onlegacyfinish)\n    stream.removeListener('close', onlegacyfinish)\n    stream.removeListener('finish', onfinish)\n    stream.removeListener('end', onend)\n    stream.removeListener('error', onerror)\n    stream.removeListener('close', onclose)\n  }\n  if (options.signal && !closed) {\n    const abort = () => {\n      // Keep it because cleanup removes it.\n      const endCallback = callback\n      cleanup()\n      endCallback.call(\n        stream,\n        new AbortError(undefined, {\n          cause: options.signal.reason\n        })\n      )\n    }\n    if (options.signal.aborted) {\n      process.nextTick(abort)\n    } else {\n      const originalCallback = callback\n      callback = once((...args) => {\n        options.signal.removeEventListener('abort', abort)\n        originalCallback.apply(stream, args)\n      })\n      options.signal.addEventListener('abort', abort)\n    }\n  }\n  return cleanup\n}\nfunction finished(stream, opts) {\n  return new Promise((resolve, reject) => {\n    eos(stream, opts, (err) => {\n      if (err) {\n        reject(err)\n      } else {\n        resolve()\n      }\n    })\n  })\n}\nmodule.exports = eos\nmodule.exports.finished = finished\n","'use strict'\n\nconst AbortController = globalThis.AbortController || require('abort-controller').AbortController\nconst {\n  codes: { ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },\n  AbortError\n} = require('../../ours/errors')\nconst { validateAbortSignal, validateInteger, validateObject } = require('../validators')\nconst kWeakHandler = require('../../ours/primordials').Symbol('kWeak')\nconst { finished } = require('./end-of-stream')\nconst {\n  ArrayPrototypePush,\n  MathFloor,\n  Number,\n  NumberIsNaN,\n  Promise,\n  PromiseReject,\n  PromisePrototypeThen,\n  Symbol\n} = require('../../ours/primordials')\nconst kEmpty = Symbol('kEmpty')\nconst kEof = Symbol('kEof')\nfunction map(fn, options) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)\n  }\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  let concurrency = 1\n  if ((options === null || options === undefined ? undefined : options.concurrency) != null) {\n    concurrency = MathFloor(options.concurrency)\n  }\n  validateInteger(concurrency, 'concurrency', 1)\n  return async function* map() {\n    var _options$signal, _options$signal2\n    const ac = new AbortController()\n    const stream = this\n    const queue = []\n    const signal = ac.signal\n    const signalOpt = {\n      signal\n    }\n    const abort = () => ac.abort()\n    if (\n      options !== null &&\n      options !== undefined &&\n      (_options$signal = options.signal) !== null &&\n      _options$signal !== undefined &&\n      _options$signal.aborted\n    ) {\n      abort()\n    }\n    options === null || options === undefined\n      ? undefined\n      : (_options$signal2 = options.signal) === null || _options$signal2 === undefined\n      ? undefined\n      : _options$signal2.addEventListener('abort', abort)\n    let next\n    let resume\n    let done = false\n    function onDone() {\n      done = true\n    }\n    async function pump() {\n      try {\n        for await (let val of stream) {\n          var _val\n          if (done) {\n            return\n          }\n          if (signal.aborted) {\n            throw new AbortError()\n          }\n          try {\n            val = fn(val, signalOpt)\n          } catch (err) {\n            val = PromiseReject(err)\n          }\n          if (val === kEmpty) {\n            continue\n          }\n          if (typeof ((_val = val) === null || _val === undefined ? undefined : _val.catch) === 'function') {\n            val.catch(onDone)\n          }\n          queue.push(val)\n          if (next) {\n            next()\n            next = null\n          }\n          if (!done && queue.length && queue.length >= concurrency) {\n            await new Promise((resolve) => {\n              resume = resolve\n            })\n          }\n        }\n        queue.push(kEof)\n      } catch (err) {\n        const val = PromiseReject(err)\n        PromisePrototypeThen(val, undefined, onDone)\n        queue.push(val)\n      } finally {\n        var _options$signal3\n        done = true\n        if (next) {\n          next()\n          next = null\n        }\n        options === null || options === undefined\n          ? undefined\n          : (_options$signal3 = options.signal) === null || _options$signal3 === undefined\n          ? undefined\n          : _options$signal3.removeEventListener('abort', abort)\n      }\n    }\n    pump()\n    try {\n      while (true) {\n        while (queue.length > 0) {\n          const val = await queue[0]\n          if (val === kEof) {\n            return\n          }\n          if (signal.aborted) {\n            throw new AbortError()\n          }\n          if (val !== kEmpty) {\n            yield val\n          }\n          queue.shift()\n          if (resume) {\n            resume()\n            resume = null\n          }\n        }\n        await new Promise((resolve) => {\n          next = resolve\n        })\n      }\n    } finally {\n      ac.abort()\n      done = true\n      if (resume) {\n        resume()\n        resume = null\n      }\n    }\n  }.call(this)\n}\nfunction asIndexedPairs(options = undefined) {\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  return async function* asIndexedPairs() {\n    let index = 0\n    for await (const val of this) {\n      var _options$signal4\n      if (\n        options !== null &&\n        options !== undefined &&\n        (_options$signal4 = options.signal) !== null &&\n        _options$signal4 !== undefined &&\n        _options$signal4.aborted\n      ) {\n        throw new AbortError({\n          cause: options.signal.reason\n        })\n      }\n      yield [index++, val]\n    }\n  }.call(this)\n}\nasync function some(fn, options = undefined) {\n  for await (const unused of filter.call(this, fn, options)) {\n    return true\n  }\n  return false\n}\nasync function every(fn, options = undefined) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)\n  }\n  // https://en.wikipedia.org/wiki/De_Morgan%27s_laws\n  return !(await some.call(\n    this,\n    async (...args) => {\n      return !(await fn(...args))\n    },\n    options\n  ))\n}\nasync function find(fn, options) {\n  for await (const result of filter.call(this, fn, options)) {\n    return result\n  }\n  return undefined\n}\nasync function forEach(fn, options) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)\n  }\n  async function forEachFn(value, options) {\n    await fn(value, options)\n    return kEmpty\n  }\n  // eslint-disable-next-line no-unused-vars\n  for await (const unused of map.call(this, forEachFn, options));\n}\nfunction filter(fn, options) {\n  if (typeof fn !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'AsyncFunction'], fn)\n  }\n  async function filterFn(value, options) {\n    if (await fn(value, options)) {\n      return value\n    }\n    return kEmpty\n  }\n  return map.call(this, filterFn, options)\n}\n\n// Specific to provide better error to reduce since the argument is only\n// missing if the stream has no items in it - but the code is still appropriate\nclass ReduceAwareErrMissingArgs extends ERR_MISSING_ARGS {\n  constructor() {\n    super('reduce')\n    this.message = 'Reduce of an empty stream requires an initial value'\n  }\n}\nasync function reduce(reducer, initialValue, options) {\n  var _options$signal5\n  if (typeof reducer !== 'function') {\n    throw new ERR_INVALID_ARG_TYPE('reducer', ['Function', 'AsyncFunction'], reducer)\n  }\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  let hasInitialValue = arguments.length > 1\n  if (\n    options !== null &&\n    options !== undefined &&\n    (_options$signal5 = options.signal) !== null &&\n    _options$signal5 !== undefined &&\n    _options$signal5.aborted\n  ) {\n    const err = new AbortError(undefined, {\n      cause: options.signal.reason\n    })\n    this.once('error', () => {}) // The error is already propagated\n    await finished(this.destroy(err))\n    throw err\n  }\n  const ac = new AbortController()\n  const signal = ac.signal\n  if (options !== null && options !== undefined && options.signal) {\n    const opts = {\n      once: true,\n      [kWeakHandler]: this\n    }\n    options.signal.addEventListener('abort', () => ac.abort(), opts)\n  }\n  let gotAnyItemFromStream = false\n  try {\n    for await (const value of this) {\n      var _options$signal6\n      gotAnyItemFromStream = true\n      if (\n        options !== null &&\n        options !== undefined &&\n        (_options$signal6 = options.signal) !== null &&\n        _options$signal6 !== undefined &&\n        _options$signal6.aborted\n      ) {\n        throw new AbortError()\n      }\n      if (!hasInitialValue) {\n        initialValue = value\n        hasInitialValue = true\n      } else {\n        initialValue = await reducer(initialValue, value, {\n          signal\n        })\n      }\n    }\n    if (!gotAnyItemFromStream && !hasInitialValue) {\n      throw new ReduceAwareErrMissingArgs()\n    }\n  } finally {\n    ac.abort()\n  }\n  return initialValue\n}\nasync function toArray(options) {\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  const result = []\n  for await (const val of this) {\n    var _options$signal7\n    if (\n      options !== null &&\n      options !== undefined &&\n      (_options$signal7 = options.signal) !== null &&\n      _options$signal7 !== undefined &&\n      _options$signal7.aborted\n    ) {\n      throw new AbortError(undefined, {\n        cause: options.signal.reason\n      })\n    }\n    ArrayPrototypePush(result, val)\n  }\n  return result\n}\nfunction flatMap(fn, options) {\n  const values = map.call(this, fn, options)\n  return async function* flatMap() {\n    for await (const val of values) {\n      yield* val\n    }\n  }.call(this)\n}\nfunction toIntegerOrInfinity(number) {\n  // We coerce here to align with the spec\n  // https://github.com/tc39/proposal-iterator-helpers/issues/169\n  number = Number(number)\n  if (NumberIsNaN(number)) {\n    return 0\n  }\n  if (number < 0) {\n    throw new ERR_OUT_OF_RANGE('number', '>= 0', number)\n  }\n  return number\n}\nfunction drop(number, options = undefined) {\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  number = toIntegerOrInfinity(number)\n  return async function* drop() {\n    var _options$signal8\n    if (\n      options !== null &&\n      options !== undefined &&\n      (_options$signal8 = options.signal) !== null &&\n      _options$signal8 !== undefined &&\n      _options$signal8.aborted\n    ) {\n      throw new AbortError()\n    }\n    for await (const val of this) {\n      var _options$signal9\n      if (\n        options !== null &&\n        options !== undefined &&\n        (_options$signal9 = options.signal) !== null &&\n        _options$signal9 !== undefined &&\n        _options$signal9.aborted\n      ) {\n        throw new AbortError()\n      }\n      if (number-- <= 0) {\n        yield val\n      }\n    }\n  }.call(this)\n}\nfunction take(number, options = undefined) {\n  if (options != null) {\n    validateObject(options, 'options')\n  }\n  if ((options === null || options === undefined ? undefined : options.signal) != null) {\n    validateAbortSignal(options.signal, 'options.signal')\n  }\n  number = toIntegerOrInfinity(number)\n  return async function* take() {\n    var _options$signal10\n    if (\n      options !== null &&\n      options !== undefined &&\n      (_options$signal10 = options.signal) !== null &&\n      _options$signal10 !== undefined &&\n      _options$signal10.aborted\n    ) {\n      throw new AbortError()\n    }\n    for await (const val of this) {\n      var _options$signal11\n      if (\n        options !== null &&\n        options !== undefined &&\n        (_options$signal11 = options.signal) !== null &&\n        _options$signal11 !== undefined &&\n        _options$signal11.aborted\n      ) {\n        throw new AbortError()\n      }\n      if (number-- > 0) {\n        yield val\n      } else {\n        return\n      }\n    }\n  }.call(this)\n}\nmodule.exports.streamReturningOperators = {\n  asIndexedPairs,\n  drop,\n  filter,\n  flatMap,\n  map,\n  take\n}\nmodule.exports.promiseReturningOperators = {\n  every,\n  forEach,\n  reduce,\n  toArray,\n  some,\n  find\n}\n","'use strict'\n\n/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n\nconst {\n  aggregateTwoErrors,\n  codes: { ERR_MULTIPLE_CALLBACK },\n  AbortError\n} = require('../../ours/errors')\nconst { Symbol } = require('../../ours/primordials')\nconst { kDestroyed, isDestroyed, isFinished, isServerRequest } = require('./utils')\nconst kDestroy = Symbol('kDestroy')\nconst kConstruct = Symbol('kConstruct')\nfunction checkError(err, w, r) {\n  if (err) {\n    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364\n    err.stack // eslint-disable-line no-unused-expressions\n\n    if (w && !w.errored) {\n      w.errored = err\n    }\n    if (r && !r.errored) {\n      r.errored = err\n    }\n  }\n}\n\n// Backwards compat. cb() is undocumented and unused in core but\n// unfortunately might be used by modules.\nfunction destroy(err, cb) {\n  const r = this._readableState\n  const w = this._writableState\n  // With duplex streams we use the writable side for state.\n  const s = w || r\n  if ((w && w.destroyed) || (r && r.destroyed)) {\n    if (typeof cb === 'function') {\n      cb()\n    }\n    return this\n  }\n\n  // We set destroyed to true before firing error callbacks in order\n  // to make it re-entrance safe in case destroy() is called within callbacks\n  checkError(err, w, r)\n  if (w) {\n    w.destroyed = true\n  }\n  if (r) {\n    r.destroyed = true\n  }\n\n  // If still constructing then defer calling _destroy.\n  if (!s.constructed) {\n    this.once(kDestroy, function (er) {\n      _destroy(this, aggregateTwoErrors(er, err), cb)\n    })\n  } else {\n    _destroy(this, err, cb)\n  }\n  return this\n}\nfunction _destroy(self, err, cb) {\n  let called = false\n  function onDestroy(err) {\n    if (called) {\n      return\n    }\n    called = true\n    const r = self._readableState\n    const w = self._writableState\n    checkError(err, w, r)\n    if (w) {\n      w.closed = true\n    }\n    if (r) {\n      r.closed = true\n    }\n    if (typeof cb === 'function') {\n      cb(err)\n    }\n    if (err) {\n      process.nextTick(emitErrorCloseNT, self, err)\n    } else {\n      process.nextTick(emitCloseNT, self)\n    }\n  }\n  try {\n    self._destroy(err || null, onDestroy)\n  } catch (err) {\n    onDestroy(err)\n  }\n}\nfunction emitErrorCloseNT(self, err) {\n  emitErrorNT(self, err)\n  emitCloseNT(self)\n}\nfunction emitCloseNT(self) {\n  const r = self._readableState\n  const w = self._writableState\n  if (w) {\n    w.closeEmitted = true\n  }\n  if (r) {\n    r.closeEmitted = true\n  }\n  if ((w && w.emitClose) || (r && r.emitClose)) {\n    self.emit('close')\n  }\n}\nfunction emitErrorNT(self, err) {\n  const r = self._readableState\n  const w = self._writableState\n  if ((w && w.errorEmitted) || (r && r.errorEmitted)) {\n    return\n  }\n  if (w) {\n    w.errorEmitted = true\n  }\n  if (r) {\n    r.errorEmitted = true\n  }\n  self.emit('error', err)\n}\nfunction undestroy() {\n  const r = this._readableState\n  const w = this._writableState\n  if (r) {\n    r.constructed = true\n    r.closed = false\n    r.closeEmitted = false\n    r.destroyed = false\n    r.errored = null\n    r.errorEmitted = false\n    r.reading = false\n    r.ended = r.readable === false\n    r.endEmitted = r.readable === false\n  }\n  if (w) {\n    w.constructed = true\n    w.destroyed = false\n    w.closed = false\n    w.closeEmitted = false\n    w.errored = null\n    w.errorEmitted = false\n    w.finalCalled = false\n    w.prefinished = false\n    w.ended = w.writable === false\n    w.ending = w.writable === false\n    w.finished = w.writable === false\n  }\n}\nfunction errorOrDestroy(stream, err, sync) {\n  // We have tests that rely on errors being emitted\n  // in the same tick, so changing this is semver major.\n  // For now when you opt-in to autoDestroy we allow\n  // the error to be emitted nextTick. In a future\n  // semver major update we should change the default to this.\n\n  const r = stream._readableState\n  const w = stream._writableState\n  if ((w && w.destroyed) || (r && r.destroyed)) {\n    return this\n  }\n  if ((r && r.autoDestroy) || (w && w.autoDestroy)) stream.destroy(err)\n  else if (err) {\n    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364\n    err.stack // eslint-disable-line no-unused-expressions\n\n    if (w && !w.errored) {\n      w.errored = err\n    }\n    if (r && !r.errored) {\n      r.errored = err\n    }\n    if (sync) {\n      process.nextTick(emitErrorNT, stream, err)\n    } else {\n      emitErrorNT(stream, err)\n    }\n  }\n}\nfunction construct(stream, cb) {\n  if (typeof stream._construct !== 'function') {\n    return\n  }\n  const r = stream._readableState\n  const w = stream._writableState\n  if (r) {\n    r.constructed = false\n  }\n  if (w) {\n    w.constructed = false\n  }\n  stream.once(kConstruct, cb)\n  if (stream.listenerCount(kConstruct) > 1) {\n    // Duplex\n    return\n  }\n  process.nextTick(constructNT, stream)\n}\nfunction constructNT(stream) {\n  let called = false\n  function onConstruct(err) {\n    if (called) {\n      errorOrDestroy(stream, err !== null && err !== undefined ? err : new ERR_MULTIPLE_CALLBACK())\n      return\n    }\n    called = true\n    const r = stream._readableState\n    const w = stream._writableState\n    const s = w || r\n    if (r) {\n      r.constructed = true\n    }\n    if (w) {\n      w.constructed = true\n    }\n    if (s.destroyed) {\n      stream.emit(kDestroy, err)\n    } else if (err) {\n      errorOrDestroy(stream, err, true)\n    } else {\n      process.nextTick(emitConstructNT, stream)\n    }\n  }\n  try {\n    stream._construct(onConstruct)\n  } catch (err) {\n    onConstruct(err)\n  }\n}\nfunction emitConstructNT(stream) {\n  stream.emit(kConstruct)\n}\nfunction isRequest(stream) {\n  return stream && stream.setHeader && typeof stream.abort === 'function'\n}\nfunction emitCloseLegacy(stream) {\n  stream.emit('close')\n}\nfunction emitErrorCloseLegacy(stream, err) {\n  stream.emit('error', err)\n  process.nextTick(emitCloseLegacy, stream)\n}\n\n// Normalize destroy for legacy.\nfunction destroyer(stream, err) {\n  if (!stream || isDestroyed(stream)) {\n    return\n  }\n  if (!err && !isFinished(stream)) {\n    err = new AbortError()\n  }\n\n  // TODO: Remove isRequest branches.\n  if (isServerRequest(stream)) {\n    stream.socket = null\n    stream.destroy(err)\n  } else if (isRequest(stream)) {\n    stream.abort()\n  } else if (isRequest(stream.req)) {\n    stream.req.abort()\n  } else if (typeof stream.destroy === 'function') {\n    stream.destroy(err)\n  } else if (typeof stream.close === 'function') {\n    // TODO: Don't lose err?\n    stream.close()\n  } else if (err) {\n    process.nextTick(emitErrorCloseLegacy, stream, err)\n  } else {\n    process.nextTick(emitCloseLegacy, stream)\n  }\n  if (!stream.destroyed) {\n    stream[kDestroyed] = true\n  }\n}\nmodule.exports = {\n  construct,\n  destroyer,\n  destroy,\n  undestroy,\n  errorOrDestroy\n}\n","'use strict'\n\nconst { ArrayIsArray, ObjectSetPrototypeOf } = require('../../ours/primordials')\nconst { EventEmitter: EE } = require('events')\nfunction Stream(opts) {\n  EE.call(this, opts)\n}\nObjectSetPrototypeOf(Stream.prototype, EE.prototype)\nObjectSetPrototypeOf(Stream, EE)\nStream.prototype.pipe = function (dest, options) {\n  const source = this\n  function ondata(chunk) {\n    if (dest.writable && dest.write(chunk) === false && source.pause) {\n      source.pause()\n    }\n  }\n  source.on('data', ondata)\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume()\n    }\n  }\n  dest.on('drain', ondrain)\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend)\n    source.on('close', onclose)\n  }\n  let didOnEnd = false\n  function onend() {\n    if (didOnEnd) return\n    didOnEnd = true\n    dest.end()\n  }\n  function onclose() {\n    if (didOnEnd) return\n    didOnEnd = true\n    if (typeof dest.destroy === 'function') dest.destroy()\n  }\n\n  // Don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup()\n    if (EE.listenerCount(this, 'error') === 0) {\n      this.emit('error', er)\n    }\n  }\n  prependListener(source, 'error', onerror)\n  prependListener(dest, 'error', onerror)\n\n  // Remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata)\n    dest.removeListener('drain', ondrain)\n    source.removeListener('end', onend)\n    source.removeListener('close', onclose)\n    source.removeListener('error', onerror)\n    dest.removeListener('error', onerror)\n    source.removeListener('end', cleanup)\n    source.removeListener('close', cleanup)\n    dest.removeListener('close', cleanup)\n  }\n  source.on('end', cleanup)\n  source.on('close', cleanup)\n  dest.on('close', cleanup)\n  dest.emit('pipe', source)\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest\n}\nfunction prependListener(emitter, event, fn) {\n  // Sadly this is not cacheable as some libraries bundle their own\n  // event emitter implementation with them.\n  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn)\n\n  // This is a hack to make sure that our error handler is attached before any\n  // userland ones.  NEVER DO THIS. This is here only because this code needs\n  // to continue to work with older versions of Node.js that do not include\n  // the prependListener() method. The goal is to eventually remove this hack.\n  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn)\n  else if (ArrayIsArray(emitter._events[event])) emitter._events[event].unshift(fn)\n  else emitter._events[event] = [fn, emitter._events[event]]\n}\nmodule.exports = {\n  Stream,\n  prependListener\n}\n","'use strict'\n\nconst { AbortError, codes } = require('../../ours/errors')\nconst eos = require('./end-of-stream')\nconst { ERR_INVALID_ARG_TYPE } = codes\n\n// This method is inlined here for readable-stream\n// It also does not allow for signal to not exist on the stream\n// https://github.com/nodejs/node/pull/36061#discussion_r533718029\nconst validateAbortSignal = (signal, name) => {\n  if (typeof signal !== 'object' || !('aborted' in signal)) {\n    throw new ERR_INVALID_ARG_TYPE(name, 'AbortSignal', signal)\n  }\n}\nfunction isNodeStream(obj) {\n  return !!(obj && typeof obj.pipe === 'function')\n}\nmodule.exports.addAbortSignal = function addAbortSignal(signal, stream) {\n  validateAbortSignal(signal, 'signal')\n  if (!isNodeStream(stream)) {\n    throw new ERR_INVALID_ARG_TYPE('stream', 'stream.Stream', stream)\n  }\n  return module.exports.addAbortSignalNoValidate(signal, stream)\n}\nmodule.exports.addAbortSignalNoValidate = function (signal, stream) {\n  if (typeof signal !== 'object' || !('aborted' in signal)) {\n    return stream\n  }\n  const onAbort = () => {\n    stream.destroy(\n      new AbortError(undefined, {\n        cause: signal.reason\n      })\n    )\n  }\n  if (signal.aborted) {\n    onAbort()\n  } else {\n    signal.addEventListener('abort', onAbort)\n    eos(stream, () => signal.removeEventListener('abort', onAbort))\n  }\n  return stream\n}\n","'use strict'\n\nconst { StringPrototypeSlice, SymbolIterator, TypedArrayPrototypeSet, Uint8Array } = require('../../ours/primordials')\nconst { Buffer } = require('buffer')\nconst { inspect } = require('../../ours/util')\nmodule.exports = class BufferList {\n  constructor() {\n    this.head = null\n    this.tail = null\n    this.length = 0\n  }\n  push(v) {\n    const entry = {\n      data: v,\n      next: null\n    }\n    if (this.length > 0) this.tail.next = entry\n    else this.head = entry\n    this.tail = entry\n    ++this.length\n  }\n  unshift(v) {\n    const entry = {\n      data: v,\n      next: this.head\n    }\n    if (this.length === 0) this.tail = entry\n    this.head = entry\n    ++this.length\n  }\n  shift() {\n    if (this.length === 0) return\n    const ret = this.head.data\n    if (this.length === 1) this.head = this.tail = null\n    else this.head = this.head.next\n    --this.length\n    return ret\n  }\n  clear() {\n    this.head = this.tail = null\n    this.length = 0\n  }\n  join(s) {\n    if (this.length === 0) return ''\n    let p = this.head\n    let ret = '' + p.data\n    while ((p = p.next) !== null) ret += s + p.data\n    return ret\n  }\n  concat(n) {\n    if (this.length === 0) return Buffer.alloc(0)\n    const ret = Buffer.allocUnsafe(n >>> 0)\n    let p = this.head\n    let i = 0\n    while (p) {\n      TypedArrayPrototypeSet(ret, p.data, i)\n      i += p.data.length\n      p = p.next\n    }\n    return ret\n  }\n\n  // Consumes a specified amount of bytes or characters from the buffered data.\n  consume(n, hasStrings) {\n    const data = this.head.data\n    if (n < data.length) {\n      // `slice` is the same for buffers and strings.\n      const slice = data.slice(0, n)\n      this.head.data = data.slice(n)\n      return slice\n    }\n    if (n === data.length) {\n      // First chunk is a perfect match.\n      return this.shift()\n    }\n    // Result spans more than one buffer.\n    return hasStrings ? this._getString(n) : this._getBuffer(n)\n  }\n  first() {\n    return this.head.data\n  }\n  *[SymbolIterator]() {\n    for (let p = this.head; p; p = p.next) {\n      yield p.data\n    }\n  }\n\n  // Consumes a specified amount of characters from the buffered data.\n  _getString(n) {\n    let ret = ''\n    let p = this.head\n    let c = 0\n    do {\n      const str = p.data\n      if (n > str.length) {\n        ret += str\n        n -= str.length\n      } else {\n        if (n === str.length) {\n          ret += str\n          ++c\n          if (p.next) this.head = p.next\n          else this.head = this.tail = null\n        } else {\n          ret += StringPrototypeSlice(str, 0, n)\n          this.head = p\n          p.data = StringPrototypeSlice(str, n)\n        }\n        break\n      }\n      ++c\n    } while ((p = p.next) !== null)\n    this.length -= c\n    return ret\n  }\n\n  // Consumes a specified amount of bytes from the buffered data.\n  _getBuffer(n) {\n    const ret = Buffer.allocUnsafe(n)\n    const retLen = n\n    let p = this.head\n    let c = 0\n    do {\n      const buf = p.data\n      if (n > buf.length) {\n        TypedArrayPrototypeSet(ret, buf, retLen - n)\n        n -= buf.length\n      } else {\n        if (n === buf.length) {\n          TypedArrayPrototypeSet(ret, buf, retLen - n)\n          ++c\n          if (p.next) this.head = p.next\n          else this.head = this.tail = null\n        } else {\n          TypedArrayPrototypeSet(ret, new Uint8Array(buf.buffer, buf.byteOffset, n), retLen - n)\n          this.head = p\n          p.data = buf.slice(n)\n        }\n        break\n      }\n      ++c\n    } while ((p = p.next) !== null)\n    this.length -= c\n    return ret\n  }\n\n  // Make sure the linked list only shows the minimal necessary information.\n  [Symbol.for('nodejs.util.inspect.custom')](_, options) {\n    return inspect(this, {\n      ...options,\n      // Only inspect one level.\n      depth: 0,\n      // It should not recurse.\n      customInspect: false\n    })\n  }\n}\n","'use strict'\n\nconst { MathFloor, NumberIsInteger } = require('../../ours/primordials')\nconst { ERR_INVALID_ARG_VALUE } = require('../../ours/errors').codes\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null\n}\nfunction getDefaultHighWaterMark(objectMode) {\n  return objectMode ? 16 : 16 * 1024\n}\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey)\n  if (hwm != null) {\n    if (!NumberIsInteger(hwm) || hwm < 0) {\n      const name = isDuplex ? `options.${duplexKey}` : 'options.highWaterMark'\n      throw new ERR_INVALID_ARG_VALUE(name, hwm)\n    }\n    return MathFloor(hwm)\n  }\n\n  // Default value\n  return getDefaultHighWaterMark(state.objectMode)\n}\nmodule.exports = {\n  getHighWaterMark,\n  getDefaultHighWaterMark\n}\n","'use strict'\n\n/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n\nconst { PromisePrototypeThen, SymbolAsyncIterator, SymbolIterator } = require('../../ours/primordials')\nconst { Buffer } = require('buffer')\nconst { ERR_INVALID_ARG_TYPE, ERR_STREAM_NULL_VALUES } = require('../../ours/errors').codes\nfunction from(Readable, iterable, opts) {\n  let iterator\n  if (typeof iterable === 'string' || iterable instanceof Buffer) {\n    return new Readable({\n      objectMode: true,\n      ...opts,\n      read() {\n        this.push(iterable)\n        this.push(null)\n      }\n    })\n  }\n  let isAsync\n  if (iterable && iterable[SymbolAsyncIterator]) {\n    isAsync = true\n    iterator = iterable[SymbolAsyncIterator]()\n  } else if (iterable && iterable[SymbolIterator]) {\n    isAsync = false\n    iterator = iterable[SymbolIterator]()\n  } else {\n    throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable)\n  }\n  const readable = new Readable({\n    objectMode: true,\n    highWaterMark: 1,\n    // TODO(ronag): What options should be allowed?\n    ...opts\n  })\n\n  // Flag to protect against _read\n  // being called before last iteration completion.\n  let reading = false\n  readable._read = function () {\n    if (!reading) {\n      reading = true\n      next()\n    }\n  }\n  readable._destroy = function (error, cb) {\n    PromisePrototypeThen(\n      close(error),\n      () => process.nextTick(cb, error),\n      // nextTick is here in case cb throws\n      (e) => process.nextTick(cb, e || error)\n    )\n  }\n  async function close(error) {\n    const hadError = error !== undefined && error !== null\n    const hasThrow = typeof iterator.throw === 'function'\n    if (hadError && hasThrow) {\n      const { value, done } = await iterator.throw(error)\n      await value\n      if (done) {\n        return\n      }\n    }\n    if (typeof iterator.return === 'function') {\n      const { value } = await iterator.return()\n      await value\n    }\n  }\n  async function next() {\n    for (;;) {\n      try {\n        const { value, done } = isAsync ? await iterator.next() : iterator.next()\n        if (done) {\n          readable.push(null)\n        } else {\n          const res = value && typeof value.then === 'function' ? await value : value\n          if (res === null) {\n            reading = false\n            throw new ERR_STREAM_NULL_VALUES()\n          } else if (readable.push(res)) {\n            continue\n          } else {\n            reading = false\n          }\n        }\n      } catch (err) {\n        readable.destroy(err)\n      }\n      break\n    }\n  }\n  return readable\n}\nmodule.exports = from\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n;('use strict')\nconst {\n  ArrayPrototypeIndexOf,\n  NumberIsInteger,\n  NumberIsNaN,\n  NumberParseInt,\n  ObjectDefineProperties,\n  ObjectKeys,\n  ObjectSetPrototypeOf,\n  Promise,\n  SafeSet,\n  SymbolAsyncIterator,\n  Symbol\n} = require('../../ours/primordials')\nmodule.exports = Readable\nReadable.ReadableState = ReadableState\nconst { EventEmitter: EE } = require('events')\nconst { Stream, prependListener } = require('./legacy')\nconst { Buffer } = require('buffer')\nconst { addAbortSignal } = require('./add-abort-signal')\nconst eos = require('./end-of-stream')\nlet debug = require('../../ours/util').debuglog('stream', (fn) => {\n  debug = fn\n})\nconst BufferList = require('./buffer_list')\nconst destroyImpl = require('./destroy')\nconst { getHighWaterMark, getDefaultHighWaterMark } = require('./state')\nconst {\n  aggregateTwoErrors,\n  codes: {\n    ERR_INVALID_ARG_TYPE,\n    ERR_METHOD_NOT_IMPLEMENTED,\n    ERR_OUT_OF_RANGE,\n    ERR_STREAM_PUSH_AFTER_EOF,\n    ERR_STREAM_UNSHIFT_AFTER_END_EVENT\n  }\n} = require('../../ours/errors')\nconst { validateObject } = require('../validators')\nconst kPaused = Symbol('kPaused')\nconst { StringDecoder } = require('string_decoder')\nconst from = require('./from')\nObjectSetPrototypeOf(Readable.prototype, Stream.prototype)\nObjectSetPrototypeOf(Readable, Stream)\nconst nop = () => {}\nconst { errorOrDestroy } = destroyImpl\nfunction ReadableState(options, stream, isDuplex) {\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof require('./duplex')\n\n  // Object stream flag. Used to make read(n) ignore n and to\n  // make all the buffer merging and length checks go away.\n  this.objectMode = !!(options && options.objectMode)\n  if (isDuplex) this.objectMode = this.objectMode || !!(options && options.readableObjectMode)\n\n  // The point at which it stops calling _read() to fill the buffer\n  // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n  this.highWaterMark = options\n    ? getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex)\n    : getDefaultHighWaterMark(false)\n\n  // A linked list is used to store data chunks instead of an array because the\n  // linked list can remove elements from the beginning faster than\n  // array.shift().\n  this.buffer = new BufferList()\n  this.length = 0\n  this.pipes = []\n  this.flowing = null\n  this.ended = false\n  this.endEmitted = false\n  this.reading = false\n\n  // Stream is still being constructed and cannot be\n  // destroyed until construction finished or failed.\n  // Async construction is opt in, therefore we start as\n  // constructed.\n  this.constructed = true\n\n  // A flag to be able to tell if the event 'readable'/'data' is emitted\n  // immediately, or on a later tick.  We set this to true at first, because\n  // any actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first read call.\n  this.sync = true\n\n  // Whenever we return null, then we set a flag to say\n  // that we're awaiting a 'readable' event emission.\n  this.needReadable = false\n  this.emittedReadable = false\n  this.readableListening = false\n  this.resumeScheduled = false\n  this[kPaused] = null\n\n  // True if the error was already emitted and should not be thrown again.\n  this.errorEmitted = false\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = !options || options.emitClose !== false\n\n  // Should .destroy() be called after 'end' (and potentially 'finish').\n  this.autoDestroy = !options || options.autoDestroy !== false\n\n  // Has it been destroyed.\n  this.destroyed = false\n\n  // Indicates whether the stream has errored. When true no further\n  // _read calls, 'data' or 'readable' events should occur. This is needed\n  // since when autoDestroy is disabled we need a way to tell whether the\n  // stream has failed.\n  this.errored = null\n\n  // Indicates whether the stream has finished destroying.\n  this.closed = false\n\n  // True if close has been emitted or would have been emitted\n  // depending on emitClose.\n  this.closeEmitted = false\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8'\n\n  // Ref the piped dest which we need a drain event on it\n  // type: null | Writable | Set<Writable>.\n  this.awaitDrainWriters = null\n  this.multiAwaitDrain = false\n\n  // If true, a maybeReadMore has been scheduled.\n  this.readingMore = false\n  this.dataEmitted = false\n  this.decoder = null\n  this.encoding = null\n  if (options && options.encoding) {\n    this.decoder = new StringDecoder(options.encoding)\n    this.encoding = options.encoding\n  }\n}\nfunction Readable(options) {\n  if (!(this instanceof Readable)) return new Readable(options)\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the ReadableState constructor, at least with V8 6.5.\n  const isDuplex = this instanceof require('./duplex')\n  this._readableState = new ReadableState(options, this, isDuplex)\n  if (options) {\n    if (typeof options.read === 'function') this._read = options.read\n    if (typeof options.destroy === 'function') this._destroy = options.destroy\n    if (typeof options.construct === 'function') this._construct = options.construct\n    if (options.signal && !isDuplex) addAbortSignal(options.signal, this)\n  }\n  Stream.call(this, options)\n  destroyImpl.construct(this, () => {\n    if (this._readableState.needReadable) {\n      maybeReadMore(this, this._readableState)\n    }\n  })\n}\nReadable.prototype.destroy = destroyImpl.destroy\nReadable.prototype._undestroy = destroyImpl.undestroy\nReadable.prototype._destroy = function (err, cb) {\n  cb(err)\n}\nReadable.prototype[EE.captureRejectionSymbol] = function (err) {\n  this.destroy(err)\n}\n\n// Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\nReadable.prototype.push = function (chunk, encoding) {\n  return readableAddChunk(this, chunk, encoding, false)\n}\n\n// Unshift should *always* be something directly out of read().\nReadable.prototype.unshift = function (chunk, encoding) {\n  return readableAddChunk(this, chunk, encoding, true)\n}\nfunction readableAddChunk(stream, chunk, encoding, addToFront) {\n  debug('readableAddChunk', chunk)\n  const state = stream._readableState\n  let err\n  if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      encoding = encoding || state.defaultEncoding\n      if (state.encoding !== encoding) {\n        if (addToFront && state.encoding) {\n          // When unshifting, if state.encoding is set, we have to save\n          // the string in the BufferList with the state encoding.\n          chunk = Buffer.from(chunk, encoding).toString(state.encoding)\n        } else {\n          chunk = Buffer.from(chunk, encoding)\n          encoding = ''\n        }\n      }\n    } else if (chunk instanceof Buffer) {\n      encoding = ''\n    } else if (Stream._isUint8Array(chunk)) {\n      chunk = Stream._uint8ArrayToBuffer(chunk)\n      encoding = ''\n    } else if (chunk != null) {\n      err = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk)\n    }\n  }\n  if (err) {\n    errorOrDestroy(stream, err)\n  } else if (chunk === null) {\n    state.reading = false\n    onEofChunk(stream, state)\n  } else if (state.objectMode || (chunk && chunk.length > 0)) {\n    if (addToFront) {\n      if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT())\n      else if (state.destroyed || state.errored) return false\n      else addChunk(stream, state, chunk, true)\n    } else if (state.ended) {\n      errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF())\n    } else if (state.destroyed || state.errored) {\n      return false\n    } else {\n      state.reading = false\n      if (state.decoder && !encoding) {\n        chunk = state.decoder.write(chunk)\n        if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false)\n        else maybeReadMore(stream, state)\n      } else {\n        addChunk(stream, state, chunk, false)\n      }\n    }\n  } else if (!addToFront) {\n    state.reading = false\n    maybeReadMore(stream, state)\n  }\n\n  // We can push more data if we are below the highWaterMark.\n  // Also, if we have no data yet, we can stand some more bytes.\n  // This is to work around cases where hwm=0, such as the repl.\n  return !state.ended && (state.length < state.highWaterMark || state.length === 0)\n}\nfunction addChunk(stream, state, chunk, addToFront) {\n  if (state.flowing && state.length === 0 && !state.sync && stream.listenerCount('data') > 0) {\n    // Use the guard to avoid creating `Set()` repeatedly\n    // when we have multiple pipes.\n    if (state.multiAwaitDrain) {\n      state.awaitDrainWriters.clear()\n    } else {\n      state.awaitDrainWriters = null\n    }\n    state.dataEmitted = true\n    stream.emit('data', chunk)\n  } else {\n    // Update the buffer info.\n    state.length += state.objectMode ? 1 : chunk.length\n    if (addToFront) state.buffer.unshift(chunk)\n    else state.buffer.push(chunk)\n    if (state.needReadable) emitReadable(stream)\n  }\n  maybeReadMore(stream, state)\n}\nReadable.prototype.isPaused = function () {\n  const state = this._readableState\n  return state[kPaused] === true || state.flowing === false\n}\n\n// Backwards compatibility.\nReadable.prototype.setEncoding = function (enc) {\n  const decoder = new StringDecoder(enc)\n  this._readableState.decoder = decoder\n  // If setEncoding(null), decoder.encoding equals utf8.\n  this._readableState.encoding = this._readableState.decoder.encoding\n  const buffer = this._readableState.buffer\n  // Iterate over current buffer to convert already stored Buffers:\n  let content = ''\n  for (const data of buffer) {\n    content += decoder.write(data)\n  }\n  buffer.clear()\n  if (content !== '') buffer.push(content)\n  this._readableState.length = content.length\n  return this\n}\n\n// Don't raise the hwm > 1GB.\nconst MAX_HWM = 0x40000000\nfunction computeNewHighWaterMark(n) {\n  if (n > MAX_HWM) {\n    throw new ERR_OUT_OF_RANGE('size', '<= 1GiB', n)\n  } else {\n    // Get the next highest power of 2 to prevent increasing hwm excessively in\n    // tiny amounts.\n    n--\n    n |= n >>> 1\n    n |= n >>> 2\n    n |= n >>> 4\n    n |= n >>> 8\n    n |= n >>> 16\n    n++\n  }\n  return n\n}\n\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction howMuchToRead(n, state) {\n  if (n <= 0 || (state.length === 0 && state.ended)) return 0\n  if (state.objectMode) return 1\n  if (NumberIsNaN(n)) {\n    // Only flow one buffer at a time.\n    if (state.flowing && state.length) return state.buffer.first().length\n    return state.length\n  }\n  if (n <= state.length) return n\n  return state.ended ? state.length : 0\n}\n\n// You can override either this method, or the async _read(n) below.\nReadable.prototype.read = function (n) {\n  debug('read', n)\n  // Same as parseInt(undefined, 10), however V8 7.3 performance regressed\n  // in this scenario, so we are doing it manually.\n  if (n === undefined) {\n    n = NaN\n  } else if (!NumberIsInteger(n)) {\n    n = NumberParseInt(n, 10)\n  }\n  const state = this._readableState\n  const nOrig = n\n\n  // If we're asking for more than the current hwm, then raise the hwm.\n  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n)\n  if (n !== 0) state.emittedReadable = false\n\n  // If we're doing read(0) to trigger a readable event, but we\n  // already have a bunch of data in the buffer, then just trigger\n  // the 'readable' event and move on.\n  if (\n    n === 0 &&\n    state.needReadable &&\n    ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)\n  ) {\n    debug('read: emitReadable', state.length, state.ended)\n    if (state.length === 0 && state.ended) endReadable(this)\n    else emitReadable(this)\n    return null\n  }\n  n = howMuchToRead(n, state)\n\n  // If we've ended, and we're now clear, then finish it up.\n  if (n === 0 && state.ended) {\n    if (state.length === 0) endReadable(this)\n    return null\n  }\n\n  // All the actual chunk generation logic needs to be\n  // *below* the call to _read.  The reason is that in certain\n  // synthetic stream cases, such as passthrough streams, _read\n  // may be a completely synchronous operation which may change\n  // the state of the read buffer, providing enough data when\n  // before there was *not* enough.\n  //\n  // So, the steps are:\n  // 1. Figure out what the state of things will be after we do\n  // a read from the buffer.\n  //\n  // 2. If that resulting state will trigger a _read, then call _read.\n  // Note that this may be asynchronous, or synchronous.  Yes, it is\n  // deeply ugly to write APIs this way, but that still doesn't mean\n  // that the Readable class should behave improperly, as streams are\n  // designed to be sync/async agnostic.\n  // Take note if the _read call is sync or async (ie, if the read call\n  // has returned yet), so that we know whether or not it's safe to emit\n  // 'readable' etc.\n  //\n  // 3. Actually pull the requested chunks out of the buffer and return.\n\n  // if we need a readable event, then we need to do some reading.\n  let doRead = state.needReadable\n  debug('need readable', doRead)\n\n  // If we currently have less than the highWaterMark, then also read some.\n  if (state.length === 0 || state.length - n < state.highWaterMark) {\n    doRead = true\n    debug('length less than watermark', doRead)\n  }\n\n  // However, if we've ended, then there's no point, if we're already\n  // reading, then it's unnecessary, if we're constructing we have to wait,\n  // and if we're destroyed or errored, then it's not allowed,\n  if (state.ended || state.reading || state.destroyed || state.errored || !state.constructed) {\n    doRead = false\n    debug('reading, ended or constructing', doRead)\n  } else if (doRead) {\n    debug('do read')\n    state.reading = true\n    state.sync = true\n    // If the length is currently zero, then we *need* a readable event.\n    if (state.length === 0) state.needReadable = true\n\n    // Call internal read method\n    try {\n      this._read(state.highWaterMark)\n    } catch (err) {\n      errorOrDestroy(this, err)\n    }\n    state.sync = false\n    // If _read pushed data synchronously, then `reading` will be false,\n    // and we need to re-evaluate how much data we can return to the user.\n    if (!state.reading) n = howMuchToRead(nOrig, state)\n  }\n  let ret\n  if (n > 0) ret = fromList(n, state)\n  else ret = null\n  if (ret === null) {\n    state.needReadable = state.length <= state.highWaterMark\n    n = 0\n  } else {\n    state.length -= n\n    if (state.multiAwaitDrain) {\n      state.awaitDrainWriters.clear()\n    } else {\n      state.awaitDrainWriters = null\n    }\n  }\n  if (state.length === 0) {\n    // If we have nothing in the buffer, then we want to know\n    // as soon as we *do* get something into the buffer.\n    if (!state.ended) state.needReadable = true\n\n    // If we tried to read() past the EOF, then emit end on the next tick.\n    if (nOrig !== n && state.ended) endReadable(this)\n  }\n  if (ret !== null && !state.errorEmitted && !state.closeEmitted) {\n    state.dataEmitted = true\n    this.emit('data', ret)\n  }\n  return ret\n}\nfunction onEofChunk(stream, state) {\n  debug('onEofChunk')\n  if (state.ended) return\n  if (state.decoder) {\n    const chunk = state.decoder.end()\n    if (chunk && chunk.length) {\n      state.buffer.push(chunk)\n      state.length += state.objectMode ? 1 : chunk.length\n    }\n  }\n  state.ended = true\n  if (state.sync) {\n    // If we are sync, wait until next tick to emit the data.\n    // Otherwise we risk emitting data in the flow()\n    // the readable code triggers during a read() call.\n    emitReadable(stream)\n  } else {\n    // Emit 'readable' now to make sure it gets picked up.\n    state.needReadable = false\n    state.emittedReadable = true\n    // We have to emit readable now that we are EOF. Modules\n    // in the ecosystem (e.g. dicer) rely on this event being sync.\n    emitReadable_(stream)\n  }\n}\n\n// Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow.  This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\nfunction emitReadable(stream) {\n  const state = stream._readableState\n  debug('emitReadable', state.needReadable, state.emittedReadable)\n  state.needReadable = false\n  if (!state.emittedReadable) {\n    debug('emitReadable', state.flowing)\n    state.emittedReadable = true\n    process.nextTick(emitReadable_, stream)\n  }\n}\nfunction emitReadable_(stream) {\n  const state = stream._readableState\n  debug('emitReadable_', state.destroyed, state.length, state.ended)\n  if (!state.destroyed && !state.errored && (state.length || state.ended)) {\n    stream.emit('readable')\n    state.emittedReadable = false\n  }\n\n  // The stream needs another readable event if:\n  // 1. It is not flowing, as the flow mechanism will take\n  //    care of it.\n  // 2. It is not ended.\n  // 3. It is below the highWaterMark, so we can schedule\n  //    another readable later.\n  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark\n  flow(stream)\n}\n\n// At this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data.  that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\nfunction maybeReadMore(stream, state) {\n  if (!state.readingMore && state.constructed) {\n    state.readingMore = true\n    process.nextTick(maybeReadMore_, stream, state)\n  }\n}\nfunction maybeReadMore_(stream, state) {\n  // Attempt to read more data if we should.\n  //\n  // The conditions for reading more data are (one of):\n  // - Not enough data buffered (state.length < state.highWaterMark). The loop\n  //   is responsible for filling the buffer with enough data if such data\n  //   is available. If highWaterMark is 0 and we are not in the flowing mode\n  //   we should _not_ attempt to buffer any extra data. We'll get more data\n  //   when the stream consumer calls read() instead.\n  // - No data in the buffer, and the stream is in flowing mode. In this mode\n  //   the loop below is responsible for ensuring read() is called. Failing to\n  //   call read here would abort the flow and there's no other mechanism for\n  //   continuing the flow if the stream consumer has just subscribed to the\n  //   'data' event.\n  //\n  // In addition to the above conditions to keep reading data, the following\n  // conditions prevent the data from being read:\n  // - The stream has ended (state.ended).\n  // - There is already a pending 'read' operation (state.reading). This is a\n  //   case where the stream has called the implementation defined _read()\n  //   method, but they are processing the call asynchronously and have _not_\n  //   called push() with new data. In this case we skip performing more\n  //   read()s. The execution ends in this method again after the _read() ends\n  //   up calling push() with more data.\n  while (\n    !state.reading &&\n    !state.ended &&\n    (state.length < state.highWaterMark || (state.flowing && state.length === 0))\n  ) {\n    const len = state.length\n    debug('maybeReadMore read 0')\n    stream.read(0)\n    if (len === state.length)\n      // Didn't get any data, stop spinning.\n      break\n  }\n  state.readingMore = false\n}\n\n// Abstract method.  to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\nReadable.prototype._read = function (n) {\n  throw new ERR_METHOD_NOT_IMPLEMENTED('_read()')\n}\nReadable.prototype.pipe = function (dest, pipeOpts) {\n  const src = this\n  const state = this._readableState\n  if (state.pipes.length === 1) {\n    if (!state.multiAwaitDrain) {\n      state.multiAwaitDrain = true\n      state.awaitDrainWriters = new SafeSet(state.awaitDrainWriters ? [state.awaitDrainWriters] : [])\n    }\n  }\n  state.pipes.push(dest)\n  debug('pipe count=%d opts=%j', state.pipes.length, pipeOpts)\n  const doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr\n  const endFn = doEnd ? onend : unpipe\n  if (state.endEmitted) process.nextTick(endFn)\n  else src.once('end', endFn)\n  dest.on('unpipe', onunpipe)\n  function onunpipe(readable, unpipeInfo) {\n    debug('onunpipe')\n    if (readable === src) {\n      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n        unpipeInfo.hasUnpiped = true\n        cleanup()\n      }\n    }\n  }\n  function onend() {\n    debug('onend')\n    dest.end()\n  }\n  let ondrain\n  let cleanedUp = false\n  function cleanup() {\n    debug('cleanup')\n    // Cleanup event handlers once the pipe is broken.\n    dest.removeListener('close', onclose)\n    dest.removeListener('finish', onfinish)\n    if (ondrain) {\n      dest.removeListener('drain', ondrain)\n    }\n    dest.removeListener('error', onerror)\n    dest.removeListener('unpipe', onunpipe)\n    src.removeListener('end', onend)\n    src.removeListener('end', unpipe)\n    src.removeListener('data', ondata)\n    cleanedUp = true\n\n    // If the reader is waiting for a drain event from this\n    // specific writer, then it would cause it to never start\n    // flowing again.\n    // So, if this is awaiting a drain, then we just call it now.\n    // If we don't know, then assume that we are waiting for one.\n    if (ondrain && state.awaitDrainWriters && (!dest._writableState || dest._writableState.needDrain)) ondrain()\n  }\n  function pause() {\n    // If the user unpiped during `dest.write()`, it is possible\n    // to get stuck in a permanently paused state if that write\n    // also returned false.\n    // => Check whether `dest` is still a piping destination.\n    if (!cleanedUp) {\n      if (state.pipes.length === 1 && state.pipes[0] === dest) {\n        debug('false write response, pause', 0)\n        state.awaitDrainWriters = dest\n        state.multiAwaitDrain = false\n      } else if (state.pipes.length > 1 && state.pipes.includes(dest)) {\n        debug('false write response, pause', state.awaitDrainWriters.size)\n        state.awaitDrainWriters.add(dest)\n      }\n      src.pause()\n    }\n    if (!ondrain) {\n      // When the dest drains, it reduces the awaitDrain counter\n      // on the source.  This would be more elegant with a .once()\n      // handler in flow(), but adding and removing repeatedly is\n      // too slow.\n      ondrain = pipeOnDrain(src, dest)\n      dest.on('drain', ondrain)\n    }\n  }\n  src.on('data', ondata)\n  function ondata(chunk) {\n    debug('ondata')\n    const ret = dest.write(chunk)\n    debug('dest.write', ret)\n    if (ret === false) {\n      pause()\n    }\n  }\n\n  // If the dest has an error, then stop piping into it.\n  // However, don't suppress the throwing behavior for this.\n  function onerror(er) {\n    debug('onerror', er)\n    unpipe()\n    dest.removeListener('error', onerror)\n    if (dest.listenerCount('error') === 0) {\n      const s = dest._writableState || dest._readableState\n      if (s && !s.errorEmitted) {\n        // User incorrectly emitted 'error' directly on the stream.\n        errorOrDestroy(dest, er)\n      } else {\n        dest.emit('error', er)\n      }\n    }\n  }\n\n  // Make sure our error handler is attached before userland ones.\n  prependListener(dest, 'error', onerror)\n\n  // Both close and finish should trigger unpipe, but only once.\n  function onclose() {\n    dest.removeListener('finish', onfinish)\n    unpipe()\n  }\n  dest.once('close', onclose)\n  function onfinish() {\n    debug('onfinish')\n    dest.removeListener('close', onclose)\n    unpipe()\n  }\n  dest.once('finish', onfinish)\n  function unpipe() {\n    debug('unpipe')\n    src.unpipe(dest)\n  }\n\n  // Tell the dest that it's being piped to.\n  dest.emit('pipe', src)\n\n  // Start the flow if it hasn't been started already.\n\n  if (dest.writableNeedDrain === true) {\n    if (state.flowing) {\n      pause()\n    }\n  } else if (!state.flowing) {\n    debug('pipe resume')\n    src.resume()\n  }\n  return dest\n}\nfunction pipeOnDrain(src, dest) {\n  return function pipeOnDrainFunctionResult() {\n    const state = src._readableState\n\n    // `ondrain` will call directly,\n    // `this` maybe not a reference to dest,\n    // so we use the real dest here.\n    if (state.awaitDrainWriters === dest) {\n      debug('pipeOnDrain', 1)\n      state.awaitDrainWriters = null\n    } else if (state.multiAwaitDrain) {\n      debug('pipeOnDrain', state.awaitDrainWriters.size)\n      state.awaitDrainWriters.delete(dest)\n    }\n    if ((!state.awaitDrainWriters || state.awaitDrainWriters.size === 0) && src.listenerCount('data')) {\n      src.resume()\n    }\n  }\n}\nReadable.prototype.unpipe = function (dest) {\n  const state = this._readableState\n  const unpipeInfo = {\n    hasUnpiped: false\n  }\n\n  // If we're not piping anywhere, then do nothing.\n  if (state.pipes.length === 0) return this\n  if (!dest) {\n    // remove all.\n    const dests = state.pipes\n    state.pipes = []\n    this.pause()\n    for (let i = 0; i < dests.length; i++)\n      dests[i].emit('unpipe', this, {\n        hasUnpiped: false\n      })\n    return this\n  }\n\n  // Try to find the right one.\n  const index = ArrayPrototypeIndexOf(state.pipes, dest)\n  if (index === -1) return this\n  state.pipes.splice(index, 1)\n  if (state.pipes.length === 0) this.pause()\n  dest.emit('unpipe', this, unpipeInfo)\n  return this\n}\n\n// Set up data events if they are asked for\n// Ensure readable listeners eventually get something.\nReadable.prototype.on = function (ev, fn) {\n  const res = Stream.prototype.on.call(this, ev, fn)\n  const state = this._readableState\n  if (ev === 'data') {\n    // Update readableListening so that resume() may be a no-op\n    // a few lines down. This is needed to support once('readable').\n    state.readableListening = this.listenerCount('readable') > 0\n\n    // Try start flowing on next tick if stream isn't explicitly paused.\n    if (state.flowing !== false) this.resume()\n  } else if (ev === 'readable') {\n    if (!state.endEmitted && !state.readableListening) {\n      state.readableListening = state.needReadable = true\n      state.flowing = false\n      state.emittedReadable = false\n      debug('on readable', state.length, state.reading)\n      if (state.length) {\n        emitReadable(this)\n      } else if (!state.reading) {\n        process.nextTick(nReadingNextTick, this)\n      }\n    }\n  }\n  return res\n}\nReadable.prototype.addListener = Readable.prototype.on\nReadable.prototype.removeListener = function (ev, fn) {\n  const res = Stream.prototype.removeListener.call(this, ev, fn)\n  if (ev === 'readable') {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this)\n  }\n  return res\n}\nReadable.prototype.off = Readable.prototype.removeListener\nReadable.prototype.removeAllListeners = function (ev) {\n  const res = Stream.prototype.removeAllListeners.apply(this, arguments)\n  if (ev === 'readable' || ev === undefined) {\n    // We need to check if there is someone still listening to\n    // readable and reset the state. However this needs to happen\n    // after readable has been emitted but before I/O (nextTick) to\n    // support once('readable', fn) cycles. This means that calling\n    // resume within the same tick will have no\n    // effect.\n    process.nextTick(updateReadableListening, this)\n  }\n  return res\n}\nfunction updateReadableListening(self) {\n  const state = self._readableState\n  state.readableListening = self.listenerCount('readable') > 0\n  if (state.resumeScheduled && state[kPaused] === false) {\n    // Flowing needs to be set to true now, otherwise\n    // the upcoming resume will not flow.\n    state.flowing = true\n\n    // Crude way to check if we should resume.\n  } else if (self.listenerCount('data') > 0) {\n    self.resume()\n  } else if (!state.readableListening) {\n    state.flowing = null\n  }\n}\nfunction nReadingNextTick(self) {\n  debug('readable nexttick read 0')\n  self.read(0)\n}\n\n// pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\nReadable.prototype.resume = function () {\n  const state = this._readableState\n  if (!state.flowing) {\n    debug('resume')\n    // We flow only if there is no one listening\n    // for readable, but we still have to call\n    // resume().\n    state.flowing = !state.readableListening\n    resume(this, state)\n  }\n  state[kPaused] = false\n  return this\n}\nfunction resume(stream, state) {\n  if (!state.resumeScheduled) {\n    state.resumeScheduled = true\n    process.nextTick(resume_, stream, state)\n  }\n}\nfunction resume_(stream, state) {\n  debug('resume', state.reading)\n  if (!state.reading) {\n    stream.read(0)\n  }\n  state.resumeScheduled = false\n  stream.emit('resume')\n  flow(stream)\n  if (state.flowing && !state.reading) stream.read(0)\n}\nReadable.prototype.pause = function () {\n  debug('call pause flowing=%j', this._readableState.flowing)\n  if (this._readableState.flowing !== false) {\n    debug('pause')\n    this._readableState.flowing = false\n    this.emit('pause')\n  }\n  this._readableState[kPaused] = true\n  return this\n}\nfunction flow(stream) {\n  const state = stream._readableState\n  debug('flow', state.flowing)\n  while (state.flowing && stream.read() !== null);\n}\n\n// Wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\nReadable.prototype.wrap = function (stream) {\n  let paused = false\n\n  // TODO (ronag): Should this.destroy(err) emit\n  // 'error' on the wrapped stream? Would require\n  // a static factory method, e.g. Readable.wrap(stream).\n\n  stream.on('data', (chunk) => {\n    if (!this.push(chunk) && stream.pause) {\n      paused = true\n      stream.pause()\n    }\n  })\n  stream.on('end', () => {\n    this.push(null)\n  })\n  stream.on('error', (err) => {\n    errorOrDestroy(this, err)\n  })\n  stream.on('close', () => {\n    this.destroy()\n  })\n  stream.on('destroy', () => {\n    this.destroy()\n  })\n  this._read = () => {\n    if (paused && stream.resume) {\n      paused = false\n      stream.resume()\n    }\n  }\n\n  // Proxy all the other methods. Important when wrapping filters and duplexes.\n  const streamKeys = ObjectKeys(stream)\n  for (let j = 1; j < streamKeys.length; j++) {\n    const i = streamKeys[j]\n    if (this[i] === undefined && typeof stream[i] === 'function') {\n      this[i] = stream[i].bind(stream)\n    }\n  }\n  return this\n}\nReadable.prototype[SymbolAsyncIterator] = function () {\n  return streamToAsyncIterator(this)\n}\nReadable.prototype.iterator = function (options) {\n  if (options !== undefined) {\n    validateObject(options, 'options')\n  }\n  return streamToAsyncIterator(this, options)\n}\nfunction streamToAsyncIterator(stream, options) {\n  if (typeof stream.read !== 'function') {\n    stream = Readable.wrap(stream, {\n      objectMode: true\n    })\n  }\n  const iter = createAsyncIterator(stream, options)\n  iter.stream = stream\n  return iter\n}\nasync function* createAsyncIterator(stream, options) {\n  let callback = nop\n  function next(resolve) {\n    if (this === stream) {\n      callback()\n      callback = nop\n    } else {\n      callback = resolve\n    }\n  }\n  stream.on('readable', next)\n  let error\n  const cleanup = eos(\n    stream,\n    {\n      writable: false\n    },\n    (err) => {\n      error = err ? aggregateTwoErrors(error, err) : null\n      callback()\n      callback = nop\n    }\n  )\n  try {\n    while (true) {\n      const chunk = stream.destroyed ? null : stream.read()\n      if (chunk !== null) {\n        yield chunk\n      } else if (error) {\n        throw error\n      } else if (error === null) {\n        return\n      } else {\n        await new Promise(next)\n      }\n    }\n  } catch (err) {\n    error = aggregateTwoErrors(error, err)\n    throw error\n  } finally {\n    if (\n      (error || (options === null || options === undefined ? undefined : options.destroyOnReturn) !== false) &&\n      (error === undefined || stream._readableState.autoDestroy)\n    ) {\n      destroyImpl.destroyer(stream, null)\n    } else {\n      stream.off('readable', next)\n      cleanup()\n    }\n  }\n}\n\n// Making it explicit these properties are not enumerable\n// because otherwise some prototype manipulation in\n// userland will fail.\nObjectDefineProperties(Readable.prototype, {\n  readable: {\n    __proto__: null,\n    get() {\n      const r = this._readableState\n      // r.readable === false means that this is part of a Duplex stream\n      // where the readable side was disabled upon construction.\n      // Compat. The user might manually disable readable side through\n      // deprecated setter.\n      return !!r && r.readable !== false && !r.destroyed && !r.errorEmitted && !r.endEmitted\n    },\n    set(val) {\n      // Backwards compat.\n      if (this._readableState) {\n        this._readableState.readable = !!val\n      }\n    }\n  },\n  readableDidRead: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return this._readableState.dataEmitted\n    }\n  },\n  readableAborted: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return !!(\n        this._readableState.readable !== false &&\n        (this._readableState.destroyed || this._readableState.errored) &&\n        !this._readableState.endEmitted\n      )\n    }\n  },\n  readableHighWaterMark: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return this._readableState.highWaterMark\n    }\n  },\n  readableBuffer: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return this._readableState && this._readableState.buffer\n    }\n  },\n  readableFlowing: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return this._readableState.flowing\n    },\n    set: function (state) {\n      if (this._readableState) {\n        this._readableState.flowing = state\n      }\n    }\n  },\n  readableLength: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState.length\n    }\n  },\n  readableObjectMode: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.objectMode : false\n    }\n  },\n  readableEncoding: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.encoding : null\n    }\n  },\n  errored: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.errored : null\n    }\n  },\n  closed: {\n    __proto__: null,\n    get() {\n      return this._readableState ? this._readableState.closed : false\n    }\n  },\n  destroyed: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.destroyed : false\n    },\n    set(value) {\n      // We ignore the value if the stream\n      // has not been initialized yet.\n      if (!this._readableState) {\n        return\n      }\n\n      // Backward compatibility, the user is explicitly\n      // managing destroyed.\n      this._readableState.destroyed = value\n    }\n  },\n  readableEnded: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._readableState ? this._readableState.endEmitted : false\n    }\n  }\n})\nObjectDefineProperties(ReadableState.prototype, {\n  // Legacy getter for `pipesCount`.\n  pipesCount: {\n    __proto__: null,\n    get() {\n      return this.pipes.length\n    }\n  },\n  // Legacy property for `paused`.\n  paused: {\n    __proto__: null,\n    get() {\n      return this[kPaused] !== false\n    },\n    set(value) {\n      this[kPaused] = !!value\n    }\n  }\n})\n\n// Exposed for testing purposes only.\nReadable._fromList = fromList\n\n// Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\nfunction fromList(n, state) {\n  // nothing buffered.\n  if (state.length === 0) return null\n  let ret\n  if (state.objectMode) ret = state.buffer.shift()\n  else if (!n || n >= state.length) {\n    // Read it all, truncate the list.\n    if (state.decoder) ret = state.buffer.join('')\n    else if (state.buffer.length === 1) ret = state.buffer.first()\n    else ret = state.buffer.concat(state.length)\n    state.buffer.clear()\n  } else {\n    // read part of list.\n    ret = state.buffer.consume(n, state.decoder)\n  }\n  return ret\n}\nfunction endReadable(stream) {\n  const state = stream._readableState\n  debug('endReadable', state.endEmitted)\n  if (!state.endEmitted) {\n    state.ended = true\n    process.nextTick(endReadableNT, state, stream)\n  }\n}\nfunction endReadableNT(state, stream) {\n  debug('endReadableNT', state.endEmitted, state.length)\n\n  // Check that we didn't get one last unshift.\n  if (!state.errored && !state.closeEmitted && !state.endEmitted && state.length === 0) {\n    state.endEmitted = true\n    stream.emit('end')\n    if (stream.writable && stream.allowHalfOpen === false) {\n      process.nextTick(endWritableNT, stream)\n    } else if (state.autoDestroy) {\n      // In case of duplex streams we need a way to detect\n      // if the writable side is ready for autoDestroy as well.\n      const wState = stream._writableState\n      const autoDestroy =\n        !wState ||\n        (wState.autoDestroy &&\n          // We don't expect the writable to ever 'finish'\n          // if writable is explicitly set to false.\n          (wState.finished || wState.writable === false))\n      if (autoDestroy) {\n        stream.destroy()\n      }\n    }\n  }\n}\nfunction endWritableNT(stream) {\n  const writable = stream.writable && !stream.writableEnded && !stream.destroyed\n  if (writable) {\n    stream.end()\n  }\n}\nReadable.from = function (iterable, opts) {\n  return from(Readable, iterable, opts)\n}\nlet webStreamsAdapters\n\n// Lazy to avoid circular references\nfunction lazyWebStreams() {\n  if (webStreamsAdapters === undefined) webStreamsAdapters = {}\n  return webStreamsAdapters\n}\nReadable.fromWeb = function (readableStream, options) {\n  return lazyWebStreams().newStreamReadableFromReadableStream(readableStream, options)\n}\nReadable.toWeb = function (streamReadable, options) {\n  return lazyWebStreams().newReadableStreamFromStreamReadable(streamReadable, options)\n}\nReadable.wrap = function (src, options) {\n  var _ref, _src$readableObjectMo\n  return new Readable({\n    objectMode:\n      (_ref =\n        (_src$readableObjectMo = src.readableObjectMode) !== null && _src$readableObjectMo !== undefined\n          ? _src$readableObjectMo\n          : src.objectMode) !== null && _ref !== undefined\n        ? _ref\n        : true,\n    ...options,\n    destroy(err, callback) {\n      destroyImpl.destroyer(src, err)\n      callback(err)\n    }\n  }).wrap(src)\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n;('use strict')\nconst {\n  ArrayPrototypeSlice,\n  Error,\n  FunctionPrototypeSymbolHasInstance,\n  ObjectDefineProperty,\n  ObjectDefineProperties,\n  ObjectSetPrototypeOf,\n  StringPrototypeToLowerCase,\n  Symbol,\n  SymbolHasInstance\n} = require('../../ours/primordials')\nmodule.exports = Writable\nWritable.WritableState = WritableState\nconst { EventEmitter: EE } = require('events')\nconst Stream = require('./legacy').Stream\nconst { Buffer } = require('buffer')\nconst destroyImpl = require('./destroy')\nconst { addAbortSignal } = require('./add-abort-signal')\nconst { getHighWaterMark, getDefaultHighWaterMark } = require('./state')\nconst {\n  ERR_INVALID_ARG_TYPE,\n  ERR_METHOD_NOT_IMPLEMENTED,\n  ERR_MULTIPLE_CALLBACK,\n  ERR_STREAM_CANNOT_PIPE,\n  ERR_STREAM_DESTROYED,\n  ERR_STREAM_ALREADY_FINISHED,\n  ERR_STREAM_NULL_VALUES,\n  ERR_STREAM_WRITE_AFTER_END,\n  ERR_UNKNOWN_ENCODING\n} = require('../../ours/errors').codes\nconst { errorOrDestroy } = destroyImpl\nObjectSetPrototypeOf(Writable.prototype, Stream.prototype)\nObjectSetPrototypeOf(Writable, Stream)\nfunction nop() {}\nconst kOnFinished = Symbol('kOnFinished')\nfunction WritableState(options, stream, isDuplex) {\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream,\n  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof require('./duplex')\n\n  // Object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!(options && options.objectMode)\n  if (isDuplex) this.objectMode = this.objectMode || !!(options && options.writableObjectMode)\n\n  // The point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write().\n  this.highWaterMark = options\n    ? getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex)\n    : getDefaultHighWaterMark(false)\n\n  // if _final has been called.\n  this.finalCalled = false\n\n  // drain event flag.\n  this.needDrain = false\n  // At the start of calling end()\n  this.ending = false\n  // When end() has been called, and returned.\n  this.ended = false\n  // When 'finish' is emitted.\n  this.finished = false\n\n  // Has it been destroyed\n  this.destroyed = false\n\n  // Should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  const noDecode = !!(options && options.decodeStrings === false)\n  this.decodeStrings = !noDecode\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = (options && options.defaultEncoding) || 'utf8'\n\n  // Not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0\n\n  // A flag to see when we're in the middle of a write.\n  this.writing = false\n\n  // When true all writes will be buffered until .uncork() call.\n  this.corked = 0\n\n  // A flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true\n\n  // A flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false\n\n  // The callback that's passed to _write(chunk, cb).\n  this.onwrite = onwrite.bind(undefined, stream)\n\n  // The callback that the user supplies to write(chunk, encoding, cb).\n  this.writecb = null\n\n  // The amount that is being written when _write is called.\n  this.writelen = 0\n\n  // Storage for data passed to the afterWrite() callback in case of\n  // synchronous _write() completion.\n  this.afterWriteTickInfo = null\n  resetBuffer(this)\n\n  // Number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted.\n  this.pendingcb = 0\n\n  // Stream is still being constructed and cannot be\n  // destroyed until construction finished or failed.\n  // Async construction is opt in, therefore we start as\n  // constructed.\n  this.constructed = true\n\n  // Emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams.\n  this.prefinished = false\n\n  // True if the error was already emitted and should not be thrown again.\n  this.errorEmitted = false\n\n  // Should close be emitted on destroy. Defaults to true.\n  this.emitClose = !options || options.emitClose !== false\n\n  // Should .destroy() be called after 'finish' (and potentially 'end').\n  this.autoDestroy = !options || options.autoDestroy !== false\n\n  // Indicates whether the stream has errored. When true all write() calls\n  // should return false. This is needed since when autoDestroy\n  // is disabled we need a way to tell whether the stream has failed.\n  this.errored = null\n\n  // Indicates whether the stream has finished destroying.\n  this.closed = false\n\n  // True if close has been emitted or would have been emitted\n  // depending on emitClose.\n  this.closeEmitted = false\n  this[kOnFinished] = []\n}\nfunction resetBuffer(state) {\n  state.buffered = []\n  state.bufferedIndex = 0\n  state.allBuffers = true\n  state.allNoop = true\n}\nWritableState.prototype.getBuffer = function getBuffer() {\n  return ArrayPrototypeSlice(this.buffered, this.bufferedIndex)\n}\nObjectDefineProperty(WritableState.prototype, 'bufferedRequestCount', {\n  __proto__: null,\n  get() {\n    return this.buffered.length - this.bufferedIndex\n  }\n})\nfunction Writable(options) {\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n\n  // Checking for a Stream.Duplex instance is faster here instead of inside\n  // the WritableState constructor, at least with V8 6.5.\n  const isDuplex = this instanceof require('./duplex')\n  if (!isDuplex && !FunctionPrototypeSymbolHasInstance(Writable, this)) return new Writable(options)\n  this._writableState = new WritableState(options, this, isDuplex)\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write\n    if (typeof options.writev === 'function') this._writev = options.writev\n    if (typeof options.destroy === 'function') this._destroy = options.destroy\n    if (typeof options.final === 'function') this._final = options.final\n    if (typeof options.construct === 'function') this._construct = options.construct\n    if (options.signal) addAbortSignal(options.signal, this)\n  }\n  Stream.call(this, options)\n  destroyImpl.construct(this, () => {\n    const state = this._writableState\n    if (!state.writing) {\n      clearBuffer(this, state)\n    }\n    finishMaybe(this, state)\n  })\n}\nObjectDefineProperty(Writable, SymbolHasInstance, {\n  __proto__: null,\n  value: function (object) {\n    if (FunctionPrototypeSymbolHasInstance(this, object)) return true\n    if (this !== Writable) return false\n    return object && object._writableState instanceof WritableState\n  }\n})\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE())\n}\nfunction _write(stream, chunk, encoding, cb) {\n  const state = stream._writableState\n  if (typeof encoding === 'function') {\n    cb = encoding\n    encoding = state.defaultEncoding\n  } else {\n    if (!encoding) encoding = state.defaultEncoding\n    else if (encoding !== 'buffer' && !Buffer.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding)\n    if (typeof cb !== 'function') cb = nop\n  }\n  if (chunk === null) {\n    throw new ERR_STREAM_NULL_VALUES()\n  } else if (!state.objectMode) {\n    if (typeof chunk === 'string') {\n      if (state.decodeStrings !== false) {\n        chunk = Buffer.from(chunk, encoding)\n        encoding = 'buffer'\n      }\n    } else if (chunk instanceof Buffer) {\n      encoding = 'buffer'\n    } else if (Stream._isUint8Array(chunk)) {\n      chunk = Stream._uint8ArrayToBuffer(chunk)\n      encoding = 'buffer'\n    } else {\n      throw new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk)\n    }\n  }\n  let err\n  if (state.ending) {\n    err = new ERR_STREAM_WRITE_AFTER_END()\n  } else if (state.destroyed) {\n    err = new ERR_STREAM_DESTROYED('write')\n  }\n  if (err) {\n    process.nextTick(cb, err)\n    errorOrDestroy(stream, err, true)\n    return err\n  }\n  state.pendingcb++\n  return writeOrBuffer(stream, state, chunk, encoding, cb)\n}\nWritable.prototype.write = function (chunk, encoding, cb) {\n  return _write(this, chunk, encoding, cb) === true\n}\nWritable.prototype.cork = function () {\n  this._writableState.corked++\n}\nWritable.prototype.uncork = function () {\n  const state = this._writableState\n  if (state.corked) {\n    state.corked--\n    if (!state.writing) clearBuffer(this, state)\n  }\n}\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = StringPrototypeToLowerCase(encoding)\n  if (!Buffer.isEncoding(encoding)) throw new ERR_UNKNOWN_ENCODING(encoding)\n  this._writableState.defaultEncoding = encoding\n  return this\n}\n\n// If we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, chunk, encoding, callback) {\n  const len = state.objectMode ? 1 : chunk.length\n  state.length += len\n\n  // stream._write resets state.length\n  const ret = state.length < state.highWaterMark\n  // We must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true\n  if (state.writing || state.corked || state.errored || !state.constructed) {\n    state.buffered.push({\n      chunk,\n      encoding,\n      callback\n    })\n    if (state.allBuffers && encoding !== 'buffer') {\n      state.allBuffers = false\n    }\n    if (state.allNoop && callback !== nop) {\n      state.allNoop = false\n    }\n  } else {\n    state.writelen = len\n    state.writecb = callback\n    state.writing = true\n    state.sync = true\n    stream._write(chunk, encoding, state.onwrite)\n    state.sync = false\n  }\n\n  // Return false if errored or destroyed in order to break\n  // any synchronous while(stream.write(data)) loops.\n  return ret && !state.errored && !state.destroyed\n}\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len\n  state.writecb = cb\n  state.writing = true\n  state.sync = true\n  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'))\n  else if (writev) stream._writev(chunk, state.onwrite)\n  else stream._write(chunk, encoding, state.onwrite)\n  state.sync = false\n}\nfunction onwriteError(stream, state, er, cb) {\n  --state.pendingcb\n  cb(er)\n  // Ensure callbacks are invoked even when autoDestroy is\n  // not enabled. Passing `er` here doesn't make sense since\n  // it's related to one specific write, not to the buffered\n  // writes.\n  errorBuffer(state)\n  // This can emit error, but error must always follow cb.\n  errorOrDestroy(stream, er)\n}\nfunction onwrite(stream, er) {\n  const state = stream._writableState\n  const sync = state.sync\n  const cb = state.writecb\n  if (typeof cb !== 'function') {\n    errorOrDestroy(stream, new ERR_MULTIPLE_CALLBACK())\n    return\n  }\n  state.writing = false\n  state.writecb = null\n  state.length -= state.writelen\n  state.writelen = 0\n  if (er) {\n    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364\n    er.stack // eslint-disable-line no-unused-expressions\n\n    if (!state.errored) {\n      state.errored = er\n    }\n\n    // In case of duplex streams we need to notify the readable side of the\n    // error.\n    if (stream._readableState && !stream._readableState.errored) {\n      stream._readableState.errored = er\n    }\n    if (sync) {\n      process.nextTick(onwriteError, stream, state, er, cb)\n    } else {\n      onwriteError(stream, state, er, cb)\n    }\n  } else {\n    if (state.buffered.length > state.bufferedIndex) {\n      clearBuffer(stream, state)\n    }\n    if (sync) {\n      // It is a common case that the callback passed to .write() is always\n      // the same. In that case, we do not schedule a new nextTick(), but\n      // rather just increase a counter, to improve performance and avoid\n      // memory allocations.\n      if (state.afterWriteTickInfo !== null && state.afterWriteTickInfo.cb === cb) {\n        state.afterWriteTickInfo.count++\n      } else {\n        state.afterWriteTickInfo = {\n          count: 1,\n          cb,\n          stream,\n          state\n        }\n        process.nextTick(afterWriteTick, state.afterWriteTickInfo)\n      }\n    } else {\n      afterWrite(stream, state, 1, cb)\n    }\n  }\n}\nfunction afterWriteTick({ stream, state, count, cb }) {\n  state.afterWriteTickInfo = null\n  return afterWrite(stream, state, count, cb)\n}\nfunction afterWrite(stream, state, count, cb) {\n  const needDrain = !state.ending && !stream.destroyed && state.length === 0 && state.needDrain\n  if (needDrain) {\n    state.needDrain = false\n    stream.emit('drain')\n  }\n  while (count-- > 0) {\n    state.pendingcb--\n    cb()\n  }\n  if (state.destroyed) {\n    errorBuffer(state)\n  }\n  finishMaybe(stream, state)\n}\n\n// If there's something in the buffer waiting, then invoke callbacks.\nfunction errorBuffer(state) {\n  if (state.writing) {\n    return\n  }\n  for (let n = state.bufferedIndex; n < state.buffered.length; ++n) {\n    var _state$errored\n    const { chunk, callback } = state.buffered[n]\n    const len = state.objectMode ? 1 : chunk.length\n    state.length -= len\n    callback(\n      (_state$errored = state.errored) !== null && _state$errored !== undefined\n        ? _state$errored\n        : new ERR_STREAM_DESTROYED('write')\n    )\n  }\n  const onfinishCallbacks = state[kOnFinished].splice(0)\n  for (let i = 0; i < onfinishCallbacks.length; i++) {\n    var _state$errored2\n    onfinishCallbacks[i](\n      (_state$errored2 = state.errored) !== null && _state$errored2 !== undefined\n        ? _state$errored2\n        : new ERR_STREAM_DESTROYED('end')\n    )\n  }\n  resetBuffer(state)\n}\n\n// If there's something in the buffer waiting, then process it.\nfunction clearBuffer(stream, state) {\n  if (state.corked || state.bufferProcessing || state.destroyed || !state.constructed) {\n    return\n  }\n  const { buffered, bufferedIndex, objectMode } = state\n  const bufferedLength = buffered.length - bufferedIndex\n  if (!bufferedLength) {\n    return\n  }\n  let i = bufferedIndex\n  state.bufferProcessing = true\n  if (bufferedLength > 1 && stream._writev) {\n    state.pendingcb -= bufferedLength - 1\n    const callback = state.allNoop\n      ? nop\n      : (err) => {\n          for (let n = i; n < buffered.length; ++n) {\n            buffered[n].callback(err)\n          }\n        }\n    // Make a copy of `buffered` if it's going to be used by `callback` above,\n    // since `doWrite` will mutate the array.\n    const chunks = state.allNoop && i === 0 ? buffered : ArrayPrototypeSlice(buffered, i)\n    chunks.allBuffers = state.allBuffers\n    doWrite(stream, state, true, state.length, chunks, '', callback)\n    resetBuffer(state)\n  } else {\n    do {\n      const { chunk, encoding, callback } = buffered[i]\n      buffered[i++] = null\n      const len = objectMode ? 1 : chunk.length\n      doWrite(stream, state, false, len, chunk, encoding, callback)\n    } while (i < buffered.length && !state.writing)\n    if (i === buffered.length) {\n      resetBuffer(state)\n    } else if (i > 256) {\n      buffered.splice(0, i)\n      state.bufferedIndex = 0\n    } else {\n      state.bufferedIndex = i\n    }\n  }\n  state.bufferProcessing = false\n}\nWritable.prototype._write = function (chunk, encoding, cb) {\n  if (this._writev) {\n    this._writev(\n      [\n        {\n          chunk,\n          encoding\n        }\n      ],\n      cb\n    )\n  } else {\n    throw new ERR_METHOD_NOT_IMPLEMENTED('_write()')\n  }\n}\nWritable.prototype._writev = null\nWritable.prototype.end = function (chunk, encoding, cb) {\n  const state = this._writableState\n  if (typeof chunk === 'function') {\n    cb = chunk\n    chunk = null\n    encoding = null\n  } else if (typeof encoding === 'function') {\n    cb = encoding\n    encoding = null\n  }\n  let err\n  if (chunk !== null && chunk !== undefined) {\n    const ret = _write(this, chunk, encoding)\n    if (ret instanceof Error) {\n      err = ret\n    }\n  }\n\n  // .end() fully uncorks.\n  if (state.corked) {\n    state.corked = 1\n    this.uncork()\n  }\n  if (err) {\n    // Do nothing...\n  } else if (!state.errored && !state.ending) {\n    // This is forgiving in terms of unnecessary calls to end() and can hide\n    // logic errors. However, usually such errors are harmless and causing a\n    // hard error can be disproportionately destructive. It is not always\n    // trivial for the user to determine whether end() needs to be called\n    // or not.\n\n    state.ending = true\n    finishMaybe(this, state, true)\n    state.ended = true\n  } else if (state.finished) {\n    err = new ERR_STREAM_ALREADY_FINISHED('end')\n  } else if (state.destroyed) {\n    err = new ERR_STREAM_DESTROYED('end')\n  }\n  if (typeof cb === 'function') {\n    if (err || state.finished) {\n      process.nextTick(cb, err)\n    } else {\n      state[kOnFinished].push(cb)\n    }\n  }\n  return this\n}\nfunction needFinish(state) {\n  return (\n    state.ending &&\n    !state.destroyed &&\n    state.constructed &&\n    state.length === 0 &&\n    !state.errored &&\n    state.buffered.length === 0 &&\n    !state.finished &&\n    !state.writing &&\n    !state.errorEmitted &&\n    !state.closeEmitted\n  )\n}\nfunction callFinal(stream, state) {\n  let called = false\n  function onFinish(err) {\n    if (called) {\n      errorOrDestroy(stream, err !== null && err !== undefined ? err : ERR_MULTIPLE_CALLBACK())\n      return\n    }\n    called = true\n    state.pendingcb--\n    if (err) {\n      const onfinishCallbacks = state[kOnFinished].splice(0)\n      for (let i = 0; i < onfinishCallbacks.length; i++) {\n        onfinishCallbacks[i](err)\n      }\n      errorOrDestroy(stream, err, state.sync)\n    } else if (needFinish(state)) {\n      state.prefinished = true\n      stream.emit('prefinish')\n      // Backwards compat. Don't check state.sync here.\n      // Some streams assume 'finish' will be emitted\n      // asynchronously relative to _final callback.\n      state.pendingcb++\n      process.nextTick(finish, stream, state)\n    }\n  }\n  state.sync = true\n  state.pendingcb++\n  try {\n    stream._final(onFinish)\n  } catch (err) {\n    onFinish(err)\n  }\n  state.sync = false\n}\nfunction prefinish(stream, state) {\n  if (!state.prefinished && !state.finalCalled) {\n    if (typeof stream._final === 'function' && !state.destroyed) {\n      state.finalCalled = true\n      callFinal(stream, state)\n    } else {\n      state.prefinished = true\n      stream.emit('prefinish')\n    }\n  }\n}\nfunction finishMaybe(stream, state, sync) {\n  if (needFinish(state)) {\n    prefinish(stream, state)\n    if (state.pendingcb === 0) {\n      if (sync) {\n        state.pendingcb++\n        process.nextTick(\n          (stream, state) => {\n            if (needFinish(state)) {\n              finish(stream, state)\n            } else {\n              state.pendingcb--\n            }\n          },\n          stream,\n          state\n        )\n      } else if (needFinish(state)) {\n        state.pendingcb++\n        finish(stream, state)\n      }\n    }\n  }\n}\nfunction finish(stream, state) {\n  state.pendingcb--\n  state.finished = true\n  const onfinishCallbacks = state[kOnFinished].splice(0)\n  for (let i = 0; i < onfinishCallbacks.length; i++) {\n    onfinishCallbacks[i]()\n  }\n  stream.emit('finish')\n  if (state.autoDestroy) {\n    // In case of duplex streams we need a way to detect\n    // if the readable side is ready for autoDestroy as well.\n    const rState = stream._readableState\n    const autoDestroy =\n      !rState ||\n      (rState.autoDestroy &&\n        // We don't expect the readable to ever 'end'\n        // if readable is explicitly set to false.\n        (rState.endEmitted || rState.readable === false))\n    if (autoDestroy) {\n      stream.destroy()\n    }\n  }\n}\nObjectDefineProperties(Writable.prototype, {\n  closed: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.closed : false\n    }\n  },\n  destroyed: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.destroyed : false\n    },\n    set(value) {\n      // Backward compatibility, the user is explicitly managing destroyed.\n      if (this._writableState) {\n        this._writableState.destroyed = value\n      }\n    }\n  },\n  writable: {\n    __proto__: null,\n    get() {\n      const w = this._writableState\n      // w.writable === false means that this is part of a Duplex stream\n      // where the writable side was disabled upon construction.\n      // Compat. The user might manually disable writable side through\n      // deprecated setter.\n      return !!w && w.writable !== false && !w.destroyed && !w.errored && !w.ending && !w.ended\n    },\n    set(val) {\n      // Backwards compatible.\n      if (this._writableState) {\n        this._writableState.writable = !!val\n      }\n    }\n  },\n  writableFinished: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.finished : false\n    }\n  },\n  writableObjectMode: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.objectMode : false\n    }\n  },\n  writableBuffer: {\n    __proto__: null,\n    get() {\n      return this._writableState && this._writableState.getBuffer()\n    }\n  },\n  writableEnded: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.ending : false\n    }\n  },\n  writableNeedDrain: {\n    __proto__: null,\n    get() {\n      const wState = this._writableState\n      if (!wState) return false\n      return !wState.destroyed && !wState.ending && wState.needDrain\n    }\n  },\n  writableHighWaterMark: {\n    __proto__: null,\n    get() {\n      return this._writableState && this._writableState.highWaterMark\n    }\n  },\n  writableCorked: {\n    __proto__: null,\n    get() {\n      return this._writableState ? this._writableState.corked : 0\n    }\n  },\n  writableLength: {\n    __proto__: null,\n    get() {\n      return this._writableState && this._writableState.length\n    }\n  },\n  errored: {\n    __proto__: null,\n    enumerable: false,\n    get() {\n      return this._writableState ? this._writableState.errored : null\n    }\n  },\n  writableAborted: {\n    __proto__: null,\n    enumerable: false,\n    get: function () {\n      return !!(\n        this._writableState.writable !== false &&\n        (this._writableState.destroyed || this._writableState.errored) &&\n        !this._writableState.finished\n      )\n    }\n  }\n})\nconst destroy = destroyImpl.destroy\nWritable.prototype.destroy = function (err, cb) {\n  const state = this._writableState\n\n  // Invoke pending callbacks.\n  if (!state.destroyed && (state.bufferedIndex < state.buffered.length || state[kOnFinished].length)) {\n    process.nextTick(errorBuffer, state)\n  }\n  destroy.call(this, err, cb)\n  return this\n}\nWritable.prototype._undestroy = destroyImpl.undestroy\nWritable.prototype._destroy = function (err, cb) {\n  cb(err)\n}\nWritable.prototype[EE.captureRejectionSymbol] = function (err) {\n  this.destroy(err)\n}\nlet webStreamsAdapters\n\n// Lazy to avoid circular references\nfunction lazyWebStreams() {\n  if (webStreamsAdapters === undefined) webStreamsAdapters = {}\n  return webStreamsAdapters\n}\nWritable.fromWeb = function (writableStream, options) {\n  return lazyWebStreams().newStreamWritableFromWritableStream(writableStream, options)\n}\nWritable.toWeb = function (streamWritable) {\n  return lazyWebStreams().newWritableStreamFromStreamWritable(streamWritable)\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n\n;('use strict')\nconst bufferModule = require('buffer')\nconst {\n  isReadable,\n  isWritable,\n  isIterable,\n  isNodeStream,\n  isReadableNodeStream,\n  isWritableNodeStream,\n  isDuplexNodeStream\n} = require('./utils')\nconst eos = require('./end-of-stream')\nconst {\n  AbortError,\n  codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE }\n} = require('../../ours/errors')\nconst { destroyer } = require('./destroy')\nconst Duplex = require('./duplex')\nconst Readable = require('./readable')\nconst { createDeferredPromise } = require('../../ours/util')\nconst from = require('./from')\nconst Blob = globalThis.Blob || bufferModule.Blob\nconst isBlob =\n  typeof Blob !== 'undefined'\n    ? function isBlob(b) {\n        return b instanceof Blob\n      }\n    : function isBlob(b) {\n        return false\n      }\nconst AbortController = globalThis.AbortController || require('abort-controller').AbortController\nconst { FunctionPrototypeCall } = require('../../ours/primordials')\n\n// This is needed for pre node 17.\nclass Duplexify extends Duplex {\n  constructor(options) {\n    super(options)\n\n    // https://github.com/nodejs/node/pull/34385\n\n    if ((options === null || options === undefined ? undefined : options.readable) === false) {\n      this._readableState.readable = false\n      this._readableState.ended = true\n      this._readableState.endEmitted = true\n    }\n    if ((options === null || options === undefined ? undefined : options.writable) === false) {\n      this._writableState.writable = false\n      this._writableState.ending = true\n      this._writableState.ended = true\n      this._writableState.finished = true\n    }\n  }\n}\nmodule.exports = function duplexify(body, name) {\n  if (isDuplexNodeStream(body)) {\n    return body\n  }\n  if (isReadableNodeStream(body)) {\n    return _duplexify({\n      readable: body\n    })\n  }\n  if (isWritableNodeStream(body)) {\n    return _duplexify({\n      writable: body\n    })\n  }\n  if (isNodeStream(body)) {\n    return _duplexify({\n      writable: false,\n      readable: false\n    })\n  }\n\n  // TODO: Webstreams\n  // if (isReadableStream(body)) {\n  //   return _duplexify({ readable: Readable.fromWeb(body) });\n  // }\n\n  // TODO: Webstreams\n  // if (isWritableStream(body)) {\n  //   return _duplexify({ writable: Writable.fromWeb(body) });\n  // }\n\n  if (typeof body === 'function') {\n    const { value, write, final, destroy } = fromAsyncGen(body)\n    if (isIterable(value)) {\n      return from(Duplexify, value, {\n        // TODO (ronag): highWaterMark?\n        objectMode: true,\n        write,\n        final,\n        destroy\n      })\n    }\n    const then = value === null || value === undefined ? undefined : value.then\n    if (typeof then === 'function') {\n      let d\n      const promise = FunctionPrototypeCall(\n        then,\n        value,\n        (val) => {\n          if (val != null) {\n            throw new ERR_INVALID_RETURN_VALUE('nully', 'body', val)\n          }\n        },\n        (err) => {\n          destroyer(d, err)\n        }\n      )\n      return (d = new Duplexify({\n        // TODO (ronag): highWaterMark?\n        objectMode: true,\n        readable: false,\n        write,\n        final(cb) {\n          final(async () => {\n            try {\n              await promise\n              process.nextTick(cb, null)\n            } catch (err) {\n              process.nextTick(cb, err)\n            }\n          })\n        },\n        destroy\n      }))\n    }\n    throw new ERR_INVALID_RETURN_VALUE('Iterable, AsyncIterable or AsyncFunction', name, value)\n  }\n  if (isBlob(body)) {\n    return duplexify(body.arrayBuffer())\n  }\n  if (isIterable(body)) {\n    return from(Duplexify, body, {\n      // TODO (ronag): highWaterMark?\n      objectMode: true,\n      writable: false\n    })\n  }\n\n  // TODO: Webstreams.\n  // if (\n  //   isReadableStream(body?.readable) &&\n  //   isWritableStream(body?.writable)\n  // ) {\n  //   return Duplexify.fromWeb(body);\n  // }\n\n  if (\n    typeof (body === null || body === undefined ? undefined : body.writable) === 'object' ||\n    typeof (body === null || body === undefined ? undefined : body.readable) === 'object'\n  ) {\n    const readable =\n      body !== null && body !== undefined && body.readable\n        ? isReadableNodeStream(body === null || body === undefined ? undefined : body.readable)\n          ? body === null || body === undefined\n            ? undefined\n            : body.readable\n          : duplexify(body.readable)\n        : undefined\n    const writable =\n      body !== null && body !== undefined && body.writable\n        ? isWritableNodeStream(body === null || body === undefined ? undefined : body.writable)\n          ? body === null || body === undefined\n            ? undefined\n            : body.writable\n          : duplexify(body.writable)\n        : undefined\n    return _duplexify({\n      readable,\n      writable\n    })\n  }\n  const then = body === null || body === undefined ? undefined : body.then\n  if (typeof then === 'function') {\n    let d\n    FunctionPrototypeCall(\n      then,\n      body,\n      (val) => {\n        if (val != null) {\n          d.push(val)\n        }\n        d.push(null)\n      },\n      (err) => {\n        destroyer(d, err)\n      }\n    )\n    return (d = new Duplexify({\n      objectMode: true,\n      writable: false,\n      read() {}\n    }))\n  }\n  throw new ERR_INVALID_ARG_TYPE(\n    name,\n    [\n      'Blob',\n      'ReadableStream',\n      'WritableStream',\n      'Stream',\n      'Iterable',\n      'AsyncIterable',\n      'Function',\n      '{ readable, writable } pair',\n      'Promise'\n    ],\n    body\n  )\n}\nfunction fromAsyncGen(fn) {\n  let { promise, resolve } = createDeferredPromise()\n  const ac = new AbortController()\n  const signal = ac.signal\n  const value = fn(\n    (async function* () {\n      while (true) {\n        const _promise = promise\n        promise = null\n        const { chunk, done, cb } = await _promise\n        process.nextTick(cb)\n        if (done) return\n        if (signal.aborted)\n          throw new AbortError(undefined, {\n            cause: signal.reason\n          })\n        ;({ promise, resolve } = createDeferredPromise())\n        yield chunk\n      }\n    })(),\n    {\n      signal\n    }\n  )\n  return {\n    value,\n    write(chunk, encoding, cb) {\n      const _resolve = resolve\n      resolve = null\n      _resolve({\n        chunk,\n        done: false,\n        cb\n      })\n    },\n    final(cb) {\n      const _resolve = resolve\n      resolve = null\n      _resolve({\n        done: true,\n        cb\n      })\n    },\n    destroy(err, cb) {\n      ac.abort()\n      cb(err)\n    }\n  }\n}\nfunction _duplexify(pair) {\n  const r = pair.readable && typeof pair.readable.read !== 'function' ? Readable.wrap(pair.readable) : pair.readable\n  const w = pair.writable\n  let readable = !!isReadable(r)\n  let writable = !!isWritable(w)\n  let ondrain\n  let onfinish\n  let onreadable\n  let onclose\n  let d\n  function onfinished(err) {\n    const cb = onclose\n    onclose = null\n    if (cb) {\n      cb(err)\n    } else if (err) {\n      d.destroy(err)\n    } else if (!readable && !writable) {\n      d.destroy()\n    }\n  }\n\n  // TODO(ronag): Avoid double buffering.\n  // Implement Writable/Readable/Duplex traits.\n  // See, https://github.com/nodejs/node/pull/33515.\n  d = new Duplexify({\n    // TODO (ronag): highWaterMark?\n    readableObjectMode: !!(r !== null && r !== undefined && r.readableObjectMode),\n    writableObjectMode: !!(w !== null && w !== undefined && w.writableObjectMode),\n    readable,\n    writable\n  })\n  if (writable) {\n    eos(w, (err) => {\n      writable = false\n      if (err) {\n        destroyer(r, err)\n      }\n      onfinished(err)\n    })\n    d._write = function (chunk, encoding, callback) {\n      if (w.write(chunk, encoding)) {\n        callback()\n      } else {\n        ondrain = callback\n      }\n    }\n    d._final = function (callback) {\n      w.end()\n      onfinish = callback\n    }\n    w.on('drain', function () {\n      if (ondrain) {\n        const cb = ondrain\n        ondrain = null\n        cb()\n      }\n    })\n    w.on('finish', function () {\n      if (onfinish) {\n        const cb = onfinish\n        onfinish = null\n        cb()\n      }\n    })\n  }\n  if (readable) {\n    eos(r, (err) => {\n      readable = false\n      if (err) {\n        destroyer(r, err)\n      }\n      onfinished(err)\n    })\n    r.on('readable', function () {\n      if (onreadable) {\n        const cb = onreadable\n        onreadable = null\n        cb()\n      }\n    })\n    r.on('end', function () {\n      d.push(null)\n    })\n    d._read = function () {\n      while (true) {\n        const buf = r.read()\n        if (buf === null) {\n          onreadable = d._read\n          return\n        }\n        if (!d.push(buf)) {\n          return\n        }\n      }\n    }\n  }\n  d._destroy = function (err, callback) {\n    if (!err && onclose !== null) {\n      err = new AbortError()\n    }\n    onreadable = null\n    ondrain = null\n    onfinish = null\n    if (onclose === null) {\n      callback(err)\n    } else {\n      onclose = callback\n      destroyer(w, err)\n      destroyer(r, err)\n    }\n  }\n  return d\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototype inheritance, this class\n// prototypically inherits from Readable, and then parasitically from\n// Writable.\n\n'use strict'\n\nconst {\n  ObjectDefineProperties,\n  ObjectGetOwnPropertyDescriptor,\n  ObjectKeys,\n  ObjectSetPrototypeOf\n} = require('../../ours/primordials')\nmodule.exports = Duplex\nconst Readable = require('./readable')\nconst Writable = require('./writable')\nObjectSetPrototypeOf(Duplex.prototype, Readable.prototype)\nObjectSetPrototypeOf(Duplex, Readable)\n{\n  const keys = ObjectKeys(Writable.prototype)\n  // Allow the keys array to be GC'ed.\n  for (let i = 0; i < keys.length; i++) {\n    const method = keys[i]\n    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]\n  }\n}\nfunction Duplex(options) {\n  if (!(this instanceof Duplex)) return new Duplex(options)\n  Readable.call(this, options)\n  Writable.call(this, options)\n  if (options) {\n    this.allowHalfOpen = options.allowHalfOpen !== false\n    if (options.readable === false) {\n      this._readableState.readable = false\n      this._readableState.ended = true\n      this._readableState.endEmitted = true\n    }\n    if (options.writable === false) {\n      this._writableState.writable = false\n      this._writableState.ending = true\n      this._writableState.ended = true\n      this._writableState.finished = true\n    }\n  } else {\n    this.allowHalfOpen = true\n  }\n}\nObjectDefineProperties(Duplex.prototype, {\n  writable: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writable')\n  },\n  writableHighWaterMark: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableHighWaterMark')\n  },\n  writableObjectMode: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableObjectMode')\n  },\n  writableBuffer: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableBuffer')\n  },\n  writableLength: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableLength')\n  },\n  writableFinished: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableFinished')\n  },\n  writableCorked: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableCorked')\n  },\n  writableEnded: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableEnded')\n  },\n  writableNeedDrain: {\n    __proto__: null,\n    ...ObjectGetOwnPropertyDescriptor(Writable.prototype, 'writableNeedDrain')\n  },\n  destroyed: {\n    __proto__: null,\n    get() {\n      if (this._readableState === undefined || this._writableState === undefined) {\n        return false\n      }\n      return this._readableState.destroyed && this._writableState.destroyed\n    },\n    set(value) {\n      // Backward compatibility, the user is explicitly\n      // managing destroyed.\n      if (this._readableState && this._writableState) {\n        this._readableState.destroyed = value\n        this._writableState.destroyed = value\n      }\n    }\n  }\n})\nlet webStreamsAdapters\n\n// Lazy to avoid circular references\nfunction lazyWebStreams() {\n  if (webStreamsAdapters === undefined) webStreamsAdapters = {}\n  return webStreamsAdapters\n}\nDuplex.fromWeb = function (pair, options) {\n  return lazyWebStreams().newStreamDuplexFromReadableWritablePair(pair, options)\n}\nDuplex.toWeb = function (duplex) {\n  return lazyWebStreams().newReadableWritablePairFromDuplex(duplex)\n}\nlet duplexify\nDuplex.from = function (body) {\n  if (!duplexify) {\n    duplexify = require('./duplexify')\n  }\n  return duplexify(body, 'body')\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a transform stream is a readable/writable stream where you do\n// something with the data.  Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored.  (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation.  For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes.  When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up.  When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer.  When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks.  If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk.  However,\n// a pathological inflate type of transform can cause excessive buffering\n// here.  For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output.  In this case, you could write a very small\n// amount of input, and end up with a very large amount of output.  In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform.  A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n\n'use strict'\n\nconst { ObjectSetPrototypeOf, Symbol } = require('../../ours/primordials')\nmodule.exports = Transform\nconst { ERR_METHOD_NOT_IMPLEMENTED } = require('../../ours/errors').codes\nconst Duplex = require('./duplex')\nconst { getHighWaterMark } = require('./state')\nObjectSetPrototypeOf(Transform.prototype, Duplex.prototype)\nObjectSetPrototypeOf(Transform, Duplex)\nconst kCallback = Symbol('kCallback')\nfunction Transform(options) {\n  if (!(this instanceof Transform)) return new Transform(options)\n\n  // TODO (ronag): This should preferably always be\n  // applied but would be semver-major. Or even better;\n  // make Transform a Readable with the Writable interface.\n  const readableHighWaterMark = options ? getHighWaterMark(this, options, 'readableHighWaterMark', true) : null\n  if (readableHighWaterMark === 0) {\n    // A Duplex will buffer both on the writable and readable side while\n    // a Transform just wants to buffer hwm number of elements. To avoid\n    // buffering twice we disable buffering on the writable side.\n    options = {\n      ...options,\n      highWaterMark: null,\n      readableHighWaterMark,\n      // TODO (ronag): 0 is not optimal since we have\n      // a \"bug\" where we check needDrain before calling _write and not after.\n      // Refs: https://github.com/nodejs/node/pull/32887\n      // Refs: https://github.com/nodejs/node/pull/35941\n      writableHighWaterMark: options.writableHighWaterMark || 0\n    }\n  }\n  Duplex.call(this, options)\n\n  // We have implemented the _read method, and done the other things\n  // that Readable wants before the first _read call, so unset the\n  // sync guard flag.\n  this._readableState.sync = false\n  this[kCallback] = null\n  if (options) {\n    if (typeof options.transform === 'function') this._transform = options.transform\n    if (typeof options.flush === 'function') this._flush = options.flush\n  }\n\n  // When the writable side finishes, then flush out anything remaining.\n  // Backwards compat. Some Transform streams incorrectly implement _final\n  // instead of or in addition to _flush. By using 'prefinish' instead of\n  // implementing _final we continue supporting this unfortunate use case.\n  this.on('prefinish', prefinish)\n}\nfunction final(cb) {\n  if (typeof this._flush === 'function' && !this.destroyed) {\n    this._flush((er, data) => {\n      if (er) {\n        if (cb) {\n          cb(er)\n        } else {\n          this.destroy(er)\n        }\n        return\n      }\n      if (data != null) {\n        this.push(data)\n      }\n      this.push(null)\n      if (cb) {\n        cb()\n      }\n    })\n  } else {\n    this.push(null)\n    if (cb) {\n      cb()\n    }\n  }\n}\nfunction prefinish() {\n  if (this._final !== final) {\n    final.call(this)\n  }\n}\nTransform.prototype._final = final\nTransform.prototype._transform = function (chunk, encoding, callback) {\n  throw new ERR_METHOD_NOT_IMPLEMENTED('_transform()')\n}\nTransform.prototype._write = function (chunk, encoding, callback) {\n  const rState = this._readableState\n  const wState = this._writableState\n  const length = rState.length\n  this._transform(chunk, encoding, (err, val) => {\n    if (err) {\n      callback(err)\n      return\n    }\n    if (val != null) {\n      this.push(val)\n    }\n    if (\n      wState.ended ||\n      // Backwards compat.\n      length === rState.length ||\n      // Backwards compat.\n      rState.length < rState.highWaterMark\n    ) {\n      callback()\n    } else {\n      this[kCallback] = callback\n    }\n  })\n}\nTransform.prototype._read = function () {\n  if (this[kCallback]) {\n    const callback = this[kCallback]\n    this[kCallback] = null\n    callback()\n  }\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n\n'use strict'\n\nconst { ObjectSetPrototypeOf } = require('../../ours/primordials')\nmodule.exports = PassThrough\nconst Transform = require('./transform')\nObjectSetPrototypeOf(PassThrough.prototype, Transform.prototype)\nObjectSetPrototypeOf(PassThrough, Transform)\nfunction PassThrough(options) {\n  if (!(this instanceof PassThrough)) return new PassThrough(options)\n  Transform.call(this, options)\n}\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n  cb(null, chunk)\n}\n","/* replacement start */\n\nconst process = require('process/')\n\n/* replacement end */\n// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n\n;('use strict')\nconst { ArrayIsArray, Promise, SymbolAsyncIterator } = require('../../ours/primordials')\nconst eos = require('./end-of-stream')\nconst { once } = require('../../ours/util')\nconst destroyImpl = require('./destroy')\nconst Duplex = require('./duplex')\nconst {\n  aggregateTwoErrors,\n  codes: {\n    ERR_INVALID_ARG_TYPE,\n    ERR_INVALID_RETURN_VALUE,\n    ERR_MISSING_ARGS,\n    ERR_STREAM_DESTROYED,\n    ERR_STREAM_PREMATURE_CLOSE\n  },\n  AbortError\n} = require('../../ours/errors')\nconst { validateFunction, validateAbortSignal } = require('../validators')\nconst { isIterable, isReadable, isReadableNodeStream, isNodeStream } = require('./utils')\nconst AbortController = globalThis.AbortController || require('abort-controller').AbortController\nlet PassThrough\nlet Readable\nfunction destroyer(stream, reading, writing) {\n  let finished = false\n  stream.on('close', () => {\n    finished = true\n  })\n  const cleanup = eos(\n    stream,\n    {\n      readable: reading,\n      writable: writing\n    },\n    (err) => {\n      finished = !err\n    }\n  )\n  return {\n    destroy: (err) => {\n      if (finished) return\n      finished = true\n      destroyImpl.destroyer(stream, err || new ERR_STREAM_DESTROYED('pipe'))\n    },\n    cleanup\n  }\n}\nfunction popCallback(streams) {\n  // Streams should never be an empty array. It should always contain at least\n  // a single stream. Therefore optimize for the average case instead of\n  // checking for length === 0 as well.\n  validateFunction(streams[streams.length - 1], 'streams[stream.length - 1]')\n  return streams.pop()\n}\nfunction makeAsyncIterable(val) {\n  if (isIterable(val)) {\n    return val\n  } else if (isReadableNodeStream(val)) {\n    // Legacy streams are not Iterable.\n    return fromReadable(val)\n  }\n  throw new ERR_INVALID_ARG_TYPE('val', ['Readable', 'Iterable', 'AsyncIterable'], val)\n}\nasync function* fromReadable(val) {\n  if (!Readable) {\n    Readable = require('./readable')\n  }\n  yield* Readable.prototype[SymbolAsyncIterator].call(val)\n}\nasync function pump(iterable, writable, finish, { end }) {\n  let error\n  let onresolve = null\n  const resume = (err) => {\n    if (err) {\n      error = err\n    }\n    if (onresolve) {\n      const callback = onresolve\n      onresolve = null\n      callback()\n    }\n  }\n  const wait = () =>\n    new Promise((resolve, reject) => {\n      if (error) {\n        reject(error)\n      } else {\n        onresolve = () => {\n          if (error) {\n            reject(error)\n          } else {\n            resolve()\n          }\n        }\n      }\n    })\n  writable.on('drain', resume)\n  const cleanup = eos(\n    writable,\n    {\n      readable: false\n    },\n    resume\n  )\n  try {\n    if (writable.writableNeedDrain) {\n      await wait()\n    }\n    for await (const chunk of iterable) {\n      if (!writable.write(chunk)) {\n        await wait()\n      }\n    }\n    if (end) {\n      writable.end()\n    }\n    await wait()\n    finish()\n  } catch (err) {\n    finish(error !== err ? aggregateTwoErrors(error, err) : err)\n  } finally {\n    cleanup()\n    writable.off('drain', resume)\n  }\n}\nfunction pipeline(...streams) {\n  return pipelineImpl(streams, once(popCallback(streams)))\n}\nfunction pipelineImpl(streams, callback, opts) {\n  if (streams.length === 1 && ArrayIsArray(streams[0])) {\n    streams = streams[0]\n  }\n  if (streams.length < 2) {\n    throw new ERR_MISSING_ARGS('streams')\n  }\n  const ac = new AbortController()\n  const signal = ac.signal\n  const outerSignal = opts === null || opts === undefined ? undefined : opts.signal\n\n  // Need to cleanup event listeners if last stream is readable\n  // https://github.com/nodejs/node/issues/35452\n  const lastStreamCleanup = []\n  validateAbortSignal(outerSignal, 'options.signal')\n  function abort() {\n    finishImpl(new AbortError())\n  }\n  outerSignal === null || outerSignal === undefined ? undefined : outerSignal.addEventListener('abort', abort)\n  let error\n  let value\n  const destroys = []\n  let finishCount = 0\n  function finish(err) {\n    finishImpl(err, --finishCount === 0)\n  }\n  function finishImpl(err, final) {\n    if (err && (!error || error.code === 'ERR_STREAM_PREMATURE_CLOSE')) {\n      error = err\n    }\n    if (!error && !final) {\n      return\n    }\n    while (destroys.length) {\n      destroys.shift()(error)\n    }\n    outerSignal === null || outerSignal === undefined ? undefined : outerSignal.removeEventListener('abort', abort)\n    ac.abort()\n    if (final) {\n      if (!error) {\n        lastStreamCleanup.forEach((fn) => fn())\n      }\n      process.nextTick(callback, error, value)\n    }\n  }\n  let ret\n  for (let i = 0; i < streams.length; i++) {\n    const stream = streams[i]\n    const reading = i < streams.length - 1\n    const writing = i > 0\n    const end = reading || (opts === null || opts === undefined ? undefined : opts.end) !== false\n    const isLastStream = i === streams.length - 1\n    if (isNodeStream(stream)) {\n      if (end) {\n        const { destroy, cleanup } = destroyer(stream, reading, writing)\n        destroys.push(destroy)\n        if (isReadable(stream) && isLastStream) {\n          lastStreamCleanup.push(cleanup)\n        }\n      }\n\n      // Catch stream errors that occur after pipe/pump has completed.\n      function onError(err) {\n        if (err && err.name !== 'AbortError' && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n          finish(err)\n        }\n      }\n      stream.on('error', onError)\n      if (isReadable(stream) && isLastStream) {\n        lastStreamCleanup.push(() => {\n          stream.removeListener('error', onError)\n        })\n      }\n    }\n    if (i === 0) {\n      if (typeof stream === 'function') {\n        ret = stream({\n          signal\n        })\n        if (!isIterable(ret)) {\n          throw new ERR_INVALID_RETURN_VALUE('Iterable, AsyncIterable or Stream', 'source', ret)\n        }\n      } else if (isIterable(stream) || isReadableNodeStream(stream)) {\n        ret = stream\n      } else {\n        ret = Duplex.from(stream)\n      }\n    } else if (typeof stream === 'function') {\n      ret = makeAsyncIterable(ret)\n      ret = stream(ret, {\n        signal\n      })\n      if (reading) {\n        if (!isIterable(ret, true)) {\n          throw new ERR_INVALID_RETURN_VALUE('AsyncIterable', `transform[${i - 1}]`, ret)\n        }\n      } else {\n        var _ret\n        if (!PassThrough) {\n          PassThrough = require('./passthrough')\n        }\n\n        // If the last argument to pipeline is not a stream\n        // we must create a proxy stream so that pipeline(...)\n        // always returns a stream which can be further\n        // composed through `.pipe(stream)`.\n\n        const pt = new PassThrough({\n          objectMode: true\n        })\n\n        // Handle Promises/A+ spec, `then` could be a getter that throws on\n        // second use.\n        const then = (_ret = ret) === null || _ret === undefined ? undefined : _ret.then\n        if (typeof then === 'function') {\n          finishCount++\n          then.call(\n            ret,\n            (val) => {\n              value = val\n              if (val != null) {\n                pt.write(val)\n              }\n              if (end) {\n                pt.end()\n              }\n              process.nextTick(finish)\n            },\n            (err) => {\n              pt.destroy(err)\n              process.nextTick(finish, err)\n            }\n          )\n        } else if (isIterable(ret, true)) {\n          finishCount++\n          pump(ret, pt, finish, {\n            end\n          })\n        } else {\n          throw new ERR_INVALID_RETURN_VALUE('AsyncIterable or Promise', 'destination', ret)\n        }\n        ret = pt\n        const { destroy, cleanup } = destroyer(ret, false, true)\n        destroys.push(destroy)\n        if (isLastStream) {\n          lastStreamCleanup.push(cleanup)\n        }\n      }\n    } else if (isNodeStream(stream)) {\n      if (isReadableNodeStream(ret)) {\n        finishCount += 2\n        const cleanup = pipe(ret, stream, finish, {\n          end\n        })\n        if (isReadable(stream) && isLastStream) {\n          lastStreamCleanup.push(cleanup)\n        }\n      } else if (isIterable(ret)) {\n        finishCount++\n        pump(ret, stream, finish, {\n          end\n        })\n      } else {\n        throw new ERR_INVALID_ARG_TYPE('val', ['Readable', 'Iterable', 'AsyncIterable'], ret)\n      }\n      ret = stream\n    } else {\n      ret = Duplex.from(stream)\n    }\n  }\n  if (\n    (signal !== null && signal !== undefined && signal.aborted) ||\n    (outerSignal !== null && outerSignal !== undefined && outerSignal.aborted)\n  ) {\n    process.nextTick(abort)\n  }\n  return ret\n}\nfunction pipe(src, dst, finish, { end }) {\n  let ended = false\n  dst.on('close', () => {\n    if (!ended) {\n      // Finish if the destination closes before the source has completed.\n      finish(new ERR_STREAM_PREMATURE_CLOSE())\n    }\n  })\n  src.pipe(dst, {\n    end\n  })\n  if (end) {\n    // Compat. Before node v10.12.0 stdio used to throw an error so\n    // pipe() did/does not end() stdio destinations.\n    // Now they allow it but \"secretly\" don't close the underlying fd.\n    src.once('end', () => {\n      ended = true\n      dst.end()\n    })\n  } else {\n    finish()\n  }\n  eos(\n    src,\n    {\n      readable: true,\n      writable: false\n    },\n    (err) => {\n      const rState = src._readableState\n      if (\n        err &&\n        err.code === 'ERR_STREAM_PREMATURE_CLOSE' &&\n        rState &&\n        rState.ended &&\n        !rState.errored &&\n        !rState.errorEmitted\n      ) {\n        // Some readable streams will emit 'close' before 'end'. However, since\n        // this is on the readable side 'end' should still be emitted if the\n        // stream has been ended and no error emitted. This should be allowed in\n        // favor of backwards compatibility. Since the stream is piped to a\n        // destination this should not result in any observable difference.\n        // We don't need to check if this is a writable premature close since\n        // eos will only fail with premature close on the reading side for\n        // duplex streams.\n        src.once('end', finish).once('error', finish)\n      } else {\n        finish(err)\n      }\n    }\n  )\n  return eos(\n    dst,\n    {\n      readable: false,\n      writable: true\n    },\n    finish\n  )\n}\nmodule.exports = {\n  pipelineImpl,\n  pipeline\n}\n","'use strict'\n\nconst { pipeline } = require('./pipeline')\nconst Duplex = require('./duplex')\nconst { destroyer } = require('./destroy')\nconst { isNodeStream, isReadable, isWritable } = require('./utils')\nconst {\n  AbortError,\n  codes: { ERR_INVALID_ARG_VALUE, ERR_MISSING_ARGS }\n} = require('../../ours/errors')\nmodule.exports = function compose(...streams) {\n  if (streams.length === 0) {\n    throw new ERR_MISSING_ARGS('streams')\n  }\n  if (streams.length === 1) {\n    return Duplex.from(streams[0])\n  }\n  const orgStreams = [...streams]\n  if (typeof streams[0] === 'function') {\n    streams[0] = Duplex.from(streams[0])\n  }\n  if (typeof streams[streams.length - 1] === 'function') {\n    const idx = streams.length - 1\n    streams[idx] = Duplex.from(streams[idx])\n  }\n  for (let n = 0; n < streams.length; ++n) {\n    if (!isNodeStream(streams[n])) {\n      // TODO(ronag): Add checks for non streams.\n      continue\n    }\n    if (n < streams.length - 1 && !isReadable(streams[n])) {\n      throw new ERR_INVALID_ARG_VALUE(`streams[${n}]`, orgStreams[n], 'must be readable')\n    }\n    if (n > 0 && !isWritable(streams[n])) {\n      throw new ERR_INVALID_ARG_VALUE(`streams[${n}]`, orgStreams[n], 'must be writable')\n    }\n  }\n  let ondrain\n  let onfinish\n  let onreadable\n  let onclose\n  let d\n  function onfinished(err) {\n    const cb = onclose\n    onclose = null\n    if (cb) {\n      cb(err)\n    } else if (err) {\n      d.destroy(err)\n    } else if (!readable && !writable) {\n      d.destroy()\n    }\n  }\n  const head = streams[0]\n  const tail = pipeline(streams, onfinished)\n  const writable = !!isWritable(head)\n  const readable = !!isReadable(tail)\n\n  // TODO(ronag): Avoid double buffering.\n  // Implement Writable/Readable/Duplex traits.\n  // See, https://github.com/nodejs/node/pull/33515.\n  d = new Duplex({\n    // TODO (ronag): highWaterMark?\n    writableObjectMode: !!(head !== null && head !== undefined && head.writableObjectMode),\n    readableObjectMode: !!(tail !== null && tail !== undefined && tail.writableObjectMode),\n    writable,\n    readable\n  })\n  if (writable) {\n    d._write = function (chunk, encoding, callback) {\n      if (head.write(chunk, encoding)) {\n        callback()\n      } else {\n        ondrain = callback\n      }\n    }\n    d._final = function (callback) {\n      head.end()\n      onfinish = callback\n    }\n    head.on('drain', function () {\n      if (ondrain) {\n        const cb = ondrain\n        ondrain = null\n        cb()\n      }\n    })\n    tail.on('finish', function () {\n      if (onfinish) {\n        const cb = onfinish\n        onfinish = null\n        cb()\n      }\n    })\n  }\n  if (readable) {\n    tail.on('readable', function () {\n      if (onreadable) {\n        const cb = onreadable\n        onreadable = null\n        cb()\n      }\n    })\n    tail.on('end', function () {\n      d.push(null)\n    })\n    d._read = function () {\n      while (true) {\n        const buf = tail.read()\n        if (buf === null) {\n          onreadable = d._read\n          return\n        }\n        if (!d.push(buf)) {\n          return\n        }\n      }\n    }\n  }\n  d._destroy = function (err, callback) {\n    if (!err && onclose !== null) {\n      err = new AbortError()\n    }\n    onreadable = null\n    ondrain = null\n    onfinish = null\n    if (onclose === null) {\n      callback(err)\n    } else {\n      onclose = callback\n      destroyer(tail, err)\n    }\n  }\n  return d\n}\n","'use strict'\n\nconst { ArrayPrototypePop, Promise } = require('../ours/primordials')\nconst { isIterable, isNodeStream } = require('../internal/streams/utils')\nconst { pipelineImpl: pl } = require('../internal/streams/pipeline')\nconst { finished } = require('../internal/streams/end-of-stream')\nfunction pipeline(...streams) {\n  return new Promise((resolve, reject) => {\n    let signal\n    let end\n    const lastArg = streams[streams.length - 1]\n    if (lastArg && typeof lastArg === 'object' && !isNodeStream(lastArg) && !isIterable(lastArg)) {\n      const options = ArrayPrototypePop(streams)\n      signal = options.signal\n      end = options.end\n    }\n    pl(\n      streams,\n      (err, value) => {\n        if (err) {\n          reject(err)\n        } else {\n          resolve(value)\n        }\n      },\n      {\n        signal,\n        end\n      }\n    )\n  })\n}\nmodule.exports = {\n  finished,\n  pipeline\n}\n","/* replacement start */\n\nconst { Buffer } = require('buffer')\n\n/* replacement end */\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n;('use strict')\nconst { ObjectDefineProperty, ObjectKeys, ReflectApply } = require('./ours/primordials')\nconst {\n  promisify: { custom: customPromisify }\n} = require('./ours/util')\nconst { streamReturningOperators, promiseReturningOperators } = require('./internal/streams/operators')\nconst {\n  codes: { ERR_ILLEGAL_CONSTRUCTOR }\n} = require('./ours/errors')\nconst compose = require('./internal/streams/compose')\nconst { pipeline } = require('./internal/streams/pipeline')\nconst { destroyer } = require('./internal/streams/destroy')\nconst eos = require('./internal/streams/end-of-stream')\nconst internalBuffer = {}\nconst promises = require('./stream/promises')\nconst utils = require('./internal/streams/utils')\nconst Stream = (module.exports = require('./internal/streams/legacy').Stream)\nStream.isDisturbed = utils.isDisturbed\nStream.isErrored = utils.isErrored\nStream.isReadable = utils.isReadable\nStream.Readable = require('./internal/streams/readable')\nfor (const key of ObjectKeys(streamReturningOperators)) {\n  const op = streamReturningOperators[key]\n  function fn(...args) {\n    if (new.target) {\n      throw ERR_ILLEGAL_CONSTRUCTOR()\n    }\n    return Stream.Readable.from(ReflectApply(op, this, args))\n  }\n  ObjectDefineProperty(fn, 'name', {\n    __proto__: null,\n    value: op.name\n  })\n  ObjectDefineProperty(fn, 'length', {\n    __proto__: null,\n    value: op.length\n  })\n  ObjectDefineProperty(Stream.Readable.prototype, key, {\n    __proto__: null,\n    value: fn,\n    enumerable: false,\n    configurable: true,\n    writable: true\n  })\n}\nfor (const key of ObjectKeys(promiseReturningOperators)) {\n  const op = promiseReturningOperators[key]\n  function fn(...args) {\n    if (new.target) {\n      throw ERR_ILLEGAL_CONSTRUCTOR()\n    }\n    return ReflectApply(op, this, args)\n  }\n  ObjectDefineProperty(fn, 'name', {\n    __proto__: null,\n    value: op.name\n  })\n  ObjectDefineProperty(fn, 'length', {\n    __proto__: null,\n    value: op.length\n  })\n  ObjectDefineProperty(Stream.Readable.prototype, key, {\n    __proto__: null,\n    value: fn,\n    enumerable: false,\n    configurable: true,\n    writable: true\n  })\n}\nStream.Writable = require('./internal/streams/writable')\nStream.Duplex = require('./internal/streams/duplex')\nStream.Transform = require('./internal/streams/transform')\nStream.PassThrough = require('./internal/streams/passthrough')\nStream.pipeline = pipeline\nconst { addAbortSignal } = require('./internal/streams/add-abort-signal')\nStream.addAbortSignal = addAbortSignal\nStream.finished = eos\nStream.destroy = destroyer\nStream.compose = compose\nObjectDefineProperty(Stream, 'promises', {\n  __proto__: null,\n  configurable: true,\n  enumerable: true,\n  get() {\n    return promises\n  }\n})\nObjectDefineProperty(pipeline, customPromisify, {\n  __proto__: null,\n  enumerable: true,\n  get() {\n    return promises.pipeline\n  }\n})\nObjectDefineProperty(eos, customPromisify, {\n  __proto__: null,\n  enumerable: true,\n  get() {\n    return promises.finished\n  }\n})\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream\nStream._isUint8Array = function isUint8Array(value) {\n  return value instanceof Uint8Array\n}\nStream._uint8ArrayToBuffer = function _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength)\n}\n","'use strict'\n\nconst Stream = require('stream')\nif (Stream && process.env.READABLE_STREAM === 'disable') {\n  const promises = Stream.promises\n\n  // Explicit export naming is needed for ESM\n  module.exports._uint8ArrayToBuffer = Stream._uint8ArrayToBuffer\n  module.exports._isUint8Array = Stream._isUint8Array\n  module.exports.isDisturbed = Stream.isDisturbed\n  module.exports.isErrored = Stream.isErrored\n  module.exports.isReadable = Stream.isReadable\n  module.exports.Readable = Stream.Readable\n  module.exports.Writable = Stream.Writable\n  module.exports.Duplex = Stream.Duplex\n  module.exports.Transform = Stream.Transform\n  module.exports.PassThrough = Stream.PassThrough\n  module.exports.addAbortSignal = Stream.addAbortSignal\n  module.exports.finished = Stream.finished\n  module.exports.destroy = Stream.destroy\n  module.exports.pipeline = Stream.pipeline\n  module.exports.compose = Stream.compose\n  Object.defineProperty(Stream, 'promises', {\n    configurable: true,\n    enumerable: true,\n    get() {\n      return promises\n    }\n  })\n  module.exports.Stream = Stream.Stream\n} else {\n  const CustomStream = require('../stream')\n  const promises = require('../stream/promises')\n  const originalDestroy = CustomStream.Readable.destroy\n  module.exports = CustomStream.Readable\n\n  // Explicit export naming is needed for ESM\n  module.exports._uint8ArrayToBuffer = CustomStream._uint8ArrayToBuffer\n  module.exports._isUint8Array = CustomStream._isUint8Array\n  module.exports.isDisturbed = CustomStream.isDisturbed\n  module.exports.isErrored = CustomStream.isErrored\n  module.exports.isReadable = CustomStream.isReadable\n  module.exports.Readable = CustomStream.Readable\n  module.exports.Writable = CustomStream.Writable\n  module.exports.Duplex = CustomStream.Duplex\n  module.exports.Transform = CustomStream.Transform\n  module.exports.PassThrough = CustomStream.PassThrough\n  module.exports.addAbortSignal = CustomStream.addAbortSignal\n  module.exports.finished = CustomStream.finished\n  module.exports.destroy = CustomStream.destroy\n  module.exports.destroy = originalDestroy\n  module.exports.pipeline = CustomStream.pipeline\n  module.exports.compose = CustomStream.compose\n  Object.defineProperty(CustomStream, 'promises', {\n    configurable: true,\n    enumerable: true,\n    get() {\n      return promises\n    }\n  })\n  module.exports.Stream = CustomStream.Stream\n}\n\n// Allow default importing\nmodule.exports.default = module.exports\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      ctor.prototype = Object.create(superCtor.prototype, {\n        constructor: {\n          value: ctor,\n          enumerable: false,\n          writable: true,\n          configurable: true\n        }\n      })\n    }\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    if (superCtor) {\n      ctor.super_ = superCtor\n      var TempCtor = function () {}\n      TempCtor.prototype = superCtor.prototype\n      ctor.prototype = new TempCtor()\n      ctor.prototype.constructor = ctor\n    }\n  }\n}\n","try {\n  var util = require('util');\n  /* istanbul ignore next */\n  if (typeof util.inherits !== 'function') throw '';\n  module.exports = util.inherits;\n} catch (e) {\n  /* istanbul ignore next */\n  module.exports = require('./inherits_browser.js');\n}\n","'use strict'\n\nconst { Buffer } = require('buffer')\nconst symbol = Symbol.for('BufferList')\n\nfunction BufferList (buf) {\n  if (!(this instanceof BufferList)) {\n    return new BufferList(buf)\n  }\n\n  BufferList._init.call(this, buf)\n}\n\nBufferList._init = function _init (buf) {\n  Object.defineProperty(this, symbol, { value: true })\n\n  this._bufs = []\n  this.length = 0\n\n  if (buf) {\n    this.append(buf)\n  }\n}\n\nBufferList.prototype._new = function _new (buf) {\n  return new BufferList(buf)\n}\n\nBufferList.prototype._offset = function _offset (offset) {\n  if (offset === 0) {\n    return [0, 0]\n  }\n\n  let tot = 0\n\n  for (let i = 0; i < this._bufs.length; i++) {\n    const _t = tot + this._bufs[i].length\n    if (offset < _t || i === this._bufs.length - 1) {\n      return [i, offset - tot]\n    }\n    tot = _t\n  }\n}\n\nBufferList.prototype._reverseOffset = function (blOffset) {\n  const bufferId = blOffset[0]\n  let offset = blOffset[1]\n\n  for (let i = 0; i < bufferId; i++) {\n    offset += this._bufs[i].length\n  }\n\n  return offset\n}\n\nBufferList.prototype.get = function get (index) {\n  if (index > this.length || index < 0) {\n    return undefined\n  }\n\n  const offset = this._offset(index)\n\n  return this._bufs[offset[0]][offset[1]]\n}\n\nBufferList.prototype.slice = function slice (start, end) {\n  if (typeof start === 'number' && start < 0) {\n    start += this.length\n  }\n\n  if (typeof end === 'number' && end < 0) {\n    end += this.length\n  }\n\n  return this.copy(null, 0, start, end)\n}\n\nBufferList.prototype.copy = function copy (dst, dstStart, srcStart, srcEnd) {\n  if (typeof srcStart !== 'number' || srcStart < 0) {\n    srcStart = 0\n  }\n\n  if (typeof srcEnd !== 'number' || srcEnd > this.length) {\n    srcEnd = this.length\n  }\n\n  if (srcStart >= this.length) {\n    return dst || Buffer.alloc(0)\n  }\n\n  if (srcEnd <= 0) {\n    return dst || Buffer.alloc(0)\n  }\n\n  const copy = !!dst\n  const off = this._offset(srcStart)\n  const len = srcEnd - srcStart\n  let bytes = len\n  let bufoff = (copy && dstStart) || 0\n  let start = off[1]\n\n  // copy/slice everything\n  if (srcStart === 0 && srcEnd === this.length) {\n    if (!copy) {\n      // slice, but full concat if multiple buffers\n      return this._bufs.length === 1\n        ? this._bufs[0]\n        : Buffer.concat(this._bufs, this.length)\n    }\n\n    // copy, need to copy individual buffers\n    for (let i = 0; i < this._bufs.length; i++) {\n      this._bufs[i].copy(dst, bufoff)\n      bufoff += this._bufs[i].length\n    }\n\n    return dst\n  }\n\n  // easy, cheap case where it's a subset of one of the buffers\n  if (bytes <= this._bufs[off[0]].length - start) {\n    return copy\n      ? this._bufs[off[0]].copy(dst, dstStart, start, start + bytes)\n      : this._bufs[off[0]].slice(start, start + bytes)\n  }\n\n  if (!copy) {\n    // a slice, we need something to copy in to\n    dst = Buffer.allocUnsafe(len)\n  }\n\n  for (let i = off[0]; i < this._bufs.length; i++) {\n    const l = this._bufs[i].length - start\n\n    if (bytes > l) {\n      this._bufs[i].copy(dst, bufoff, start)\n      bufoff += l\n    } else {\n      this._bufs[i].copy(dst, bufoff, start, start + bytes)\n      bufoff += l\n      break\n    }\n\n    bytes -= l\n\n    if (start) {\n      start = 0\n    }\n  }\n\n  // safeguard so that we don't return uninitialized memory\n  if (dst.length > bufoff) return dst.slice(0, bufoff)\n\n  return dst\n}\n\nBufferList.prototype.shallowSlice = function shallowSlice (start, end) {\n  start = start || 0\n  end = typeof end !== 'number' ? this.length : end\n\n  if (start < 0) {\n    start += this.length\n  }\n\n  if (end < 0) {\n    end += this.length\n  }\n\n  if (start === end) {\n    return this._new()\n  }\n\n  const startOffset = this._offset(start)\n  const endOffset = this._offset(end)\n  const buffers = this._bufs.slice(startOffset[0], endOffset[0] + 1)\n\n  if (endOffset[1] === 0) {\n    buffers.pop()\n  } else {\n    buffers[buffers.length - 1] = buffers[buffers.length - 1].slice(0, endOffset[1])\n  }\n\n  if (startOffset[1] !== 0) {\n    buffers[0] = buffers[0].slice(startOffset[1])\n  }\n\n  return this._new(buffers)\n}\n\nBufferList.prototype.toString = function toString (encoding, start, end) {\n  return this.slice(start, end).toString(encoding)\n}\n\nBufferList.prototype.consume = function consume (bytes) {\n  // first, normalize the argument, in accordance with how Buffer does it\n  bytes = Math.trunc(bytes)\n  // do nothing if not a positive number\n  if (Number.isNaN(bytes) || bytes <= 0) return this\n\n  while (this._bufs.length) {\n    if (bytes >= this._bufs[0].length) {\n      bytes -= this._bufs[0].length\n      this.length -= this._bufs[0].length\n      this._bufs.shift()\n    } else {\n      this._bufs[0] = this._bufs[0].slice(bytes)\n      this.length -= bytes\n      break\n    }\n  }\n\n  return this\n}\n\nBufferList.prototype.duplicate = function duplicate () {\n  const copy = this._new()\n\n  for (let i = 0; i < this._bufs.length; i++) {\n    copy.append(this._bufs[i])\n  }\n\n  return copy\n}\n\nBufferList.prototype.append = function append (buf) {\n  if (buf == null) {\n    return this\n  }\n\n  if (buf.buffer) {\n    // append a view of the underlying ArrayBuffer\n    this._appendBuffer(Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength))\n  } else if (Array.isArray(buf)) {\n    for (let i = 0; i < buf.length; i++) {\n      this.append(buf[i])\n    }\n  } else if (this._isBufferList(buf)) {\n    // unwrap argument into individual BufferLists\n    for (let i = 0; i < buf._bufs.length; i++) {\n      this.append(buf._bufs[i])\n    }\n  } else {\n    // coerce number arguments to strings, since Buffer(number) does\n    // uninitialized memory allocation\n    if (typeof buf === 'number') {\n      buf = buf.toString()\n    }\n\n    this._appendBuffer(Buffer.from(buf))\n  }\n\n  return this\n}\n\nBufferList.prototype._appendBuffer = function appendBuffer (buf) {\n  this._bufs.push(buf)\n  this.length += buf.length\n}\n\nBufferList.prototype.indexOf = function (search, offset, encoding) {\n  if (encoding === undefined && typeof offset === 'string') {\n    encoding = offset\n    offset = undefined\n  }\n\n  if (typeof search === 'function' || Array.isArray(search)) {\n    throw new TypeError('The \"value\" argument must be one of type string, Buffer, BufferList, or Uint8Array.')\n  } else if (typeof search === 'number') {\n    search = Buffer.from([search])\n  } else if (typeof search === 'string') {\n    search = Buffer.from(search, encoding)\n  } else if (this._isBufferList(search)) {\n    search = search.slice()\n  } else if (Array.isArray(search.buffer)) {\n    search = Buffer.from(search.buffer, search.byteOffset, search.byteLength)\n  } else if (!Buffer.isBuffer(search)) {\n    search = Buffer.from(search)\n  }\n\n  offset = Number(offset || 0)\n\n  if (isNaN(offset)) {\n    offset = 0\n  }\n\n  if (offset < 0) {\n    offset = this.length + offset\n  }\n\n  if (offset < 0) {\n    offset = 0\n  }\n\n  if (search.length === 0) {\n    return offset > this.length ? this.length : offset\n  }\n\n  const blOffset = this._offset(offset)\n  let blIndex = blOffset[0] // index of which internal buffer we're working on\n  let buffOffset = blOffset[1] // offset of the internal buffer we're working on\n\n  // scan over each buffer\n  for (; blIndex < this._bufs.length; blIndex++) {\n    const buff = this._bufs[blIndex]\n\n    while (buffOffset < buff.length) {\n      const availableWindow = buff.length - buffOffset\n\n      if (availableWindow >= search.length) {\n        const nativeSearchResult = buff.indexOf(search, buffOffset)\n\n        if (nativeSearchResult !== -1) {\n          return this._reverseOffset([blIndex, nativeSearchResult])\n        }\n\n        buffOffset = buff.length - search.length + 1 // end of native search window\n      } else {\n        const revOffset = this._reverseOffset([blIndex, buffOffset])\n\n        if (this._match(revOffset, search)) {\n          return revOffset\n        }\n\n        buffOffset++\n      }\n    }\n\n    buffOffset = 0\n  }\n\n  return -1\n}\n\nBufferList.prototype._match = function (offset, search) {\n  if (this.length - offset < search.length) {\n    return false\n  }\n\n  for (let searchOffset = 0; searchOffset < search.length; searchOffset++) {\n    if (this.get(offset + searchOffset) !== search[searchOffset]) {\n      return false\n    }\n  }\n  return true\n}\n\n;(function () {\n  const methods = {\n    readDoubleBE: 8,\n    readDoubleLE: 8,\n    readFloatBE: 4,\n    readFloatLE: 4,\n    readBigInt64BE: 8,\n    readBigInt64LE: 8,\n    readBigUInt64BE: 8,\n    readBigUInt64LE: 8,\n    readInt32BE: 4,\n    readInt32LE: 4,\n    readUInt32BE: 4,\n    readUInt32LE: 4,\n    readInt16BE: 2,\n    readInt16LE: 2,\n    readUInt16BE: 2,\n    readUInt16LE: 2,\n    readInt8: 1,\n    readUInt8: 1,\n    readIntBE: null,\n    readIntLE: null,\n    readUIntBE: null,\n    readUIntLE: null\n  }\n\n  for (const m in methods) {\n    (function (m) {\n      if (methods[m] === null) {\n        BufferList.prototype[m] = function (offset, byteLength) {\n          return this.slice(offset, offset + byteLength)[m](0, byteLength)\n        }\n      } else {\n        BufferList.prototype[m] = function (offset = 0) {\n          return this.slice(offset, offset + methods[m])[m](0)\n        }\n      }\n    }(m))\n  }\n}())\n\n// Used internally by the class and also as an indicator of this object being\n// a `BufferList`. It's not possible to use `instanceof BufferList` in a browser\n// environment because there could be multiple different copies of the\n// BufferList class and some `BufferList`s might be `BufferList`s.\nBufferList.prototype._isBufferList = function _isBufferList (b) {\n  return b instanceof BufferList || BufferList.isBufferList(b)\n}\n\nBufferList.isBufferList = function isBufferList (b) {\n  return b != null && b[symbol]\n}\n\nmodule.exports = BufferList\n","'use strict'\n\nconst DuplexStream = require('readable-stream').Duplex\nconst inherits = require('inherits')\nconst BufferList = require('./BufferList')\n\nfunction BufferListStream (callback) {\n  if (!(this instanceof BufferListStream)) {\n    return new BufferListStream(callback)\n  }\n\n  if (typeof callback === 'function') {\n    this._callback = callback\n\n    const piper = function piper (err) {\n      if (this._callback) {\n        this._callback(err)\n        this._callback = null\n      }\n    }.bind(this)\n\n    this.on('pipe', function onPipe (src) {\n      src.on('error', piper)\n    })\n    this.on('unpipe', function onUnpipe (src) {\n      src.removeListener('error', piper)\n    })\n\n    callback = null\n  }\n\n  BufferList._init.call(this, callback)\n  DuplexStream.call(this)\n}\n\ninherits(BufferListStream, DuplexStream)\nObject.assign(BufferListStream.prototype, BufferList.prototype)\n\nBufferListStream.prototype._new = function _new (callback) {\n  return new BufferListStream(callback)\n}\n\nBufferListStream.prototype._write = function _write (buf, encoding, callback) {\n  this._appendBuffer(buf)\n\n  if (typeof callback === 'function') {\n    callback()\n  }\n}\n\nBufferListStream.prototype._read = function _read (size) {\n  if (!this.length) {\n    return this.push(null)\n  }\n\n  size = Math.min(size, this.length)\n  this.push(this.slice(0, size))\n  this.consume(size)\n}\n\nBufferListStream.prototype.end = function end (chunk) {\n  DuplexStream.prototype.end.call(this, chunk)\n\n  if (this._callback) {\n    this._callback(null, this.slice())\n    this._callback = null\n  }\n}\n\nBufferListStream.prototype._destroy = function _destroy (err, cb) {\n  this._bufs.length = 0\n  this.length = 0\n  cb(err)\n}\n\nBufferListStream.prototype._isBufferList = function _isBufferList (b) {\n  return b instanceof BufferListStream || b instanceof BufferList || BufferListStream.isBufferList(b)\n}\n\nBufferListStream.isBufferList = BufferList.isBufferList\n\nmodule.exports = BufferListStream\nmodule.exports.BufferListStream = BufferListStream\nmodule.exports.BufferList = BufferList\n","module.exports = typeof queueMicrotask === 'function' ? queueMicrotask : (fn) => Promise.resolve().then(fn)\n","module.exports = (typeof process !== 'undefined' && typeof process.nextTick === 'function')\n  ? process.nextTick.bind(process)\n  : require('./queue-microtask')\n","module.exports = class FixedFIFO {\n  constructor (hwm) {\n    if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) throw new Error('Max size for a FixedFIFO should be a power of two')\n    this.buffer = new Array(hwm)\n    this.mask = hwm - 1\n    this.top = 0\n    this.btm = 0\n    this.next = null\n  }\n\n  push (data) {\n    if (this.buffer[this.top] !== undefined) return false\n    this.buffer[this.top] = data\n    this.top = (this.top + 1) & this.mask\n    return true\n  }\n\n  shift () {\n    const last = this.buffer[this.btm]\n    if (last === undefined) return undefined\n    this.buffer[this.btm] = undefined\n    this.btm = (this.btm + 1) & this.mask\n    return last\n  }\n\n  peek () {\n    return this.buffer[this.btm]\n  }\n\n  isEmpty () {\n    return this.buffer[this.btm] === undefined\n  }\n}\n","const FixedFIFO = require('./fixed-size')\n\nmodule.exports = class FastFIFO {\n  constructor (hwm) {\n    this.hwm = hwm || 16\n    this.head = new FixedFIFO(this.hwm)\n    this.tail = this.head\n  }\n\n  push (val) {\n    if (!this.head.push(val)) {\n      const prev = this.head\n      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length)\n      this.head.push(val)\n    }\n  }\n\n  shift () {\n    const val = this.tail.shift()\n    if (val === undefined && this.tail.next) {\n      const next = this.tail.next\n      this.tail.next = null\n      this.tail = next\n      return this.tail.shift()\n    }\n    return val\n  }\n\n  peek () {\n    return this.tail.peek()\n  }\n\n  isEmpty () {\n    return this.head.isEmpty()\n  }\n}\n","const { EventEmitter } = require('events')\nconst STREAM_DESTROYED = new Error('Stream was destroyed')\nconst PREMATURE_CLOSE = new Error('Premature close')\n\nconst queueTick = require('queue-tick')\nconst FIFO = require('fast-fifo')\n\n/* eslint-disable no-multi-spaces */\n\n// 26 bits used total (4 from shared, 13 from read, and 9 from write)\nconst MAX = ((1 << 26) - 1)\n\n// Shared state\nconst OPENING       = 0b0001\nconst PREDESTROYING = 0b0010\nconst DESTROYING    = 0b0100\nconst DESTROYED     = 0b1000\n\nconst NOT_OPENING = MAX ^ OPENING\nconst NOT_PREDESTROYING = MAX ^ PREDESTROYING\n\n// Read state (4 bit offset from shared state)\nconst READ_ACTIVE           = 0b0000000000001 << 4\nconst READ_PRIMARY          = 0b0000000000010 << 4\nconst READ_SYNC             = 0b0000000000100 << 4\nconst READ_QUEUED           = 0b0000000001000 << 4\nconst READ_RESUMED          = 0b0000000010000 << 4\nconst READ_PIPE_DRAINED     = 0b0000000100000 << 4\nconst READ_ENDING           = 0b0000001000000 << 4\nconst READ_EMIT_DATA        = 0b0000010000000 << 4\nconst READ_EMIT_READABLE    = 0b0000100000000 << 4\nconst READ_EMITTED_READABLE = 0b0001000000000 << 4\nconst READ_DONE             = 0b0010000000000 << 4\nconst READ_NEXT_TICK        = 0b0100000000001 << 4 // also active\nconst READ_NEEDS_PUSH       = 0b1000000000000 << 4\n\n// Combined read state\nconst READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED\nconst READ_ACTIVE_AND_SYNC = READ_ACTIVE | READ_SYNC\nconst READ_ACTIVE_AND_SYNC_AND_NEEDS_PUSH = READ_ACTIVE | READ_SYNC | READ_NEEDS_PUSH\nconst READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE\nconst READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED\n\nconst READ_NOT_ACTIVE             = MAX ^ READ_ACTIVE\nconst READ_NON_PRIMARY            = MAX ^ READ_PRIMARY\nconst READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH)\nconst READ_NOT_SYNC               = MAX ^ READ_SYNC\nconst READ_PUSHED                 = MAX ^ READ_NEEDS_PUSH\nconst READ_PAUSED                 = MAX ^ READ_RESUMED\nconst READ_NOT_QUEUED             = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE)\nconst READ_NOT_ENDING             = MAX ^ READ_ENDING\nconst READ_PIPE_NOT_DRAINED       = MAX ^ READ_FLOWING\nconst READ_NOT_NEXT_TICK          = MAX ^ READ_NEXT_TICK\n\n// Write state (17 bit offset, 4 bit offset from shared state and 13 from read state)\nconst WRITE_ACTIVE     = 0b000000001 << 17\nconst WRITE_PRIMARY    = 0b000000010 << 17\nconst WRITE_SYNC       = 0b000000100 << 17\nconst WRITE_QUEUED     = 0b000001000 << 17\nconst WRITE_UNDRAINED  = 0b000010000 << 17\nconst WRITE_DONE       = 0b000100000 << 17\nconst WRITE_EMIT_DRAIN = 0b001000000 << 17\nconst WRITE_NEXT_TICK  = 0b010000001 << 17 // also active\nconst WRITE_FINISHING  = 0b100000000 << 17\n\nconst WRITE_NOT_ACTIVE    = MAX ^ WRITE_ACTIVE\nconst WRITE_NOT_SYNC      = MAX ^ WRITE_SYNC\nconst WRITE_NON_PRIMARY   = MAX ^ WRITE_PRIMARY\nconst WRITE_NOT_FINISHING = MAX ^ WRITE_FINISHING\nconst WRITE_DRAINED       = MAX ^ WRITE_UNDRAINED\nconst WRITE_NOT_QUEUED    = MAX ^ WRITE_QUEUED\nconst WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK\n\n// Combined shared state\nconst ACTIVE = READ_ACTIVE | WRITE_ACTIVE\nconst NOT_ACTIVE = MAX ^ ACTIVE\nconst DONE = READ_DONE | WRITE_DONE\nconst DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING\nconst OPEN_STATUS = DESTROY_STATUS | OPENING\nconst AUTO_DESTROY = DESTROY_STATUS | DONE\nconst NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY\nconst ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK\nconst TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE\nconst IS_OPENING = OPEN_STATUS | TICKING\n\n// Combined shared state and read state\nconst READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE\nconst READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED\nconst READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED\nconst READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE\nconst SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH\nconst READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE\n\n// Combined write state\nconst WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE\nconst WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED\nconst WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE\nconst WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE\nconst WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED\nconst WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE\nconst WRITE_ACTIVE_AND_SYNC = WRITE_ACTIVE | WRITE_SYNC\nconst WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE\nconst WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE\n\nconst asyncIterator = Symbol.asyncIterator || Symbol('asyncIterator')\n\nclass WritableState {\n  constructor (stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {\n    this.stream = stream\n    this.queue = new FIFO()\n    this.highWaterMark = highWaterMark\n    this.buffered = 0\n    this.error = null\n    this.pipeline = null\n    this.byteLength = byteLengthWritable || byteLength || defaultByteLength\n    this.map = mapWritable || map\n    this.afterWrite = afterWrite.bind(this)\n    this.afterUpdateNextTick = updateWriteNT.bind(this)\n  }\n\n  get ended () {\n    return (this.stream._duplexState & WRITE_DONE) !== 0\n  }\n\n  push (data) {\n    if (this.map !== null) data = this.map(data)\n\n    this.buffered += this.byteLength(data)\n    this.queue.push(data)\n\n    if (this.buffered < this.highWaterMark) {\n      this.stream._duplexState |= WRITE_QUEUED\n      return true\n    }\n\n    this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED\n    return false\n  }\n\n  shift () {\n    const data = this.queue.shift()\n    const stream = this.stream\n\n    this.buffered -= this.byteLength(data)\n    if (this.buffered === 0) stream._duplexState &= WRITE_NOT_QUEUED\n\n    return data\n  }\n\n  end (data) {\n    if (typeof data === 'function') this.stream.once('finish', data)\n    else if (data !== undefined && data !== null) this.push(data)\n    this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY\n  }\n\n  autoBatch (data, cb) {\n    const buffer = []\n    const stream = this.stream\n\n    buffer.push(data)\n    while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {\n      buffer.push(stream._writableState.shift())\n    }\n\n    if ((stream._duplexState & OPEN_STATUS) !== 0) return cb(null)\n    stream._writev(buffer, cb)\n  }\n\n  update () {\n    const stream = this.stream\n\n    while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {\n      const data = this.shift()\n      stream._duplexState |= WRITE_ACTIVE_AND_SYNC\n      stream._write(data, this.afterWrite)\n      stream._duplexState &= WRITE_NOT_SYNC\n    }\n\n    if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()\n  }\n\n  updateNonPrimary () {\n    const stream = this.stream\n\n    if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {\n      stream._duplexState = (stream._duplexState | WRITE_ACTIVE) & WRITE_NOT_FINISHING\n      stream._final(afterFinal.bind(this))\n      return\n    }\n\n    if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {\n      if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {\n        stream._duplexState |= ACTIVE\n        stream._destroy(afterDestroy.bind(this))\n      }\n      return\n    }\n\n    if ((stream._duplexState & IS_OPENING) === OPENING) {\n      stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING\n      stream._open(afterOpen.bind(this))\n    }\n  }\n\n  updateNextTick () {\n    if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return\n    this.stream._duplexState |= WRITE_NEXT_TICK\n    queueTick(this.afterUpdateNextTick)\n  }\n}\n\nclass ReadableState {\n  constructor (stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {\n    this.stream = stream\n    this.queue = new FIFO()\n    this.highWaterMark = highWaterMark\n    this.buffered = 0\n    this.error = null\n    this.pipeline = null\n    this.byteLength = byteLengthReadable || byteLength || defaultByteLength\n    this.map = mapReadable || map\n    this.pipeTo = null\n    this.afterRead = afterRead.bind(this)\n    this.afterUpdateNextTick = updateReadNT.bind(this)\n  }\n\n  get ended () {\n    return (this.stream._duplexState & READ_DONE) !== 0\n  }\n\n  pipe (pipeTo, cb) {\n    if (this.pipeTo !== null) throw new Error('Can only pipe to one destination')\n    if (typeof cb !== 'function') cb = null\n\n    this.stream._duplexState |= READ_PIPE_DRAINED\n    this.pipeTo = pipeTo\n    this.pipeline = new Pipeline(this.stream, pipeTo, cb)\n\n    if (cb) this.stream.on('error', noop) // We already error handle this so supress crashes\n\n    if (isStreamx(pipeTo)) {\n      pipeTo._writableState.pipeline = this.pipeline\n      if (cb) pipeTo.on('error', noop) // We already error handle this so supress crashes\n      pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline)) // TODO: just call finished from pipeTo itself\n    } else {\n      const onerror = this.pipeline.done.bind(this.pipeline, pipeTo)\n      const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null) // onclose has a weird bool arg\n      pipeTo.on('error', onerror)\n      pipeTo.on('close', onclose)\n      pipeTo.on('finish', this.pipeline.finished.bind(this.pipeline))\n    }\n\n    pipeTo.on('drain', afterDrain.bind(this))\n    this.stream.emit('piping', pipeTo)\n    pipeTo.emit('pipe', this.stream)\n  }\n\n  push (data) {\n    const stream = this.stream\n\n    if (data === null) {\n      this.highWaterMark = 0\n      stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED\n      return false\n    }\n\n    if (this.map !== null) data = this.map(data)\n    this.buffered += this.byteLength(data)\n    this.queue.push(data)\n\n    stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED\n\n    return this.buffered < this.highWaterMark\n  }\n\n  shift () {\n    const data = this.queue.shift()\n\n    this.buffered -= this.byteLength(data)\n    if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED\n    return data\n  }\n\n  unshift (data) {\n    let tail\n    const pending = []\n\n    while ((tail = this.queue.shift()) !== undefined) {\n      pending.push(tail)\n    }\n\n    this.push(data)\n\n    for (let i = 0; i < pending.length; i++) {\n      this.queue.push(pending[i])\n    }\n  }\n\n  read () {\n    const stream = this.stream\n\n    if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {\n      const data = this.shift()\n      if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED\n      if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data)\n      return data\n    }\n\n    return null\n  }\n\n  drain () {\n    const stream = this.stream\n\n    while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {\n      const data = this.shift()\n      if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED\n      if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit('data', data)\n    }\n  }\n\n  update () {\n    const stream = this.stream\n\n    this.drain()\n\n    while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === 0) {\n      stream._duplexState |= READ_ACTIVE_AND_SYNC_AND_NEEDS_PUSH\n      stream._read(this.afterRead)\n      stream._duplexState &= READ_NOT_SYNC\n      if ((stream._duplexState & READ_ACTIVE) === 0) this.drain()\n    }\n\n    if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {\n      stream._duplexState |= READ_EMITTED_READABLE\n      stream.emit('readable')\n    }\n\n    if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary()\n  }\n\n  updateNonPrimary () {\n    const stream = this.stream\n\n    if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {\n      stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING\n      stream.emit('end')\n      if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING\n      if (this.pipeTo !== null) this.pipeTo.end()\n    }\n\n    if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {\n      if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {\n        stream._duplexState |= ACTIVE\n        stream._destroy(afterDestroy.bind(this))\n      }\n      return\n    }\n\n    if ((stream._duplexState & IS_OPENING) === OPENING) {\n      stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING\n      stream._open(afterOpen.bind(this))\n    }\n  }\n\n  updateNextTick () {\n    if ((this.stream._duplexState & READ_NEXT_TICK) !== 0) return\n    this.stream._duplexState |= READ_NEXT_TICK\n    queueTick(this.afterUpdateNextTick)\n  }\n}\n\nclass TransformState {\n  constructor (stream) {\n    this.data = null\n    this.afterTransform = afterTransform.bind(stream)\n    this.afterFinal = null\n  }\n}\n\nclass Pipeline {\n  constructor (src, dst, cb) {\n    this.from = src\n    this.to = dst\n    this.afterPipe = cb\n    this.error = null\n    this.pipeToFinished = false\n  }\n\n  finished () {\n    this.pipeToFinished = true\n  }\n\n  done (stream, err) {\n    if (err) this.error = err\n\n    if (stream === this.to) {\n      this.to = null\n\n      if (this.from !== null) {\n        if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {\n          this.from.destroy(this.error || new Error('Writable stream closed prematurely'))\n        }\n        return\n      }\n    }\n\n    if (stream === this.from) {\n      this.from = null\n\n      if (this.to !== null) {\n        if ((stream._duplexState & READ_DONE) === 0) {\n          this.to.destroy(this.error || new Error('Readable stream closed before ending'))\n        }\n        return\n      }\n    }\n\n    if (this.afterPipe !== null) this.afterPipe(this.error)\n    this.to = this.from = this.afterPipe = null\n  }\n}\n\nfunction afterDrain () {\n  this.stream._duplexState |= READ_PIPE_DRAINED\n  if ((this.stream._duplexState & READ_ACTIVE_AND_SYNC) === 0) this.updateNextTick()\n  else this.drain()\n}\n\nfunction afterFinal (err) {\n  const stream = this.stream\n  if (err) stream.destroy(err)\n  if ((stream._duplexState & DESTROY_STATUS) === 0) {\n    stream._duplexState |= WRITE_DONE\n    stream.emit('finish')\n  }\n  if ((stream._duplexState & AUTO_DESTROY) === DONE) {\n    stream._duplexState |= DESTROYING\n  }\n\n  stream._duplexState &= WRITE_NOT_ACTIVE\n  this.update()\n}\n\nfunction afterDestroy (err) {\n  const stream = this.stream\n\n  if (!err && this.error !== STREAM_DESTROYED) err = this.error\n  if (err) stream.emit('error', err)\n  stream._duplexState |= DESTROYED\n  stream.emit('close')\n\n  const rs = stream._readableState\n  const ws = stream._writableState\n\n  if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err)\n  if (ws !== null && ws.pipeline !== null) ws.pipeline.done(stream, err)\n}\n\nfunction afterWrite (err) {\n  const stream = this.stream\n\n  if (err) stream.destroy(err)\n  stream._duplexState &= WRITE_NOT_ACTIVE\n\n  if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {\n    stream._duplexState &= WRITE_DRAINED\n    if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {\n      stream.emit('drain')\n    }\n  }\n\n  if ((stream._duplexState & WRITE_SYNC) === 0) this.update()\n}\n\nfunction afterRead (err) {\n  if (err) this.stream.destroy(err)\n  this.stream._duplexState &= READ_NOT_ACTIVE\n  if ((this.stream._duplexState & READ_SYNC) === 0) this.update()\n}\n\nfunction updateReadNT () {\n  this.stream._duplexState &= READ_NOT_NEXT_TICK\n  this.update()\n}\n\nfunction updateWriteNT () {\n  this.stream._duplexState &= WRITE_NOT_NEXT_TICK\n  this.update()\n}\n\nfunction afterOpen (err) {\n  const stream = this.stream\n\n  if (err) stream.destroy(err)\n\n  if ((stream._duplexState & DESTROYING) === 0) {\n    if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY\n    if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY\n    stream.emit('open')\n  }\n\n  stream._duplexState &= NOT_ACTIVE\n\n  if (stream._writableState !== null) {\n    stream._writableState.update()\n  }\n\n  if (stream._readableState !== null) {\n    stream._readableState.update()\n  }\n}\n\nfunction afterTransform (err, data) {\n  if (data !== undefined && data !== null) this.push(data)\n  this._writableState.afterWrite(err)\n}\n\nclass Stream extends EventEmitter {\n  constructor (opts) {\n    super()\n\n    this._duplexState = 0\n    this._readableState = null\n    this._writableState = null\n\n    if (opts) {\n      if (opts.open) this._open = opts.open\n      if (opts.destroy) this._destroy = opts.destroy\n      if (opts.predestroy) this._predestroy = opts.predestroy\n      if (opts.signal) {\n        opts.signal.addEventListener('abort', abort.bind(this))\n      }\n    }\n  }\n\n  _open (cb) {\n    cb(null)\n  }\n\n  _destroy (cb) {\n    cb(null)\n  }\n\n  _predestroy () {\n    // does nothing\n  }\n\n  get readable () {\n    return this._readableState !== null ? true : undefined\n  }\n\n  get writable () {\n    return this._writableState !== null ? true : undefined\n  }\n\n  get destroyed () {\n    return (this._duplexState & DESTROYED) !== 0\n  }\n\n  get destroying () {\n    return (this._duplexState & DESTROY_STATUS) !== 0\n  }\n\n  destroy (err) {\n    if ((this._duplexState & DESTROY_STATUS) === 0) {\n      if (!err) err = STREAM_DESTROYED\n      this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY\n\n      if (this._readableState !== null) this._readableState.error = err\n      if (this._writableState !== null) this._writableState.error = err\n\n      this._duplexState |= PREDESTROYING\n      this._predestroy()\n      this._duplexState &= NOT_PREDESTROYING\n\n      if (this._readableState !== null) this._readableState.updateNextTick()\n      if (this._writableState !== null) this._writableState.updateNextTick()\n    }\n  }\n\n  on (name, fn) {\n    if (this._readableState !== null) {\n      if (name === 'data') {\n        this._duplexState |= (READ_EMIT_DATA | READ_RESUMED)\n        this._readableState.updateNextTick()\n      }\n      if (name === 'readable') {\n        this._duplexState |= READ_EMIT_READABLE\n        this._readableState.updateNextTick()\n      }\n    }\n\n    if (this._writableState !== null) {\n      if (name === 'drain') {\n        this._duplexState |= WRITE_EMIT_DRAIN\n        this._writableState.updateNextTick()\n      }\n    }\n\n    return super.on(name, fn)\n  }\n}\n\nclass Readable extends Stream {\n  constructor (opts) {\n    super(opts)\n\n    this._duplexState |= OPENING | WRITE_DONE\n    this._readableState = new ReadableState(this, opts)\n\n    if (opts) {\n      if (opts.read) this._read = opts.read\n      if (opts.eagerOpen) this.resume().pause()\n    }\n  }\n\n  _read (cb) {\n    cb(null)\n  }\n\n  pipe (dest, cb) {\n    this._readableState.pipe(dest, cb)\n    this._readableState.updateNextTick()\n    return dest\n  }\n\n  read () {\n    this._readableState.updateNextTick()\n    return this._readableState.read()\n  }\n\n  push (data) {\n    this._readableState.updateNextTick()\n    return this._readableState.push(data)\n  }\n\n  unshift (data) {\n    this._readableState.updateNextTick()\n    return this._readableState.unshift(data)\n  }\n\n  resume () {\n    this._duplexState |= READ_RESUMED\n    this._readableState.updateNextTick()\n    return this\n  }\n\n  pause () {\n    this._duplexState &= READ_PAUSED\n    return this\n  }\n\n  static _fromAsyncIterator (ite, opts) {\n    let destroy\n\n    const rs = new Readable({\n      ...opts,\n      read (cb) {\n        ite.next().then(push).then(cb.bind(null, null)).catch(cb)\n      },\n      predestroy () {\n        destroy = ite.return()\n      },\n      destroy (cb) {\n        if (!destroy) return cb(null)\n        destroy.then(cb.bind(null, null)).catch(cb)\n      }\n    })\n\n    return rs\n\n    function push (data) {\n      if (data.done) rs.push(null)\n      else rs.push(data.value)\n    }\n  }\n\n  static from (data, opts) {\n    if (isReadStreamx(data)) return data\n    if (data[asyncIterator]) return this._fromAsyncIterator(data[asyncIterator](), opts)\n    if (!Array.isArray(data)) data = data === undefined ? [] : [data]\n\n    let i = 0\n    return new Readable({\n      ...opts,\n      read (cb) {\n        this.push(i === data.length ? null : data[i++])\n        cb(null)\n      }\n    })\n  }\n\n  static isBackpressured (rs) {\n    return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark\n  }\n\n  static isPaused (rs) {\n    return (rs._duplexState & READ_RESUMED) === 0\n  }\n\n  [asyncIterator] () {\n    const stream = this\n\n    let error = null\n    let promiseResolve = null\n    let promiseReject = null\n\n    this.on('error', (err) => { error = err })\n    this.on('readable', onreadable)\n    this.on('close', onclose)\n\n    return {\n      [asyncIterator] () {\n        return this\n      },\n      next () {\n        return new Promise(function (resolve, reject) {\n          promiseResolve = resolve\n          promiseReject = reject\n          const data = stream.read()\n          if (data !== null) ondata(data)\n          else if ((stream._duplexState & DESTROYED) !== 0) ondata(null)\n        })\n      },\n      return () {\n        return destroy(null)\n      },\n      throw (err) {\n        return destroy(err)\n      }\n    }\n\n    function onreadable () {\n      if (promiseResolve !== null) ondata(stream.read())\n    }\n\n    function onclose () {\n      if (promiseResolve !== null) ondata(null)\n    }\n\n    function ondata (data) {\n      if (promiseReject === null) return\n      if (error) promiseReject(error)\n      else if (data === null && (stream._duplexState & READ_DONE) === 0) promiseReject(STREAM_DESTROYED)\n      else promiseResolve({ value: data, done: data === null })\n      promiseReject = promiseResolve = null\n    }\n\n    function destroy (err) {\n      stream.destroy(err)\n      return new Promise((resolve, reject) => {\n        if (stream._duplexState & DESTROYED) return resolve({ value: undefined, done: true })\n        stream.once('close', function () {\n          if (err) reject(err)\n          else resolve({ value: undefined, done: true })\n        })\n      })\n    }\n  }\n}\n\nclass Writable extends Stream {\n  constructor (opts) {\n    super(opts)\n\n    this._duplexState |= OPENING | READ_DONE\n    this._writableState = new WritableState(this, opts)\n\n    if (opts) {\n      if (opts.writev) this._writev = opts.writev\n      if (opts.write) this._write = opts.write\n      if (opts.final) this._final = opts.final\n    }\n  }\n\n  _writev (batch, cb) {\n    cb(null)\n  }\n\n  _write (data, cb) {\n    this._writableState.autoBatch(data, cb)\n  }\n\n  _final (cb) {\n    cb(null)\n  }\n\n  static isBackpressured (ws) {\n    return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0\n  }\n\n  write (data) {\n    this._writableState.updateNextTick()\n    return this._writableState.push(data)\n  }\n\n  end (data) {\n    this._writableState.updateNextTick()\n    this._writableState.end(data)\n    return this\n  }\n}\n\nclass Duplex extends Readable { // and Writable\n  constructor (opts) {\n    super(opts)\n\n    this._duplexState = OPENING\n    this._writableState = new WritableState(this, opts)\n\n    if (opts) {\n      if (opts.writev) this._writev = opts.writev\n      if (opts.write) this._write = opts.write\n      if (opts.final) this._final = opts.final\n    }\n  }\n\n  _writev (batch, cb) {\n    cb(null)\n  }\n\n  _write (data, cb) {\n    this._writableState.autoBatch(data, cb)\n  }\n\n  _final (cb) {\n    cb(null)\n  }\n\n  write (data) {\n    this._writableState.updateNextTick()\n    return this._writableState.push(data)\n  }\n\n  end (data) {\n    this._writableState.updateNextTick()\n    this._writableState.end(data)\n    return this\n  }\n}\n\nclass Transform extends Duplex {\n  constructor (opts) {\n    super(opts)\n    this._transformState = new TransformState(this)\n\n    if (opts) {\n      if (opts.transform) this._transform = opts.transform\n      if (opts.flush) this._flush = opts.flush\n    }\n  }\n\n  _write (data, cb) {\n    if (this._readableState.buffered >= this._readableState.highWaterMark) {\n      this._transformState.data = data\n    } else {\n      this._transform(data, this._transformState.afterTransform)\n    }\n  }\n\n  _read (cb) {\n    if (this._transformState.data !== null) {\n      const data = this._transformState.data\n      this._transformState.data = null\n      cb(null)\n      this._transform(data, this._transformState.afterTransform)\n    } else {\n      cb(null)\n    }\n  }\n\n  _transform (data, cb) {\n    cb(null, data)\n  }\n\n  _flush (cb) {\n    cb(null)\n  }\n\n  _final (cb) {\n    this._transformState.afterFinal = cb\n    this._flush(transformAfterFlush.bind(this))\n  }\n}\n\nclass PassThrough extends Transform {}\n\nfunction transformAfterFlush (err, data) {\n  const cb = this._transformState.afterFinal\n  if (err) return cb(err)\n  if (data !== null && data !== undefined) this.push(data)\n  this.push(null)\n  cb(null)\n}\n\nfunction pipelinePromise (...streams) {\n  return new Promise((resolve, reject) => {\n    return pipeline(...streams, (err) => {\n      if (err) return reject(err)\n      resolve()\n    })\n  })\n}\n\nfunction pipeline (stream, ...streams) {\n  const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams]\n  const done = (all.length && typeof all[all.length - 1] === 'function') ? all.pop() : null\n\n  if (all.length < 2) throw new Error('Pipeline requires at least 2 streams')\n\n  let src = all[0]\n  let dest = null\n  let error = null\n\n  for (let i = 1; i < all.length; i++) {\n    dest = all[i]\n\n    if (isStreamx(src)) {\n      src.pipe(dest, onerror)\n    } else {\n      errorHandle(src, true, i > 1, onerror)\n      src.pipe(dest)\n    }\n\n    src = dest\n  }\n\n  if (done) {\n    let fin = false\n\n    dest.on('finish', () => { fin = true })\n    dest.on('error', err => { error = error || err })\n    dest.on('close', () => done(error || (fin ? null : PREMATURE_CLOSE)))\n  }\n\n  return dest\n\n  function errorHandle (s, rd, wr, onerror) {\n    s.on('error', onerror)\n    s.on('close', onclose)\n\n    function onclose () {\n      if (rd && s._readableState && !s._readableState.ended) return onerror(PREMATURE_CLOSE)\n      if (wr && s._writableState && !s._writableState.ended) return onerror(PREMATURE_CLOSE)\n    }\n  }\n\n  function onerror (err) {\n    if (!err || error) return\n    error = err\n\n    for (const s of all) {\n      s.destroy(err)\n    }\n  }\n}\n\nfunction isStream (stream) {\n  return !!stream._readableState || !!stream._writableState\n}\n\nfunction isStreamx (stream) {\n  return typeof stream._duplexState === 'number' && isStream(stream)\n}\n\nfunction getStreamError (stream) {\n  return (stream._readableState && stream._readableState.error) || (stream._writableState && stream._writableState.error)\n}\n\nfunction isReadStreamx (stream) {\n  return isStreamx(stream) && stream.readable\n}\n\nfunction isTypedArray (data) {\n  return typeof data === 'object' && data !== null && typeof data.byteLength === 'number'\n}\n\nfunction defaultByteLength (data) {\n  return isTypedArray(data) ? data.byteLength : 1024\n}\n\nfunction noop () {}\n\nfunction abort () {\n  this.destroy(new Error('Stream aborted.'))\n}\n\nmodule.exports = {\n  pipeline,\n  pipelinePromise,\n  isStream,\n  isStreamx,\n  getStreamError,\n  Stream,\n  Writable,\n  Readable,\n  Duplex,\n  Transform,\n  // Export PassThrough for compatibility with Node.js core's stream module\n  PassThrough\n}\n","function isBuffer (value) {\n  return Buffer.isBuffer(value) || value instanceof Uint8Array\n}\n\nfunction isEncoding (encoding) {\n  return Buffer.isEncoding(encoding)\n}\n\nfunction alloc (size, fill, encoding) {\n  return Buffer.alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n  return Buffer.allocUnsafe(size)\n}\n\nfunction allocUnsafeSlow (size) {\n  return Buffer.allocUnsafeSlow(size)\n}\n\nfunction byteLength (string, encoding) {\n  return Buffer.byteLength(string, encoding)\n}\n\nfunction compare (a, b) {\n  return Buffer.compare(a, b)\n}\n\nfunction concat (buffers, totalLength) {\n  return Buffer.concat(buffers, totalLength)\n}\n\nfunction copy (source, target, targetStart, start, end) {\n  return toBuffer(source).copy(target, targetStart, start, end)\n}\n\nfunction equals (a, b) {\n  return toBuffer(a).equals(b)\n}\n\nfunction fill (buffer, value, offset, end, encoding) {\n  return toBuffer(buffer).fill(value, offset, end, encoding)\n}\n\nfunction from (value, encodingOrOffset, length) {\n  return Buffer.from(value, encodingOrOffset, length)\n}\n\nfunction includes (buffer, value, byteOffset, encoding) {\n  return toBuffer(buffer).includes(value, byteOffset, encoding)\n}\n\nfunction indexOf (buffer, value, byfeOffset, encoding) {\n  return toBuffer(buffer).indexOf(value, byfeOffset, encoding)\n}\n\nfunction lastIndexOf (buffer, value, byteOffset, encoding) {\n  return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding)\n}\n\nfunction swap16 (buffer) {\n  return toBuffer(buffer).swap16()\n}\n\nfunction swap32 (buffer) {\n  return toBuffer(buffer).swap32()\n}\n\nfunction swap64 (buffer) {\n  return toBuffer(buffer).swap64()\n}\n\nfunction toBuffer (buffer) {\n  if (Buffer.isBuffer(buffer)) return buffer\n  return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength)\n}\n\nfunction toString (buffer, encoding, start, end) {\n  return toBuffer(buffer).toString(encoding, start, end)\n}\n\nfunction write (buffer, string, offset, length, encoding) {\n  return toBuffer(buffer).write(string, offset, length, encoding)\n}\n\nfunction writeDoubleLE (buffer, value, offset) {\n  return toBuffer(buffer).writeDoubleLE(value, offset)\n}\n\nfunction writeFloatLE (buffer, value, offset) {\n  return toBuffer(buffer).writeFloatLE(value, offset)\n}\n\nfunction writeUInt32LE (buffer, value, offset) {\n  return toBuffer(buffer).writeUInt32LE(value, offset)\n}\n\nfunction writeInt32LE (buffer, value, offset) {\n  return toBuffer(buffer).writeInt32LE(value, offset)\n}\n\nfunction readDoubleLE (buffer, offset) {\n  return toBuffer(buffer).readDoubleLE(offset)\n}\n\nfunction readFloatLE (buffer, offset) {\n  return toBuffer(buffer).readFloatLE(offset)\n}\n\nfunction readUInt32LE (buffer, offset) {\n  return toBuffer(buffer).readUInt32LE(offset)\n}\n\nfunction readInt32LE (buffer, offset) {\n  return toBuffer(buffer).readInt32LE(offset)\n}\n\nmodule.exports = {\n  isBuffer,\n  isEncoding,\n  alloc,\n  allocUnsafe,\n  allocUnsafeSlow,\n  byteLength,\n  compare,\n  concat,\n  copy,\n  equals,\n  fill,\n  from,\n  includes,\n  indexOf,\n  lastIndexOf,\n  swap16,\n  swap32,\n  swap64,\n  toBuffer,\n  toString,\n  write,\n  writeDoubleLE,\n  writeFloatLE,\n  writeUInt32LE,\n  writeInt32LE,\n  readDoubleLE,\n  readFloatLE,\n  readUInt32LE,\n  readInt32LE\n}\n","const b4a = require('b4a')\n\nconst ZEROS = '0000000000000000000'\nconst SEVENS = '7777777777777777777'\nconst ZERO_OFFSET = '0'.charCodeAt(0)\nconst USTAR_MAGIC = b4a.from('ustar\\x00', 'binary')\nconst USTAR_VER = b4a.from('00', 'binary')\nconst GNU_MAGIC = b4a.from('ustar\\x20', 'binary')\nconst GNU_VER = b4a.from('\\x20\\x00', 'binary')\nconst MASK = 0o7777\nconst MAGIC_OFFSET = 257\nconst VERSION_OFFSET = 263\n\nconst clamp = function (index, len, defaultValue) {\n  if (typeof index !== 'number') return defaultValue\n  index = ~~index // Coerce to integer.\n  if (index >= len) return len\n  if (index >= 0) return index\n  index += len\n  if (index >= 0) return index\n  return 0\n}\n\nconst toType = function (flag) {\n  switch (flag) {\n    case 0:\n      return 'file'\n    case 1:\n      return 'link'\n    case 2:\n      return 'symlink'\n    case 3:\n      return 'character-device'\n    case 4:\n      return 'block-device'\n    case 5:\n      return 'directory'\n    case 6:\n      return 'fifo'\n    case 7:\n      return 'contiguous-file'\n    case 72:\n      return 'pax-header'\n    case 55:\n      return 'pax-global-header'\n    case 27:\n      return 'gnu-long-link-path'\n    case 28:\n    case 30:\n      return 'gnu-long-path'\n  }\n\n  return null\n}\n\nconst toTypeflag = function (flag) {\n  switch (flag) {\n    case 'file':\n      return 0\n    case 'link':\n      return 1\n    case 'symlink':\n      return 2\n    case 'character-device':\n      return 3\n    case 'block-device':\n      return 4\n    case 'directory':\n      return 5\n    case 'fifo':\n      return 6\n    case 'contiguous-file':\n      return 7\n    case 'pax-header':\n      return 72\n  }\n\n  return 0\n}\n\nconst indexOf = function (block, num, offset, end) {\n  for (; offset < end; offset++) {\n    if (block[offset] === num) return offset\n  }\n  return end\n}\n\nconst cksum = function (block) {\n  let sum = 8 * 32\n  for (let i = 0; i < 148; i++) sum += block[i]\n  for (let j = 156; j < 512; j++) sum += block[j]\n  return sum\n}\n\nconst encodeOct = function (val, n) {\n  val = val.toString(8)\n  if (val.length > n) return SEVENS.slice(0, n) + ' '\n  else return ZEROS.slice(0, n - val.length) + val + ' '\n}\n\n/* Copied from the node-tar repo and modified to meet\n * tar-stream coding standard.\n *\n * Source: https://github.com/npm/node-tar/blob/51b6627a1f357d2eb433e7378e5f05e83b7aa6cd/lib/header.js#L349\n */\nfunction parse256 (buf) {\n  // first byte MUST be either 80 or FF\n  // 80 for positive, FF for 2's comp\n  let positive\n  if (buf[0] === 0x80) positive = true\n  else if (buf[0] === 0xFF) positive = false\n  else return null\n\n  // build up a base-256 tuple from the least sig to the highest\n  const tuple = []\n  let i\n  for (i = buf.length - 1; i > 0; i--) {\n    const byte = buf[i]\n    if (positive) tuple.push(byte)\n    else tuple.push(0xFF - byte)\n  }\n\n  let sum = 0\n  const l = tuple.length\n  for (i = 0; i < l; i++) {\n    sum += tuple[i] * Math.pow(256, i)\n  }\n\n  return positive ? sum : -1 * sum\n}\n\nconst decodeOct = function (val, offset, length) {\n  val = val.slice(offset, offset + length)\n  offset = 0\n\n  // If prefixed with 0x80 then parse as a base-256 integer\n  if (val[offset] & 0x80) {\n    return parse256(val)\n  } else {\n    // Older versions of tar can prefix with spaces\n    while (offset < val.length && val[offset] === 32) offset++\n    const end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length)\n    while (offset < end && val[offset] === 0) offset++\n    if (end === offset) return 0\n    return parseInt(val.slice(offset, end).toString(), 8)\n  }\n}\n\nconst decodeStr = function (val, offset, length, encoding) {\n  return val.slice(offset, indexOf(val, 0, offset, offset + length)).toString(encoding)\n}\n\nconst addLength = function (str) {\n  const len = b4a.byteLength(str)\n  let digits = Math.floor(Math.log(len) / Math.log(10)) + 1\n  if (len + digits >= Math.pow(10, digits)) digits++\n\n  return (len + digits) + str\n}\n\nexports.decodeLongPath = function (buf, encoding) {\n  return decodeStr(buf, 0, buf.length, encoding)\n}\n\nexports.encodePax = function (opts) { // TODO: encode more stuff in pax\n  let result = ''\n  if (opts.name) result += addLength(' path=' + opts.name + '\\n')\n  if (opts.linkname) result += addLength(' linkpath=' + opts.linkname + '\\n')\n  const pax = opts.pax\n  if (pax) {\n    for (const key in pax) {\n      result += addLength(' ' + key + '=' + pax[key] + '\\n')\n    }\n  }\n  return b4a.from(result)\n}\n\nexports.decodePax = function (buf) {\n  const result = {}\n\n  while (buf.length) {\n    let i = 0\n    while (i < buf.length && buf[i] !== 32) i++\n    const len = parseInt(buf.slice(0, i).toString(), 10)\n    if (!len) return result\n\n    const b = buf.slice(i + 1, len - 1).toString()\n    const keyIndex = b.indexOf('=')\n    if (keyIndex === -1) return result\n    result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1)\n\n    buf = buf.slice(len)\n  }\n\n  return result\n}\n\nexports.encode = function (opts) {\n  const buf = b4a.alloc(512)\n  let name = opts.name\n  let prefix = ''\n\n  if (opts.typeflag === 5 && name[name.length - 1] !== '/') name += '/'\n  if (b4a.byteLength(name) !== name.length) return null // utf-8\n\n  while (b4a.byteLength(name) > 100) {\n    const i = name.indexOf('/')\n    if (i === -1) return null\n    prefix += prefix ? '/' + name.slice(0, i) : name.slice(0, i)\n    name = name.slice(i + 1)\n  }\n\n  if (b4a.byteLength(name) > 100 || b4a.byteLength(prefix) > 155) return null\n  if (opts.linkname && b4a.byteLength(opts.linkname) > 100) return null\n\n  b4a.write(buf, name)\n  b4a.write(buf, encodeOct(opts.mode & MASK, 6), 100)\n  b4a.write(buf, encodeOct(opts.uid, 6), 108)\n  b4a.write(buf, encodeOct(opts.gid, 6), 116)\n  b4a.write(buf, encodeOct(opts.size, 11), 124)\n  b4a.write(buf, encodeOct((opts.mtime.getTime() / 1000) | 0, 11), 136)\n\n  buf[156] = ZERO_OFFSET + toTypeflag(opts.type)\n\n  if (opts.linkname) b4a.write(buf, opts.linkname, 157)\n\n  b4a.copy(USTAR_MAGIC, buf, MAGIC_OFFSET)\n  b4a.copy(USTAR_VER, buf, VERSION_OFFSET)\n  if (opts.uname) b4a.write(buf, opts.uname, 265)\n  if (opts.gname) b4a.write(buf, opts.gname, 297)\n  b4a.write(buf, encodeOct(opts.devmajor || 0, 6), 329)\n  b4a.write(buf, encodeOct(opts.devminor || 0, 6), 337)\n\n  if (prefix) b4a.write(buf, prefix, 345)\n\n  b4a.write(buf, encodeOct(cksum(buf), 6), 148)\n\n  return buf\n}\n\nexports.decode = function (buf, filenameEncoding, allowUnknownFormat) {\n  let typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET\n\n  let name = decodeStr(buf, 0, 100, filenameEncoding)\n  const mode = decodeOct(buf, 100, 8)\n  const uid = decodeOct(buf, 108, 8)\n  const gid = decodeOct(buf, 116, 8)\n  const size = decodeOct(buf, 124, 12)\n  const mtime = decodeOct(buf, 136, 12)\n  const type = toType(typeflag)\n  const linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding)\n  const uname = decodeStr(buf, 265, 32)\n  const gname = decodeStr(buf, 297, 32)\n  const devmajor = decodeOct(buf, 329, 8)\n  const devminor = decodeOct(buf, 337, 8)\n\n  const c = cksum(buf)\n\n  // checksum is still initial value if header was null.\n  if (c === 8 * 32) return null\n\n  // valid checksum\n  if (c !== decodeOct(buf, 148, 8)) throw new Error('Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?')\n\n  if (USTAR_MAGIC.compare(buf, MAGIC_OFFSET, MAGIC_OFFSET + 6) === 0) {\n    // ustar (posix) format.\n    // prepend prefix, if present.\n    if (buf[345]) name = decodeStr(buf, 345, 155, filenameEncoding) + '/' + name\n  } else if (GNU_MAGIC.compare(buf, MAGIC_OFFSET, MAGIC_OFFSET + 6) === 0 &&\n             GNU_VER.compare(buf, VERSION_OFFSET, VERSION_OFFSET + 2) === 0) {\n    // 'gnu'/'oldgnu' format. Similar to ustar, but has support for incremental and\n    // multi-volume tarballs.\n  } else {\n    if (!allowUnknownFormat) {\n      throw new Error('Invalid tar header: unknown format.')\n    }\n  }\n\n  // to support old tar versions that use trailing / to indicate dirs\n  if (typeflag === 0 && name && name[name.length - 1] === '/') typeflag = 5\n\n  return {\n    name,\n    mode,\n    uid,\n    gid,\n    size,\n    mtime: new Date(1000 * mtime),\n    type,\n    linkname,\n    uname,\n    gname,\n    devmajor,\n    devminor\n  }\n}\n","const { constants } = require('fs')\nconst { Readable, Writable } = require('streamx')\nconst { StringDecoder } = require('string_decoder')\nconst b4a = require('b4a')\n\nconst headers = require('./headers')\n\nconst DMODE = 0o755\nconst FMODE = 0o644\n\nconst END_OF_TAR = b4a.alloc(1024)\n\nconst noop = function () {}\n\nconst overflow = function (self, size) {\n  size &= 511\n  if (size) self.push(END_OF_TAR.subarray(0, 512 - size))\n}\n\nfunction modeToType (mode) {\n  switch (mode & constants.S_IFMT) {\n    case constants.S_IFBLK: return 'block-device'\n    case constants.S_IFCHR: return 'character-device'\n    case constants.S_IFDIR: return 'directory'\n    case constants.S_IFIFO: return 'fifo'\n    case constants.S_IFLNK: return 'symlink'\n  }\n\n  return 'file'\n}\n\nclass Sink extends Writable {\n  constructor (to) {\n    super()\n    this.written = 0\n    this._to = to\n  }\n\n  _write (data, cb) {\n    this.written += data.byteLength\n    if (this._to.push(data)) return cb()\n    this._to._drain = cb\n  }\n}\n\nclass LinkSink extends Writable {\n  constructor () {\n    super()\n    this.linkname = ''\n    this._decoder = new StringDecoder('utf-8')\n  }\n\n  _write (data, cb) {\n    this.linkname += this._decoder.write(data)\n    cb()\n  }\n}\n\nclass Void extends Writable {\n  _write (data, cb) {\n    cb(new Error('No body allowed for this entry'))\n  }\n}\n\nclass Pack extends Readable {\n  constructor (opts) {\n    super(opts)\n    this._drain = noop\n    this._finalized = false\n    this._finalizing = false\n    this._stream = null\n  }\n\n  entry (header, buffer, callback) {\n    if (this._stream) throw new Error('already piping an entry')\n    if (this._finalized || this.destroyed) return\n\n    if (typeof buffer === 'function') {\n      callback = buffer\n      buffer = null\n    }\n\n    if (!callback) callback = noop\n\n    const self = this\n\n    if (!header.size || header.type === 'symlink') header.size = 0\n    if (!header.type) header.type = modeToType(header.mode)\n    if (!header.mode) header.mode = header.type === 'directory' ? DMODE : FMODE\n    if (!header.uid) header.uid = 0\n    if (!header.gid) header.gid = 0\n    if (!header.mtime) header.mtime = new Date()\n\n    if (typeof buffer === 'string') buffer = b4a.from(buffer)\n    if (b4a.isBuffer(buffer)) {\n      header.size = buffer.byteLength\n      this._encode(header)\n      const ok = this.push(buffer)\n      overflow(self, header.size)\n      if (ok) process.nextTick(callback)\n      else this._drain = callback\n      return new Void()\n    }\n\n    if (header.type === 'symlink' && !header.linkname) {\n      const linkSink = new LinkSink()\n      linkSink\n        .on('error', function (err) {\n          self.destroy()\n          callback(err)\n        })\n        .on('close', function () {\n          header.linkname = linkSink.linkname\n          self._encode(header)\n          callback()\n        })\n\n      return linkSink\n    }\n\n    this._encode(header)\n\n    if (header.type !== 'file' && header.type !== 'contiguous-file') {\n      process.nextTick(callback)\n      return new Void()\n    }\n\n    const sink = new Sink(this)\n    sink\n      .on('error', function (err) {\n        self._stream = null\n        self.destroy()\n        callback(err)\n      })\n      .on('close', function () {\n        self._stream = null\n\n        if (sink.written !== header.size) { // corrupting tar\n        }\n\n        overflow(self, header.size)\n        if (self._finalizing) { self.finalize() }\n        callback()\n      })\n\n    this._stream = sink\n\n    return sink\n  }\n\n  finalize () {\n    if (this._stream) {\n      this._finalizing = true\n      return\n    }\n\n    if (this._finalized) return\n    this._finalized = true\n    this.push(END_OF_TAR)\n    this.push(null)\n  }\n\n  _encode (header) {\n    if (!header.pax) {\n      const buf = headers.encode(header)\n      if (buf) {\n        this.push(buf)\n        return\n      }\n    }\n    this._encodePax(header)\n  }\n\n  _encodePax (header) {\n    const paxHeader = headers.encodePax({\n      name: header.name,\n      linkname: header.linkname,\n      pax: header.pax\n    })\n\n    const newHeader = {\n      name: 'PaxHeader',\n      mode: header.mode,\n      uid: header.uid,\n      gid: header.gid,\n      size: paxHeader.byteLength,\n      mtime: header.mtime,\n      type: 'pax-header',\n      linkname: header.linkname && 'PaxHeader',\n      uname: header.uname,\n      gname: header.gname,\n      devmajor: header.devmajor,\n      devminor: header.devminor\n    }\n\n    this.push(headers.encode(newHeader))\n    this.push(paxHeader)\n    overflow(this, paxHeader.byteLength)\n\n    newHeader.size = header.size\n    newHeader.type = header.type\n    this.push(headers.encode(newHeader))\n  }\n\n  _read (cb) {\n    const drain = this._drain\n    this._drain = noop\n    drain()\n    cb()\n  }\n}\n\nmodule.exports = function pack (opts) {\n  return new Pack(opts)\n}\n","exports.extract = require('./extract')\nexports.pack = require('./pack')\n",null],"names":["require$$0","require$$1","require$$2","process","global","require$$3","require$$4","require$$5","endOfStreamModule","endOfStream","require$$6","require$$7","require$$8","require$$9","require$$10","require$$11","require$$12","require$$14","require$$15","streamModule","require$$13","require$$16","require$$17","inherits_browserModule","Buffer","BufferList","blModule","bl","noop","Readable","Writable","indexOf","b4a","headers","pack"],"mappings":"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"}