extra-request 4.1.2 → 4.1.4

package/dist/es2015/index.mjs

@@ -1,6 +1,6 @@
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var es2018$d = {};
+var es2018$a = {};
 
 var fetch_browser = {};
 
@@ -71,34 +71,34 @@ __exportStar(abortError_browser, exports);
 __exportStar(blob_browser, exports);
 __exportStar(eventSource_browser, exports);
 
-}(es2018$d));
+}(es2018$a));
 
-var es2018$c = {};
+var es2018$9 = {};
 
-var es2018$b = {};
+var es2018$8 = {};
 
 var customError = {};
 
-var es2018$a = {};
+var es2018$7 = {};
 
-var middleware = {};
+var intermediate = {};
 
 var chunkAsync$1 = {};
 
-var es2018$9 = {};
+var es2018$6 = {};
 
-var go$3 = {};
+var go$1 = {};
 
-go$3.go = void 0;
-function go$2(fn) {
+go$1.go = void 0;
+function go(fn) {
     return fn();
 }
-go$3.go = go$2;
+go$1.go = go;
 
-var goMicrotask$3 = {};
+var goMicrotask$1 = {};
 
-goMicrotask$3.goMicrotask = void 0;
-function goMicrotask$2(fn) {
+goMicrotask$1.goMicrotask = void 0;
+function goMicrotask(fn) {
     return new Promise((resolve, reject) => {
         queueMicrotask(async () => {
             try {
@@ -110,15 +110,15 @@ function goMicrotask$2(fn) {
         });
     });
 }
-goMicrotask$3.goMicrotask = goMicrotask$2;
+goMicrotask$1.goMicrotask = goMicrotask;
 
-var goMacrotask$3 = {};
+var goMacrotask$1 = {};
 
-var es2018$8 = {};
+var es2018$5 = {};
 
 var exponentialBackoff = {};
 
-var es2018$7 = {};
+var es2018$4 = {};
 
 var random$1 = {};
 
@@ -162,10 +162,10 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 __exportStar(randomInt$1, exports);
 __exportStar(randomIntInclusive$1, exports);
 
-}(es2018$7));
+}(es2018$4));
 
 exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
-const extra_rand_1 = es2018$7;
+const extra_rand_1 = es2018$4;
 function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
     const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
     if (jitter) {
@@ -280,13 +280,13 @@ __exportStar(setImmediate$1, exports);
 __exportStar(setTimeoutLoop$1, exports);
 __exportStar(setDynamicTimeoutLoop$1, exports);
 
-}(es2018$8));
+}(es2018$5));
 
