@blackglory/match 0.3.2 → 0.3.5

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$5 = {};
+var es2018$7 = {};
 
 var flatMap$1 = {};
 
@@ -34,14 +34,14 @@ flatMap$1.flatMap = void 0;
 const utils_1$5 = utils$1;
 const remove_all_children_1 = removeAllChildren$1;
 function flatMap(node, fn) {
-    const newNodes = utils_1$5.cloneNodes(fn(utils_1$5.clone(node)));
+    const newNodes = (0, utils_1$5.cloneNodes)(fn((0, utils_1$5.clone)(node)));
     return newNodes.map(node => {
         const newChildNodes = [];
         for (const childNode of node.childNodes) {
-            newChildNodes.push(...utils_1$5.cloneNodes(flatMap(childNode, fn)));
+            newChildNodes.push(...(0, utils_1$5.cloneNodes)(flatMap(childNode, fn)));
         }
-        remove_all_children_1.removeAllChildren(node);
-        utils_1$5.copyNodesToChildNodes(newChildNodes, node);
+        (0, remove_all_children_1.removeAllChildren)(node);
+        (0, utils_1$5.copyNodesToChildNodes)(newChildNodes, node);
         return node;
     });
 }
@@ -52,7 +52,7 @@ var map$3 = {};
 map$3.map = void 0;
 const utils_1$4 = utils$1;
 function map$2(node, fn) {
-    const newNode = utils_1$4.clone(fn(utils_1$4.clone(node)));
+    const newNode = (0, utils_1$4.clone)(fn((0, utils_1$4.clone)(node)));
     for (const node of newNode.childNodes) {
         newNode.replaceChild(map$2(node, fn), node);
     }
@@ -65,7 +65,7 @@ var filter$3 = {};
 filter$3.filter = void 0;
 const flat_map_1$1 = flatMap$1;
 function filter$2(node, predicate) {
-    const results = flat_map_1$1.flatMap(node, node => {
+    const results = (0, flat_map_1$1.flatMap)(node, node => {
         if (predicate(node)) {
             return [node];
         }
@@ -81,13 +81,13 @@ filter$3.filter = filter$2;
 
 var unwrap$1 = {};
 
-var es2018$4 = {};
+var es2018$6 = {};
 
 var middleware = {};
 
 var chunkAsync$1 = {};
 
-var es2018$3 = {};
+var es2018$5 = {};
 
 var go$1 = {};
 
@@ -109,9 +109,9 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };__exportStar(go$1, exports);
 
-}(es2018$3));
+}(es2018$5));
 
-var es2018$2 = {};
+var es2018$4 = {};
 
 var customError = {};
 
@@ -189,15 +189,15 @@ __exportStar(normalize$3, exports);
 __exportStar(refute$1, exports);
 __exportStar(assert$1, exports);
 
-}(es2018$2));
+}(es2018$4));
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$f = es2018$3;
-const errors_1$m = es2018$2;
+const go_1$g = es2018$5;
+const errors_1$m = es2018$4;
 function chunkAsync(iterable, size) {
-    errors_1$m.assert(Number.isInteger(size), 'The parameter size must be an integer');
-    errors_1$m.assert(size > 0, 'The parameter size must be greater than 0');
-    return go_1$f.go(async function* () {
+    (0, errors_1$m.assert)(Number.isInteger(size), 'The parameter size must be an integer');
+    (0, errors_1$m.assert)(size > 0, 'The parameter size must be greater than 0');
+    return (0, go_1$g.go)(async function* () {
         let buffer = [];
         for await (const element of iterable) {
             buffer.push(element);
@@ -214,319 +214,297 @@ chunkAsync$1.chunkAsync = chunkAsync;
 
 var chunkByAsync$1 = {};
 
-var es2018$1 = {};
+var es2018$3 = {};
 
-var array = {};
+var array$1 = {};
 
-array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
-function isArray(val) {
+array$1.isntEmptyArray = array$1.isEmptyArray = array$1.isntArray = array$1.isArray = void 0;
+function isArray$1(val) {
     return Array.isArray(val);
 }
-array.isArray = isArray;
-function isntArray(val) {
-    return !isArray(val);
+array$1.isArray = isArray$1;
+function isntArray$1(val) {
+    return !isArray$1(val);
 }
-array.isntArray = isntArray;
-function isEmptyArray(val) {
+array$1.isntArray = isntArray$1;
+function isEmptyArray$1(val) {
     return val.length === 0;
 }
-array.isEmptyArray = isEmptyArray;
-function isntEmptyArray(val) {
+array$1.isEmptyArray = isEmptyArray$1;
+function isntEmptyArray$1(val) {
     return val.length !== 0;
 }
-array.isntEmptyArray = isntEmptyArray;
+array$1.isntEmptyArray = isntEmptyArray$1;
 
-var asyncIterable = {};
+var asyncIterable$1 = {};
 
-var _null = {};
+var _null$1 = {};
 
-_null.isntNull = _null.isNull = void 0;
-function isNull(val) {
+_null$1.isntNull = _null$1.isNull = void 0;
+function isNull$1(val) {
     return val === null;
 }
-_null.isNull = isNull;
-function isntNull(val) {
-    return !isNull(val);
+_null$1.isNull = isNull$1;
+function isntNull$1(val) {
+    return !isNull$1(val);
 }
-_null.isntNull = isntNull;
+_null$1.isntNull = isntNull$1;
 
-var _undefined = {};
+var _undefined$1 = {};
 
-_undefined.isntUndefined = _undefined.isUndefined = void 0;
-function isUndefined(val) {
+_undefined$1.isntUndefined = _undefined$1.isUndefined = void 0;
+function isUndefined$1(val) {
     return val === undefined;
 }
-_undefined.isUndefined = isUndefined;
-function isntUndefined(val) {
-    return !isUndefined(val);
+_undefined$1.isUndefined = isUndefined$1;
+function isntUndefined$1(val) {
+    return !isUndefined$1(val);
 }
-_undefined.isntUndefined = isntUndefined;
+_undefined$1.isntUndefined = isntUndefined$1;
 
-asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
-const null_1$1 = _null;
-const undefined_1$2 = _undefined;
-function isAsyncIterable(val) {
-    return null_1$1.isntNull(val)
-        && undefined_1$2.isntUndefined(val)
+asyncIterable$1.isntAsyncIterable = asyncIterable$1.isAsyncIterable = void 0;
+const null_1$3 = _null$1;
+const undefined_1$5 = _undefined$1;
+function isAsyncIterable$1(val) {
+    return (0, null_1$3.isntNull)(val)
+        && (0, undefined_1$5.isntUndefined)(val)
         && typeof val[Symbol.asyncIterator] === 'function';
 }
-asyncIterable.isAsyncIterable = isAsyncIterable;
-function isntAsyncIterable(val) {
-    return !isAsyncIterable(val);
+asyncIterable$1.isAsyncIterable = isAsyncIterable$1;
+function isntAsyncIterable$1(val) {
+    return !isAsyncIterable$1(val);
 }
-asyncIterable.isntAsyncIterable = isntAsyncIterable;
+asyncIterable$1.isntAsyncIterable = isntAsyncIterable$1;
 
-var bigint = {};
+var bigint$1 = {};
 
-bigint.isntBigInt = bigint.isBigInt = void 0;
-function isBigInt(val) {
+bigint$1.isntBigInt = bigint$1.isBigInt = void 0;
+function isBigInt$1(val) {
     return typeof val === 'bigint';
 }
-bigint.isBigInt = isBigInt;
-function isntBigInt(val) {
-    return !isBigInt(val);
+bigint$1.isBigInt = isBigInt$1;
+function isntBigInt$1(val) {
+    return !isBigInt$1(val);
 }
-bigint.isntBigInt = isntBigInt;
+bigint$1.isntBigInt = isntBigInt$1;
 
-var boolean = {};
+var boolean$1 = {};
 
-boolean.isntBoolean = boolean.isBoolean = void 0;
-function isBoolean(val) {
+boolean$1.isntBoolean = boolean$1.isBoolean = void 0;
+function isBoolean$1(val) {
     return typeof val === 'boolean';
 }
-boolean.isBoolean = isBoolean;
-function isntBoolean(val) {
-    return !isBoolean(val);
+boolean$1.isBoolean = isBoolean$1;
+function isntBoolean$1(val) {
+    return !isBoolean$1(val);
 }
-boolean.isntBoolean = isntBoolean;
+boolean$1.isntBoolean = isntBoolean$1;
 
-var char = {};
+var char$1 = {};
 
-var string = {};
+var string$1 = {};
 
-string.isntStringObject = string.isStringObject = string.isntStringPrimitive = string.isStringPrimitive = string.isntString = string.isString = void 0;
-function isString(val) {
-    return isStringPrimitive(val) || isStringObject(val);
-}
-string.isString = isString;
-function isntString(val) {
-    return !isString(val);
-}
-string.isntString = isntString;
-function isStringPrimitive(val) {
+string$1.isntString = string$1.isString = void 0;
+function isString$1(val) {
     return typeof val === 'string';
 }
-string.isStringPrimitive = isStringPrimitive;
-function isntStringPrimitive(val) {
-    return !isStringPrimitive(val);
-}
-string.isntStringPrimitive = isntStringPrimitive;
-function isStringObject(val) {
-    return typeof val === 'object' && val instanceof String;
+string$1.isString = isString$1;
+function isntString$1(val) {
+    return !isString$1(val);
 }
-string.isStringObject = isStringObject;
-function isntStringObject(val) {
-    return !isStringObject(val);
-}
-string.isntStringObject = isntStringObject;
+string$1.isntString = isntString$1;
 
-char.isntCharObject = char.isCharObject = char.isntCharPrimitive = char.isCharPrimitive = char.isntChar = char.isChar = void 0;
-const string_1$1 = string;
-function isChar(val) {
-    return (string_1$1.isString(val) || string_1$1.isStringObject(val))
-        && val.length === 1;
-}
-char.isChar = isChar;
-function isntChar(val) {
-    return !isChar(val);
-}
-char.isntChar = isntChar;
-function isCharPrimitive(val) {
-    return string_1$1.isString(val)
+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)
         && val.length === 1;
 }
-char.isCharPrimitive = isCharPrimitive;
-function isntCharPrimitive(val) {
-    return !isCharPrimitive(val);
+char$1.isChar = isChar$1;
+function isntChar$1(val) {
+    return !isChar$1(val);
 }
-char.isntCharPrimitive = isntCharPrimitive;
-function isCharObject(val) {
-    return string_1$1.isStringObject(val)
-        && val.length === 1;
-}
-char.isCharObject = isCharObject;
-function isntCharObject(val) {
-    return !isCharObject(val);
-}
-char.isntCharObject = isntCharObject;
+char$1.isntChar = isntChar$1;
 
-var date = {};
+var date$1 = {};
 
-date.isntDate = date.isDate = void 0;
-function isDate(val) {
+date$1.isntDate = date$1.isDate = void 0;
+function isDate$1(val) {
     return val instanceof Date;
 }
-date.isDate = isDate;
-function isntDate(val) {
-    return !isDate(val);
+date$1.isDate = isDate$1;
+function isntDate$1(val) {
+    return !isDate$1(val);
 }
-date.isntDate = isntDate;
+date$1.isntDate = isntDate$1;
 
-var _enum = {};
+var _enum$1 = {};
 
-_enum.inEnum = void 0;
-function inEnum(val, _enum) {
+_enum$1.inEnum = void 0;
+function inEnum$1(val, _enum) {
     return Object.values(_enum).includes(val);
 }
-_enum.inEnum = inEnum;
+_enum$1.inEnum = inEnum$1;
 
-var falsy = {};
+var error$1 = {};
 
-falsy.isntFalsy = falsy.isFalsy = void 0;
-function isFalsy(val) {
+error$1.isntError = error$1.isError = void 0;
+function isError$1(val) {
+    return val instanceof Error;
+}
+error$1.isError = isError$1;
+function isntError$1(val) {
+    return !isError$1(val);
+}
+error$1.isntError = isntError$1;
+
+var falsy$1 = {};
+
+falsy$1.isntFalsy = falsy$1.isFalsy = void 0;
+function isFalsy$1(val) {
     return !val;
 }
-falsy.isFalsy = isFalsy;
-function isntFalsy(val) {
-    return !isFalsy(val);
+falsy$1.isFalsy = isFalsy$1;
+function isntFalsy$1(val) {
+    return !isFalsy$1(val);
 }
-falsy.isntFalsy = isntFalsy;
+falsy$1.isntFalsy = isntFalsy$1;
 
-var _function = {};
+var _function$1 = {};
 
-_function.isntFunction = _function.isFunction = void 0;
-function isFunction(val) {
+_function$1.isntFunction = _function$1.isFunction = void 0;
+function isFunction$1(val) {
     return typeof val === 'function';
 }
-_function.isFunction = isFunction;
-function isntFunction(val) {
-    return !isFunction(val);
+_function$1.isFunction = isFunction$1;
+function isntFunction$1(val) {
+    return !isFunction$1(val);
 }
-_function.isntFunction = isntFunction;
+_function$1.isntFunction = isntFunction$1;
 
-var iterable = {};
+var iterable$1 = {};
 
-iterable.isntIterable = iterable.isIterable = void 0;
-const null_1 = _null;
-const undefined_1$1 = _undefined;
-function isIterable(val) {
-    return null_1.isntNull(val)
-        && undefined_1$1.isntUndefined(val)
+iterable$1.isntIterable = iterable$1.isIterable = void 0;
+const null_1$2 = _null$1;
+const undefined_1$4 = _undefined$1;
+function isIterable$1(val) {
+    return (0, null_1$2.isntNull)(val)
+        && (0, undefined_1$4.isntUndefined)(val)
         && typeof val[Symbol.iterator] === 'function';
 }
-iterable.isIterable = isIterable;
-function isntIterable(val) {
-    return !isIterable(val);
+iterable$1.isIterable = isIterable$1;
+function isntIterable$1(val) {
+    return !isIterable$1(val);
 }
-iterable.isntIterable = isntIterable;
+iterable$1.isntIterable = isntIterable$1;
 
-var jsonRpc = {};
+var jsonRpc$1 = {};
 
-var object = {};
+var object$1 = {};
 
-object.isntEmptyObject = object.isEmptyObject = object.isRecord = object.isntObject = object.isObject = void 0;
-function isObject(val) {
+object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isRecord = object$1.isntObject = object$1.isObject = void 0;
+function isObject$2(val) {
     return val !== null && typeof val === 'object';
 }
-object.isObject = isObject;
-function isntObject(val) {
-    return !isObject(val);
+object$1.isObject = isObject$2;
+function isntObject$1(val) {
+    return !isObject$2(val);
 }
-object.isntObject = isntObject;
+object$1.isntObject = isntObject$1;
 function isRecord(val) {
-    return isObject(val);
+    return isObject$2(val);
 }
-object.isRecord = isRecord;
-function isEmptyObject(val) {
+object$1.isRecord = isRecord;
+function isEmptyObject$1(val) {
     return Object.keys(val).length === 0;
 }
-object.isEmptyObject = isEmptyObject;
-function isntEmptyObject(val) {
+object$1.isEmptyObject = isEmptyObject$1;
+function isntEmptyObject$1(val) {
     return Object.keys(val).length !== 0;
 }
-object.isntEmptyObject = isntEmptyObject;
+object$1.isntEmptyObject = isntEmptyObject$1;
 
-var number = {};
+var number$1 = {};
 
-number.isntNumber = number.isNumber = void 0;
-function isNumber(val) {
+number$1.isntNumber = number$1.isNumber = void 0;
+function isNumber$1(val) {
     return typeof val === 'number';
 }
-number.isNumber = isNumber;
-function isntNumber(val) {
-    return !isNumber(val);
-}
-number.isntNumber = isntNumber;
-
-jsonRpc.isntJsonRpcError = jsonRpc.isJsonRpcError = jsonRpc.isntJsonRpcSuccess = jsonRpc.isJsonRpcSuccess = jsonRpc.isntJsonRpcRequest = jsonRpc.isJsonRpcRequest = jsonRpc.isntJsonRpcNotification = jsonRpc.isJsonRpcNotification = void 0;
-const array_1 = array;
-const object_1 = object;
-const string_1 = string;
-const number_1 = number;
-const undefined_1 = _undefined;
-function isJsonRpcId(val) {
-    return string_1.isString(val) || number_1.isNumber(val);
-}
-function isJsonRpcParams(val) {
-    return array_1.isArray(val) || object_1.isObject(val);
-}
-function isJsonRpcNotification(val) {
-    return object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
-        && string_1.isString(val.method)
-        && undefined_1.isUndefined(val.id)
-        && isJsonRpcParams(val.params);
-}
-jsonRpc.isJsonRpcNotification = isJsonRpcNotification;
-function isntJsonRpcNotification(val) {
-    return !isJsonRpcNotification(val);
-}
-jsonRpc.isntJsonRpcNotification = isntJsonRpcNotification;
-function isJsonRpcRequest(val) {
-    return object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
-        && string_1.isString(val.method)
-        && isJsonRpcId(val.id)
-        && isJsonRpcParams(val.params);
-}
-jsonRpc.isJsonRpcRequest = isJsonRpcRequest;
-function isntJsonRpcRequest(val) {
-    return !isJsonRpcRequest(val);
-}
-jsonRpc.isntJsonRpcRequest = isntJsonRpcRequest;
-function isJsonRpcSuccess(val) {
-    return object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
-        && string_1.isString(val.id)
-        && undefined_1.isntUndefined(val.result);
-}
-jsonRpc.isJsonRpcSuccess = isJsonRpcSuccess;
-function isntJsonRpcSuccess(val) {
-    return !isJsonRpcSuccess(val);
-}
-jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
-function isJsonRpcError(val) {
-    return object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
-        && isJsonRpcId(val.id)
-        && isJsonRpcErrorObject(val.error);
-}
-jsonRpc.isJsonRpcError = isJsonRpcError;
-function isntJsonRpcError(val) {
-    return !isJsonRpcError(val);
-}
-jsonRpc.isntJsonRpcError = isntJsonRpcError;
-function isJsonRpcErrorObject(val) {
-    return object_1.isRecord(val)
-        && number_1.isNumber(val.code)
-        && string_1.isString(val.message)
-        && (undefined_1.isUndefined(val.data) || object_1.isObject(val.data));
-}
-
-var json = {};
-
-json.isntJson = json.isJson = void 0;
-function isJson(val) {
+number$1.isNumber = isNumber$1;
+function isntNumber$1(val) {
+    return !isNumber$1(val);
+}
+number$1.isntNumber = isntNumber$1;
+
+jsonRpc$1.isntJsonRpcError = jsonRpc$1.isJsonRpcError = jsonRpc$1.isntJsonRpcSuccess = jsonRpc$1.isJsonRpcSuccess = jsonRpc$1.isntJsonRpcRequest = jsonRpc$1.isJsonRpcRequest = jsonRpc$1.isntJsonRpcNotification = jsonRpc$1.isJsonRpcNotification = void 0;
+const array_1$1 = array$1;
+const object_1$1 = object$1;
+const string_1$2 = string$1;
+const number_1$1 = number$1;
+const undefined_1$3 = _undefined$1;
+function isJsonRpcId$1(val) {
+    return (0, string_1$2.isString)(val) || (0, number_1$1.isNumber)(val);
+}
+function isJsonRpcParams$1(val) {
+    return (0, array_1$1.isArray)(val) || (0, object_1$1.isObject)(val);
+}
+function isJsonRpcNotification$1(val) {
+    return (0, object_1$1.isRecord)(val)
+        && (0, string_1$2.isString)(val.jsonrpc)
+        && (0, string_1$2.isString)(val.method)
+        && (0, undefined_1$3.isUndefined)(val.id)
+        && isJsonRpcParams$1(val.params);
+}
+jsonRpc$1.isJsonRpcNotification = isJsonRpcNotification$1;
+function isntJsonRpcNotification$1(val) {
+    return !isJsonRpcNotification$1(val);
+}
+jsonRpc$1.isntJsonRpcNotification = isntJsonRpcNotification$1;
+function isJsonRpcRequest$1(val) {
+    return (0, object_1$1.isRecord)(val)
+        && (0, string_1$2.isString)(val.jsonrpc)
+        && (0, string_1$2.isString)(val.method)
+        && isJsonRpcId$1(val.id)
+        && isJsonRpcParams$1(val.params);
+}
+jsonRpc$1.isJsonRpcRequest = isJsonRpcRequest$1;
+function isntJsonRpcRequest$1(val) {
+    return !isJsonRpcRequest$1(val);
+}
+jsonRpc$1.isntJsonRpcRequest = isntJsonRpcRequest$1;
+function isJsonRpcSuccess$1(val) {
+    return (0, object_1$1.isRecord)(val)
+        && (0, string_1$2.isString)(val.jsonrpc)
+        && (0, string_1$2.isString)(val.id)
+        && 'result' in val;
+}
+jsonRpc$1.isJsonRpcSuccess = isJsonRpcSuccess$1;
+function isntJsonRpcSuccess$1(val) {
+    return !isJsonRpcSuccess$1(val);
+}
+jsonRpc$1.isntJsonRpcSuccess = isntJsonRpcSuccess$1;
+function isJsonRpcError$1(val) {
+    return (0, object_1$1.isRecord)(val)
+        && (0, string_1$2.isString)(val.jsonrpc)
+        && isJsonRpcId$1(val.id)
+        && isJsonRpcErrorObject$1(val.error);
+}
+jsonRpc$1.isJsonRpcError = isJsonRpcError$1;
+function isntJsonRpcError$1(val) {
+    return !isJsonRpcError$1(val);
+}
+jsonRpc$1.isntJsonRpcError = isntJsonRpcError$1;
+function isJsonRpcErrorObject$1(val) {
+    return (0, object_1$1.isRecord)(val)
+        && (0, number_1$1.isNumber)(val.code)
+        && (0, string_1$2.isString)(val.message)
+        && ((0, undefined_1$3.isUndefined)(val.data) || (0, object_1$1.isObject)(val.data));
+}
+
+var json$1 = {};
+
+json$1.isntJson = json$1.isJson = void 0;
+function isJson$1(val) {
     try {
         JSON.stringify(val);
         return true;
@@ -535,16 +513,16 @@ function isJson(val) {
         return false;
     }
 }
-json.isJson = isJson;
-function isntJson(val) {
-    return !isntJson();
+json$1.isJson = isJson$1;
+function isntJson$1(val) {
+    return !isntJson$1();
 }
-json.isntJson = isntJson;
+json$1.isntJson = isntJson$1;
 
-var url = {};
+var url$1 = {};
 
-url.isAbsoluteURL = void 0;
-function isAbsoluteURL(str) {
+url$1.isAbsoluteURL = void 0;
+function isAbsoluteURL$1(str) {
     try {
         new URL(str);
         return true;
@@ -553,7 +531,7 @@ function isAbsoluteURL(str) {
         return false;
     }
 }
-url.isAbsoluteURL = isAbsoluteURL;
+url$1.isAbsoluteURL = isAbsoluteURL$1;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -565,31 +543,32 @@ 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, exports);
-__exportStar(asyncIterable, exports);
-__exportStar(bigint, exports);
-__exportStar(boolean, exports);
-__exportStar(char, exports);
-__exportStar(date, exports);
-__exportStar(_enum, exports);
-__exportStar(falsy, exports);
-__exportStar(_function, exports);
-__exportStar(iterable, exports);
-__exportStar(jsonRpc, exports);
-__exportStar(json, exports);
-__exportStar(_null, exports);
-__exportStar(number, exports);
-__exportStar(object, exports);
-__exportStar(string, exports);
-__exportStar(_undefined, exports);
-__exportStar(url, exports);
+};__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(jsonRpc$1, exports);
+__exportStar(json$1, exports);
+__exportStar(_null$1, exports);
+__exportStar(number$1, exports);
+__exportStar(object$1, exports);
+__exportStar(string$1, exports);
+__exportStar(_undefined$1, exports);
+__exportStar(url$1, exports);
 
-}(es2018$1));
+}(es2018$3));
 
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$l = es2018$1;
+const types_1$l = es2018$3;
 function chunkByAsync(iterable, predicate) {
-    if (types_1$l.isAsyncIterable(iterable)) {
+    if ((0, types_1$l.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
     }
     else {
@@ -648,12 +627,12 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$e = es2018$3;
-const errors_1$l = es2018$2;
+const go_1$f = es2018$5;
+const errors_1$l = es2018$4;
 function chunk(iterable, size) {
-    errors_1$l.assert(Number.isInteger(size), 'The parameter size must be an integer');
-    errors_1$l.assert(size > 0, 'The parameter size must be greater than 0');
-    return go_1$e.go(function* () {
+    (0, errors_1$l.assert)(Number.isInteger(size), 'The parameter size must be an integer');
+    (0, errors_1$l.assert)(size > 0, 'The parameter size must be greater than 0');
+    return (0, go_1$f.go)(function* () {
         let buffer = [];
         for (const element of iterable) {
             buffer.push(element);
@@ -671,12 +650,12 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$k = es2018$1;
-const go_1$d = es2018$3;
+const types_1$k = es2018$3;
+const go_1$e = es2018$5;
 function concatAsync(iterable, ...otherIterables) {
-    return go_1$d.go(async function* () {
+    return (0, go_1$e.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
-            if (types_1$k.isAsyncIterable(iter)) {
+            if ((0, types_1$k.isAsyncIterable)(iter)) {
                 for await (const element of iter) {
                     yield element;
                 }
@@ -694,9 +673,9 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$2 = {};
 
 concat$2.concat = void 0;
-const go_1$c = es2018$3;
+const go_1$d = es2018$5;
 function concat$1(iterable, ...otherIterables) {
-    return go_1$c.go(function* () {
+    return (0, go_1$d.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
             yield* iter;
         }
@@ -723,15 +702,15 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$b = es2018$3;
+const go_1$c = es2018$5;
 const utils_1$3 = utils;
-const errors_1$k = es2018$2;
+const errors_1$k = es2018$4;
 function dropAsync(iterable, count) {
-    errors_1$k.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$k.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
+    (0, errors_1$k.assert)(Number.isInteger(count), 'The parameter count must be an integer');
+    (0, errors_1$k.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
     if (count === 0)
-        return utils_1$3.copyAsyncIterable(iterable);
-    return go_1$b.go(async function* () {
+        return (0, utils_1$3.copyAsyncIterable)(iterable);
+    return (0, go_1$c.go)(async function* () {
         var _a;
         const iterator = iterable[Symbol.asyncIterator]();
         let done;
@@ -758,15 +737,15 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$a = es2018$3;
+const go_1$b = es2018$5;
 const utils_1$2 = utils;
-const errors_1$j = es2018$2;
+const errors_1$j = es2018$4;
 function dropRightAsync(iterable, count) {
-    errors_1$j.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$j.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
+    (0, errors_1$j.assert)(Number.isInteger(count), 'The parameter count must be an integer');
+    (0, errors_1$j.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
     if (count === 0)
-        return utils_1$2.copyAsyncIterable(iterable);
-    return go_1$a.go(async function* () {
+        return (0, utils_1$2.copyAsyncIterable)(iterable);
+    return (0, go_1$b.go)(async function* () {
         const arr = await toArrayAsync$2(iterable);
         const result = arr.slice(0, -count);
         for (const value of result) {
@@ -786,15 +765,15 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$9 = es2018$3;
+const go_1$a = es2018$5;
 const utils_1$1 = utils;
-const errors_1$i = es2018$2;
+const errors_1$i = es2018$4;
 function dropRight(iterable, count) {
-    errors_1$i.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$i.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
+    (0, errors_1$i.assert)(Number.isInteger(count), 'The parameter count must be an integer');
+    (0, errors_1$i.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
     if (count === 0)
-        return utils_1$1.copyIterable(iterable);
-    return go_1$9.go(function* () {
+        return (0, utils_1$1.copyIterable)(iterable);
+    return (0, go_1$a.go)(function* () {
         const arr = Array.from(iterable);
         yield* arr.slice(0, -count);
     });
@@ -804,9 +783,9 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$j = es2018$1;
+const types_1$j = es2018$3;
 function dropUntilAsync(iterable, predicate) {
-    if (types_1$j.isAsyncIterable(iterable)) {
+    if ((0, types_1$j.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
     }
     else {
@@ -886,15 +865,15 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$8 = es2018$3;
+const go_1$9 = es2018$5;
 const utils_1 = utils;
-const errors_1$h = es2018$2;
+const errors_1$h = es2018$4;
 function drop(iterable, count) {
-    errors_1$h.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$h.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
+    (0, errors_1$h.assert)(Number.isInteger(count), 'The parameter count must be an integer');
+    (0, errors_1$h.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
     if (count === 0)
-        return utils_1.copyIterable(iterable);
-    return go_1$8.go(function* () {
+        return (0, utils_1.copyIterable)(iterable);
+    return (0, go_1$9.go)(function* () {
         var _a;
         const iterator = iterable[Symbol.iterator]();
         let done;
@@ -921,9 +900,9 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$i = es2018$1;
+const types_1$i = es2018$3;
 function filterAsync(iterable, predicate) {
-    if (types_1$i.isAsyncIterable(iterable)) {
+    if ((0, types_1$i.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
     }
     else {
@@ -968,9 +947,9 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$h = es2018$1;
+const types_1$h = es2018$3;
 function flattenByAsync(iterable, predicate) {
-    if (types_1$h.isAsyncIterable(iterable)) {
+    if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
     }
     else {
@@ -1003,30 +982,30 @@ function flattenByAsync(iterable, predicate) {
 }
 flattenByAsync$1.flattenByAsync = flattenByAsync;
 function isFiniteIterable$1(val) {
-    return types_1$h.isIterable(val) && types_1$h.isntChar(val);
+    return (0, types_1$h.isIterable)(val) && (0, types_1$h.isntChar)(val);
 }
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$g = es2018$2;
+const errors_1$g = es2018$4;
 function flattenDeepAsync(iterable, depth = Infinity) {
-    errors_1$g.assert(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
-    errors_1$g.assert(depth >= 0, 'The parameter depth must be greater than or equal to 0');
-    return flatten_by_async_1.flattenByAsync(iterable, (_, level) => level <= depth);
+    (0, errors_1$g.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
+    (0, errors_1$g.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
+    return (0, flatten_by_async_1.flattenByAsync)(iterable, (_, level) => level <= depth);
 }
 flattenDeepAsync$1.flattenDeepAsync = flattenDeepAsync;
 
 flattenAsync$1.flattenAsync = void 0;
 const flatten_deep_async_1 = flattenDeepAsync$1;
 function flattenAsync(iterable) {
-    return flatten_deep_async_1.flattenDeepAsync(iterable, 1);
+    return (0, flatten_deep_async_1.flattenDeepAsync)(iterable, 1);
 }
 flattenAsync$1.flattenAsync = flattenAsync;
 
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$g = es2018$1;
+const types_1$g = es2018$3;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1042,18 +1021,18 @@ function flattenBy(iterable, predicate) {
 }
 flattenBy$1.flattenBy = flattenBy;
 function isFiniteIterable(val) {
-    return types_1$g.isIterable(val) && types_1$g.isntChar(val);
+    return (0, types_1$g.isIterable)(val) && (0, types_1$g.isntChar)(val);
 }
 
 var flattenDeep$1 = {};
 
 flattenDeep$1.flattenDeep = void 0;
 const flatten_by_1 = flattenBy$1;
-const errors_1$f = es2018$2;
+const errors_1$f = es2018$4;
 function flattenDeep(iterable, depth = Infinity) {
-    errors_1$f.assert(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
-    errors_1$f.assert(depth >= 0, 'The parameter depth must be greater than or equal to 0');
-    return flatten_by_1.flattenBy(iterable, (_, level) => level <= depth);
+    (0, errors_1$f.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
+    (0, errors_1$f.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
+    return (0, flatten_by_1.flattenBy)(iterable, (_, level) => level <= depth);
 }
 flattenDeep$1.flattenDeep = flattenDeep;
 
@@ -1062,16 +1041,16 @@ var flatten$1 = {};
 flatten$1.flatten = void 0;
 const flatten_deep_1 = flattenDeep$1;
 function flatten(iterable) {
-    return flatten_deep_1.flattenDeep(iterable, 1);
+    return (0, flatten_deep_1.flattenDeep)(iterable, 1);
 }
 flatten$1.flatten = flatten;
 
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$f = es2018$1;
+const types_1$f = es2018$3;
 function mapAsync(iterable, fn) {
-    if (types_1$f.isAsyncIterable(iterable)) {
+    if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
     }
     else {
@@ -1109,14 +1088,14 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$7 = es2018$3;
-const errors_1$e = es2018$2;
+const go_1$8 = es2018$5;
+const errors_1$e = es2018$4;
 function repeatAsync(iterable, times) {
-    errors_1$e.assert(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
-    errors_1$e.assert(times >= 0, 'The parameter times must be greater than or equal to 0');
+    (0, errors_1$e.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
+    (0, errors_1$e.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
     if (times === Infinity)
         warnInfiniteLoop$1();
-    return go_1$7.go(async function* () {
+    return (0, go_1$8.go)(async function* () {
         const cache = [];
         if (times > 0) {
             for await (const element of iterable) {
@@ -1144,14 +1123,14 @@ function isProduction$1() {
 var repeat$4 = {};
 
 repeat$4.repeat = void 0;
-const go_1$6 = es2018$3;
-const errors_1$d = es2018$2;
+const go_1$7 = es2018$5;
+const errors_1$d = es2018$4;
 function repeat$3(iterable, times) {
-    errors_1$d.assert(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
-    errors_1$d.assert(times >= 0, 'The parameter times must be greater than or equal to 0');
+    (0, errors_1$d.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
+    (0, errors_1$d.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
     if (times === Infinity)
         warnInfiniteLoop();
-    return go_1$6.go(function* () {
+    return (0, go_1$7.go)(function* () {
         const cache = [];
         if (times > 0) {
             for (const element of iterable) {
@@ -1179,14 +1158,14 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$5 = es2018$3;
-const errors_1$c = es2018$2;
+const go_1$6 = es2018$5;
+const errors_1$c = es2018$4;
 function sliceAsync(iterable, start, end = Infinity) {
-    errors_1$c.assert(Number.isInteger(start), 'The parameter start must be an integer');
-    errors_1$c.assert(start >= 0, 'The parameter start must be greater than or equal to 0');
-    errors_1$c.assert(Number.isInteger(end), 'The parameter end must be an integer');
-    errors_1$c.assert(end >= start, 'The parameter end must be greater than or equal to start');
-    return go_1$5.go(async function* () {
+    (0, errors_1$c.assert)(Number.isInteger(start), 'The parameter start must be an integer');
+    (0, errors_1$c.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
+    (0, errors_1$c.assert)(Number.isInteger(end), 'The parameter end must be an integer');
+    (0, errors_1$c.assert)(end >= start, 'The parameter end must be greater than or equal to start');
+    return (0, go_1$6.go)(async function* () {
         let index = 0;
         for await (const element of iterable) {
             if (index >= end)
@@ -1202,14 +1181,14 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$4 = es2018$3;
-const errors_1$b = es2018$2;
+const go_1$5 = es2018$5;
+const errors_1$b = es2018$4;
 function slice(iterable, start, end = Infinity) {
-    errors_1$b.assert(Number.isInteger(start), 'The parameter start must be an integer');
-    errors_1$b.assert(start >= 0, 'The parameter start must be greater than or equal to 0');
-    errors_1$b.assert(Number.isInteger(end), 'The parameter end must be an integer');
-    errors_1$b.assert(end >= start, 'The parameter end must be greater than or equal to start');
-    return go_1$4.go(function* () {
+    (0, errors_1$b.assert)(Number.isInteger(start), 'The parameter start must be an integer');
+    (0, errors_1$b.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
+    (0, errors_1$b.assert)(Number.isInteger(end), 'The parameter end must be an integer');
+    (0, errors_1$b.assert)(end >= start, 'The parameter end must be greater than or equal to start');
+    return (0, go_1$5.go)(function* () {
         let index = 0;
         for (const element of iterable) {
             if (index >= end)
@@ -1243,9 +1222,9 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$e = es2018$1;
+const types_1$e = es2018$3;
 function splitByAsync(iterable, predicate) {
-    if (types_1$e.isAsyncIterable(iterable)) {
+    if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
     }
     else {
@@ -1325,12 +1304,12 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$3 = es2018$3;
-const errors_1$a = es2018$2;
+const go_1$4 = es2018$5;
+const errors_1$a = es2018$4;
 function takeAsync(iterable, count) {
-    errors_1$a.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$a.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
-    return go_1$3.go(async function* () {
+    (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');
+    return (0, go_1$4.go)(async function* () {
         if (count === 0)
             return;
         for await (const element of iterable) {
@@ -1346,12 +1325,12 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$2 = es2018$3;
-const errors_1$9 = es2018$2;
+const go_1$3 = es2018$5;
+const errors_1$9 = es2018$4;
 function takeRightAsync(iterable, count) {
-    errors_1$9.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$9.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
-    return go_1$2.go(async function* () {
+    (0, errors_1$9.assert)(Number.isInteger(count), 'The parameter count must be an integer');
+    (0, errors_1$9.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
+    return (0, go_1$3.go)(async function* () {
         var _a;
         const iterator = iterable[Symbol.asyncIterator]();
         let done;
@@ -1376,12 +1355,12 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$1 = es2018$3;
-const errors_1$8 = es2018$2;
+const go_1$2 = es2018$5;
+const errors_1$8 = es2018$4;
 function takeRight(iterable, count) {
-    errors_1$8.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$8.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
-    return go_1$1.go(function* () {
+    (0, errors_1$8.assert)(Number.isInteger(count), 'The parameter count must be an integer');
+    (0, errors_1$8.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
+    return (0, go_1$2.go)(function* () {
         var _a;
         const iterator = iterable[Symbol.iterator]();
         let done;
@@ -1406,9 +1385,9 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$d = es2018$1;
+const types_1$d = es2018$3;
 function takeUntilAsync(iterable, predicate) {
-    if (types_1$d.isAsyncIterable(iterable)) {
+    if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
     }
     else {
@@ -1452,12 +1431,12 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1 = es2018$3;
-const errors_1$7 = es2018$2;
+const go_1$1 = es2018$5;
+const errors_1$7 = es2018$4;
 function take(iterable, count) {
-    errors_1$7.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$7.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
-    return go_1.go(function* () {
+    (0, errors_1$7.assert)(Number.isInteger(count), 'The parameter count must be an integer');
+    (0, errors_1$7.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
+    return (0, go_1$1.go)(function* () {
         if (count === 0)
             return;
         for (const element of iterable) {
@@ -1473,9 +1452,9 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$c = es2018$1;
+const types_1$c = es2018$3;
 function tapAsync(iterable, fn) {
-    if (types_1$c.isAsyncIterable(iterable)) {
+    if ((0, types_1$c.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
     }
     else {
@@ -1556,9 +1535,9 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$b = es2018$1;
+const types_1$b = es2018$3;
 function uniqByAsync(iterable, fn) {
-    if (types_1$b.isAsyncIterable(iterable)) {
+    if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
     }
     else {
@@ -1625,7 +1604,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$a = es2018$1;
+const types_1$a = es2018$3;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -1639,7 +1618,7 @@ async function* zipWithSize$1(...iterables) {
     var _a, _b, _c, _d;
     const length = iterables.length;
     const iterators = iterables.map(iterable => {
-        if (types_1$a.isAsyncIterable(iterable)) {
+        if ((0, types_1$a.isAsyncIterable)(iterable)) {
             return [Kind.Async, iterable[Symbol.asyncIterator]()];
         }
         else {
@@ -1785,9 +1764,9 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$9 = es2018$1;
+const types_1$9 = es2018$3;
 function eachAsync(iterable, fn) {
-    if (types_1$9.isAsyncIterable(iterable)) {
+    if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
     }
     else {
@@ -1825,9 +1804,9 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$8 = es2018$1;
+const types_1$8 = es2018$3;
 function everyAsync(iterable, predicate) {
-    if (types_1$8.isAsyncIterable(iterable)) {
+    if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
     }
     else {
@@ -1871,9 +1850,9 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$7 = es2018$1;
+const types_1$7 = es2018$3;
 function findAsync(iterable, predicate) {
-    if (types_1$7.isAsyncIterable(iterable)) {
+    if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
     }
     else {
@@ -1995,9 +1974,9 @@ match$2.match = match$1;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$6 = es2018$1;
+const types_1$6 = es2018$3;
 function reduceAsync(iterable, fn, initialValue) {
-    if (types_1$6.isUndefined(initialValue)) {
+    if ((0, types_1$6.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
     }
     else {
@@ -2006,7 +1985,7 @@ function reduceAsync(iterable, fn, initialValue) {
 }
 reduceAsync$1.reduceAsync = reduceAsync;
 function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
-    if (types_1$6.isAsyncIterable(iterable)) {
+    if ((0, types_1$6.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2028,7 +2007,7 @@ function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
     }
 }
 function reduceAsyncWithoutInitialValue(iterable, fn) {
-    if (types_1$6.isAsyncIterable(iterable)) {
+    if ((0, types_1$6.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2091,9 +2070,9 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$5 = es2018$1;
+const types_1$5 = es2018$3;
 function reduce(iterable, fn, initialValue) {
-    if (types_1$5.isUndefined(initialValue)) {
+    if ((0, types_1$5.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
     }
     else {
@@ -2138,9 +2117,9 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1$4 = es2018$1;
+const types_1$4 = es2018$3;
 function someAsync(iterable, predicate) {
-    if (types_1$4.isAsyncIterable(iterable)) {
+    if ((0, types_1$4.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
     }
     else {
@@ -2230,7 +2209,7 @@ var toArrayAsync$1 = {};
 toArrayAsync$1.toArrayAsync = void 0;
 const consume_1$3 = consume$1;
 function toArrayAsync(iterable) {
-    return consume_1$3.consume(iterable, async (iterable) => {
+    return (0, consume_1$3.consume)(iterable, async (iterable) => {
         const result = [];
         for await (const element of iterable) {
             result.push(element);
@@ -2245,7 +2224,7 @@ var toArray$1 = {};
 toArray$1.toArray = void 0;
 const consume_1$2 = consume$1;
 function toArray(iterable) {
-    return consume_1$2.consume(iterable, iterable => Array.from(iterable));
+    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
 }
 toArray$1.toArray = toArray;
 
@@ -2254,7 +2233,7 @@ var toSetAsync$1 = {};
 toSetAsync$1.toSetAsync = void 0;
 const consume_1$1 = consume$1;
 function toSetAsync(iterable) {
-    return consume_1$1.consume(iterable, async (iterable) => {
+    return (0, consume_1$1.consume)(iterable, async (iterable) => {
         const result = new Set();
         for await (const element of iterable) {
             result.add(element);
@@ -2269,7 +2248,7 @@ var toSet$1 = {};
 toSet$1.toSet = void 0;
 const consume_1 = consume$1;
 function toSet(iterable) {
-    return consume_1.consume(iterable, iterable => new Set(iterable));
+    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
 }
 toSet$1.toSet = toSet;
 
@@ -2322,15 +2301,15 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 };__exportStar(middleware, exports);
 __exportStar(output, exports);
 
-}(es2018$4));
+}(es2018$6));
 
 unwrap$1.unwrap = void 0;
 const flat_map_1 = flatMap$1;
-const iterable_operator_1$2 = es2018$4;
+const iterable_operator_1$2 = es2018$6;
 function unwrap(node, predicate) {
-    return flat_map_1.flatMap(node, node => {
+    return (0, flat_map_1.flatMap)(node, node => {
         if (predicate(node)) {
-            return iterable_operator_1$2.toArray(iterable_operator_1$2.flatten(iterable_operator_1$2.map(node.childNodes, node => unwrap(node, predicate))));
+            return (0, iterable_operator_1$2.toArray)((0, iterable_operator_1$2.flatten)((0, iterable_operator_1$2.map)(node.childNodes, node => unwrap(node, predicate))));
         }
         else {
             return [node];
@@ -2356,9 +2335,9 @@ traverseDescendantNodes$1.traverseDescendantNodes = traverseDescendantNodes;
 
 findInDescendantNodes$1.findInDescendantNodes = void 0;
 const traverse_descendant_nodes_1 = traverseDescendantNodes$1;
-const iterable_operator_1$1 = es2018$4;
+const iterable_operator_1$1 = es2018$6;
 function findInDescendantNodes(node, predicate) {
-    return iterable_operator_1$1.find(traverse_descendant_nodes_1.traverseDescendantNodes(node), node => predicate(node));
+    return (0, iterable_operator_1$1.find)((0, traverse_descendant_nodes_1.traverseDescendantNodes)(node), node => predicate(node));
 }
 findInDescendantNodes$1.findInDescendantNodes = findInDescendantNodes;
 
@@ -2367,7 +2346,7 @@ const find_in_descendant_nodes_1 = findInDescendantNodes$1;
 function find(node, predicate) {
     if (predicate(node))
         return node;
-    return find_in_descendant_nodes_1.findInDescendantNodes(node, predicate);
+    return (0, find_in_descendant_nodes_1.findInDescendantNodes)(node, predicate);
 }
 find$1.find = find;
 
@@ -2397,7 +2376,7 @@ normalize$1.normalize = void 0;
 const parse_1 = parse$1;
 const stringify_1 = stringify$1;
 function normalize(html) {
-    return stringify_1.stringify(parse_1.parse(html));
+    return (0, stringify_1.stringify)((0, parse_1.parse)(html));
 }
 normalize$1.normalize = normalize;
 
@@ -2466,52 +2445,553 @@ const nodeExists = 'Node' in globalThis;
 
 }(nodeType));
 
-isDocument$1.isDocument = void 0;
-const node_type_1$2 = nodeType;
-const types_1$3 = es2018$1;
-function isDocument(val) {
-    if ('HTMLDocument' in globalThis && val instanceof HTMLDocument)
-        return true;
-    return types_1$3.isRecord(val) && val.nodeType === node_type_1$2.NodeType.DOCUMENT_NODE;
-}
-isDocument$1.isDocument = isDocument;
+var es2018$2 = {};
 
-var isElement$1 = {};
+var array = {};
 
-isElement$1.isElement = void 0;
-const node_type_1$1 = nodeType;
-const types_1$2 = es2018$1;
-function isElement(val) {
-    if ('HTMLElement' in globalThis && val instanceof HTMLElement)
-        return true;
-    return types_1$2.isRecord(val) && val.nodeType === node_type_1$1.NodeType.ELEMENT_NODE;
+array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
+function isArray(val) {
+    return Array.isArray(val);
 }
-isElement$1.isElement = isElement;
-
-getBySelector$1.getBySelector = void 0;
-const is_document_1$2 = isDocument$1;
-const is_element_1$4 = isElement$1;
-function getBySelector(selectors) {
-    const root = (is_element_1$4.isElement(this) || is_document_1$2.isDocument(this)
-        ? this
-        : document);
-    const result = root.querySelector(selectors);
-    if (result) {
-        return result;
-    }
-    else {
-        throw new Error(`Could not find any elements matching ${selectors}`);
-    }
+array.isArray = isArray;
+function isntArray(val) {
+    return !isArray(val);
 }
-getBySelector$1.getBySelector = getBySelector;
-
-var getAllBySelector$1 = {};
+array.isntArray = isntArray;
+function isEmptyArray(val) {
+    return val.length === 0;
+}
+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;
+
+asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
+const null_1$1 = _null;
+const undefined_1$2 = _undefined;
+function isAsyncIterable(val) {
+    return (0, null_1$1.isntNull)(val)
+        && (0, undefined_1$2.isntUndefined)(val)
+        && typeof val[Symbol.asyncIterator] === 'function';
+}
+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 _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;
+
+var iterable = {};
+
+iterable.isntIterable = iterable.isIterable = void 0;
+const null_1 = _null;
+const undefined_1$1 = _undefined;
+function isIterable(val) {
+    return (0, null_1.isntNull)(val)
+        && (0, undefined_1$1.isntUndefined)(val)
+        && typeof val[Symbol.iterator] === 'function';
+}
+iterable.isIterable = isIterable;
+function isntIterable(val) {
+    return !isIterable(val);
+}
+iterable.isntIterable = isntIterable;
+
+var jsonRpc = {};
+
+var object = {};
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+  // Many host objects are `Object` objects that can coerce to strings
+  // despite having improperly defined `toString` methods.
+  var result = false;
+  if (value != null && typeof value.toString != 'function') {
+    try {
+      result = !!(value + '');
+    } catch (e) {}
+  }
+  return result;
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto$1 = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto$1.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString$1 = objectProto$1.toString;
+
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike$1(value) {
+  return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject$1(value) {
+  if (!isObjectLike$1(value) ||
+      objectToString$1.call(value) != objectTag || isHostObject(value)) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+  return (typeof Ctor == 'function' &&
+    Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);
+}
+
+var lodash_isplainobject = isPlainObject$1;
+
+var __importDefault$1 = (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 lodash_isplainobject_1 = __importDefault$1(lodash_isplainobject);
+function isObject$1(val) {
+    return val !== null
+        && typeof val === 'object';
+}
+object.isObject = isObject$1;
+function isntObject(val) {
+    return !isObject$1(val);
+}
+object.isntObject = isntObject;
+function isPlainObject(val) {
+    return (0, lodash_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;
+
+var number = {};
+
+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;
+
+jsonRpc.isntJsonRpcError = jsonRpc.isJsonRpcError = jsonRpc.isntJsonRpcSuccess = jsonRpc.isJsonRpcSuccess = jsonRpc.isntJsonRpcRequest = jsonRpc.isJsonRpcRequest = jsonRpc.isntJsonRpcNotification = jsonRpc.isJsonRpcNotification = void 0;
+const array_1 = array;
+const object_1 = object;
+const string_1 = string;
+const number_1 = number;
+const undefined_1 = _undefined;
+function isJsonRpcId(val) {
+    return (0, string_1.isString)(val) || (0, number_1.isNumber)(val);
+}
+function isJsonRpcParams(val) {
+    return (0, array_1.isArray)(val) || (0, object_1.isObject)(val);
+}
+function isJsonRpcNotification(val) {
+    return (0, object_1.isPlainObject)(val)
+        && (0, string_1.isString)(val.jsonrpc)
+        && (0, string_1.isString)(val.method)
+        && (0, undefined_1.isUndefined)(val.id)
+        && isJsonRpcParams(val.params);
+}
+jsonRpc.isJsonRpcNotification = isJsonRpcNotification;
+function isntJsonRpcNotification(val) {
+    return !isJsonRpcNotification(val);
+}
+jsonRpc.isntJsonRpcNotification = isntJsonRpcNotification;
+function isJsonRpcRequest(val) {
+    return (0, object_1.isPlainObject)(val)
+        && (0, string_1.isString)(val.jsonrpc)
+        && (0, string_1.isString)(val.method)
+        && isJsonRpcId(val.id)
+        && isJsonRpcParams(val.params);
+}
+jsonRpc.isJsonRpcRequest = isJsonRpcRequest;
+function isntJsonRpcRequest(val) {
+    return !isJsonRpcRequest(val);
+}
+jsonRpc.isntJsonRpcRequest = isntJsonRpcRequest;
+function isJsonRpcSuccess(val) {
+    return (0, object_1.isPlainObject)(val)
+        && (0, string_1.isString)(val.jsonrpc)
+        && (0, string_1.isString)(val.id)
+        && 'result' in val;
+}
+jsonRpc.isJsonRpcSuccess = isJsonRpcSuccess;
+function isntJsonRpcSuccess(val) {
+    return !isJsonRpcSuccess(val);
+}
+jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
+function isJsonRpcError(val) {
+    return (0, object_1.isPlainObject)(val)
+        && (0, string_1.isString)(val.jsonrpc)
+        && isJsonRpcId(val.id)
+        && isJsonRpcErrorObject(val.error);
+}
+jsonRpc.isJsonRpcError = isJsonRpcError;
+function isntJsonRpcError(val) {
+    return !isJsonRpcError(val);
+}
+jsonRpc.isntJsonRpcError = isntJsonRpcError;
+function isJsonRpcErrorObject(val) {
+    return (0, object_1.isPlainObject)(val)
+        && (0, number_1.isNumber)(val.code)
+        && (0, string_1.isString)(val.message)
+        && ((0, undefined_1.isUndefined)(val.data) || (0, object_1.isObject)(val.data));
+}
+
+var json = {};
+
+json.isntJson = json.isJson = void 0;
+function isJson(val) {
+    try {
+        JSON.stringify(val);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+json.isJson = isJson;
+function isntJson(val) {
+    return !isntJson();
+}
+json.isntJson = isntJson;
+
+var url = {};
+
+url.isAbsoluteURL = void 0;
+function isAbsoluteURL(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+url.isAbsoluteURL = isAbsoluteURL;
+
+(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(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(jsonRpc, exports);
+__exportStar(json, exports);
+__exportStar(_null, exports);
+__exportStar(number, exports);
+__exportStar(object, exports);
+__exportStar(string, exports);
+__exportStar(_undefined, exports);
+__exportStar(url, exports);
+
+}(es2018$2));
+
+isDocument$1.isDocument = void 0;
+const node_type_1$2 = nodeType;
+const types_1$3 = es2018$2;
+function isDocument(val) {
+    if ('HTMLDocument' in globalThis && val instanceof HTMLDocument)
+        return true;
+    return (0, types_1$3.isObject)(val)
+        && val.nodeType === node_type_1$2.NodeType.DOCUMENT_NODE;
+}
+isDocument$1.isDocument = isDocument;
+
+var isElement$1 = {};
+
+isElement$1.isElement = void 0;
+const node_type_1$1 = nodeType;
+const types_1$2 = es2018$2;
+function isElement(val) {
+    if ('HTMLElement' in globalThis && val instanceof HTMLElement)
+        return true;
+    return (0, types_1$2.isObject)(val)
+        && val.nodeType === node_type_1$1.NodeType.ELEMENT_NODE;
+}
+isElement$1.isElement = isElement;
+
+getBySelector$1.getBySelector = void 0;
+const is_document_1$2 = isDocument$1;
+const is_element_1$4 = isElement$1;
+function getBySelector(selectors) {
+    const root = ((0, is_element_1$4.isElement)(this) || (0, is_document_1$2.isDocument)(this)
+        ? this
+        : document);
+    const result = root.querySelector(selectors);
+    if (result) {
+        return result;
+    }
+    else {
+        throw new Error(`Could not find any elements matching ${selectors}`);
+    }
+}
+getBySelector$1.getBySelector = getBySelector;
+
+var getAllBySelector$1 = {};
 
 getAllBySelector$1.getAllBySelector = void 0;
 const is_document_1$1 = isDocument$1;
 const is_element_1$3 = isElement$1;
 function getAllBySelector(selectors) {
-    const root = (is_element_1$3.isElement(this) || is_document_1$1.isDocument(this)
+    const root = ((0, is_element_1$3.isElement)(this) || (0, is_document_1$1.isDocument)(this)
         ? this
         : document);
     const results = root.querySelectorAll(selectors);
@@ -2540,9 +3020,9 @@ var findInAncestorNodes$1 = {};
 
 findInAncestorNodes$1.findInAncestorNodes = void 0;
 const traverse_ancestor_nodes_1 = traverseAncestorNodes$1;
-const iterable_operator_1 = es2018$4;
+const iterable_operator_1 = es2018$6;
 function findInAncestorNodes(node, predicate) {
-    return iterable_operator_1.find(traverse_ancestor_nodes_1.traverseAncestorNodes(node), node => predicate(node));
+    return (0, iterable_operator_1.find)((0, traverse_ancestor_nodes_1.traverseAncestorNodes)(node), node => predicate(node));
 }
 findInAncestorNodes$1.findInAncestorNodes = findInAncestorNodes;
 
@@ -2581,10 +3061,10 @@ findInPrecedingSiblingNodes$1.findInPrecedingSiblingNodes = findInPrecedingSibli
 var parentNode$1 = {};
 
 parentNode$1.parentNode = void 0;
-const errors_1$6 = es2018$2;
+const errors_1$6 = es2018$4;
 function parentNode(node, distance = 1) {
-    errors_1$6.assert(Number.isInteger(distance), 'parameter distance must be an integer');
-    errors_1$6.assert(distance >= 1, 'parameter distance must be greater than or equal to 1');
+    (0, errors_1$6.assert)(Number.isInteger(distance), 'parameter distance must be an integer');
+    (0, errors_1$6.assert)(distance >= 1, 'parameter distance must be greater than or equal to 1');
     return _parentNode(node, distance);
 }
 parentNode$1.parentNode = parentNode;
@@ -2603,10 +3083,10 @@ function _parentNode(node, distance) {
 var nextSibling$2 = {};
 
 nextSibling$2.nextSibling = void 0;
-const errors_1$5 = es2018$2;
+const errors_1$5 = es2018$4;
 function nextSibling$1(node, distance = 1) {
-    errors_1$5.assert(Number.isInteger(distance), 'parameter distance must be an integer');
-    errors_1$5.assert(distance >= 1, 'parameter distance must be greater than or equal to 1');
+    (0, errors_1$5.assert)(Number.isInteger(distance), 'parameter distance must be an integer');
+    (0, errors_1$5.assert)(distance >= 1, 'parameter distance must be greater than or equal to 1');
     return _nextSibling(node, distance);
 }
 nextSibling$2.nextSibling = nextSibling$1;
@@ -2625,33 +3105,33 @@ function _nextSibling(node, distance) {
 var previousSibling$1 = {};
 
 previousSibling$1.previousSibling = void 0;
-const errors_1$4 = es2018$2;
+const errors_1$4 = es2018$4;
 function previousSibling(node, distance = 1) {
-    errors_1$4.assert(Number.isInteger(distance), 'parameter distance must be an integer');
-    errors_1$4.assert(distance >= 1, 'parameter distance must be greater than or equal to 1');
-    return _previousSibling(node, distance);
-}
-previousSibling$1.previousSibling = previousSibling;
-function _previousSibling(node, distance = 1) {
-    const currentNode = node.previousSibling;
-    if (!currentNode)
-        return undefined;
-    if (distance === 1) {
-        return currentNode;
-    }
-    else {
-        return _previousSibling(currentNode, distance - 1);
+    (0, errors_1$4.assert)(Number.isInteger(distance), 'parameter distance must be an integer');
+    (0, errors_1$4.assert)(distance >= 1, 'parameter distance must be greater than or equal to 1');
+    return previousSibling(node, distance);
+    function previousSibling(node, distance = 1) {
+        const currentNode = node.previousSibling;
+        if (!currentNode)
+            return undefined;
+        if (distance === 1) {
+            return currentNode;
+        }
+        else {
+            return previousSibling(currentNode, distance - 1);
+        }
     }
 }
+previousSibling$1.previousSibling = previousSibling;
 
 var nextElementSibling$2 = {};
 
 nextElementSibling$2.nextElementSibling = void 0;
 const is_element_1$2 = isElement$1;
-const errors_1$3 = es2018$2;
+const errors_1$3 = es2018$4;
 function nextElementSibling$1(node, distance = 1) {
-    errors_1$3.assert(Number.isInteger(distance), 'parameter distance must be an integer');
-    errors_1$3.assert(distance >= 1, 'parameter distance must be greater than or equal to 1');
+    (0, errors_1$3.assert)(Number.isInteger(distance), 'parameter distance must be an integer');
+    (0, errors_1$3.assert)(distance >= 1, 'parameter distance must be greater than or equal to 1');
     return _nextElementSibling(node, distance);
 }
 nextElementSibling$2.nextElementSibling = nextElementSibling$1;
@@ -2659,7 +3139,7 @@ function _nextElementSibling(node, distance) {
     const currentNode = node.nextSibling;
     if (!currentNode)
         return undefined;
-    if (is_element_1$2.isElement(currentNode)) {
+    if ((0, is_element_1$2.isElement)(currentNode)) {
         if (distance === 1) {
             return currentNode;
         }
@@ -2676,36 +3156,36 @@ var previousElementSibling$1 = {};
 
 previousElementSibling$1.previousElementSibling = void 0;
 const is_element_1$1 = isElement$1;
-const errors_1$2 = es2018$2;
+const errors_1$2 = es2018$4;
 function previousElementSibling(node, distance = 1) {
-    errors_1$2.assert(Number.isInteger(distance), 'parameter distance must be an integer');
-    errors_1$2.assert(distance >= 1, 'parameter distance must be greater than or equal to 1');
-    return _previousElementSibling(node, distance);
-}
-previousElementSibling$1.previousElementSibling = previousElementSibling;
-function _previousElementSibling(node, distance = 1) {
-    const currentNode = node.previousSibling;
-    if (!currentNode)
-        return undefined;
-    if (is_element_1$1.isElement(currentNode)) {
-        if (distance === 1) {
-            return currentNode;
+    (0, errors_1$2.assert)(Number.isInteger(distance), 'parameter distance must be an integer');
+    (0, errors_1$2.assert)(distance >= 1, 'parameter distance must be greater than or equal to 1');
+    return previousElementSibling(node, distance);
+    function previousElementSibling(node, distance = 1) {
+        const currentNode = node.previousSibling;
+        if (!currentNode)
+            return undefined;
+        if ((0, is_element_1$1.isElement)(currentNode)) {
+            if (distance === 1) {
+                return currentNode;
+            }
+            else {
+                return previousElementSibling(currentNode, distance - 1);
+            }
         }
         else {
-            return _previousElementSibling(currentNode, distance - 1);
+            return previousElementSibling(currentNode, distance);
         }
     }
-    else {
-        return _previousElementSibling(currentNode, distance);
-    }
 }
+previousElementSibling$1.previousElementSibling = previousElementSibling;
 
 var isntDocument$1 = {};
 
 isntDocument$1.isntDocument = void 0;
 const is_document_1 = isDocument$1;
 function isntDocument(val) {
-    return !is_document_1.isDocument(val);
+    return !(0, is_document_1.isDocument)(val);
 }
 isntDocument$1.isntDocument = isntDocument;
 
@@ -2714,18 +3194,18 @@ var isntElement$1 = {};
 isntElement$1.isntElement = void 0;
 const is_element_1 = isElement$1;
 function isntElement(val) {
-    return !is_element_1.isElement(val);
+    return !(0, is_element_1.isElement)(val);
 }
 isntElement$1.isntElement = isntElement;
 
 var isNode$1 = {};
 
 isNode$1.isNode = void 0;
-const types_1$1 = es2018$1;
+const types_1$1 = es2018$2;
 function isNode(val) {
     if ('Node' in globalThis && val instanceof Node)
         return true;
-    return types_1$1.isObject(val) && 'nodeType' in val;
+    return (0, types_1$1.isObject)(val) && 'nodeType' in val;
 }
 isNode$1.isNode = isNode;
 
@@ -2734,7 +3214,7 @@ var isntNode$1 = {};
 isntNode$1.isntNode = void 0;
 const is_node_1$1 = isNode$1;
 function isntNode(val) {
-    return !is_node_1$1.isNode(val);
+    return !(0, is_node_1$1.isNode)(val);
 }
 isntNode$1.isntNode = isntNode;
 
@@ -2742,11 +3222,12 @@ var isTextNode$1 = {};
 
 isTextNode$1.isTextNode = void 0;
 const node_type_1 = nodeType;
-const types_1 = es2018$1;
+const types_1 = es2018$2;
 function isTextNode(val) {
     if ('Text' in globalThis && val instanceof Text)
         return true;
-    return types_1.isRecord(val) && val.nodeType === node_type_1.NodeType.TEXT_NODE;
+    return (0, types_1.isObject)(val)
+        && val.nodeType === node_type_1.NodeType.TEXT_NODE;
 }
 isTextNode$1.isTextNode = isTextNode;
 
@@ -2755,7 +3236,7 @@ var isntTextNode$1 = {};
 isntTextNode$1.isntTextNode = void 0;
 const is_text_node_1 = isTextNode$1;
 function isntTextNode(val) {
-    return !is_text_node_1.isTextNode(val);
+    return !(0, is_text_node_1.isTextNode)(val);
 }
 isntTextNode$1.isntTextNode = isntTextNode;
 
@@ -2764,7 +3245,7 @@ var isParentNode$1 = {};
 isParentNode$1.isParentNode = void 0;
 const is_node_1 = isNode$1;
 function isParentNode(val) {
-    return is_node_1.isNode(val) && 'children' in val;
+    return (0, is_node_1.isNode)(val) && 'children' in val;
 }
 isParentNode$1.isParentNode = isParentNode;
 
@@ -2773,7 +3254,7 @@ var isntParentNode$1 = {};
 isntParentNode$1.isntParentNode = void 0;
 const is_parent_node_1 = isParentNode$1;
 function isntParentNode(val) {
-    return !is_parent_node_1.isParentNode(val);
+    return !(0, is_parent_node_1.isParentNode)(val);
 }
 isntParentNode$1.isntParentNode = isntParentNode;
 
@@ -2822,7 +3303,7 @@ var replaceBrWithNewline$1 = {};
 replaceBrWithNewline$1.replaceBrWithNewline = void 0;
 const map_1 = map$3;
 function replaceBrWithNewline(node) {
-    return map_1.map(node, node => {
+    return (0, map_1.map)(node, node => {
         if (node.nodeName === 'BR') {
             return document.createTextNode('\n');
         }
@@ -2908,7 +3389,7 @@ __exportStar(replaceBrWithNewline$1, exports);
 __exportStar(isBefore$1, exports);
 __exportStar(isAfter$1, exports);
 
-}(es2018$5));
+}(es2018$7));
 
 function matchOneByOne(context, source, ...matchers) {
     if (matchers.length === 0)
@@ -2918,7 +3399,7 @@ function matchOneByOne(context, source, ...matchers) {
     const [matcher, ...otherMatchers] = matchers;
     const result = Reflect.apply(matcher, context, [source]);
     // TerminalMatcher
-    if (es2018$1.isBoolean(result)) {
+    if (es2018$3.isBoolean(result)) {
         if (result) {
             const nextNode = context.next(source);
             return matchOneByOne(context, nextNode, ...otherMatchers);
@@ -2928,13 +3409,13 @@ function matchOneByOne(context, source, ...matchers) {
         }
     }
     // 此处一定是成功匹配, 因为SkipMatcher在失败时会返回false.
-    if (es2018$1.isNumber(result)) {
+    if (es2018$3.isNumber(result)) {
         const distance = result;
         const nextNode = context.next(source, distance);
         return matchOneByOne(context, nextNode, ...otherMatchers);
     }
     // SkipMatcher返回Iterable意味着存在多种可能性, 可能出现失败回溯.
-    if (es2018$1.isIterable(result)) {
+    if (es2018$3.isIterable(result)) {
         for (const distance of result) {
             const nextNode = context.next(source, distance);
             if (matchOneByOne(context, nextNode, ...otherMatchers)) {
@@ -2950,11 +3431,11 @@ function matchOneByOne(context, source, ...matchers) {
 function nextSibling(node, distance = 1) {
     if (distance === 0)
         return node;
-    return es2018$5.nextSibling(node, distance);
+    return es2018$7.nextSibling(node, distance);
 }
 
 function match(node, ...matchers) {
-    const document = es2018$5.isDocument(this) ? this : globalThis.document;
+    const document = es2018$7.isDocument(this) ? this : globalThis.document;
     const context = {
         document,
         collection: {},
@@ -2971,11 +3452,11 @@ function match(node, ...matchers) {
 function nextElementSibling(node, distance = 1) {
     if (distance === 0)
         return node;
-    return es2018$5.nextElementSibling(node, distance);
+    return es2018$7.nextElementSibling(node, distance);
 }
 
 function matchElement(element, ...matchers) {
-    const document = es2018$5.isDocument(this) ? this : globalThis.document;
+    const document = es2018$7.isDocument(this) ? this : globalThis.document;
     const context = {
         document,
         collection: {},
@@ -2995,11 +3476,11 @@ function anyOf(...matchers) {
     };
 }
 
-function merge(target, source) {
+function mergeInPlace(target, source) {
     for (const [key, value] of Object.entries(source)) {
         if (target[key]) {
-            if (Array.isArray(target[key])) {
-                if (Array.isArray(value)) {
+            if (es2018$3.isArray(target[key])) {
+                if (es2018$3.isArray(value)) {
                     target[key] = [...target[key], ...value];
                 }
                 else {
@@ -3007,7 +3488,7 @@ function merge(target, source) {
                 }
             }
             else {
-                if (Array.isArray(value)) {
+                if (es2018$3.isArray(value)) {
                     target[key] = [target[key], ...value];
                 }
                 else {
@@ -3032,7 +3513,7 @@ function childNodes(...matchers) {
         const context = Object.assign(Object.assign({}, this), { collection: {}, next: nextSibling });
         const result = matchOneByOne(context, node.childNodes[0], ...matchers);
         if (result) {
-            merge(this.collection, context.collection);
+            mergeInPlace(this.collection, context.collection);
         }
         return result;
     };
@@ -3049,7 +3530,7 @@ function children(...matchers) {
         const context = Object.assign(Object.assign({}, this), { collection: {}, next: nextElementSibling });
         const result = matchOneByOne(context, element.children[0], ...matchers);
         if (result) {
-            merge(this.collection, context.collection);
+            mergeInPlace(this.collection, context.collection);
         }
         return result;
     };
@@ -3066,7 +3547,7 @@ function concat(strings, values) {
 }
 
 function css(...args) {
-    if (es2018$1.isString(args[0])) {
+    if (es2018$3.isString(args[0])) {
         const [selector] = args;
         return (element) => element.matches(selector);
     }
@@ -3078,24 +3559,24 @@ function css(...args) {
 }
 
 function element(...args) {
-    if (Array.isArray(args[0])) {
+    if (es2018$3.isArray(args[0])) {
         const [strings, ...values] = args;
         const name = concat(strings, values).join('');
         return (...matchers) => element(name, ...matchers);
     }
-    if (es2018$1.isString(args[0])) {
+    if (es2018$3.isString(args[0])) {
         const [name, ...matchers] = args;
         return function (_element) {
             const result = element(...matchers).call(this, _element);
             if (result) {
-                merge(this.collection, { [name]: _element });
+                mergeInPlace(this.collection, { [name]: _element });
             }
             return result;
         };
     }
     const [...matchers] = args;
     return function (element) {
-        if (es2018$5.isntElement(element))
+        if (es2018$7.isntElement(element))
             return false;
         if (matchers.length === 0)
             return true;
@@ -3103,7 +3584,7 @@ function element(...args) {
     };
 }
 
-var es2018 = {};
+var es2018$1 = {};
 
 var of$1 = {};
 
@@ -3116,14 +3597,15 @@ of$1.of = of;
 var repeat$2 = {};
 
 repeat$2.repeat = void 0;
-const errors_1$1 = es2018$2;
+const errors_1$1 = es2018$4;
+const go_1 = es2018$5;
 function repeat$1(val, times = Infinity) {
-    errors_1$1.assert(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
-    return (function* () {
+    (0, errors_1$1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
+    return (0, go_1.go)(function* () {
         while (times-- > 0) {
             yield val;
         }
-    })();
+    });
 }
 repeat$2.repeat = repeat$1;
 
@@ -3154,9 +3636,9 @@ countup$1.countup = countup;
 var range$1 = {};
 
 range$1.range = void 0;
-const errors_1 = es2018$2;
+const errors_1 = es2018$4;
 function range(start, end, step = 1) {
-    errors_1.assert(step > 0, 'step parameter must be greater than 0');
+    (0, errors_1.assert)(step > 0, 'step parameter must be greater than 0');
     return rangeByUnsignedStep(start, end, step);
 }
 range$1.range = range;
@@ -3177,18 +3659,24 @@ var stringifyJsonStream = {};
 
 stringifyJsonStream.stringifyJSONStream = void 0;
 function* stringifyJSONStream(iterable) {
+    var _a;
     const iter = iterable[Symbol.iterator]();
-    const firstResult = iter.next();
-    yield '[';
-    if (!firstResult.done)
-        yield JSON.stringify(firstResult.value);
-    while (true) {
-        const result = iter.next();
-        if (result.done)
-            break;
-        yield ',' + JSON.stringify(result.value);
+    let done;
+    try {
+        let value;
+        ({ value, done } = iter.next());
+        yield '[';
+        if (!done)
+            yield JSON.stringify(value);
+        while ({ value, done } = iter.next(), !done) {
+            yield ',' + JSON.stringify(value);
+        }
+        yield ']';
+    }
+    finally {
+        if (!done)
+            (_a = iter.return) === null || _a === void 0 ? void 0 : _a.call(iter);
     }
-    yield ']';
 }
 stringifyJsonStream.stringifyJSONStream = stringifyJSONStream;
 
@@ -3196,18 +3684,24 @@ var stringifyJsonStreamAsync = {};
 
 stringifyJsonStreamAsync.stringifyJSONStreamAsync = void 0;
 async function* stringifyJSONStreamAsync(asyncIterable) {
+    var _a;
     const iter = asyncIterable[Symbol.asyncIterator]();
-    const firstResult = await iter.next();
-    yield '[';
-    if (!firstResult.done)
-        yield JSON.stringify(firstResult.value);
-    while (true) {
-        const result = await iter.next();
-        if (result.done)
-            break;
-        yield ',' + JSON.stringify(result.value);
+    let done;
+    try {
+        let value;
+        ({ value, done } = await iter.next());
+        yield '[';
+        if (!done)
+            yield JSON.stringify(value);
+        while ({ value, done } = await iter.next(), !done) {
+            yield ',' + JSON.stringify(value);
+        }
+        yield ']';
+    }
+    finally {
+        if (!done)
+            await ((_a = iter.return) === null || _a === void 0 ? void 0 : _a.call(iter));
     }
-    yield ']';
 }
 stringifyJsonStreamAsync.stringifyJSONStreamAsync = stringifyJSONStreamAsync;
 
@@ -3215,15 +3709,21 @@ var stringifyNdjsonStream = {};
 
 stringifyNdjsonStream.stringifyNDJSONStream = void 0;
 function* stringifyNDJSONStream(iterable) {
+    var _a;
     const iter = iterable[Symbol.iterator]();
-    const firstResult = iter.next();
-    if (!firstResult.done)
-        yield JSON.stringify(firstResult.value);
-    while (true) {
-        const result = iter.next();
-        if (result.done)
-            break;
-        yield '\n' + JSON.stringify(result.value);
+    let done;
+    try {
+        let value;
+        ({ value, done } = iter.next());
+        if (!done)
+            yield JSON.stringify(value);
+        while ({ value, done } = iter.next(), !done) {
+            yield '\n' + JSON.stringify(value);
+        }
+    }
+    finally {
+        if (!done)
+            (_a = iter.return) === null || _a === void 0 ? void 0 : _a.call(iter);
     }
 }
 stringifyNdjsonStream.stringifyNDJSONStream = stringifyNDJSONStream;
@@ -3232,15 +3732,21 @@ var stringifyNdjsonStreamAsync = {};
 
 stringifyNdjsonStreamAsync.stringifyNDJSONStreamAsync = void 0;
 async function* stringifyNDJSONStreamAsync(asyncIterable) {
+    var _a;
     const iter = asyncIterable[Symbol.asyncIterator]();
-    const firstResult = await iter.next();
-    if (!firstResult.done)
-        yield JSON.stringify(firstResult.value);
-    while (true) {
-        const result = await iter.next();
-        if (result.done)
-            break;
-        yield '\n' + JSON.stringify(result.value);
+    let done;
+    try {
+        let value;
+        ({ value, done } = await iter.next());
+        if (!done)
+            yield JSON.stringify(value);
+        while ({ value, done } = await iter.next(), !done) {
+            yield '\n' + JSON.stringify(value);
+        }
+    }
+    finally {
+        if (!done)
+            await ((_a = iter.return) === null || _a === void 0 ? void 0 : _a.call(iter));
     }
 }
 stringifyNdjsonStreamAsync.stringifyNDJSONStreamAsync = stringifyNDJSONStreamAsync;
@@ -3262,6 +3768,454 @@ function* sse(message) {
 }
 sse$1.sse = sse;
 
+var reusableIterable = {};
+
+var es2018 = {};
+
+var lazy$1 = {};
+
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** Used as the `TypeError` message for "Functions" methods. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0,
+    MAX_INTEGER = 1.7976931348623157e+308,
+    NAN = 0 / 0;
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/** Used to match leading and trailing whitespace. */
+var reTrim = /^\s+|\s+$/g;
+
+/** Used to detect bad signed hexadecimal string values. */
+var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+
+/** Used to detect binary string values. */
+var reIsBinary = /^0b[01]+$/i;
+
+/** Used to detect octal string values. */
+var reIsOctal = /^0o[0-7]+$/i;
+
+/** Built-in method references without a dependency on `root`. */
+var freeParseInt = parseInt;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString = objectProto.toString;
+
+/**
+ * Creates a function that invokes `func`, with the `this` binding and arguments
+ * of the created function, while it's called less than `n` times. Subsequent
+ * calls to the created function return the result of the last `func` invocation.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.0.0
+ * @category Function
+ * @param {number} n The number of calls at which `func` is no longer invoked.
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * jQuery(element).on('click', _.before(5, addContactToList));
+ * // => Allows adding up to 4 contacts to the list.
+ */
+function before(n, func) {
+  var result;
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  n = toInteger(n);
+  return function() {
+    if (--n > 0) {
+      result = func.apply(this, arguments);
+    }
+    if (n <= 1) {
+      func = undefined;
+    }
+    return result;
+  };
+}
+
+/**
+ * Creates a function that is restricted to invoking `func` once. Repeat calls
+ * to the function return the value of the first invocation. The `func` is
+ * invoked with the `this` binding and arguments of the created function.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to restrict.
+ * @returns {Function} Returns the new restricted function.
+ * @example
+ *
+ * var initialize = _.once(createApplication);
+ * initialize();
+ * initialize();
+ * // => `createApplication` is invoked once
+ */
+function once(func) {
+  return before(2, func);
+}
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject(value) {
+  var type = typeof value;
+  return !!value && (type == 'object' || type == 'function');
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike(value) {
+  return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return typeof value == 'symbol' ||
+    (isObjectLike(value) && objectToString.call(value) == symbolTag);
+}
+
+/**
+ * Converts `value` to a finite number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.12.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted number.
+ * @example
+ *
+ * _.toFinite(3.2);
+ * // => 3.2
+ *
+ * _.toFinite(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toFinite(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toFinite('3.2');
+ * // => 3.2
+ */
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = (value < 0 ? -1 : 1);
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+
+/**
+ * Converts `value` to an integer.
+ *
+ * **Note:** This method is loosely based on
+ * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {number} Returns the converted integer.
+ * @example
+ *
+ * _.toInteger(3.2);
+ * // => 3
+ *
+ * _.toInteger(Number.MIN_VALUE);
+ * // => 0
+ *
+ * _.toInteger(Infinity);
+ * // => 1.7976931348623157e+308
+ *
+ * _.toInteger('3.2');
+ * // => 3
+ */
+function toInteger(value) {
+  var result = toFinite(value),
+      remainder = result % 1;
+
+  return result === result ? (remainder ? result - remainder : result) : 0;
+}
+
+/**
+ * Converts `value` to a number.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to process.
+ * @returns {number} Returns the number.
+ * @example
+ *
+ * _.toNumber(3.2);
+ * // => 3.2
+ *
+ * _.toNumber(Number.MIN_VALUE);
+ * // => 5e-324
+ *
+ * _.toNumber(Infinity);
+ * // => Infinity
+ *
+ * _.toNumber('3.2');
+ * // => 3.2
+ */
+function toNumber(value) {
+  if (typeof value == 'number') {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject(value)) {
+    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
+    value = isObject(other) ? (other + '') : other;
+  }
+  if (typeof value != 'string') {
+    return value === 0 ? value : +value;
+  }
+  value = value.replace(reTrim, '');
+  var isBinary = reIsBinary.test(value);
+  return (isBinary || reIsOctal.test(value))
+    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)
+    : (reIsBadHex.test(value) ? NAN : +value);
+}
+
+var lodash_once = once;
+
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};lazy$1.lazy = void 0;
+const lodash_once_1 = __importDefault(lodash_once);
+function lazy(getter) {
+    return (0, lodash_once_1.default)(getter);
+}
+lazy$1.lazy = lazy;
+
+var lazyFunction$1 = {};
+
+lazyFunction$1.lazyFunction = void 0;
+const lazy_1 = lazy$1;
+function lazyFunction(getter) {
+    const getFn = (0, lazy_1.lazy)(getter);
+    return (...args) => getFn()(...args);
+}
+lazyFunction$1.lazyFunction = lazyFunction;
+
+(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(lazy$1, exports);
+__exportStar(lazyFunction$1, exports);
+
+}(es2018));
+
+var __classPrivateFieldGet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ReusableIterable_done;reusableIterable.ReusableIterable = void 0;
+const extra_lazy_1$1 = es2018;
+class ReusableIterable {
+    constructor(iterable) {
+        _ReusableIterable_done.set(this, void 0);
+        this.getIterator = (0, extra_lazy_1$1.lazy)(() => iterable[Symbol.iterator]());
+    }
+    get done() {
+        return __classPrivateFieldGet$1(this, _ReusableIterable_done, "f");
+    }
+    close() {
+        var _a, _b;
+        if (!this.done) {
+            __classPrivateFieldSet$1(this, _ReusableIterable_done, true, "f");
+            (_b = (_a = this.getIterator()).return) === null || _b === void 0 ? void 0 : _b.call(_a);
+        }
+    }
+    [(_ReusableIterable_done = new WeakMap(), Symbol.iterator)]() {
+        return {
+            next: () => {
+                if (__classPrivateFieldGet$1(this, _ReusableIterable_done, "f"))
+                    return { done: true, value: undefined };
+                const { value, done } = this.getIterator().next();
+                if (done) {
+                    __classPrivateFieldSet$1(this, _ReusableIterable_done, true, "f");
+                }
+                return { value, done };
+            }
+        };
+    }
+}
+reusableIterable.ReusableIterable = ReusableIterable;
+
+var reusableAsyncIterable = {};
+
+var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ReusableAsyncIterable_done;reusableAsyncIterable.ReusableAsyncIterable = void 0;
+const extra_lazy_1 = es2018;
+class ReusableAsyncIterable {
+    constructor(iterable) {
+        _ReusableAsyncIterable_done.set(this, void 0);
+        this.getIterator = (0, extra_lazy_1.lazy)(() => iterable[Symbol.asyncIterator]());
+    }
+    get done() {
+        return __classPrivateFieldGet(this, _ReusableAsyncIterable_done, "f");
+    }
+    async close() {
+        var _a, _b;
+        if (!this.done) {
+            __classPrivateFieldSet(this, _ReusableAsyncIterable_done, true, "f");
+            await ((_b = (_a = this.getIterator()).return) === null || _b === void 0 ? void 0 : _b.call(_a));
+        }
+    }
+    [(_ReusableAsyncIterable_done = new WeakMap(), Symbol.asyncIterator)]() {
+        return {
+            next: async () => {
+                if (__classPrivateFieldGet(this, _ReusableAsyncIterable_done, "f"))
+                    return { done: true, value: undefined };
+                const { value, done } = await this.getIterator().next();
+                if (done) {
+                    __classPrivateFieldSet(this, _ReusableAsyncIterable_done, true, "f");
+                }
+                return { value, done };
+            }
+        };
+    }
+}
+reusableAsyncIterable.ReusableAsyncIterable = ReusableAsyncIterable;
+
+var timestampBasedId$1 = {};
+
+timestampBasedId$1.timestampBasedId = void 0;
+function* timestampBasedId() {
+    const num = 0;
+    const timestamp = Date.now();
+    yield [timestamp, num];
+    let lastTimestamp = timestamp;
+    let lastNum = num;
+    while (true) {
+        const timestamp = Date.now();
+        if (timestamp === lastTimestamp) {
+            yield [lastTimestamp, ++lastNum];
+        }
+        else {
+            lastNum = 0;
+            lastTimestamp = timestamp;
+            yield [lastTimestamp, lastNum];
+        }
+    }
+}
+timestampBasedId$1.timestampBasedId = timestampBasedId;
+
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -3282,15 +4236,18 @@ __exportStar(stringifyJsonStreamAsync, exports);
 __exportStar(stringifyNdjsonStream, exports);
 __exportStar(stringifyNdjsonStreamAsync, exports);
 __exportStar(sse$1, exports);
+__exportStar(reusableIterable, exports);
+__exportStar(reusableAsyncIterable, exports);
+__exportStar(timestampBasedId$1, exports);
 
-}(es2018));
+}(es2018$1));
 
 /**
  * @returns {number} 返回值为成功匹配的元素个数, 当此值等于ubound时, 代表匹配成功.
  */
 function matchMultiple(node, ubound, matcher) {
     let currentNode = node;
-    for (const round of es2018.countup(1, ubound)) {
+    for (const round of es2018$1.countup(1, ubound)) {
         if (!currentNode)
             return round - 1;
         const result = matcher.call(this, currentNode);
@@ -3310,10 +4267,10 @@ var Range;
     Range[Range["Max"] = 1] = "Max";
 })(Range || (Range = {}));
 function multiple([min, max], matcher, options = { greedy: true }) {
-    es2018$2.assert(Number.isInteger(min), 'parameter min must be an integer');
-    es2018$2.assert(Number.isInteger(max) || max === Infinity, 'parameter max must be an integer or Infinity');
-    es2018$2.assert(min >= 0, 'parameter min must be greater than or equal to 0');
-    es2018$2.assert(min <= max, 'parameter max must be greater than or equal to min');
+    es2018$4.assert(Number.isInteger(min), 'parameter min must be an integer');
+    es2018$4.assert(Number.isInteger(max) || max === Infinity, 'parameter max must be an integer or Infinity');
+    es2018$4.assert(min >= 0, 'parameter min must be greater than or equal to 0');
+    es2018$4.assert(min <= max, 'parameter max must be greater than or equal to min');
     return function* (node) {
         if (options.greedy) {
             let ubound = max;
@@ -3328,7 +4285,7 @@ function multiple([min, max], matcher, options = { greedy: true }) {
             }
         }
         else {
-            for (const ubound of es2018.countup(min, max)) {
+            for (const ubound of es2018$1.countup(min, max)) {
                 const result = matchMultiple.call(this, node, ubound, matcher);
                 // 如果匹配的节点数量少于ubound, 说明匹配失败, 即使尝试更长的匹配也不会成功.
                 if (result < ubound)
@@ -3341,17 +4298,17 @@ function multiple([min, max], matcher, options = { greedy: true }) {
 }
 
 function node(...args) {
-    if (Array.isArray(args[0])) {
+    if (es2018$3.isArray(args[0])) {
         const [strings, ...values] = args;
         const name = concat(strings, values).join('');
         return (...matchers) => node(name, ...matchers);
     }
-    if (es2018$1.isString(args[0])) {
+    if (es2018$3.isString(args[0])) {
         const [name, ...matchers] = args;
         return function (_node) {
             const result = node(...matchers).call(this, _node);
             if (result) {
-                merge(this.collection, { [name]: _node });
+                mergeInPlace(this.collection, { [name]: _node });
             }
             return result;
         };
@@ -3369,8 +4326,8 @@ function optional(matcher) {
 }
 
 function repeat(times, matcher) {
-    es2018$2.assert(Number.isInteger(times), 'parameter times must be an integer');
-    es2018$2.assert(times >= 0, 'parameter number must be greater than or equal to 0');
+    es2018$4.assert(Number.isInteger(times), 'parameter times must be an integer');
+    es2018$4.assert(times >= 0, 'parameter number must be greater than or equal to 0');
     return function (node) {
         const result = matchMultiple.call(this, node, times, matcher);
         if (result === times) {
@@ -3392,7 +4349,7 @@ function tap(matcher, callback) {
 
 function textContentEquals(text, { caseSensitive = true, trim = false } = {}) {
     return (node) => {
-        if (es2018$1.isNull(node.textContent))
+        if (es2018$3.isNull(node.textContent))
             return false;
         let textContent = node.textContent;
         if (!caseSensitive) {
@@ -3407,7 +4364,7 @@ function textContentEquals(text, { caseSensitive = true, trim = false } = {}) {
 
 function textContentIncludes(searchString, { caseSensitive = true, trim = false } = {}) {
     return (node) => {
-        if (es2018$1.isNull(node.textContent))
+        if (es2018$3.isNull(node.textContent))
             return false;
         let textContent = node.textContent;
         if (!caseSensitive) {
@@ -3422,7 +4379,7 @@ function textContentIncludes(searchString, { caseSensitive = true, trim = false
 
 function textContentMatches(pattern, { trim = false } = {}) {
     return (node) => {
-        if (es2018$1.isNull(node.textContent))
+        if (es2018$3.isNull(node.textContent))
             return false;
         let textContent = node.textContent;
         if (trim)
@@ -3432,24 +4389,24 @@ function textContentMatches(pattern, { trim = false } = {}) {
 }
 
 function textNode(...args) {
-    if (Array.isArray(args[0])) {
+    if (es2018$3.isArray(args[0])) {
         const [strings, ...values] = args;
         const name = concat(strings, values).join('');
         return (...matchers) => textNode(name, ...matchers);
     }
-    if (es2018$1.isString(args[0])) {
+    if (es2018$3.isString(args[0])) {
         const [name, ...matchers] = args;
         return function (node) {
             const result = textNode(...matchers).call(this, node);
             if (result) {
-                merge(this.collection, { [name]: node });
+                mergeInPlace(this.collection, { [name]: node });
             }
             return result;
         };
     }
     const [...matchers] = args;
     return function (node) {
-        if (es2018$5.isntTextNode(node))
+        if (es2018$7.isntTextNode(node))
             return false;
         if (matchers.length === 0)
             return true;
@@ -3461,9 +4418,9 @@ const UNORDERED_NODE_ITERATOR_TYPE = 'XPathResult' in globalThis
     ? XPathResult.UNORDERED_NODE_ITERATOR_TYPE
     : 4;
 function xpath(...args) {
-    if (es2018$1.isString(args[0])) {
+    if (es2018$3.isString(args[0])) {
         const [expression] = args;
-        es2018$2.assert(expression.startsWith('//*'), 'XPath expressions must start with "//*"');
+        es2018$4.assert(expression.startsWith('//*'), 'XPath expressions must start with "//*"');
         return function (node) {
             return xpathMatches(this.document, expression, node);
         };