@blackglory/match 0.3.3 → 0.3.4

package/dist/es2015/index.umd.js

@@ -6,7 +6,7 @@
 
 	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-	var es2018$6 = {};
+	var es2018$8 = {};
 
 	var flatMap$1 = {};
 
@@ -87,21 +87,21 @@
 
 	var unwrap$1 = {};
 
-	var es2018$5 = {};
+	var es2018$7 = {};
 
 	var middleware = {};
 
 	var chunkAsync$1 = {};
 
-	var es2018$4 = {};
+	var es2018$6 = {};
 
-	var go$1 = {};
+	var go$3 = {};
 
-	go$1.go = void 0;
-	function go(fn) {
+	go$3.go = void 0;
+	function go$2(fn) {
 	    return fn();
 	}
-	go$1.go = go;
+	go$3.go = go$2;
 
 	(function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -113,11 +113,11 @@
 	}));
 	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};__exportStar(go$1, exports);
+	};__exportStar(go$3, exports);
 
-	}(es2018$4));
+	}(es2018$6));
 
-	var es2018$3 = {};
+	var es2018$5 = {};
 
 	var customError = {};
 
@@ -195,15 +195,15 @@
 	__exportStar(refute$1, exports);
 	__exportStar(assert$1, exports);
 
-	}(es2018$3));
+	}(es2018$5));
 
 	chunkAsync$1.chunkAsync = void 0;