-goMacrotask$3.goMacrotask = void 0;
-const extra_timers_1$1 = es2018$8;
-function goMacrotask$2(fn) {
+goMacrotask$1.goMacrotask = void 0;
+const extra_timers_1 = es2018$5;
+function goMacrotask(fn) {
     return new Promise((resolve, reject) => {
-        (0, extra_timers_1$1.setImmediate)(async () => {
+        (0, extra_timers_1.setImmediate)(async () => {
             try {
                 resolve(await fn());
             }
@@ -296,7 +296,7 @@ function goMacrotask$2(fn) {
         });
     });
 }
-goMacrotask$3.goMacrotask = goMacrotask$2;
+goMacrotask$1.goMacrotask = goMacrotask;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -312,15 +312,15 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(go$3, exports);
-__exportStar(goMicrotask$3, exports);
-__exportStar(goMacrotask$3, exports);
+};__exportStar(go$1, exports);
+__exportStar(goMicrotask$1, exports);
+__exportStar(goMacrotask$1, exports);
 
-}(es2018$9));
+}(es2018$6));
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$g = es2018$9;
-const errors_1$f = es2018$b;
+const go_1$g = es2018$6;
+const errors_1$f = es2018$8;
 function chunkAsync(iterable, size) {
     (0, errors_1$f.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$f.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -341,227 +341,227 @@ chunkAsync$1.chunkAsync = chunkAsync;
 
 var chunkByAsync$1 = {};
 
-var es2018$6 = {};
+var es2018$3 = {};
 
-var array$1 = {};
+var array = {};
 
-array$1.isntEmptyArray = array$1.isEmptyArray = array$1.isntArray = array$1.isArray = void 0;
-function isArray$1(val) {
+array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
+function isArray(val) {
     return Array.isArray(val);
 }
-array$1.isArray = isArray$1;
-function isntArray$1(val) {
-    return !isArray$1(val);
+array.isArray = isArray;
+function isntArray(val) {
+    return !isArray(val);
 }
-array$1.isntArray = isntArray$1;
-function isEmptyArray$1(val) {
+array.isntArray = isntArray;
+function isEmptyArray(val) {
     return val.length === 0;
 }
-array$1.isEmptyArray = isEmptyArray$1;
-function isntEmptyArray$1(val) {
+array.isEmptyArray = isEmptyArray;
+function isntEmptyArray(val) {
     return val.length !== 0;
 }
-array$1.isntEmptyArray = isntEmptyArray$1;
+array.isntEmptyArray = isntEmptyArray;
 
-var asyncIterable$1 = {};
+var asyncIterable = {};
 
-var _null$1 = {};
+var _null = {};
 
-_null$1.isntNull = _null$1.isNull = void 0;
-function isNull$1(val) {
+_null.isntNull = _null.isNull = void 0;
+function isNull(val) {
     return val === null;
 }
-_null$1.isNull = isNull$1;
-function isntNull$1(val) {
-    return !isNull$1(val);
+_null.isNull = isNull;
+function isntNull(val) {
+    return !isNull(val);
 }
-_null$1.isntNull = isntNull$1;
+_null.isntNull = isntNull;
 
-var _undefined$1 = {};
+var _undefined = {};
 
-_undefined$1.isntUndefined = _undefined$1.isUndefined = void 0;
-function isUndefined$1(val) {
+_undefined.isntUndefined = _undefined.isUndefined = void 0;
+function isUndefined(val) {
     return val === undefined;
 }
-_undefined$1.isUndefined = isUndefined$1;
-function isntUndefined$1(val) {
-    return !isUndefined$1(val);
+_undefined.isUndefined = isUndefined;
+function isntUndefined(val) {
+    return !isUndefined(val);
 }
-_undefined$1.isntUndefined = isntUndefined$1;
+_undefined.isntUndefined = isntUndefined;
 
-var _function$1 = {};
+var _function = {};
 
-_function$1.isntFunction = _function$1.isFunction = void 0;
-function isFunction$1(val) {
+_function.isntFunction = _function.isFunction = void 0;
+function isFunction(val) {
     return typeof val === 'function';
 }
-_function$1.isFunction = isFunction$1;
-function isntFunction$1(val) {
-    return !isFunction$1(val);
+_function.isFunction = isFunction;
+function isntFunction(val) {
+    return !isFunction(val);
 }
-_function$1.isntFunction = isntFunction$1;
+_function.isntFunction = isntFunction;
 
-asyncIterable$1.isntAsyncIterable = asyncIterable$1.isAsyncIterable = void 0;
-const null_1$5 = _null$1;
-const undefined_1$3 = _undefined$1;
-const function_1$5 = _function$1;
-function isAsyncIterable$1(val) {
-    return (0, null_1$5.isntNull)(val)
-        && (0, undefined_1$3.isntUndefined)(val)
-        && (0, function_1$5.isFunction)(val[Symbol.asyncIterator]);
+asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
+const null_1$3 = _null;
+const undefined_1$2 = _undefined;
+const function_1$2 = _function;
+function isAsyncIterable(val) {
+    return (0, null_1$3.isntNull)(val)
+        && (0, undefined_1$2.isntUndefined)(val)
+        && (0, function_1$2.isFunction)(val[Symbol.asyncIterator]);
 }
-asyncIterable$1.isAsyncIterable = isAsyncIterable$1;
-function isntAsyncIterable$1(val) {
-    return !isAsyncIterable$1(val);
+asyncIterable.isAsyncIterable = isAsyncIterable;
+function isntAsyncIterable(val) {
+    return !isAsyncIterable(val);
 }
-asyncIterable$1.isntAsyncIterable = isntAsyncIterable$1;
+asyncIterable.isntAsyncIterable = isntAsyncIterable;
 
-var bigint$1 = {};
+var bigint = {};
 
-bigint$1.isntBigInt = bigint$1.isBigInt = void 0;
-function isBigInt$1(val) {
+bigint.isntBigInt = bigint.isBigInt = void 0;
+function isBigInt(val) {
     return typeof val === 'bigint';
 }
-bigint$1.isBigInt = isBigInt$1;
-function isntBigInt$1(val) {
-    return !isBigInt$1(val);
+bigint.isBigInt = isBigInt;
+function isntBigInt(val) {
+    return !isBigInt(val);
 }
-bigint$1.isntBigInt = isntBigInt$1;
+bigint.isntBigInt = isntBigInt;
 
-var boolean$1 = {};
+var boolean = {};
 
-boolean$1.isntBoolean = boolean$1.isBoolean = void 0;
-function isBoolean$1(val) {
+boolean.isntBoolean = boolean.isBoolean = void 0;
+function isBoolean(val) {
     return typeof val === 'boolean';
 }
-boolean$1.isBoolean = isBoolean$1;
-function isntBoolean$1(val) {
-    return !isBoolean$1(val);
+boolean.isBoolean = isBoolean;
+function isntBoolean(val) {
+    return !isBoolean(val);
 }
-boolean$1.isntBoolean = isntBoolean$1;
+boolean.isntBoolean = isntBoolean;
 
-var char$1 = {};
+var char = {};
 
-var string$1 = {};
+var string = {};
 
-string$1.isntString = string$1.isString = void 0;
-function isString$1(val) {
+string.isntString = string.isString = void 0;
+function isString(val) {
     return typeof val === 'string';
 }
-string$1.isString = isString$1;
-function isntString$1(val) {
-    return !isString$1(val);
+string.isString = isString;
+function isntString(val) {
+    return !isString(val);
 }
-string$1.isntString = isntString$1;
+string.isntString = isntString;
 
-char$1.isntChar = char$1.isChar = void 0;
-const string_1$3 = string$1;
-function isChar$1(val) {
-    return (0, string_1$3.isString)(val)
+char.isntChar = char.isChar = void 0;
+const string_1$1 = string;
+function isChar(val) {
+    return (0, string_1$1.isString)(val)
         && val.length === 1;
 }
-char$1.isChar = isChar$1;
-function isntChar$1(val) {
-    return !isChar$1(val);
+char.isChar = isChar;
+function isntChar(val) {
+    return !isChar(val);
 }
-char$1.isntChar = isntChar$1;
+char.isntChar = isntChar;
 
-var date$1 = {};
+var date = {};
 
-date$1.isntDate = date$1.isDate = void 0;
-function isDate$1(val) {
+date.isntDate = date.isDate = void 0;
+function isDate(val) {
     return val instanceof Date;
 }
-date$1.isDate = isDate$1;
-function isntDate$1(val) {
-    return !isDate$1(val);
+date.isDate = isDate;
+function isntDate(val) {
+    return !isDate(val);
 }
-date$1.isntDate = isntDate$1;
+date.isntDate = isntDate;
 
-var _enum$1 = {};
+var _enum = {};
 
-_enum$1.inEnum = void 0;
-function inEnum$1(val, _enum) {
+_enum.inEnum = void 0;
+function inEnum(val, _enum) {
     return Object.values(_enum).includes(val);
 }
-_enum$1.inEnum = inEnum$1;
+_enum.inEnum = inEnum;
 
-var error$1 = {};
+var error = {};
 
-error$1.isntError = error$1.isError = void 0;
-function isError$1(val) {
+error.isntError = error.isError = void 0;
+function isError(val) {
     return val instanceof Error;
 }
-error$1.isError = isError$1;
-function isntError$1(val) {
-    return !isError$1(val);
+error.isError = isError;
+function isntError(val) {
+    return !isError(val);
 }
-error$1.isntError = isntError$1;
+error.isntError = isntError;
 
-var falsy$1 = {};
+var falsy = {};
 
-falsy$1.isntFalsy = falsy$1.isFalsy = void 0;
-function isFalsy$1(val) {
+falsy.isntFalsy = falsy.isFalsy = void 0;
+function isFalsy(val) {
     return !val;
 }
-falsy$1.isFalsy = isFalsy$1;
-function isntFalsy$1(val) {
-    return !isFalsy$1(val);
+falsy.isFalsy = isFalsy;
+function isntFalsy(val) {
+    return !isFalsy(val);
 }
-falsy$1.isntFalsy = isntFalsy$1;
+falsy.isntFalsy = isntFalsy;
 
-var iterable$1 = {};
+var iterable = {};
 
-iterable$1.isntIterable = iterable$1.isIterable = void 0;
-const null_1$4 = _null$1;
-const undefined_1$2 = _undefined$1;
-const function_1$4 = _function$1;
-function isIterable$1(val) {
-    return (0, null_1$4.isntNull)(val)
-        && (0, undefined_1$2.isntUndefined)(val)
-        && (0, function_1$4.isFunction)(val[Symbol.iterator]);
+iterable.isntIterable = iterable.isIterable = void 0;
+const null_1$2 = _null;
+const undefined_1$1 = _undefined;
+const function_1$1 = _function;
+function isIterable(val) {
+    return (0, null_1$2.isntNull)(val)
+        && (0, undefined_1$1.isntUndefined)(val)
+        && (0, function_1$1.isFunction)(val[Symbol.iterator]);
 }
-iterable$1.isIterable = isIterable$1;
-function isntIterable$1(val) {
-    return !isIterable$1(val);
+iterable.isIterable = isIterable;
+function isntIterable(val) {
+    return !isIterable(val);
 }
-iterable$1.isntIterable = isntIterable$1;
+iterable.isntIterable = isntIterable;
 
-var json$2 = {};
+var json$1 = {};
 
-var number$1 = {};
+var number = {};
 
-number$1.isntNaN = number$1.isNaN = number$1.isNegativeInfinity = number$1.isPositiveInfinity = number$1.isFinite = number$1.isntNumber = number$1.isNumber = void 0;
-function isNumber$1(val) {
+number.isntNaN = number.isNaN = number.isNegativeInfinity = number.isPositiveInfinity = number.isFinite = number.isntNumber = number.isNumber = void 0;
+function isNumber(val) {
     return typeof val === 'number';
 }
-number$1.isNumber = isNumber$1;
-function isntNumber$1(val) {
-    return !isNumber$1(val);
+number.isNumber = isNumber;
+function isntNumber(val) {
+    return !isNumber(val);
 }
-number$1.isntNumber = isntNumber$1;
-function isFinite$1(val) {
+number.isntNumber = isntNumber;
+function isFinite(val) {
     return Number.isFinite(val);
 }
-number$1.isFinite = isFinite$1;
-function isPositiveInfinity$1(val) {
+number.isFinite = isFinite;
+function isPositiveInfinity(val) {
     return val === Infinity;
 }
-number$1.isPositiveInfinity = isPositiveInfinity$1;
-function isNegativeInfinity$1(val) {
+number.isPositiveInfinity = isPositiveInfinity;
+function isNegativeInfinity(val) {
     return val === -Infinity;
 }
-number$1.isNegativeInfinity = isNegativeInfinity$1;
-function isNaN$1(val) {
+number.isNegativeInfinity = isNegativeInfinity;
+function isNaN(val) {
     return Number.isNaN(val);
 }
-number$1.isNaN = isNaN$1;
-function isntNaN$1(val) {
-    return !isNaN$1(val);
+number.isNaN = isNaN;
+function isntNaN(val) {
+    return !isNaN(val);
 }
-number$1.isntNaN = isntNaN$1;
+number.isntNaN = isntNaN;
 
-var object$1 = {};
+var object = {};
 
 /** Detect free variable `global` from Node.js. */
 
@@ -789,7 +789,7 @@ var objectCtorString = funcToString.call(Object);
  * _.isPlainObject(Object.create(null));
  * // => true
  */
-function isPlainObject$2(value) {
+function isPlainObject$1(value) {
   if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
     return false;
   }
@@ -802,59 +802,59 @@ function isPlainObject$2(value) {
     funcToString.call(Ctor) == objectCtorString;
 }
 
-var isPlainObject_1$2 = isPlainObject$2;
+var isPlainObject_1$1 = isPlainObject$1;
 
-var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
-};object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isntPlainObject = object$1.isPlainObject = object$1.isntObject = object$1.isObject = void 0;
-const isPlainObject_1$1 = __importDefault$1(isPlainObject_1$2);
-function isObject$1(val) {
+};object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
+const isPlainObject_1 = __importDefault(isPlainObject_1$1);
+function isObject(val) {
     return val !== null
         && typeof val === 'object';
 }
-object$1.isObject = isObject$1;
-function isntObject$1(val) {
-    return !isObject$1(val);
+object.isObject = isObject;
+function isntObject(val) {
+    return !isObject(val);
 }
-object$1.isntObject = isntObject$1;
-function isPlainObject$1(val) {
-    return (0, isPlainObject_1$1.default)(val);
+object.isntObject = isntObject;
+function isPlainObject(val) {
+    return (0, isPlainObject_1.default)(val);
 }
-object$1.isPlainObject = isPlainObject$1;
-function isntPlainObject$1(val) {
-    return !isPlainObject$1(val);
+object.isPlainObject = isPlainObject;
+function isntPlainObject(val) {
+    return !isPlainObject(val);
 }
-object$1.isntPlainObject = isntPlainObject$1;
-function isEmptyObject$1(val) {
+object.isntPlainObject = isntPlainObject;
+function isEmptyObject(val) {
     return Object.keys(val).length === 0;
 }
-object$1.isEmptyObject = isEmptyObject$1;
-function isntEmptyObject$1(val) {
+object.isEmptyObject = isEmptyObject;
+function isntEmptyObject(val) {
     return Object.keys(val).length !== 0;
 }
-object$1.isntEmptyObject = isntEmptyObject$1;
-
-json$2.isntJsonable = json$2.isJsonable = json$2.isntJson = json$2.isJson = void 0;
-const null_1$3 = _null$1;
-const boolean_1$1 = boolean$1;
-const string_1$2 = string$1;
-const number_1$1 = number$1;
-const array_1$1 = array$1;
-const object_1$3 = object$1;
-function isJson$1(val) {
-    return (0, null_1$3.isNull)(val)
-        || (0, boolean_1$1.isBoolean)(val)
-        || (0, string_1$2.isString)(val)
-        || (0, number_1$1.isNumber)(val)
-        || ((0, array_1$1.isArray)(val) && val.every(isJson$1))
-        || ((0, object_1$3.isPlainObject)(val) && Object.values(val).every(isJson$1));
-}
-json$2.isJson = isJson$1;
-function isntJson$1(val) {
-    return !isJson$1(val);
-}
-json$2.isntJson = isntJson$1;
-function isJsonable$1(val) {
+object.isntEmptyObject = isntEmptyObject;
+
+json$1.isntJsonable = json$1.isJsonable = json$1.isntJson = json$1.isJson = void 0;
+const null_1$1 = _null;
+const boolean_1 = boolean;
+const string_1 = string;
+const number_1 = number;
+const array_1 = array;
+const object_1$1 = object;
+function isJson(val) {
+    return (0, null_1$1.isNull)(val)
+        || (0, boolean_1.isBoolean)(val)
+        || (0, string_1.isString)(val)
+        || (0, number_1.isNumber)(val)
+        || ((0, array_1.isArray)(val) && val.every(isJson))
+        || ((0, object_1$1.isPlainObject)(val) && Object.values(val).every(isJson));
+}
+json$1.isJson = isJson;
+function isntJson(val) {
+    return !isJson(val);
+}
+json$1.isntJson = isntJson;
+function isJsonable(val) {
     try {
         JSON.stringify(val);
         return true;
@@ -863,39 +863,54 @@ function isJsonable$1(val) {
         return false;
     }
 }
-json$2.isJsonable = isJsonable$1;
-function isntJsonable$1(val) {
-    return !isntJsonable$1();
+json$1.isJsonable = isJsonable;
+function isntJsonable(val) {
+    return !isntJsonable();
+}
+json$1.isntJsonable = isntJsonable;
+
+var nullish = {};
+
+nullish.isntNullish = nullish.isNullish = void 0;
+const null_1 = _null;
+const undefined_1 = _undefined;
+function isNullish(val) {
+    return (0, null_1.isNull)(val)
+        || (0, undefined_1.isUndefined)(val);
+}
+nullish.isNullish = isNullish;
+function isntNullish(val) {
+    return !isNullish(val);
 }
-json$2.isntJsonable = isntJsonable$1;
+nullish.isntNullish = isntNullish;
 
-var promise$1 = {};
+var promise = {};
 
-promise$1.isPromiseLike = promise$1.isntPromiseLike = promise$1.isntPromise = promise$1.isPromise = void 0;
-const object_1$2 = object$1;
-const function_1$3 = _function$1;
-function isPromise$1(val) {
+promise.isPromiseLike = promise.isntPromiseLike = promise.isntPromise = promise.isPromise = void 0;
+const object_1 = object;
+const function_1 = _function;
+function isPromise(val) {
     return val instanceof Promise;
 }
-promise$1.isPromise = isPromise$1;
-function isntPromise$1(val) {
-    return !isPromise$1(val);
+promise.isPromise = isPromise;
+function isntPromise(val) {
+    return !isPromise(val);
 }
-promise$1.isntPromise = isntPromise$1;
-function isntPromiseLike$1(val) {
-    return !isPromiseLike$1(val);
+promise.isntPromise = isntPromise;
+function isntPromiseLike(val) {
+    return !isPromiseLike(val);
 }
-promise$1.isntPromiseLike = isntPromiseLike$1;
-function isPromiseLike$1(val) {
-    return (0, object_1$2.isObject)(val)
-        && (0, function_1$3.isFunction)(val.then);
+promise.isntPromiseLike = isntPromiseLike;
+function isPromiseLike(val) {
+    return (0, object_1.isObject)(val)
+        && (0, function_1.isFunction)(val.then);
 }
-promise$1.isPromiseLike = isPromiseLike$1;
+promise.isPromiseLike = isPromiseLike;
 
-var url$2 = {};
+var url$1 = {};
 
-url$2.isAbsoluteURL = void 0;
-function isAbsoluteURL$1(str) {
+url$1.isAbsoluteURL = void 0;
+function isAbsoluteURL(str) {
     try {
         new URL(str);
         return true;
@@ -904,31 +919,31 @@ function isAbsoluteURL$1(str) {
         return false;
     }
 }
-url$2.isAbsoluteURL = isAbsoluteURL$1;
+url$1.isAbsoluteURL = isAbsoluteURL;
 
-var regexp$1 = {};
+var regexp = {};
 
-regexp$1.isntRegExp = regexp$1.isRegExp = void 0;
-function isRegExp$1(val) {
+regexp.isntRegExp = regexp.isRegExp = void 0;
+function isRegExp(val) {
     return val instanceof RegExp;
 }
-regexp$1.isRegExp = isRegExp$1;
-function isntRegExp$1(val) {
-    return !isRegExp$1(val);
+regexp.isRegExp = isRegExp;
+function isntRegExp(val) {
+    return !isRegExp(val);
 }
-regexp$1.isntRegExp = isntRegExp$1;
+regexp.isntRegExp = isntRegExp;
 
-var symbol$1 = {};
+var symbol = {};
 
-symbol$1.isntSymbol = symbol$1.isSymbol = void 0;
-function isSymbol$1(val) {
+symbol.isntSymbol = symbol.isSymbol = void 0;
+function isSymbol(val) {
     return typeof val === 'symbol';
 }
-symbol$1.isSymbol = isSymbol$1;
-function isntSymbol$1(val) {
-    return !isSymbol$1(val);
+symbol.isSymbol = isSymbol;
+function isntSymbol(val) {
+    return !isSymbol(val);
 }
-symbol$1.isntSymbol = isntSymbol$1;
+symbol.isntSymbol = isntSymbol;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -944,34 +959,35 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(array$1, exports);
-__exportStar(asyncIterable$1, exports);
-__exportStar(bigint$1, exports);
-__exportStar(boolean$1, exports);
-__exportStar(char$1, exports);
-__exportStar(date$1, exports);
-__exportStar(_enum$1, exports);
-__exportStar(error$1, exports);
-__exportStar(falsy$1, exports);
-__exportStar(_function$1, exports);
-__exportStar(iterable$1, exports);
-__exportStar(json$2, exports);
-__exportStar(_null$1, exports);
-__exportStar(number$1, exports);
-__exportStar(object$1, exports);
-__exportStar(promise$1, exports);
-__exportStar(string$1, exports);
-__exportStar(_undefined$1, exports);
-__exportStar(url$2, exports);
-__exportStar(regexp$1, exports);
-__exportStar(symbol$1, exports);
-
-}(es2018$6));
-
-chunkByAsync$1.chunkByAsync = void 0;
-const types_1$m = es2018$6;
-function chunkByAsync(iterable, predicate) {
-    if ((0, types_1$m.isAsyncIterable)(iterable)) {
+};__exportStar(array, exports);
+__exportStar(asyncIterable, exports);
+__exportStar(bigint, exports);
+__exportStar(boolean, exports);
+__exportStar(char, exports);
+__exportStar(date, exports);
+__exportStar(_enum, exports);
+__exportStar(error, exports);
+__exportStar(falsy, exports);
+__exportStar(_function, exports);
+__exportStar(iterable, exports);
+__exportStar(json$1, exports);
+__exportStar(_null, exports);
+__exportStar(nullish, exports);
+__exportStar(number, exports);
+__exportStar(object, exports);
+__exportStar(promise, exports);
+__exportStar(string, exports);
+__exportStar(_undefined, exports);
+__exportStar(url$1, exports);
+__exportStar(regexp, exports);
+__exportStar(symbol, exports);
+
+}(es2018$3));
+
+chunkByAsync$1.chunkByAsync = void 0;
+const types_1$m = es2018$3;
+function chunkByAsync(iterable, predicate) {
+    if ((0, types_1$m.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable, predicate);
     }
     else {
@@ -1030,8 +1046,8 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$f = es2018$9;
-const errors_1$e = es2018$b;
+const go_1$f = es2018$6;
+const errors_1$e = es2018$8;
 function chunk(iterable, size) {
     (0, errors_1$e.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$e.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -1053,8 +1069,8 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$l = es2018$6;
-const go_1$e = es2018$9;
+const types_1$l = es2018$3;
+const go_1$e = es2018$6;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$e.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1076,7 +1092,7 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$1 = {};
 
 concat$1.concat = void 0;
-const go_1$d = es2018$9;
+const go_1$d = es2018$6;
 function concat(iterable, ...otherIterables) {
     return (0, go_1$d.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1086,6 +1102,91 @@ function concat(iterable, ...otherIterables) {
 }
 concat$1.concat = concat;
 
+var differenceAsync$1 = {};
+
+var filterAsync$1 = {};
+
+filterAsync$1.filterAsync = void 0;
+const types_1$k = es2018$3;
+function filterAsync(iterable, predicate) {
+    if ((0, types_1$k.isAsyncIterable)(iterable)) {
+        return filterAsyncIterable(iterable, predicate);
+    }
+    else {
+        return filterIterable(iterable, predicate);
+    }
+}
+filterAsync$1.filterAsync = filterAsync;
+async function* filterAsyncIterable(iterable, predicate) {
+    let index = 0;
+    for await (const element of iterable) {
+        if (await predicate(element, index))
+            yield element;
+        index++;
+    }
+}
+async function* filterIterable(iterable, predicate) {
+    let index = 0;
+    for (const element of iterable) {
+        if (await predicate(element, index))
+            yield element;
+        index++;
+    }
+}
+
+var toSetAsync$1 = {};
+
+toSetAsync$1.toSetAsync = void 0;
+async function toSetAsync(iterable) {
+    const result = new Set();
+    for await (const element of iterable) {
+        result.add(await element);
+    }
+    return result;
+}
+toSetAsync$1.toSetAsync = toSetAsync;
+
+differenceAsync$1.differenceAsync = void 0;
+const filter_async_1$1 = filterAsync$1;
+const to_set_async_1$1 = toSetAsync$1;
+async function* differenceAsync(left, right) {
+    const rightSet = await (0, to_set_async_1$1.toSetAsync)(right);
+    yield* (0, filter_async_1$1.filterAsync)(left, async (x) => !rightSet.has(await x));
+}
+differenceAsync$1.differenceAsync = differenceAsync;
+
+var difference$1 = {};
+
+var filter$1 = {};
+
+filter$1.filter = void 0;
+function* filter(iterable, predicate) {
+    let index = 0;
+    for (const element of iterable) {
+        if (predicate(element, index))
+            yield element;
+        index++;
+    }
+}
+filter$1.filter = filter;
+
+var toSet$1 = {};
+
+toSet$1.toSet = void 0;
+function toSet(iterable) {
+    return new Set(iterable);
+}
+toSet$1.toSet = toSet;
+
+difference$1.difference = void 0;
+const filter_1$1 = filter$1;
+const to_set_1$1 = toSet$1;
+function difference(left, right) {
+    const rightSet = (0, to_set_1$1.toSet)(right);
+    return (0, filter_1$1.filter)(left, x => !rightSet.has(x));
+}
+difference$1.difference = difference;
+
 var dropAsync$1 = {};
 
 var utils = {};
@@ -1105,9 +1206,9 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$c = es2018$9;
+const go_1$c = es2018$6;
 const utils_1$3 = utils;
-const errors_1$d = es2018$b;
+const errors_1$d = es2018$8;
 function dropAsync(iterable, count) {
     (0, errors_1$d.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$d.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1139,17 +1240,30 @@ dropAsync$1.dropAsync = dropAsync;
 
 var dropRightAsync$1 = {};
 
+var toArrayAsync$1 = {};
+
+toArrayAsync$1.toArrayAsync = void 0;
+async function toArrayAsync(iterable) {
+    const result = [];
+    for await (const element of iterable) {
+        result.push(element);
+    }
+    return result;
+}
+toArrayAsync$1.toArrayAsync = toArrayAsync;
+
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$b = es2018$9;
+const go_1$b = es2018$6;
 const utils_1$2 = utils;
-const errors_1$c = es2018$b;
+const errors_1$c = es2018$8;
+const to_array_async_1 = toArrayAsync$1;
 function dropRightAsync(iterable, count) {
     (0, errors_1$c.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$c.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
     if (count === 0)
         return (0, utils_1$2.copyAsyncIterable)(iterable);
     return (0, go_1$b.go)(async function* () {
-        const arr = await toArrayAsync$2(iterable);
+        const arr = await (0, to_array_async_1.toArrayAsync)(iterable);
         const result = arr.slice(0, -count);
         for (const value of result) {
             yield value;
@@ -1157,20 +1271,13 @@ function dropRightAsync(iterable, count) {
     });
 }
 dropRightAsync$1.dropRightAsync = dropRightAsync;
-async function toArrayAsync$2(iterable) {
-    const result = [];
-    for await (const element of iterable) {
-        result.push(element);
-    }
-    return result;
-}
 
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$a = es2018$9;
+const go_1$a = es2018$6;
 const utils_1$1 = utils;
-const errors_1$b = es2018$b;
+const errors_1$b = es2018$8;
 function dropRight(iterable, count) {
     (0, errors_1$b.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$b.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1186,9 +1293,9 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$k = es2018$6;
+const types_1$j = es2018$3;
 function dropUntilAsync(iterable, predicate) {
-    if ((0, types_1$k.isAsyncIterable)(iterable)) {
+    if ((0, types_1$j.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable, predicate);
     }
     else {
@@ -1268,9 +1375,9 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$9 = es2018$9;
+const go_1$9 = es2018$6;
 const utils_1 = utils;
-const errors_1$a = es2018$b;
+const errors_1$a = es2018$8;
 function drop(iterable, count) {
     (0, errors_1$a.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$a.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1300,49 +1407,6 @@ function drop(iterable, count) {
 }
 drop$1.drop = drop;
 
-var filterAsync$1 = {};
-
-filterAsync$1.filterAsync = void 0;
-const types_1$j = es2018$6;
-function filterAsync(iterable, predicate) {
-    if ((0, types_1$j.isAsyncIterable)(iterable)) {
-        return filterAsyncIterable(iterable, predicate);
-    }
-    else {
-        return filterIterable(iterable, predicate);
-    }
-}
-filterAsync$1.filterAsync = filterAsync;
-async function* filterAsyncIterable(iterable, predicate) {
-    let index = 0;
-    for await (const element of iterable) {
-        if (await predicate(element, index))
-            yield element;
-        index++;
-    }
-}
-async function* filterIterable(iterable, predicate) {
-    let index = 0;
-    for (const element of iterable) {
-        if (await predicate(element, index))
-            yield element;
-        index++;
-    }
-}
-
-var filter$1 = {};
-
-filter$1.filter = void 0;
-function* filter(iterable, predicate) {
-    let index = 0;
-    for (const element of iterable) {
-        if (predicate(element, index))
-            yield element;
-        index++;
-    }
-}
-filter$1.filter = filter;
-
 var flattenAsync$1 = {};
 
 var flattenDeepAsync$1 = {};
@@ -1350,7 +1414,7 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$i = es2018$6;
+const types_1$i = es2018$3;
 function flattenByAsync(iterable, predicate) {
     if ((0, types_1$i.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable, predicate);
@@ -1390,7 +1454,7 @@ function isFiniteIterable$1(val) {
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$9 = es2018$b;
+const errors_1$9 = es2018$8;
 function flattenDeepAsync(iterable, depth = Infinity) {
     (0, errors_1$9.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$9.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -1408,7 +1472,7 @@ flattenAsync$1.flattenAsync = flattenAsync;
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$h = es2018$6;
+const types_1$h = es2018$3;
 function flattenBy(iterable, predicate) {
     return flatten$2(iterable, predicate, 1);
 }
@@ -1431,7 +1495,7 @@ var flattenDeep$1 = {};
 
 flattenDeep$1.flattenDeep = void 0;
 const flatten_by_1 = flattenBy$1;
-const errors_1$8 = es2018$b;
+const errors_1$8 = es2018$8;
 function flattenDeep(iterable, depth = Infinity) {
     (0, errors_1$8.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$8.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -1448,10 +1512,32 @@ function flatten(iterable) {
 }
 flatten$1.flatten = flatten;
 
+var intersectionAsync$1 = {};
+
+intersectionAsync$1.intersectionAsync = void 0;
+const filter_async_1 = filterAsync$1;
+const to_set_async_1 = toSetAsync$1;
+async function* intersectionAsync(left, right) {
+    const rightSet = await (0, to_set_async_1.toSetAsync)(right);
+    yield* (0, filter_async_1.filterAsync)(left, async (x) => rightSet.has(await x));
+}
+intersectionAsync$1.intersectionAsync = intersectionAsync;
+
+var intersection$1 = {};
+
+intersection$1.intersection = void 0;
+const filter_1 = filter$1;
+const to_set_1 = toSet$1;
+function intersection(left, right) {
+    const rightSet = (0, to_set_1.toSet)(right);
+    return (0, filter_1.filter)(left, x => rightSet.has(x));
+}
+intersection$1.intersection = intersection;
+
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$g = es2018$6;
+const types_1$g = es2018$3;
 function mapAsync(iterable, fn) {
     if ((0, types_1$g.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable, fn);
@@ -1491,8 +1577,8 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$8 = es2018$9;
-const errors_1$7 = es2018$b;
+const go_1$8 = es2018$6;
+const errors_1$7 = es2018$8;
 function repeatAsync(iterable, times) {
     (0, errors_1$7.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$7.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -1526,8 +1612,8 @@ function isProduction$1() {
 var repeat$1 = {};
 
 repeat$1.repeat = void 0;
-const go_1$7 = es2018$9;
-const errors_1$6 = es2018$b;
+const go_1$7 = es2018$6;
+const errors_1$6 = es2018$8;
 function repeat(iterable, times) {
     (0, errors_1$6.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$6.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -1561,8 +1647,8 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$6 = es2018$9;
-const errors_1$5 = es2018$b;
+const go_1$6 = es2018$6;
+const errors_1$5 = es2018$8;
 function sliceAsync(iterable, start, end = Infinity) {
     (0, errors_1$5.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$5.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -1584,8 +1670,8 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$5 = es2018$9;
-const errors_1$4 = es2018$b;
+const go_1$5 = es2018$6;
+const errors_1$4 = es2018$8;
 function slice(iterable, start, end = Infinity) {
     (0, errors_1$4.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$4.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -1625,7 +1711,7 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$f = es2018$6;
+const types_1$f = es2018$3;
 function splitByAsync(iterable, predicate) {
     if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable, predicate);
@@ -1707,8 +1793,8 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$4 = es2018$9;
-const errors_1$3 = es2018$b;
+const go_1$4 = es2018$6;
+const errors_1$3 = es2018$8;
 function takeAsync(iterable, count) {
     (0, errors_1$3.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$3.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1728,8 +1814,8 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$3 = es2018$9;
-const errors_1$2 = es2018$b;
+const go_1$3 = es2018$6;
+const errors_1$2 = es2018$8;
 function takeRightAsync(iterable, count) {
     (0, errors_1$2.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$2.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1758,8 +1844,8 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$2 = es2018$9;
-const errors_1$1 = es2018$b;
+const go_1$2 = es2018$6;
+const errors_1$1 = es2018$8;
 function takeRight(iterable, count) {
     (0, errors_1$1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$1.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1788,7 +1874,7 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$e = es2018$6;
+const types_1$e = es2018$3;
 function takeUntilAsync(iterable, predicate) {
     if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable, predicate);
@@ -1834,8 +1920,8 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1$1 = es2018$9;
-const errors_1 = es2018$b;
+const go_1$1 = es2018$6;
+const errors_1 = es2018$8;
 function take(iterable, count) {
     (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1855,7 +1941,7 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$d = es2018$6;
+const types_1$d = es2018$3;
 function tapAsync(iterable, fn) {
     if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable, fn);
@@ -1900,7 +1986,7 @@ var toAsyncIterable$1 = {};
 toAsyncIterable$1.toAsyncIterable = void 0;
 async function* toAsyncIterable(iterable) {
     for (const value of iterable) {
-        yield value;
+        yield await value;
     }
 }
 toAsyncIterable$1.toAsyncIterable = toAsyncIterable;
@@ -1938,7 +2024,7 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$c = es2018$6;
+const types_1$c = es2018$3;
 function uniqByAsync(iterable, fn) {
     if ((0, types_1$c.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable, fn);
@@ -2007,7 +2093,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$b = es2018$6;
+const types_1$b = es2018$3;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -2045,7 +2131,7 @@ async function* zipWithSize$1(...iterables) {
                     dones[i] = true;
                     return;
                 }
-                result[i] = temp.value;
+                result[i] = await temp.value;
             }
             yield result;
         }
@@ -2114,6 +2200,8 @@ __exportStar(chunkBy$1, exports);
 __exportStar(chunk$1, exports);
 __exportStar(concatAsync$1, exports);
 __exportStar(concat$1, exports);
+__exportStar(differenceAsync$1, exports);
+__exportStar(difference$1, exports);
 __exportStar(dropAsync$1, exports);
 __exportStar(dropRightAsync$1, exports);
 __exportStar(dropRight$1, exports);
@@ -2128,6 +2216,8 @@ __exportStar(flattenBy$1, exports);
 __exportStar(flattenDeepAsync$1, exports);
 __exportStar(flattenDeep$1, exports);
 __exportStar(flatten$1, exports);
+__exportStar(intersectionAsync$1, exports);
+__exportStar(intersection$1, exports);
 __exportStar(mapAsync$1, exports);
 __exportStar(map$1, exports);
 __exportStar(repeatAsync$1, exports);
@@ -2156,9 +2246,9 @@ __exportStar(uniq$1, exports);
 __exportStar(zipAsync$1, exports);
 __exportStar(zip$1, exports);
 
-}(middleware));
+}(intermediate));
 
-var output = {};
+var terminal = {};
 
 var consume$1 = {};
 
@@ -2168,10 +2258,18 @@ function consume(iterable, consumer) {
 }
 consume$1.consume = consume;
 
+var consumeAsync$1 = {};
+
+consumeAsync$1.consumeAsync = void 0;
+async function consumeAsync(iterable, consumer) {
+    return await consumer(iterable);
+}
+consumeAsync$1.consumeAsync = consumeAsync;
+
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$a = es2018$6;
+const types_1$a = es2018$3;
 function eachAsync(iterable, fn) {
     if ((0, types_1$a.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable, fn);
@@ -2211,7 +2309,7 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$9 = es2018$6;
+const types_1$9 = es2018$3;
 function everyAsync(iterable, predicate) {
     if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable, predicate);
@@ -2257,7 +2355,7 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$8 = es2018$6;
+const types_1$8 = es2018$3;
 function findAsync(iterable, predicate) {
     if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable, predicate);
@@ -2346,42 +2444,10 @@ function includes(iterable, value) {
 }
 includes$1.includes = includes;
 
-var matchAsync$1 = {};
-
-matchAsync$1.matchAsync = void 0;
-async function matchAsync(iterable, sequence) {
-    const sequenceLength = sequence.length;
-    let matchCount = 0;
-    for await (const element of iterable) {
-        if (element === sequence[matchCount])
-            matchCount++;
-        if (matchCount === sequenceLength)
-            return true;
-    }
-    return false;
-}
-matchAsync$1.matchAsync = matchAsync;
-
-var match$1 = {};
-
-match$1.match = void 0;
-function match(iterable, sequence) {
-    const sequenceLength = sequence.length;
-    let matchCount = 0;
-    for (const element of iterable) {
-        if (element === sequence[matchCount])
-            matchCount++;
-        if (matchCount === sequenceLength)
-            return true;
-    }
-    return false;
-}
-match$1.match = match;
-
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$7 = es2018$6;
+const types_1$7 = es2018$3;
 function reduceAsync(iterable, fn, initialValue) {
     if ((0, types_1$7.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
@@ -2477,7 +2543,7 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$6 = es2018$6;
+const types_1$6 = es2018$3;
 function reduce(iterable, fn, initialValue) {
     if ((0, types_1$6.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
@@ -2524,7 +2590,7 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1$5 = es2018$6;
+const types_1$5 = es2018$3;
 function someAsync(iterable, predicate) {
     if ((0, types_1$5.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable, predicate);
@@ -2611,54 +2677,14 @@ function last(iterable) {
 }
 last$1.last = last;
 
-var toArrayAsync$1 = {};
-
-toArrayAsync$1.toArrayAsync = void 0;
-const consume_1$3 = consume$1;
-function toArrayAsync(iterable) {
-    return (0, consume_1$3.consume)(iterable, async (iterable) => {
-        const result = [];
-        for await (const element of iterable) {
-            result.push(element);
-        }
-        return result;
-    });
-}
-toArrayAsync$1.toArrayAsync = toArrayAsync;
-
 var toArray$1 = {};
 
 toArray$1.toArray = void 0;
-const consume_1$2 = consume$1;
 function toArray(iterable) {
-    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
+    return Array.from(iterable);
 }
 toArray$1.toArray = toArray;
 
-var toSetAsync$1 = {};
-
-toSetAsync$1.toSetAsync = void 0;
-const consume_1$1 = consume$1;
-function toSetAsync(iterable) {
-    return (0, consume_1$1.consume)(iterable, async (iterable) => {
-        const result = new Set();
-        for await (const element of iterable) {
-            result.add(element);
-        }
-        return result;
-    });
-}
-toSetAsync$1.toSetAsync = toSetAsync;
-
-var toSet$1 = {};
-
-toSet$1.toSet = void 0;
-const consume_1 = consume$1;
-function toSet(iterable) {
-    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
-}
-toSet$1.toSet = toSet;
-
 var count$1 = {};
 
 count$1.count = void 0;
@@ -2732,6 +2758,7 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };__exportStar(consume$1, exports);
+__exportStar(consumeAsync$1, exports);
 __exportStar(eachAsync$1, exports);
 __exportStar(each$1, exports);
 __exportStar(everyAsync$1, exports);
@@ -2742,8 +2769,6 @@ __exportStar(firstAsync$1, exports);
 __exportStar(first$1, exports);
 __exportStar(includesAsync$1, exports);
 __exportStar(includes$1, exports);
-__exportStar(matchAsync$1, exports);
-__exportStar(match$1, exports);
 __exportStar(reduceAsync$1, exports);
 __exportStar(reduce$1, exports);
 __exportStar(someAsync$1, exports);
@@ -2759,7 +2784,7 @@ __exportStar(countAsync$1, exports);
 __exportStar(groupBy$1, exports);
 __exportStar(groupByAsync$1, exports);
 
-}(output));
+}(terminal));
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -2775,10 +2800,10 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(middleware, exports);
-__exportStar(output, exports);
+};__exportStar(intermediate, exports);
+__exportStar(terminal, exports);
 
-}(es2018$a));
+}(es2018$7));
 
 var getErrorNames$1 = {};
 
@@ -2796,7 +2821,7 @@ function* traverseErrorPrototypeChain(err) {
 traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 getErrorNames$1.getErrorNames = void 0;
-const types_1$4 = es2018$6;
+const types_1$4 = es2018$3;
 const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 function* getErrorNames(err) {
     var _a;
@@ -2817,7 +2842,7 @@ getErrorNames$1.getErrorNames = getErrorNames;
 var serializableError = {};
 
 serializableError.isSerializableError = void 0;
-const types_1$3 = es2018$6;
+const types_1$3 = es2018$3;
 function isSerializableError(val) {
     return (0, types_1$3.isObject)(val)
         && (0, types_1$3.isString)(val.name)
@@ -2828,9 +2853,9 @@ function isSerializableError(val) {
 serializableError.isSerializableError = isSerializableError;
 
 customError.CustomError = void 0;
-const iterable_operator_1$1 = es2018$a;
+const iterable_operator_1$1 = es2018$7;
 const get_error_names_1$1 = getErrorNames$1;
-const types_1$2 = es2018$6;
+const types_1$2 = es2018$3;
 const serializable_error_1 = serializableError;
 class CustomError extends Error {
     get name() {
@@ -2866,7 +2891,7 @@ var normalize$1 = {};
 
 normalize$1.normalize = void 0;
 const get_error_names_1 = getErrorNames$1;
-const iterable_operator_1 = es2018$a;
+const iterable_operator_1 = es2018$7;
 function normalize(err) {
     var _a;
     const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
@@ -2881,13 +2906,19 @@ normalize$1.normalize = normalize;
 
 var hydrate$1 = {};
 
-var es2018$5 = {};
+var es2018$2 = {};
+
+var pass$1 = {};
 
-var pass$3 = {};
+pass$1.pass = void 0;
+function pass() { }
+pass$1.pass = pass;
+
+var passAsync$1 = {};
 
-pass$3.pass = void 0;
-function pass$2() { }
-pass$3.pass = pass$2;
+passAsync$1.passAsync = void 0;
+async function passAsync() { }
+passAsync$1.passAsync = passAsync;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -2899,12 +2930,13 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(pass$3, exports);
+};__exportStar(pass$1, exports);
+__exportStar(passAsync$1, exports);
 
-}(es2018$5));
+}(es2018$2));
 
 hydrate$1.hydrate = void 0;
-const pass_1 = es2018$5;
+const pass_1 = es2018$2;
 function hydrate(err) {
     var _a;
     const errorNames = [err.name, ...err.ancestors]
@@ -2962,9 +2994,9 @@ __exportStar(assert$1, exports);
 __exportStar(getErrorNames$1, exports);
 __exportStar(traverseErrorPrototypeChain$1, exports);
 
-}(es2018$b));
+}(es2018$8));
 
-var es2018$4 = {};
+var es2018$1 = {};
 
 var log$1 = {};
 
@@ -2977,420 +3009,59 @@ log$1.log = log;
 
 var time$1 = {};
 
-var highResolutionTimestamp_browser = {};
+var lib = {};
+
+var performanceNow_browser = {};
 
-highResolutionTimestamp_browser.elapsed = highResolutionTimestamp_browser.now = void 0;
-function now() {
+performanceNow_browser.performanceNow = void 0;
+function performanceNow() {
     return performance.now();
 }
-highResolutionTimestamp_browser.now = now;
-function elapsed(startTime, endTime) {
-    return `${endTime - startTime}ms`;
-}
-highResolutionTimestamp_browser.elapsed = elapsed;
+performanceNow_browser.performanceNow = performanceNow;
 
-var es2018$3 = {};
+(function (exports) {
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};__exportStar(performanceNow_browser, exports);
 
-var array = {};
+}(lib));
 
-array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
-function isArray(val) {
-    return Array.isArray(val);
-}
-array.isArray = isArray;
-function isntArray(val) {
-    return !isArray(val);
-}
-array.isntArray = isntArray;
-function isEmptyArray(val) {
-    return val.length === 0;
+var getElapsedTime$1 = {};
+
+getElapsedTime$1.getElapsedTime = void 0;
+function getElapsedTime(startTime, endTime) {
+    return `${endTime - startTime}ms`;
 }
-array.isEmptyArray = isEmptyArray;
-function isntEmptyArray(val) {
-    return val.length !== 0;
-}
-array.isntEmptyArray = isntEmptyArray;
-
-var asyncIterable = {};
-
-var _null = {};
-
-_null.isntNull = _null.isNull = void 0;
-function isNull(val) {
-    return val === null;
-}
-_null.isNull = isNull;
-function isntNull(val) {
-    return !isNull(val);
-}
-_null.isntNull = isntNull;
-
-var _undefined = {};
-
-_undefined.isntUndefined = _undefined.isUndefined = void 0;
-function isUndefined(val) {
-    return val === undefined;
-}
-_undefined.isUndefined = isUndefined;
-function isntUndefined(val) {
-    return !isUndefined(val);
-}
-_undefined.isntUndefined = isntUndefined;
-
-var _function = {};
-
-_function.isntFunction = _function.isFunction = void 0;
-function isFunction(val) {
-    return typeof val === 'function';
-}
-_function.isFunction = isFunction;
-function isntFunction(val) {
-    return !isFunction(val);
-}
-_function.isntFunction = isntFunction;
-
-asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
-const null_1$2 = _null;
-const undefined_1$1 = _undefined;
-const function_1$2 = _function;
-function isAsyncIterable(val) {
-    return (0, null_1$2.isntNull)(val)
-        && (0, undefined_1$1.isntUndefined)(val)
-        && (0, function_1$2.isFunction)(val[Symbol.asyncIterator]);
-}
-asyncIterable.isAsyncIterable = isAsyncIterable;
-function isntAsyncIterable(val) {
-    return !isAsyncIterable(val);
-}
-asyncIterable.isntAsyncIterable = isntAsyncIterable;
-
-var bigint = {};
-
-bigint.isntBigInt = bigint.isBigInt = void 0;
-function isBigInt(val) {
-    return typeof val === 'bigint';
-}
-bigint.isBigInt = isBigInt;
-function isntBigInt(val) {
-    return !isBigInt(val);
-}
-bigint.isntBigInt = isntBigInt;
-
-var boolean = {};
-
-boolean.isntBoolean = boolean.isBoolean = void 0;
-function isBoolean(val) {
-    return typeof val === 'boolean';
-}
-boolean.isBoolean = isBoolean;
-function isntBoolean(val) {
-    return !isBoolean(val);
-}
-boolean.isntBoolean = isntBoolean;
-
-var char = {};
-
-var string = {};
-
-string.isntString = string.isString = void 0;
-function isString(val) {
-    return typeof val === 'string';
-}
-string.isString = isString;
-function isntString(val) {
-    return !isString(val);
-}
-string.isntString = isntString;
-
-char.isntChar = char.isChar = void 0;
-const string_1$1 = string;
-function isChar(val) {
-    return (0, string_1$1.isString)(val)
-        && val.length === 1;
-}
-char.isChar = isChar;
-function isntChar(val) {
-    return !isChar(val);
-}
-char.isntChar = isntChar;
-
-var date = {};
-
-date.isntDate = date.isDate = void 0;
-function isDate(val) {
-    return val instanceof Date;
-}
-date.isDate = isDate;
-function isntDate(val) {
-    return !isDate(val);
-}
-date.isntDate = isntDate;
-
-var _enum = {};
-
-_enum.inEnum = void 0;
-function inEnum(val, _enum) {
-    return Object.values(_enum).includes(val);
-}
-_enum.inEnum = inEnum;
-
-var error = {};
-
-error.isntError = error.isError = void 0;
-function isError(val) {
-    return val instanceof Error;
-}
-error.isError = isError;
-function isntError(val) {
-    return !isError(val);
-}
-error.isntError = isntError;
-
-var falsy = {};
-
-falsy.isntFalsy = falsy.isFalsy = void 0;
-function isFalsy(val) {
-    return !val;
-}
-falsy.isFalsy = isFalsy;
-function isntFalsy(val) {
-    return !isFalsy(val);
-}
-falsy.isntFalsy = isntFalsy;
-
-var iterable = {};
-
-iterable.isntIterable = iterable.isIterable = void 0;
-const null_1$1 = _null;
-const undefined_1 = _undefined;
-const function_1$1 = _function;
-function isIterable(val) {
-    return (0, null_1$1.isntNull)(val)
-        && (0, undefined_1.isntUndefined)(val)
-        && (0, function_1$1.isFunction)(val[Symbol.iterator]);
-}
-iterable.isIterable = isIterable;
-function isntIterable(val) {
-    return !isIterable(val);
-}
-iterable.isntIterable = isntIterable;
-
-var json$1 = {};
-
-var number = {};
-
-number.isntNaN = number.isNaN = number.isNegativeInfinity = number.isPositiveInfinity = number.isFinite = number.isntNumber = number.isNumber = void 0;
-function isNumber(val) {
-    return typeof val === 'number';
-}
-number.isNumber = isNumber;
-function isntNumber(val) {
-    return !isNumber(val);
-}
-number.isntNumber = isntNumber;
-function isFinite(val) {
-    return Number.isFinite(val);
-}
-number.isFinite = isFinite;
-function isPositiveInfinity(val) {
-    return val === Infinity;
-}
-number.isPositiveInfinity = isPositiveInfinity;
-function isNegativeInfinity(val) {
-    return val === -Infinity;
-}
-number.isNegativeInfinity = isNegativeInfinity;
-function isNaN(val) {
-    return Number.isNaN(val);
-}
-number.isNaN = isNaN;
-function isntNaN(val) {
-    return !isNaN(val);
-}
-number.isntNaN = isntNaN;
-
-var object = {};
-
-var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
-const isPlainObject_1 = __importDefault(isPlainObject_1$2);
-function isObject(val) {
-    return val !== null
-        && typeof val === 'object';
-}
-object.isObject = isObject;
-function isntObject(val) {
-    return !isObject(val);
-}
-object.isntObject = isntObject;
-function isPlainObject(val) {
-    return (0, isPlainObject_1.default)(val);
-}
-object.isPlainObject = isPlainObject;
-function isntPlainObject(val) {
-    return !isPlainObject(val);
-}
-object.isntPlainObject = isntPlainObject;
-function isEmptyObject(val) {
-    return Object.keys(val).length === 0;
-}
-object.isEmptyObject = isEmptyObject;
-function isntEmptyObject(val) {
-    return Object.keys(val).length !== 0;
-}
-object.isntEmptyObject = isntEmptyObject;
-
-json$1.isntJsonable = json$1.isJsonable = json$1.isntJson = json$1.isJson = void 0;
-const null_1 = _null;
-const boolean_1 = boolean;
-const string_1 = string;
-const number_1 = number;
-const array_1 = array;
-const object_1$1 = object;
-function isJson(val) {
-    return (0, null_1.isNull)(val)
-        || (0, boolean_1.isBoolean)(val)
-        || (0, string_1.isString)(val)
-        || (0, number_1.isNumber)(val)
-        || ((0, array_1.isArray)(val) && val.every(isJson))
-        || ((0, object_1$1.isPlainObject)(val) && Object.values(val).every(isJson));
-}
-json$1.isJson = isJson;
-function isntJson(val) {
-    return !isJson(val);
-}
-json$1.isntJson = isntJson;
-function isJsonable(val) {
-    try {
-        JSON.stringify(val);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-json$1.isJsonable = isJsonable;
-function isntJsonable(val) {
-    return !isntJsonable();
-}
-json$1.isntJsonable = isntJsonable;
-
-var promise = {};
-
-promise.isPromiseLike = promise.isntPromiseLike = promise.isntPromise = promise.isPromise = void 0;
-const object_1 = object;
-const function_1 = _function;
-function isPromise(val) {
-    return val instanceof Promise;
-}
-promise.isPromise = isPromise;
-function isntPromise(val) {
-    return !isPromise(val);
-}
-promise.isntPromise = isntPromise;
-function isntPromiseLike(val) {
-    return !isPromiseLike(val);
-}
-promise.isntPromiseLike = isntPromiseLike;
-function isPromiseLike(val) {
-    return (0, object_1.isObject)(val)
-        && (0, function_1.isFunction)(val.then);
-}
-promise.isPromiseLike = isPromiseLike;
-
-var url$1 = {};
-
-url$1.isAbsoluteURL = void 0;
-function isAbsoluteURL(str) {
-    try {
-        new URL(str);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-url$1.isAbsoluteURL = isAbsoluteURL;
-
-var regexp = {};
-
-regexp.isntRegExp = regexp.isRegExp = void 0;
-function isRegExp(val) {
-    return val instanceof RegExp;
-}
-regexp.isRegExp = isRegExp;
-function isntRegExp(val) {
-    return !isRegExp(val);
-}
-regexp.isntRegExp = isntRegExp;
-
-var symbol = {};
-
-symbol.isntSymbol = symbol.isSymbol = void 0;
-function isSymbol(val) {
-    return typeof val === 'symbol';
-}
-symbol.isSymbol = isSymbol;
-function isntSymbol(val) {
-    return !isSymbol(val);
-}
-symbol.isntSymbol = isntSymbol;
-
-(function (exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(array, exports);
-__exportStar(asyncIterable, exports);
-__exportStar(bigint, exports);
-__exportStar(boolean, exports);
-__exportStar(char, exports);
-__exportStar(date, exports);
-__exportStar(_enum, exports);
-__exportStar(error, exports);
-__exportStar(falsy, exports);
-__exportStar(_function, exports);
-__exportStar(iterable, exports);
-__exportStar(json$1, exports);
-__exportStar(_null, exports);
-__exportStar(number, exports);
-__exportStar(object, exports);
-__exportStar(promise, exports);
-__exportStar(string, exports);
-__exportStar(_undefined, exports);
-__exportStar(url$1, exports);
-__exportStar(regexp, exports);
-__exportStar(symbol, exports);
-
-}(es2018$3));
+getElapsedTime$1.getElapsedTime = getElapsedTime;
 
 time$1.time = void 0;
-const high_resolution_timestamp_1$2 = highResolutionTimestamp_browser;
+const extra_compatible_1$2 = lib;
+const get_elapsed_time_1$2 = getElapsedTime$1;
 const types_1$1 = es2018$3;
 function time(message, fn) {
-    const startTime = (0, high_resolution_timestamp_1$2.now)();
+    const startTime = (0, extra_compatible_1$2.performanceNow)();
     const result = fn();
     if ((0, types_1$1.isPromiseLike)(result)) {
         return result.then(() => {
-            const endTime = (0, high_resolution_timestamp_1$2.now)();
-            console.log(message, (0, high_resolution_timestamp_1$2.elapsed)(startTime, endTime));
+            const endTime = (0, extra_compatible_1$2.performanceNow)();
+            console.log(message, (0, get_elapsed_time_1$2.getElapsedTime)(startTime, endTime));
             return result;
         });
     }
     else {
-        const endTime = (0, high_resolution_timestamp_1$2.now)();
-        console.log(message, (0, high_resolution_timestamp_1$2.elapsed)(startTime, endTime));
+        const endTime = (0, extra_compatible_1$2.performanceNow)();
+        console.log(message, (0, get_elapsed_time_1$2.getElapsedTime)(startTime, endTime));
         return result;
     }
 }
@@ -3399,13 +3070,14 @@ time$1.time = time;
 var timeFunction$1 = {};
 
 timeFunction$1.timeFunction = void 0;
-const high_resolution_timestamp_1$1 = highResolutionTimestamp_browser;
+const extra_compatible_1$1 = lib;
+const get_elapsed_time_1$1 = getElapsedTime$1;
 function timeFunction(message, fn) {
     return function (...args) {
-        const startTime = (0, high_resolution_timestamp_1$1.now)();
+        const startTime = (0, extra_compatible_1$1.performanceNow)();
         const result = fn(...args);
-        const endTime = (0, high_resolution_timestamp_1$1.now)();
-        console.log(message, (0, high_resolution_timestamp_1$1.elapsed)(startTime, endTime));
+        const endTime = (0, extra_compatible_1$1.performanceNow)();
+        console.log(message, (0, get_elapsed_time_1$1.getElapsedTime)(startTime, endTime));
         return result;
     };
 }
@@ -3414,13 +3086,14 @@ timeFunction$1.timeFunction = timeFunction;
 var timeAsyncFunction$1 = {};
 
 timeAsyncFunction$1.timeAsyncFunction = void 0;
-const high_resolution_timestamp_1 = highResolutionTimestamp_browser;
+const extra_compatible_1 = lib;
+const get_elapsed_time_1 = getElapsedTime$1;
 function timeAsyncFunction(message, fn) {
     return async function (...args) {
-        const startTime = (0, high_resolution_timestamp_1.now)();
+        const startTime = (0, extra_compatible_1.performanceNow)();
         const result = await fn(...args);
-        const endTime = (0, high_resolution_timestamp_1.now)();
-        console.log(message, (0, high_resolution_timestamp_1.elapsed)(startTime, endTime));
+        const endTime = (0, extra_compatible_1.performanceNow)();
+        console.log(message, (0, get_elapsed_time_1.getElapsedTime)(startTime, endTime));
         return result;
     };
 }
@@ -3428,73 +3101,8 @@ timeAsyncFunction$1.timeAsyncFunction = timeAsyncFunction;
 
 var group$1 = {};
 
-var es2018$2 = {};
-
-var go$1 = {};
-
-go$1.go = void 0;
-function go(fn) {
-    return fn();
-}
-go$1.go = go;
-
-var goMicrotask$1 = {};
-
-goMicrotask$1.goMicrotask = void 0;
-function goMicrotask(fn) {
-    return new Promise((resolve, reject) => {
-        queueMicrotask(async () => {
-            try {
-                resolve(await fn());
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-    });
-}
-goMicrotask$1.goMicrotask = goMicrotask;
-
-var goMacrotask$1 = {};
-
-goMacrotask$1.goMacrotask = void 0;
-const extra_timers_1 = es2018$8;
-function goMacrotask(fn) {
-    return new Promise((resolve, reject) => {
-        (0, extra_timers_1.setImmediate)(async () => {
-            try {
-                resolve(await fn());
-            }
-            catch (e) {
-                reject(e);
-            }
-        });
-    });
-}
-goMacrotask$1.goMacrotask = goMacrotask;
-
-(function (exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(go$1, exports);
-__exportStar(goMicrotask$1, exports);
-__exportStar(goMacrotask$1, exports);
-
-}(es2018$2));
-
 group$1.group = void 0;
-const go_1 = es2018$2;
+const go_1 = es2018$6;
 const types_1 = es2018$3;
 function group(...args) {
     const [label, fn] = (0, go_1.go)(() => {
@@ -3539,9 +3147,9 @@ __exportStar(timeFunction$1, exports);
 __exportStar(timeAsyncFunction$1, exports);
 __exportStar(group$1, exports);
 
-}(es2018$4));
+}(es2018$1));
 
-var es2018$1 = {};
+var es2018 = {};
 
 var lazy$1 = {};
 
@@ -3653,54 +3261,25 @@ __exportStar(lazyFunction$1, exports);
 __exportStar(lazyAsyncFunction$1, exports);
 __exportStar(lazyStatic$1, exports);
 
-}(es2018$1));
-
-var es2018 = {};
-
-var pass$1 = {};
-
-pass$1.pass = void 0;
-function pass() { }
-pass$1.pass = pass;
-
-var passAsync$1 = {};
-
-passAsync$1.passAsync = void 0;
-async function passAsync() { }
-passAsync$1.passAsync = passAsync;
-
-(function (exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(pass$1, exports);
-__exportStar(passAsync$1, exports);
-
 }(es2018));
 
 (function (exports) {
-exports.isntNumber = exports.isntNull = exports.isntJson = exports.isntIterable = exports.isntFunction = exports.isntFalsy = exports.isntError = exports.isntEmptyObject = exports.isntEmptyArray = exports.isntDate = exports.isntChar = exports.isntBoolean = exports.isntBigInt = exports.isntAsyncIterable = exports.isntArray = exports.isSymbol = exports.isRegExp = exports.isUndefined = exports.isString = exports.isPromiseLike = exports.isPromise = exports.isPlainObject = exports.isObject = exports.isntNaN = exports.isNaN = exports.isNegativeInfinity = exports.isPositiveInfinity = exports.isFinite = exports.isNumber = exports.isNull = exports.isJson = exports.isIterable = exports.isFunction = exports.isFalsy = exports.isError = exports.isEmptyObject = exports.isEmptyArray = exports.isDate = exports.isChar = exports.isBoolean = exports.isBigInt = exports.isAsyncIterable = exports.isArray = exports.toArrayAsync = exports.toArray = exports.pass = exports.lazy = exports.log = exports.go = exports.assert = void 0;
-exports.isntSymbol = exports.isntRegExp = exports.isntUndefined = exports.isntString = exports.isntPromiseLike = exports.isntPromise = exports.isntPlainObject = exports.isntObject = void 0;
-var errors_1 = es2018$b;
+exports.isntNull = exports.isntJson = exports.isntIterable = exports.isntFunction = exports.isntFalsy = exports.isntError = exports.isntEmptyObject = exports.isntEmptyArray = exports.isntDate = exports.isntChar = exports.isntBoolean = exports.isntBigInt = exports.isntAsyncIterable = exports.isntArray = exports.isSymbol = exports.isRegExp = exports.isUndefined = exports.isString = exports.isPromiseLike = exports.isPromise = exports.isPlainObject = exports.isObject = exports.isntNaN = exports.isNaN = exports.isNegativeInfinity = exports.isPositiveInfinity = exports.isFinite = exports.isNumber = exports.isNullish = exports.isNull = exports.isJson = exports.isIterable = exports.isFunction = exports.isFalsy = exports.isError = exports.isEmptyObject = exports.isEmptyArray = exports.isDate = exports.isChar = exports.isBoolean = exports.isBigInt = exports.isAsyncIterable = exports.isArray = exports.toArrayAsync = exports.toArray = exports.pass = exports.lazy = exports.log = exports.go = exports.assert = void 0;
+exports.isntSymbol = exports.isntRegExp = exports.isntUndefined = exports.isntString = exports.isntPromiseLike = exports.isntPromise = exports.isntPlainObject = exports.isntObject = exports.isntNumber = exports.isntNullish = void 0;
+var errors_1 = es2018$8;
 Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return errors_1.assert; } });
-var go_1 = es2018$9;
+var go_1 = es2018$6;
 Object.defineProperty(exports, "go", { enumerable: true, get: function () { return go_1.go; } });
-var log_1 = es2018$4;
+var log_1 = es2018$1;
 Object.defineProperty(exports, "log", { enumerable: true, get: function () { return log_1.log; } });
-var extra_lazy_1 = es2018$1;
+var extra_lazy_1 = es2018;
 Object.defineProperty(exports, "lazy", { enumerable: true, get: function () { return extra_lazy_1.lazy; } });
-var pass_1 = es2018;
+var pass_1 = es2018$2;
 Object.defineProperty(exports, "pass", { enumerable: true, get: function () { return pass_1.pass; } });
-var iterable_operator_1 = es2018$a;
+var iterable_operator_1 = es2018$7;
 Object.defineProperty(exports, "toArray", { enumerable: true, get: function () { return iterable_operator_1.toArray; } });
 Object.defineProperty(exports, "toArrayAsync", { enumerable: true, get: function () { return iterable_operator_1.toArrayAsync; } });
-var types_1 = es2018$6;
+var types_1 = es2018$3;
 Object.defineProperty(exports, "isArray", { enumerable: true, get: function () { return types_1.isArray; } });
 Object.defineProperty(exports, "isAsyncIterable", { enumerable: true, get: function () { return types_1.isAsyncIterable; } });
 Object.defineProperty(exports, "isBigInt", { enumerable: true, get: function () { return types_1.isBigInt; } });
@@ -3715,6 +3294,7 @@ Object.defineProperty(exports, "isFunction", { enumerable: true, get: function (
 Object.defineProperty(exports, "isIterable", { enumerable: true, get: function () { return types_1.isIterable; } });
 Object.defineProperty(exports, "isJson", { enumerable: true, get: function () { return types_1.isJson; } });
 Object.defineProperty(exports, "isNull", { enumerable: true, get: function () { return types_1.isNull; } });
+Object.defineProperty(exports, "isNullish", { enumerable: true, get: function () { return types_1.isNullish; } });
 Object.defineProperty(exports, "isNumber", { enumerable: true, get: function () { return types_1.isNumber; } });
 Object.defineProperty(exports, "isFinite", { enumerable: true, get: function () { return types_1.isFinite; } });
 Object.defineProperty(exports, "isPositiveInfinity", { enumerable: true, get: function () { return types_1.isPositiveInfinity; } });
@@ -3743,6 +3323,7 @@ Object.defineProperty(exports, "isntFunction", { enumerable: true, get: function
 Object.defineProperty(exports, "isntIterable", { enumerable: true, get: function () { return types_1.isntIterable; } });
 Object.defineProperty(exports, "isntJson", { enumerable: true, get: function () { return types_1.isntJson; } });
 Object.defineProperty(exports, "isntNull", { enumerable: true, get: function () { return types_1.isntNull; } });
+Object.defineProperty(exports, "isntNullish", { enumerable: true, get: function () { return types_1.isntNullish; } });
 Object.defineProperty(exports, "isntNumber", { enumerable: true, get: function () { return types_1.isntNumber; } });
 Object.defineProperty(exports, "isntObject", { enumerable: true, get: function () { return types_1.isntObject; } });
 Object.defineProperty(exports, "isntPlainObject", { enumerable: true, get: function () { return types_1.isntPlainObject; } });
@@ -3753,7 +3334,7 @@ Object.defineProperty(exports, "isntUndefined", { enumerable: true, get: functio
 Object.defineProperty(exports, "isntRegExp", { enumerable: true, get: function () { return types_1.isntRegExp; } });
 Object.defineProperty(exports, "isntSymbol", { enumerable: true, get: function () { return types_1.isntSymbol; } });
 
-}(es2018$c));
+}(es2018$9));
 
 function get(...transformers) {
     return request('GET', ...transformers);
@@ -3774,12 +3355,12 @@ function del(...transformers) {
     return request('DELETE', ...transformers);
 }
 function request(method, ...transformers) {
-    const options = transformers.reduce((options, trans) => es2018$c.isFunction(trans) ? trans(options) : options, {
+    const options = transformers.reduce((options, trans) => es2018$9.isFunction(trans) ? trans(options) : options, {
         url: new URL('http://localhost'),
-        headers: new es2018$d.Headers()
+        headers: new es2018$a.Headers()
     });
-    const headers = new es2018$d.Headers(options.headers);
-    return new es2018$d.Request(options.url.href, {
+    const headers = new es2018$a.Headers(options.headers);
+    return new es2018$a.Request(options.url.href, {
         method,
         headers,
         signal: options.signal,
@@ -3797,7 +3378,7 @@ function url(...urls) {
 
 function text(payload) {
     return (options) => {
-        const headers = new es2018$d.Headers(options.headers);
+        const headers = new es2018$a.Headers(options.headers);
         headers.set('Content-Type', 'application/x-www-form-urlencoded');
         return Object.assign(Object.assign({}, options), { headers,
             payload });
@@ -3806,7 +3387,7 @@ function text(payload) {
 
 function json(payload) {
     return (options) => {
-        const headers = new es2018$d.Headers(options.headers);
+        const headers = new es2018$a.Headers(options.headers);
         headers.set('Content-Type', 'application/json');
         return Object.assign(Object.assign({}, options), { headers, payload: JSON.stringify(payload) });
     };
@@ -3826,9 +3407,9 @@ License: MIT
 }(papaparse_min));
 
 function csv(payload) {
-    es2018$c.assert(payload.length > 0, 'payload must be a non-empty array');
+    es2018$9.assert(payload.length > 0, 'payload must be a non-empty array');
     return (options) => {
-        const headers = new es2018$d.Headers(options.headers);
+        const headers = new es2018$a.Headers(options.headers);
         headers.set('Content-Type', 'text/csv');
         return Object.assign(Object.assign({}, options), { headers, payload: stringify(payload) });
     };
@@ -3846,7 +3427,7 @@ function signal(signal) {
 
 function header(name, value) {
     return (options) => {
-        const headers = new es2018$d.Headers(options.headers);
+        const headers = new es2018$a.Headers(options.headers);
         headers.set(name, value);
         return Object.assign(Object.assign({}, options), { headers });
     };
@@ -3854,7 +3435,7 @@ function header(name, value) {
 
 function appendHeader(name, value) {
     return (options) => {
-        const headers = new es2018$d.Headers(options.headers);
+        const headers = new es2018$a.Headers(options.headers);
         headers.append(name, value);
         return Object.assign(Object.assign({}, options), { headers });
     };
@@ -3862,7 +3443,7 @@ function appendHeader(name, value) {
 
 function headers(headers) {
     return (options) => {
-        const newHeaders = new es2018$d.Headers(options.headers);
+        const newHeaders = new es2018$a.Headers(options.headers);
         for (const [name, value] of Object.entries(headers)) {
             newHeaders.set(name, value);
         }
@@ -3900,7 +3481,7 @@ function pathname(pathname) {
 
 function appendPathname(pathname) {
     return (options) => {
-        const base = es2018$c.go(() => {
+        const base = es2018$9.go(() => {
             const url = new URL(options.url.href);
             url.pathname = url.pathname.endsWith('/')
                 ? url.pathname
@@ -3956,10 +3537,10 @@ function appendSearchParam(name, value) {
 
 function formDataField(name, value) {
     return (options) => {
-        const formData = options.payload instanceof es2018$d.FormData
+        const formData = options.payload instanceof es2018$a.FormData
             ? cloneFormData(options.payload)
-            : new es2018$d.FormData();
-        if (es2018$c.isArray(value)) {
+            : new es2018$a.FormData();
+        if (es2018$9.isArray(value)) {
             value.forEach(x => formData.append(name, x));
         }
         else {
@@ -3969,7 +3550,7 @@ function formDataField(name, value) {
     };
 }
 function cloneFormData(formData) {
-    const result = new es2018$d.FormData();
+    const result = new es2018$a.FormData();
     for (const [name, value] of formData.entries()) {
         result.append(name, value);
     }