-	const go_1$f = es2018$4;
-	const errors_1$m = es2018$3;
+	const go_1$g = es2018$6;
+	const errors_1$m = es2018$5;
 	function chunkAsync(iterable, size) {
 	    (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$f.go)(async function* () {
+	    return (0, go_1$g.go)(async function* () {
 	        let buffer = [];
 	        for await (const element of iterable) {
 	            buffer.push(element);
@@ -220,297 +220,297 @@
 
 	var chunkByAsync$1 = {};
 
-	var es2018$2 = {};
+	var es2018$4 = {};
 
-	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 (0, null_1$1.isntNull)(val)
-	        && (0, 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.isntString = string.isString = void 0;
-	function isString(val) {
+	string$1.isntString = string$1.isString = void 0;
+	function isString$1(val) {
 	    return typeof val === 'string';
 	}
-	string.isString = isString;
-	function isntString(val) {
-	    return !isString(val);
+	string$1.isString = isString$1;
+	function isntString$1(val) {
+	    return !isString$1(val);
 	}
-	string.isntString = isntString;
+	string$1.isntString = isntString$1;
 
-	char.isntChar = char.isChar = void 0;
-	const string_1$1 = string;
-	function isChar(val) {
-	    return (0, 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.isChar = isChar;
-	function isntChar(val) {
-	    return !isChar(val);
+	char$1.isChar = isChar$1;
+	function isntChar$1(val) {
+	    return !isChar$1(val);
 	}
-	char.isntChar = isntChar;
+	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 error = {};
+	var error$1 = {};
 
-	error.isntError = error.isError = void 0;
-	function isError(val) {
+	error$1.isntError = error$1.isError = void 0;
+	function isError$1(val) {
 	    return val instanceof Error;
 	}
-	error.isError = isError;
-	function isntError(val) {
-	    return !isError(val);
+	error$1.isError = isError$1;
+	function isntError$1(val) {
+	    return !isError$1(val);
 	}
-	error.isntError = isntError;
+	error$1.isntError = isntError$1;
 
-	var falsy = {};
+	var falsy$1 = {};
 
-	falsy.isntFalsy = falsy.isFalsy = void 0;
-	function isFalsy(val) {
+	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 (0, null_1.isntNull)(val)
-	        && (0, 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$1(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$1;
-	function isntObject(val) {
-	    return !isObject$1(val);
+	object$1.isObject = isObject$2;
+	function isntObject$1(val) {
+	    return !isObject$2(val);
 	}
-	object.isntObject = isntObject;
-	function isRecord(val) {
-	    return isObject$1(val);
+	object$1.isntObject = isntObject$1;
+	function isRecord$1(val) {
+	    return isObject$2(val);
 	}
-	object.isRecord = isRecord;
-	function isEmptyObject(val) {
+	object$1.isRecord = isRecord$1;
+	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 (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.isRecord)(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.isRecord)(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.isRecord)(val)
-	        && (0, string_1.isString)(val.jsonrpc)
-	        && (0, string_1.isString)(val.id)
-	        && (0, undefined_1.isntUndefined)(val.result);
-	}
-	jsonRpc.isJsonRpcSuccess = isJsonRpcSuccess;
-	function isntJsonRpcSuccess(val) {
-	    return !isJsonRpcSuccess(val);
-	}
-	jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
-	function isJsonRpcError(val) {
-	    return (0, object_1.isRecord)(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.isRecord)(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) {
+	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)
+	        && (0, undefined_1$3.isntUndefined)(val.result);
+	}
+	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;
@@ -519,16 +519,16 @@
 	        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;
@@ -537,7 +537,7 @@
 	        return false;
 	    }
 	}
-	url.isAbsoluteURL = isAbsoluteURL;
+	url$1.isAbsoluteURL = isAbsoluteURL$1;
 
 	(function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -549,30 +549,30 @@
 	}));
 	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);
+	};__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$2));
+	}(es2018$4));
 
 	chunkByAsync$1.chunkByAsync = void 0;
-	const types_1$l = es2018$2;
+	const types_1$l = es2018$4;
 	function chunkByAsync(iterable, predicate) {
 	    if ((0, types_1$l.isAsyncIterable)(iterable)) {
 	        return chunkByAsyncIterable(iterable);
@@ -633,12 +633,12 @@
 	var chunk$1 = {};
 
 	chunk$1.chunk = void 0;
-	const go_1$e = es2018$4;
-	const errors_1$l = es2018$3;
+	const go_1$f = es2018$6;
+	const errors_1$l = es2018$5;
 	function chunk(iterable, size) {
 	    (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$e.go)(function* () {
+	    return (0, go_1$f.go)(function* () {
 	        let buffer = [];
 	        for (const element of iterable) {
 	            buffer.push(element);
@@ -656,10 +656,10 @@
 	var concatAsync$1 = {};
 
 	concatAsync$1.concatAsync = void 0;
-	const types_1$k = es2018$2;
-	const go_1$d = es2018$4;
+	const types_1$k = es2018$4;
+	const go_1$e = es2018$6;
 	function concatAsync(iterable, ...otherIterables) {
-	    return (0, go_1$d.go)(async function* () {
+	    return (0, go_1$e.go)(async function* () {
 	        for (const iter of [iterable, ...otherIterables]) {
 	            if ((0, types_1$k.isAsyncIterable)(iter)) {
 	                for await (const element of iter) {
@@ -679,9 +679,9 @@
 	var concat$2 = {};
 
 	concat$2.concat = void 0;
-	const go_1$c = es2018$4;
+	const go_1$d = es2018$6;
 	function concat$1(iterable, ...otherIterables) {
-	    return (0, go_1$c.go)(function* () {
+	    return (0, go_1$d.go)(function* () {
 	        for (const iter of [iterable, ...otherIterables]) {
 	            yield* iter;
 	        }
@@ -708,15 +708,15 @@
 	utils.copyIterable = copyIterable;
 
 	dropAsync$1.dropAsync = void 0;
-	const go_1$b = es2018$4;
+	const go_1$c = es2018$6;
 	const utils_1$3 = utils;
-	const errors_1$k = es2018$3;
+	const errors_1$k = es2018$5;
 	function dropAsync(iterable, count) {
 	    (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 (0, utils_1$3.copyAsyncIterable)(iterable);
-	    return (0, go_1$b.go)(async function* () {
+	    return (0, go_1$c.go)(async function* () {
 	        var _a;
 	        const iterator = iterable[Symbol.asyncIterator]();
 	        let done;
@@ -743,15 +743,15 @@
 	var dropRightAsync$1 = {};
 
 	dropRightAsync$1.dropRightAsync = void 0;
-	const go_1$a = es2018$4;
+	const go_1$b = es2018$6;
 	const utils_1$2 = utils;
-	const errors_1$j = es2018$3;
+	const errors_1$j = es2018$5;
 	function dropRightAsync(iterable, count) {
 	    (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 (0, utils_1$2.copyAsyncIterable)(iterable);
-	    return (0, go_1$a.go)(async function* () {
+	    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) {
@@ -771,15 +771,15 @@
 	var dropRight$1 = {};
 
 	dropRight$1.dropRight = void 0;
-	const go_1$9 = es2018$4;
+	const go_1$a = es2018$6;
 	const utils_1$1 = utils;
-	const errors_1$i = es2018$3;
+	const errors_1$i = es2018$5;
 	function dropRight(iterable, count) {
 	    (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 (0, utils_1$1.copyIterable)(iterable);
-	    return (0, go_1$9.go)(function* () {
+	    return (0, go_1$a.go)(function* () {
 	        const arr = Array.from(iterable);
 	        yield* arr.slice(0, -count);
 	    });
@@ -789,7 +789,7 @@
 	var dropUntilAsync$1 = {};
 
 	dropUntilAsync$1.dropUntilAsync = void 0;
-	const types_1$j = es2018$2;
+	const types_1$j = es2018$4;
 	function dropUntilAsync(iterable, predicate) {
 	    if ((0, types_1$j.isAsyncIterable)(iterable)) {
 	        return dropUntilAsyncIterable(iterable);
@@ -871,15 +871,15 @@
 	var drop$1 = {};
 
 	drop$1.drop = void 0;
-	const go_1$8 = es2018$4;
+	const go_1$9 = es2018$6;
 	const utils_1 = utils;
-	const errors_1$h = es2018$3;
+	const errors_1$h = es2018$5;
 	function drop(iterable, count) {
 	    (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 (0, utils_1.copyIterable)(iterable);
-	    return (0, go_1$8.go)(function* () {
+	    return (0, go_1$9.go)(function* () {
 	        var _a;
 	        const iterator = iterable[Symbol.iterator]();
 	        let done;
@@ -906,7 +906,7 @@
 	var filterAsync$1 = {};
 
 	filterAsync$1.filterAsync = void 0;
-	const types_1$i = es2018$2;
+	const types_1$i = es2018$4;
 	function filterAsync(iterable, predicate) {
 	    if ((0, types_1$i.isAsyncIterable)(iterable)) {
 	        return filterAsyncIterable(iterable);
@@ -953,7 +953,7 @@
 	var flattenByAsync$1 = {};
 
 	flattenByAsync$1.flattenByAsync = void 0;
-	const types_1$h = es2018$2;
+	const types_1$h = es2018$4;
 	function flattenByAsync(iterable, predicate) {
 	    if ((0, types_1$h.isAsyncIterable)(iterable)) {
 	        return flattenByAsyncIterable(iterable);
@@ -993,7 +993,7 @@
 
 	flattenDeepAsync$1.flattenDeepAsync = void 0;
 	const flatten_by_async_1 = flattenByAsync$1;
-	const errors_1$g = es2018$3;
+	const errors_1$g = es2018$5;
 	function flattenDeepAsync(iterable, depth = Infinity) {
 	    (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');
@@ -1011,7 +1011,7 @@
 	var flattenBy$1 = {};
 
 	flattenBy$1.flattenBy = void 0;
-	const types_1$g = es2018$2;
+	const types_1$g = es2018$4;
 	function flattenBy(iterable, predicate) {
 	    return flatten(iterable, 1);
 	    function* flatten(iterable, level) {
@@ -1034,7 +1034,7 @@
 
 	flattenDeep$1.flattenDeep = void 0;
 	const flatten_by_1 = flattenBy$1;
-	const errors_1$f = es2018$3;
+	const errors_1$f = es2018$5;
 	function flattenDeep(iterable, depth = Infinity) {
 	    (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');
@@ -1054,7 +1054,7 @@
 	var mapAsync$1 = {};
 
 	mapAsync$1.mapAsync = void 0;
-	const types_1$f = es2018$2;
+	const types_1$f = es2018$4;
 	function mapAsync(iterable, fn) {
 	    if ((0, types_1$f.isAsyncIterable)(iterable)) {
 	        return mapAsyncIterable(iterable);
@@ -1094,14 +1094,14 @@
 	var repeatAsync$1 = {};
 
 	repeatAsync$1.repeatAsync = void 0;
-	const go_1$7 = es2018$4;
-	const errors_1$e = es2018$3;
+	const go_1$8 = es2018$6;
+	const errors_1$e = es2018$5;
 	function repeatAsync(iterable, times) {
 	    (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 (0, 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) {
@@ -1129,14 +1129,14 @@
 	var repeat$4 = {};
 
 	repeat$4.repeat = void 0;
-	const go_1$6 = es2018$4;
-	const errors_1$d = es2018$3;
+	const go_1$7 = es2018$6;
+	const errors_1$d = es2018$5;
 	function repeat$3(iterable, times) {
 	    (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 (0, go_1$6.go)(function* () {
+	    return (0, go_1$7.go)(function* () {
 	        const cache = [];
 	        if (times > 0) {
 	            for (const element of iterable) {
@@ -1164,14 +1164,14 @@
 	var sliceAsync$1 = {};
 
 	sliceAsync$1.sliceAsync = void 0;
-	const go_1$5 = es2018$4;
-	const errors_1$c = es2018$3;
+	const go_1$6 = es2018$6;
+	const errors_1$c = es2018$5;
 	function sliceAsync(iterable, start, end = Infinity) {
 	    (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$5.go)(async function* () {
+	    return (0, go_1$6.go)(async function* () {
 	        let index = 0;
 	        for await (const element of iterable) {
 	            if (index >= end)
@@ -1187,14 +1187,14 @@
 	var slice$1 = {};
 
 	slice$1.slice = void 0;
-	const go_1$4 = es2018$4;
-	const errors_1$b = es2018$3;
+	const go_1$5 = es2018$6;
+	const errors_1$b = es2018$5;
 	function slice(iterable, start, end = Infinity) {
 	    (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$4.go)(function* () {
+	    return (0, go_1$5.go)(function* () {
 	        let index = 0;
 	        for (const element of iterable) {
 	            if (index >= end)
@@ -1228,7 +1228,7 @@
 	var splitByAsync$1 = {};
 
 	splitByAsync$1.splitByAsync = void 0;
-	const types_1$e = es2018$2;
+	const types_1$e = es2018$4;
 	function splitByAsync(iterable, predicate) {
 	    if ((0, types_1$e.isAsyncIterable)(iterable)) {
 	        return splitByAsyncIterable(iterable);
@@ -1310,12 +1310,12 @@
 	var takeAsync$1 = {};
 
 	takeAsync$1.takeAsync = void 0;
-	const go_1$3 = es2018$4;
-	const errors_1$a = es2018$3;
+	const go_1$4 = es2018$6;
+	const errors_1$a = es2018$5;
 	function takeAsync(iterable, count) {
 	    (0, errors_1$a.assert)(Number.isInteger(count), 'The parameter count must be an integer');
 	    (0, errors_1$a.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
-	    return (0, go_1$3.go)(async function* () {
+	    return (0, go_1$4.go)(async function* () {
 	        if (count === 0)
 	            return;
 	        for await (const element of iterable) {
@@ -1331,12 +1331,12 @@
 	var takeRightAsync$1 = {};
 
 	takeRightAsync$1.takeRightAsync = void 0;
-	const go_1$2 = es2018$4;
-	const errors_1$9 = es2018$3;
+	const go_1$3 = es2018$6;
+	const errors_1$9 = es2018$5;
 	function takeRightAsync(iterable, count) {
 	    (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$2.go)(async function* () {
+	    return (0, go_1$3.go)(async function* () {
 	        var _a;
 	        const iterator = iterable[Symbol.asyncIterator]();
 	        let done;
@@ -1361,12 +1361,12 @@
 	var takeRight$1 = {};
 
 	takeRight$1.takeRight = void 0;
-	const go_1$1 = es2018$4;
-	const errors_1$8 = es2018$3;
+	const go_1$2 = es2018$6;
+	const errors_1$8 = es2018$5;
 	function takeRight(iterable, count) {
 	    (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$1.go)(function* () {
+	    return (0, go_1$2.go)(function* () {
 	        var _a;
 	        const iterator = iterable[Symbol.iterator]();
 	        let done;
@@ -1391,7 +1391,7 @@
 	var takeUntilAsync$1 = {};
 
 	takeUntilAsync$1.takeUntilAsync = void 0;
-	const types_1$d = es2018$2;
+	const types_1$d = es2018$4;
 	function takeUntilAsync(iterable, predicate) {
 	    if ((0, types_1$d.isAsyncIterable)(iterable)) {
 	        return takeUntilAsyncIterable(iterable);
@@ -1437,12 +1437,12 @@
 	var take$1 = {};
 
 	take$1.take = void 0;
-	const go_1 = es2018$4;
-	const errors_1$7 = es2018$3;
+	const go_1$1 = es2018$6;
+	const errors_1$7 = es2018$5;
 	function take(iterable, count) {
 	    (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.go)(function* () {
+	    return (0, go_1$1.go)(function* () {
 	        if (count === 0)
 	            return;
 	        for (const element of iterable) {
@@ -1458,7 +1458,7 @@
 	var tapAsync$1 = {};
 
 	tapAsync$1.tapAsync = void 0;
-	const types_1$c = es2018$2;
+	const types_1$c = es2018$4;
 	function tapAsync(iterable, fn) {
 	    if ((0, types_1$c.isAsyncIterable)(iterable)) {
 	        return tapAsyncIterable(iterable);
@@ -1541,7 +1541,7 @@
 	var uniqByAsync$1 = {};
 
 	uniqByAsync$1.uniqByAsync = void 0;
-	const types_1$b = es2018$2;
+	const types_1$b = es2018$4;
 	function uniqByAsync(iterable, fn) {
 	    if ((0, types_1$b.isAsyncIterable)(iterable)) {
 	        return uniqByAsyncIterable(iterable);
@@ -1610,7 +1610,7 @@
 	var zipAsync$1 = {};
 
 	zipAsync$1.zipAsync = void 0;
-	const types_1$a = es2018$2;
+	const types_1$a = es2018$4;
 	var Kind;
 	(function (Kind) {
 	    Kind[Kind["Sync"] = 0] = "Sync";
@@ -1770,7 +1770,7 @@
 	var eachAsync$1 = {};
 
 	eachAsync$1.eachAsync = void 0;
-	const types_1$9 = es2018$2;
+	const types_1$9 = es2018$4;
 	function eachAsync(iterable, fn) {
 	    if ((0, types_1$9.isAsyncIterable)(iterable)) {
 	        return eachAsyncIterable(iterable);
@@ -1810,7 +1810,7 @@
 	var everyAsync$1 = {};
 
 	everyAsync$1.everyAsync = void 0;
-	const types_1$8 = es2018$2;
+	const types_1$8 = es2018$4;
 	function everyAsync(iterable, predicate) {
 	    if ((0, types_1$8.isAsyncIterable)(iterable)) {
 	        return everyAsyncIterable(iterable);
@@ -1856,7 +1856,7 @@
 	var findAsync$1 = {};
 
 	findAsync$1.findAsync = void 0;
-	const types_1$7 = es2018$2;
+	const types_1$7 = es2018$4;
 	function findAsync(iterable, predicate) {
 	    if ((0, types_1$7.isAsyncIterable)(iterable)) {
 	        return findAsyncIterable(iterable);
@@ -1980,7 +1980,7 @@
 	var reduceAsync$1 = {};
 
 	reduceAsync$1.reduceAsync = void 0;
-	const types_1$6 = es2018$2;
+	const types_1$6 = es2018$4;
 	function reduceAsync(iterable, fn, initialValue) {
 	    if ((0, types_1$6.isUndefined)(initialValue)) {
 	        return reduceAsyncWithoutInitialValue(iterable, fn);
@@ -2076,7 +2076,7 @@
 	var reduce$1 = {};
 
 	reduce$1.reduce = void 0;
-	const types_1$5 = es2018$2;
+	const types_1$5 = es2018$4;
 	function reduce(iterable, fn, initialValue) {
 	    if ((0, types_1$5.isUndefined)(initialValue)) {
 	        return reduceWithoutInitialValue(iterable, fn);
@@ -2123,7 +2123,7 @@
 	var someAsync$1 = {};
 
 	someAsync$1.someAsync = void 0;
-	const types_1$4 = es2018$2;
+	const types_1$4 = es2018$4;
 	function someAsync(iterable, predicate) {
 	    if ((0, types_1$4.isAsyncIterable)(iterable)) {
 	        return someAsyncIterable(iterable);
@@ -2307,11 +2307,11 @@
 	};__exportStar(middleware, exports);
 	__exportStar(output, exports);
 
-	}(es2018$5));
+	}(es2018$7));
 
 	unwrap$1.unwrap = void 0;
 	const flat_map_1 = flatMap$1;
-	const iterable_operator_1$2 = es2018$5;
+	const iterable_operator_1$2 = es2018$7;
 	function unwrap(node, predicate) {
 	    return (0, flat_map_1.flatMap)(node, node => {
 	        if (predicate(node)) {
@@ -2341,7 +2341,7 @@
 
 	findInDescendantNodes$1.findInDescendantNodes = void 0;
 	const traverse_descendant_nodes_1 = traverseDescendantNodes$1;
-	const iterable_operator_1$1 = es2018$5;
+	const iterable_operator_1$1 = es2018$7;
 	function findInDescendantNodes(node, predicate) {
 	    return (0, iterable_operator_1$1.find)((0, traverse_descendant_nodes_1.traverseDescendantNodes)(node), node => predicate(node));
 	}
@@ -2451,9 +2451,360 @@
 
 	}(nodeType));
 
+	var es2018$3 = {};
+
+	var array = {};
+
+	array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
+	function isArray(val) {
+	    return Array.isArray(val);
+	}
+	array.isArray = isArray;
+	function isntArray(val) {
+	    return !isArray(val);
+	}
+	array.isntArray = isntArray;
+	function isEmptyArray(val) {
+	    return val.length === 0;
+	}
+	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 = {};
+
+	object.isntEmptyObject = object.isEmptyObject = object.isRecord = object.isntObject = object.isObject = void 0;
+	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 isRecord(val) {
+	    return isObject$1(val);
+	}
+	object.isRecord = isRecord;
+	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.isRecord)(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.isRecord)(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.isRecord)(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.isRecord)(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.isRecord)(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$3));
+
 	isDocument$1.isDocument = void 0;
 	const node_type_1$2 = nodeType;
-	const types_1$3 = es2018$2;
+	const types_1$3 = es2018$3;
 	function isDocument(val) {
 	    if ('HTMLDocument' in globalThis && val instanceof HTMLDocument)
 	        return true;
@@ -2465,7 +2816,7 @@
 
 	isElement$1.isElement = void 0;
 	const node_type_1$1 = nodeType;
-	const types_1$2 = es2018$2;
+	const types_1$2 = es2018$3;
 	function isElement(val) {
 	    if ('HTMLElement' in globalThis && val instanceof HTMLElement)
 	        return true;
@@ -2525,7 +2876,7 @@
 
 	findInAncestorNodes$1.findInAncestorNodes = void 0;
 	const traverse_ancestor_nodes_1 = traverseAncestorNodes$1;
-	const iterable_operator_1 = es2018$5;
+	const iterable_operator_1 = es2018$7;
 	function findInAncestorNodes(node, predicate) {
 	    return (0, iterable_operator_1.find)((0, traverse_ancestor_nodes_1.traverseAncestorNodes)(node), node => predicate(node));
 	}
@@ -2566,7 +2917,7 @@
 	var parentNode$1 = {};
 
 	parentNode$1.parentNode = void 0;
-	const errors_1$6 = es2018$3;
+	const errors_1$6 = es2018$5;
 	function parentNode(node, distance = 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');
@@ -2588,7 +2939,7 @@
 	var nextSibling$2 = {};
 
 	nextSibling$2.nextSibling = void 0;
-	const errors_1$5 = es2018$3;
+	const errors_1$5 = es2018$5;
 	function nextSibling$1(node, distance = 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');
@@ -2610,30 +2961,30 @@
 	var previousSibling$1 = {};
 
 	previousSibling$1.previousSibling = void 0;
-	const errors_1$4 = es2018$3;
+	const errors_1$4 = es2018$5;
 	function previousSibling(node, 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);
-	}
-	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);
+	    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$3;
+	const errors_1$3 = es2018$5;
 	function nextElementSibling$1(node, distance = 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');
@@ -2661,29 +3012,29 @@
 
 	previousElementSibling$1.previousElementSibling = void 0;
 	const is_element_1$1 = isElement$1;
-	const errors_1$2 = es2018$3;
+	const errors_1$2 = es2018$5;
 	function previousElementSibling(node, distance = 1) {
 	    (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);
-	}
-	previousElementSibling$1.previousElementSibling = previousElementSibling;
-	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;
+	    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 = {};
 
@@ -2706,7 +3057,7 @@
 	var isNode$1 = {};
 
 	isNode$1.isNode = void 0;
-	const types_1$1 = es2018$2;
+	const types_1$1 = es2018$3;
 	function isNode(val) {
 	    if ('Node' in globalThis && val instanceof Node)
 	        return true;
@@ -2727,7 +3078,7 @@
 
 	isTextNode$1.isTextNode = void 0;
 	const node_type_1 = nodeType;
-	const types_1 = es2018$2;
+	const types_1 = es2018$3;
 	function isTextNode(val) {
 	    if ('Text' in globalThis && val instanceof Text)
 	        return true;
@@ -2893,7 +3244,7 @@
 	__exportStar(isBefore$1, exports);
 	__exportStar(isAfter$1, exports);
 
-	}(es2018$6));
+	}(es2018$8));
 
 	function matchOneByOne(context, source, ...matchers) {
 	    if (matchers.length === 0)
@@ -2903,7 +3254,7 @@
 	    const [matcher, ...otherMatchers] = matchers;
 	    const result = Reflect.apply(matcher, context, [source]);
 	    // TerminalMatcher
-	    if (es2018$2.isBoolean(result)) {
+	    if (es2018$3.isBoolean(result)) {
 	        if (result) {
 	            const nextNode = context.next(source);
 	            return matchOneByOne(context, nextNode, ...otherMatchers);
@@ -2913,13 +3264,13 @@
 	        }
 	    }
 	    // 此处一定是成功匹配, 因为SkipMatcher在失败时会返回false.
-	    if (es2018$2.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$2.isIterable(result)) {
+	    if (es2018$3.isIterable(result)) {
 	        for (const distance of result) {
 	            const nextNode = context.next(source, distance);
 	            if (matchOneByOne(context, nextNode, ...otherMatchers)) {
@@ -2935,11 +3286,11 @@
 	function nextSibling(node, distance = 1) {
 	    if (distance === 0)
 	        return node;
-	    return es2018$6.nextSibling(node, distance);
+	    return es2018$8.nextSibling(node, distance);
 	}
 
 	function match(node, ...matchers) {
-	    const document = es2018$6.isDocument(this) ? this : globalThis.document;
+	    const document = es2018$8.isDocument(this) ? this : globalThis.document;
 	    const context = {
 	        document,
 	        collection: {},
@@ -2956,11 +3307,11 @@
 	function nextElementSibling(node, distance = 1) {
 	    if (distance === 0)
 	        return node;
-	    return es2018$6.nextElementSibling(node, distance);
+	    return es2018$8.nextElementSibling(node, distance);
 	}
 
 	function matchElement(element, ...matchers) {
-	    const document = es2018$6.isDocument(this) ? this : globalThis.document;
+	    const document = es2018$8.isDocument(this) ? this : globalThis.document;
 	    const context = {
 	        document,
 	        collection: {},
@@ -2983,8 +3334,8 @@
 	function merge(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 {
@@ -2992,7 +3343,7 @@
 	                }
 	            }
 	            else {
-	                if (Array.isArray(value)) {
+	                if (es2018$3.isArray(value)) {
 	                    target[key] = [target[key], ...value];
 	                }
 	                else {
@@ -3051,7 +3402,7 @@
 	}
 
 	function css(...args) {
-	    if (es2018$2.isString(args[0])) {
+	    if (es2018$3.isString(args[0])) {
 	        const [selector] = args;
 	        return (element) => element.matches(selector);
 	    }
@@ -3063,12 +3414,12 @@
 	}
 
 	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$2.isString(args[0])) {
+	    if (es2018$3.isString(args[0])) {
 	        const [name, ...matchers] = args;
 	        return function (_element) {
 	            const result = element(...matchers).call(this, _element);
@@ -3080,7 +3431,7 @@
 	    }
 	    const [...matchers] = args;
 	    return function (element) {
-	        if (es2018$6.isntElement(element))
+	        if (es2018$8.isntElement(element))
 	            return false;
 	        if (matchers.length === 0)
 	            return true;
@@ -3088,7 +3439,7 @@
 	    };
 	}
 
-	var es2018$1 = {};
+	var es2018$2 = {};
 
 	var of$1 = {};
 
@@ -3100,15 +3451,40 @@
 
 	var repeat$2 = {};
 
+	var es2018$1 = {};
+
+	var go$1 = {};
+
+	go$1.go = void 0;
+	function go(fn) {
+	    return fn();
+	}
+	go$1.go = go;
+
+	(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(go$1, exports);
+
+	}(es2018$1));
+
 	repeat$2.repeat = void 0;
-	const errors_1$1 = es2018$3;
+	const errors_1$1 = es2018$5;
+	const go_1 = es2018$1;
 	function repeat$1(val, times = Infinity) {
 	    (0, errors_1$1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
-	    return (function* () {
+	    return (0, go_1.go)(function* () {
 	        while (times-- > 0) {
 	            yield val;
 	        }
-	    })();
+	    });
 	}
 	repeat$2.repeat = repeat$1;
 
@@ -3139,7 +3515,7 @@
 	var range$1 = {};
 
 	range$1.range = void 0;
-	const errors_1 = es2018$3;
+	const errors_1 = es2018$5;
 	function range(start, end, step = 1) {
 	    (0, errors_1.assert)(step > 0, 'step parameter must be greater than 0');
 	    return rangeByUnsignedStep(start, end, step);
@@ -3696,6 +4072,29 @@
 	}
 	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;
@@ -3718,15 +4117,16 @@
 	__exportStar(sse$1, exports);
 	__exportStar(reusableIterable, exports);
 	__exportStar(reusableAsyncIterable, exports);
+	__exportStar(timestampBasedId$1, exports);
 
-	}(es2018$1));
+	}(es2018$2));
 
 	/**
 	 * @returns {number} 返回值为成功匹配的元素个数, 当此值等于ubound时, 代表匹配成功.
 	 */
 	function matchMultiple(node, ubound, matcher) {
 	    let currentNode = node;
-	    for (const round of es2018$1.countup(1, ubound)) {
+	    for (const round of es2018$2.countup(1, ubound)) {
 	        if (!currentNode)
 	            return round - 1;
 	        const result = matcher.call(this, currentNode);
@@ -3746,10 +4146,10 @@
 	    Range[Range["Max"] = 1] = "Max";
 	})(Range || (Range = {}));
 	function multiple([min, max], matcher, options = { greedy: true }) {
-	    es2018$3.assert(Number.isInteger(min), 'parameter min must be an integer');
-	    es2018$3.assert(Number.isInteger(max) || max === Infinity, 'parameter max must be an integer or Infinity');
-	    es2018$3.assert(min >= 0, 'parameter min must be greater than or equal to 0');
-	    es2018$3.assert(min <= max, 'parameter max must be greater than or equal to min');
+	    es2018$5.assert(Number.isInteger(min), 'parameter min must be an integer');
+	    es2018$5.assert(Number.isInteger(max) || max === Infinity, 'parameter max must be an integer or Infinity');
+	    es2018$5.assert(min >= 0, 'parameter min must be greater than or equal to 0');
+	    es2018$5.assert(min <= max, 'parameter max must be greater than or equal to min');
 	    return function* (node) {
 	        if (options.greedy) {
 	            let ubound = max;
@@ -3764,7 +4164,7 @@
 	            }
 	        }
 	        else {
-	            for (const ubound of es2018$1.countup(min, max)) {
+	            for (const ubound of es2018$2.countup(min, max)) {
 	                const result = matchMultiple.call(this, node, ubound, matcher);
 	                // 如果匹配的节点数量少于ubound, 说明匹配失败, 即使尝试更长的匹配也不会成功.
 	                if (result < ubound)
@@ -3777,12 +4177,12 @@
 	}
 
 	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$2.isString(args[0])) {
+	    if (es2018$3.isString(args[0])) {
 	        const [name, ...matchers] = args;
 	        return function (_node) {
 	            const result = node(...matchers).call(this, _node);
@@ -3805,8 +4205,8 @@
 	}
 
 	function repeat(times, matcher) {
-	    es2018$3.assert(Number.isInteger(times), 'parameter times must be an integer');
-	    es2018$3.assert(times >= 0, 'parameter number must be greater than or equal to 0');
+	    es2018$5.assert(Number.isInteger(times), 'parameter times must be an integer');
+	    es2018$5.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) {
@@ -3828,7 +4228,7 @@
 
 	function textContentEquals(text, { caseSensitive = true, trim = false } = {}) {
 	    return (node) => {
-	        if (es2018$2.isNull(node.textContent))
+	        if (es2018$3.isNull(node.textContent))
 	            return false;
 	        let textContent = node.textContent;
 	        if (!caseSensitive) {
@@ -3843,7 +4243,7 @@
 
 	function textContentIncludes(searchString, { caseSensitive = true, trim = false } = {}) {
 	    return (node) => {
-	        if (es2018$2.isNull(node.textContent))
+	        if (es2018$3.isNull(node.textContent))
 	            return false;
 	        let textContent = node.textContent;
 	        if (!caseSensitive) {
@@ -3858,7 +4258,7 @@
 
 	function textContentMatches(pattern, { trim = false } = {}) {
 	    return (node) => {
-	        if (es2018$2.isNull(node.textContent))
+	        if (es2018$3.isNull(node.textContent))
 	            return false;
 	        let textContent = node.textContent;
 	        if (trim)
@@ -3868,12 +4268,12 @@
 	}
 
 	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$2.isString(args[0])) {
+	    if (es2018$3.isString(args[0])) {
 	        const [name, ...matchers] = args;
 	        return function (node) {
 	            const result = textNode(...matchers).call(this, node);
@@ -3885,7 +4285,7 @@
 	    }
 	    const [...matchers] = args;
 	    return function (node) {
-	        if (es2018$6.isntTextNode(node))
+	        if (es2018$8.isntTextNode(node))
 	            return false;
 	        if (matchers.length === 0)
 	            return true;
@@ -3897,9 +4297,9 @@
 	    ? XPathResult.UNORDERED_NODE_ITERATOR_TYPE
 	    : 4;
 	function xpath(...args) {
-	    if (es2018$2.isString(args[0])) {
+	    if (es2018$3.isString(args[0])) {
 	        const [expression] = args;
-	        es2018$3.assert(expression.startsWith('//*'), 'XPath expressions must start with "//*"');
+	        es2018$5.assert(expression.startsWith('//*'), 'XPath expressions must start with "//*"');
 	        return function (node) {
 	            return xpathMatches(this.document, expression, node);
 	        };