@blackglory/match 0.3.3

package/dist/es2015/index.umd.js

@@ -0,0 +1,3944 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Match = {}));
+})(this, (function (exports) { 'use strict';
+
+	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+	var es2018$6 = {};
+
+	var flatMap$1 = {};
+
+	var utils$1 = {};
+
+	utils$1.copyNodesToChildNodes = utils$1.cloneNodes = utils$1.clone = void 0;
+	function clone(node) {
+	    return node.cloneNode(true);
+	}
+	utils$1.clone = clone;
+	function cloneNodes(nodes) {
+	    return nodes.map(x => clone(x));
+	}
+	utils$1.cloneNodes = cloneNodes;
+	function copyNodesToChildNodes(nodes, node) {
+	    nodes.forEach(x => node.appendChild(x));
+	}
+	utils$1.copyNodesToChildNodes = copyNodesToChildNodes;
+
+	var removeAllChildren$1 = {};
+
+	removeAllChildren$1.removeAllChildren = void 0;
+	function removeAllChildren(node) {
+	    while (node.firstChild) {
+	        node.removeChild(node.firstChild);
+	    }
+	}
+	removeAllChildren$1.removeAllChildren = removeAllChildren;
+
+	flatMap$1.flatMap = void 0;
+	const utils_1$5 = utils$1;
+	const remove_all_children_1 = removeAllChildren$1;
+	function flatMap(node, fn) {
+	    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(...(0, utils_1$5.cloneNodes)(flatMap(childNode, fn)));
+	        }
+	        (0, remove_all_children_1.removeAllChildren)(node);
+	        (0, utils_1$5.copyNodesToChildNodes)(newChildNodes, node);
+	        return node;
+	    });
+	}
+	flatMap$1.flatMap = flatMap;
+
+	var map$3 = {};
+
+	map$3.map = void 0;
+	const utils_1$4 = utils$1;
+	function map$2(node, fn) {
+	    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);
+	    }
+	    return newNode;
+	}
+	map$3.map = map$2;
+
+	var filter$3 = {};
+
+	filter$3.filter = void 0;
+	const flat_map_1$1 = flatMap$1;
+	function filter$2(node, predicate) {
+	    const results = (0, flat_map_1$1.flatMap)(node, node => {
+	        if (predicate(node)) {
+	            return [node];
+	        }
+	        else {
+	            return [];
+	        }
+	    });
+	    if (results.length === 1)
+	        return results[0];
+	    return undefined;
+	}
+	filter$3.filter = filter$2;
+
+	var unwrap$1 = {};
+
+	var es2018$5 = {};
+
+	var middleware = {};
+
+	var chunkAsync$1 = {};
+
+	var es2018$4 = {};
+
+	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$4));
+
+	var es2018$3 = {};
+
+	var customError = {};
+
+	customError.CustomError = void 0;
+	class CustomError extends Error {
+	    get name() {
+	        return this.constructor.name;
+	    }
+	}
+	customError.CustomError = CustomError;
+
+	var expectedError = {};
+
+	expectedError.ExpectedError = void 0;
+	const custom_error_1$1 = customError;
+	class ExpectedError extends custom_error_1$1.CustomError {
+	}
+	expectedError.ExpectedError = ExpectedError;
+
+	var assertionError = {};
+
+	assertionError.AssertionError = void 0;
+	const custom_error_1 = customError;
+	class AssertionError extends custom_error_1.CustomError {
+	}
+	assertionError.AssertionError = AssertionError;
+
+	var normalize$3 = {};
+
+	normalize$3.normalize = void 0;
+	function normalize$2(err) {
+	    var _a;
+	    return {
+	        name: err.name,
+	        message: err.message,
+	        stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
+	    };
+	}
+	normalize$3.normalize = normalize$2;
+
+	var refute$1 = {};
+
+	refute$1.refute = void 0;
+	const expected_error_1 = expectedError;
+	function refute(condition, message) {
+	    if (condition)
+	        throw new expected_error_1.ExpectedError(message);
+	}
+	refute$1.refute = refute;
+
+	var assert$1 = {};
+
+	assert$1.assert = void 0;
+	const assertion_error_1 = assertionError;
+	function assert(condition, message) {
+	    if (!condition)
+	        throw new assertion_error_1.AssertionError(message);
+	}
+	assert$1.assert = assert;
+
+	(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(customError, exports);
+	__exportStar(expectedError, exports);
+	__exportStar(assertionError, exports);
+	__exportStar(normalize$3, exports);
+	__exportStar(refute$1, exports);
+	__exportStar(assert$1, exports);
+
+	}(es2018$3));
+
+	chunkAsync$1.chunkAsync = void 0;
+	const go_1$f = es2018$4;
+	const errors_1$m = es2018$3;
+	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* () {
+	        let buffer = [];
+	        for await (const element of iterable) {
+	            buffer.push(element);
+	            if (buffer.length >= size) {
+	                yield buffer;
+	                buffer = [];
+	            }
+	        }
+	        if (buffer.length)
+	            yield buffer;
+	    });
+	}
+	chunkAsync$1.chunkAsync = chunkAsync;
+
+	var chunkByAsync$1 = {};
+
+	var es2018$2 = {};
+
+	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)
+	        && (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) {
+	    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));
+
+	chunkByAsync$1.chunkByAsync = void 0;
+	const types_1$l = es2018$2;
+	function chunkByAsync(iterable, predicate) {
+	    if ((0, types_1$l.isAsyncIterable)(iterable)) {
+	        return chunkByAsyncIterable(iterable);
+	    }
+	    else {
+	        return chunkByIterable(iterable);
+	    }
+	    async function* chunkByAsyncIterable(iterable) {
+	        let buffer = [];
+	        let index = 0;
+	        for await (const element of iterable) {
+	            buffer.push(element);
+	            if (await predicate(element, index)) {
+	                yield buffer;
+	                buffer = [];
+	            }
+	            index++;
+	        }
+	        if (buffer.length)
+	            yield buffer;
+	    }
+	    async function* chunkByIterable(iterable) {
+	        let buffer = [];
+	        let index = 0;
+	        for (const element of iterable) {
+	            buffer.push(element);
+	            if (await predicate(element, index)) {
+	                yield buffer;
+	                buffer = [];
+	            }
+	            index++;
+	        }
+	        if (buffer.length)
+	            yield buffer;
+	    }
+	}
+	chunkByAsync$1.chunkByAsync = chunkByAsync;
+
+	var chunkBy$1 = {};
+
+	chunkBy$1.chunkBy = void 0;
+	function* chunkBy(iterable, predicate) {
+	    let buffer = [];
+	    let index = 0;
+	    for (const element of iterable) {
+	        buffer.push(element);
+	        if (predicate(element, index)) {
+	            yield buffer;
+	            buffer = [];
+	        }
+	        index++;
+	    }
+	    if (buffer.length)
+	        yield buffer;
+	}
+	chunkBy$1.chunkBy = chunkBy;
+
+	var chunk$1 = {};
+
+	chunk$1.chunk = void 0;
+	const go_1$e = es2018$4;
+	const errors_1$l = es2018$3;
+	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* () {
+	        let buffer = [];
+	        for (const element of iterable) {
+	            buffer.push(element);
+	            if (buffer.length >= size) {
+	                yield buffer;
+	                buffer = [];
+	            }
+	        }
+	        if (buffer.length)
+	            yield buffer;
+	    });
+	}
+	chunk$1.chunk = chunk;
+
+	var concatAsync$1 = {};
+
+	concatAsync$1.concatAsync = void 0;
+	const types_1$k = es2018$2;
+	const go_1$d = es2018$4;
+	function concatAsync(iterable, ...otherIterables) {
+	    return (0, go_1$d.go)(async function* () {
+	        for (const iter of [iterable, ...otherIterables]) {
+	            if ((0, types_1$k.isAsyncIterable)(iter)) {
+	                for await (const element of iter) {
+	                    yield element;
+	                }
+	            }
+	            else {
+	                for (const element of iter) {
+	                    yield element;
+	                }
+	            }
+	        }
+	    });
+	}
+	concatAsync$1.concatAsync = concatAsync;
+
+	var concat$2 = {};
+
+	concat$2.concat = void 0;
+	const go_1$c = es2018$4;
+	function concat$1(iterable, ...otherIterables) {
+	    return (0, go_1$c.go)(function* () {
+	        for (const iter of [iterable, ...otherIterables]) {
+	            yield* iter;
+	        }
+	    });
+	}
+	concat$2.concat = concat$1;
+
+	var dropAsync$1 = {};
+
+	var utils = {};
+
+	utils.copyIterable = utils.copyAsyncIterable = void 0;
+	async function* copyAsyncIterable(iterable) {
+	    for await (const element of iterable) {
+	        yield element;
+	    }
+	}
+	utils.copyAsyncIterable = copyAsyncIterable;
+	function* copyIterable(iterable) {
+	    for (const element of iterable) {
+	        yield element;
+	    }
+	}
+	utils.copyIterable = copyIterable;
+
+	dropAsync$1.dropAsync = void 0;
+	const go_1$b = es2018$4;
+	const utils_1$3 = utils;
+	const errors_1$k = es2018$3;
+	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* () {
+	        var _a;
+	        const iterator = iterable[Symbol.asyncIterator]();
+	        let done;
+	        try {
+	            let value;
+	            while ({ value, done } = await iterator.next(), !done) {
+	                if (count <= 0)
+	                    break;
+	                count--;
+	            }
+	            while (!done) {
+	                yield value;
+	                ({ value, done } = await iterator.next());
+	            }
+	        }
+	        finally {
+	            if (!done)
+	                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+	        }
+	    });
+	}
+	dropAsync$1.dropAsync = dropAsync;
+
+	var dropRightAsync$1 = {};
+
+	dropRightAsync$1.dropRightAsync = void 0;
+	const go_1$a = es2018$4;
+	const utils_1$2 = utils;
+	const errors_1$j = es2018$3;
+	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* () {
+	        const arr = await toArrayAsync$2(iterable);
+	        const result = arr.slice(0, -count);
+	        for (const value of result) {
+	            yield value;
+	        }
+	    });
+	}
+	dropRightAsync$1.dropRightAsync = dropRightAsync;
+	async function toArrayAsync$2(iterable) {
+	    const result = [];
+	    for await (const element of iterable) {
+	        result.push(element);
+	    }
+	    return result;
+	}
+
+	var dropRight$1 = {};
+
+	dropRight$1.dropRight = void 0;
+	const go_1$9 = es2018$4;
+	const utils_1$1 = utils;
+	const errors_1$i = es2018$3;
+	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* () {
+	        const arr = Array.from(iterable);
+	        yield* arr.slice(0, -count);
+	    });
+	}
+	dropRight$1.dropRight = dropRight;
+
+	var dropUntilAsync$1 = {};
+
+	dropUntilAsync$1.dropUntilAsync = void 0;
+	const types_1$j = es2018$2;
+	function dropUntilAsync(iterable, predicate) {
+	    if ((0, types_1$j.isAsyncIterable)(iterable)) {
+	        return dropUntilAsyncIterable(iterable);
+	    }
+	    else {
+	        return dropUntilIterable(iterable);
+	    }
+	    async function* dropUntilAsyncIterable(iterable) {
+	        var _a;
+	        const iterator = iterable[Symbol.asyncIterator]();
+	        let done;
+	        try {
+	            let index = 0;
+	            let value;
+	            while ({ value, done } = await iterator.next(), !done) {
+	                if (await predicate(value, index++))
+	                    break;
+	            }
+	            while (!done) {
+	                yield value;
+	                ({ value, done } = await iterator.next());
+	            }
+	        }
+	        finally {
+	            if (!done)
+	                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+	        }
+	    }
+	    async function* dropUntilIterable(iterable) {
+	        var _a;
+	        const iterator = iterable[Symbol.iterator]();
+	        let done;
+	        try {
+	            let index = 0;
+	            let value;
+	            while ({ value, done } = iterator.next(), !done) {
+	                if (await predicate(value, index++))
+	                    break;
+	            }
+	            while (!done) {
+	                yield value;
+	                ({ value, done } = iterator.next());
+	            }
+	        }
+	        finally {
+	            if (!done)
+	                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+	        }
+	    }
+	}
+	dropUntilAsync$1.dropUntilAsync = dropUntilAsync;
+
+	var dropUntil$1 = {};
+
+	dropUntil$1.dropUntil = void 0;
+	function* dropUntil(iterable, predicate) {
+	    var _a;
+	    const iterator = iterable[Symbol.iterator]();
+	    let done;
+	    try {
+	        let index = 0;
+	        let value;
+	        while ({ value, done } = iterator.next(), !done) {
+	            if (predicate(value, index++))
+	                break;
+	        }
+	        while (!done) {
+	            yield value;
+	            ({ value, done } = iterator.next());
+	        }
+	    }
+	    finally {
+	        if (!done)
+	            (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+	    }
+	}
+	dropUntil$1.dropUntil = dropUntil;
+
+	var drop$1 = {};
+
+	drop$1.drop = void 0;
+	const go_1$8 = es2018$4;
+	const utils_1 = utils;
+	const errors_1$h = es2018$3;
+	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* () {
+	        var _a;
+	        const iterator = iterable[Symbol.iterator]();
+	        let done;
+	        try {
+	            let value;
+	            while ({ value, done } = iterator.next(), !done) {
+	                if (count <= 0)
+	                    break;
+	                count--;
+	            }
+	            while (!done) {
+	                yield value;
+	                ({ value, done } = iterator.next());
+	            }
+	        }
+	        finally {
+	            if (!done)
+	                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+	        }
+	    });
+	}
+	drop$1.drop = drop;
+
+	var filterAsync$1 = {};
+
+	filterAsync$1.filterAsync = void 0;
+	const types_1$i = es2018$2;
+	function filterAsync(iterable, predicate) {
+	    if ((0, types_1$i.isAsyncIterable)(iterable)) {
+	        return filterAsyncIterable(iterable);
+	    }
+	    else {
+	        return filterIterable(iterable);
+	    }
+	    async function* filterAsyncIterable(iterable) {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            if (await predicate(element, index))
+	                yield element;
+	            index++;
+	        }
+	    }
+	    async function* filterIterable(iterable) {
+	        let index = 0;
+	        for (const element of iterable) {
+	            if (await predicate(element, index))
+	                yield element;
+	            index++;
+	        }
+	    }
+	}
+	filterAsync$1.filterAsync = filterAsync;
+
+	var filter$1 = {};
+
+	filter$1.filter = void 0;
+	function* filter(iterable, predicate) {
+	    let index = 0;
+	    for (const element of iterable) {
+	        if (predicate(element, index))
+	            yield element;
+	        index++;
+	    }
+	}
+	filter$1.filter = filter;
+
+	var flattenAsync$1 = {};
+
+	var flattenDeepAsync$1 = {};
+
+	var flattenByAsync$1 = {};
+
+	flattenByAsync$1.flattenByAsync = void 0;
+	const types_1$h = es2018$2;
+	function flattenByAsync(iterable, predicate) {
+	    if ((0, types_1$h.isAsyncIterable)(iterable)) {
+	        return flattenByAsyncIterable(iterable);
+	    }
+	    else {
+	        return flattenByIterable(iterable);
+	    }
+	    async function* flattenByAsyncIterable(iterable) {
+	        const level = 1;
+	        for await (const element of iterable) {
+	            if (isFiniteIterable$1(element) && await predicate(element, level)) {
+	                yield* flatten(element, level + 1);
+	            }
+	            else {
+	                yield element;
+	            }
+	        }
+	    }
+	    function flattenByIterable(iterable) {
+	        return flatten(iterable, 1);
+	    }
+	    async function* flatten(iterable, level) {
+	        for (const element of iterable) {
+	            if (isFiniteIterable$1(element) && await predicate(element, level)) {
+	                yield* flatten(element, level + 1);
+	            }
+	            else {
+	                yield element;
+	            }
+	        }
+	    }
+	}
+	flattenByAsync$1.flattenByAsync = flattenByAsync;
+	function isFiniteIterable$1(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$3;
+	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');
+	    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 (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$2;
+	function flattenBy(iterable, predicate) {
+	    return flatten(iterable, 1);
+	    function* flatten(iterable, level) {
+	        for (const element of iterable) {
+	            if (isFiniteIterable(element) && predicate(element, level)) {
+	                yield* flatten(element, level + 1);
+	            }
+	            else {
+	                yield element;
+	            }
+	        }
+	    }
+	}
+	flattenBy$1.flattenBy = flattenBy;
+	function isFiniteIterable(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$3;
+	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');
+	    return (0, flatten_by_1.flattenBy)(iterable, (_, level) => level <= depth);
+	}
+	flattenDeep$1.flattenDeep = flattenDeep;
+
+	var flatten$1 = {};
+
+	flatten$1.flatten = void 0;
+	const flatten_deep_1 = flattenDeep$1;
+	function flatten(iterable) {
+	    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$2;
+	function mapAsync(iterable, fn) {
+	    if ((0, types_1$f.isAsyncIterable)(iterable)) {
+	        return mapAsyncIterable(iterable);
+	    }
+	    else {
+	        return mapIterable(iterable);
+	    }
+	    async function* mapAsyncIterable(iterable) {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            yield await fn(element, index);
+	            index++;
+	        }
+	    }
+	    async function* mapIterable(iterable) {
+	        let index = 0;
+	        for (const element of iterable) {
+	            yield await fn(element, index);
+	            index++;
+	        }
+	    }
+	}
+	mapAsync$1.mapAsync = mapAsync;
+
+	var map$1 = {};
+
+	map$1.map = void 0;
+	function* map(iterable, fn) {
+	    let index = 0;
+	    for (const element of iterable) {
+	        yield fn(element, index);
+	        index++;
+	    }
+	}
+	map$1.map = map;
+
+	var repeatAsync$1 = {};
+
+	repeatAsync$1.repeatAsync = void 0;
+	const go_1$7 = es2018$4;
+	const errors_1$e = es2018$3;
+	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* () {
+	        const cache = [];
+	        if (times > 0) {
+	            for await (const element of iterable) {
+	                yield element;
+	                cache.push(element);
+	            }
+	            times--;
+	        }
+	        while (times > 0) {
+	            yield* cache;
+	            times--;
+	        }
+	    });
+	}
+	repeatAsync$1.repeatAsync = repeatAsync;
+	function warnInfiniteLoop$1() {
+	    if (isProduction$1())
+	        return;
+	    console.warn('When iterable has no elements and times is Infinity, repeat() will be in dead loop');
+	}
+	function isProduction$1() {
+	    return process.env.NODE_ENV === 'production';
+	}
+
+	var repeat$4 = {};
+
+	repeat$4.repeat = void 0;
+	const go_1$6 = es2018$4;
+	const errors_1$d = es2018$3;
+	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* () {
+	        const cache = [];
+	        if (times > 0) {
+	            for (const element of iterable) {
+	                yield element;
+	                cache.push(element);
+	            }
+	            times--;
+	        }
+	        while (times > 0) {
+	            yield* cache;
+	            times--;
+	        }
+	    });
+	}
+	repeat$4.repeat = repeat$3;
+	function warnInfiniteLoop() {
+	    if (isProduction())
+	        return;
+	    console.warn('When iterable has no elements and times is Infinity, repeat() will be in dead loop');
+	}
+	function isProduction() {
+	    return process.env.NODE_ENV === 'production';
+	}
+
+	var sliceAsync$1 = {};
+
+	sliceAsync$1.sliceAsync = void 0;
+	const go_1$5 = es2018$4;
+	const errors_1$c = es2018$3;
+	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* () {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            if (index >= end)
+	                break;
+	            if (index >= start)
+	                yield element;
+	            index++;
+	        }
+	    });
+	}
+	sliceAsync$1.sliceAsync = sliceAsync;
+
+	var slice$1 = {};
+
+	slice$1.slice = void 0;
+	const go_1$4 = es2018$4;
+	const errors_1$b = es2018$3;
+	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* () {
+	        let index = 0;
+	        for (const element of iterable) {
+	            if (index >= end)
+	                break;
+	            if (index >= start)
+	                yield element;
+	            index++;
+	        }
+	    });
+	}
+	slice$1.slice = slice;
+
+	var splitAsync$1 = {};
+
+	splitAsync$1.splitAsync = void 0;
+	async function* splitAsync(iterable, separator) {
+	    let buffer = [];
+	    for await (const element of iterable) {
+	        if (element === separator) {
+	            yield buffer;
+	            buffer = [];
+	        }
+	        else {
+	            buffer.push(element);
+	        }
+	    }
+	    yield buffer;
+	}
+	splitAsync$1.splitAsync = splitAsync;
+
+	var splitByAsync$1 = {};
+
+	splitByAsync$1.splitByAsync = void 0;
+	const types_1$e = es2018$2;
+	function splitByAsync(iterable, predicate) {
+	    if ((0, types_1$e.isAsyncIterable)(iterable)) {
+	        return splitByAsyncIterable(iterable);
+	    }
+	    else {
+	        return splitByIterable(iterable);
+	    }
+	    async function* splitByIterable(iterable) {
+	        let buffer = [];
+	        let index = 0;
+	        for (const element of iterable) {
+	            if (await predicate(element, index)) {
+	                yield buffer;
+	                buffer = [];
+	            }
+	            else {
+	                buffer.push(element);
+	            }
+	            index++;
+	        }
+	        yield buffer;
+	    }
+	    async function* splitByAsyncIterable(iterable) {
+	        let buffer = [];
+	        let index = 0;
+	        for await (const element of iterable) {
+	            if (await predicate(element, index)) {
+	                yield buffer;
+	                buffer = [];
+	            }
+	            else {
+	                buffer.push(element);
+	            }
+	            index++;
+	        }
+	        yield buffer;
+	    }
+	}
+	splitByAsync$1.splitByAsync = splitByAsync;
+
+	var splitBy$1 = {};
+
+	splitBy$1.splitBy = void 0;
+	function* splitBy(iterable, predicate) {
+	    let buffer = [];
+	    let index = 0;
+	    for (const element of iterable) {
+	        if (predicate(element, index)) {
+	            yield buffer;
+	            buffer = [];
+	        }
+	        else {
+	            buffer.push(element);
+	        }
+	        index++;
+	    }
+	    yield buffer;
+	}
+	splitBy$1.splitBy = splitBy;
+
+	var split$1 = {};
+
+	split$1.split = void 0;
+	function* split(iterable, separator) {
+	    let buffer = [];
+	    for (const element of iterable) {
+	        if (element === separator) {
+	            yield buffer;
+	            buffer = [];
+	        }
+	        else {
+	            buffer.push(element);
+	        }
+	    }
+	    yield buffer;
+	}
+	split$1.split = split;
+
+	var takeAsync$1 = {};
+
+	takeAsync$1.takeAsync = void 0;
+	const go_1$3 = es2018$4;
+	const errors_1$a = es2018$3;
+	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* () {
+	        if (count === 0)
+	            return;
+	        for await (const element of iterable) {
+	            yield element;
+	            count--;
+	            if (count === 0)
+	                break;
+	        }
+	    });
+	}
+	takeAsync$1.takeAsync = takeAsync;
+
+	var takeRightAsync$1 = {};
+
+	takeRightAsync$1.takeRightAsync = void 0;
+	const go_1$2 = es2018$4;
+	const errors_1$9 = es2018$3;
+	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* () {
+	        var _a;
+	        const iterator = iterable[Symbol.asyncIterator]();
+	        let done;
+	        try {
+	            const buffer = [];
+	            let value;
+	            while ({ value, done } = await iterator.next(), !done) {
+	                buffer.push(value);
+	                if (buffer.length > count)
+	                    buffer.shift();
+	            }
+	            yield* buffer;
+	        }
+	        finally {
+	            if (!done)
+	                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+	        }
+	    });
+	}
+	takeRightAsync$1.takeRightAsync = takeRightAsync;
+
+	var takeRight$1 = {};
+
+	takeRight$1.takeRight = void 0;
+	const go_1$1 = es2018$4;
+	const errors_1$8 = es2018$3;
+	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* () {
+	        var _a;
+	        const iterator = iterable[Symbol.iterator]();
+	        let done;
+	        try {
+	            const buffer = [];
+	            let value;
+	            while ({ value, done } = iterator.next(), !done) {
+	                buffer.push(value);
+	                if (buffer.length > count)
+	                    buffer.shift();
+	            }
+	            yield* buffer;
+	        }
+	        finally {
+	            if (!done)
+	                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+	        }
+	    });
+	}
+	takeRight$1.takeRight = takeRight;
+
+	var takeUntilAsync$1 = {};
+
+	takeUntilAsync$1.takeUntilAsync = void 0;
+	const types_1$d = es2018$2;
+	function takeUntilAsync(iterable, predicate) {
+	    if ((0, types_1$d.isAsyncIterable)(iterable)) {
+	        return takeUntilAsyncIterable(iterable);
+	    }
+	    else {
+	        return takeUntilIterable(iterable);
+	    }
+	    async function* takeUntilAsyncIterable(iterable) {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            if (await predicate(element, index))
+	                break;
+	            yield element;
+	            index++;
+	        }
+	    }
+	    async function* takeUntilIterable(iterable) {
+	        let index = 0;
+	        for (const element of iterable) {
+	            if (await predicate(element, index))
+	                break;
+	            yield element;
+	            index++;
+	        }
+	    }
+	}
+	takeUntilAsync$1.takeUntilAsync = takeUntilAsync;
+
+	var takeUntil$1 = {};
+
+	takeUntil$1.takeUntil = void 0;
+	function* takeUntil(iterable, predicate) {
+	    let index = 0;
+	    for (const element of iterable) {
+	        if (predicate(element, index))
+	            break;
+	        yield element;
+	        index++;
+	    }
+	}
+	takeUntil$1.takeUntil = takeUntil;
+
+	var take$1 = {};
+
+	take$1.take = void 0;
+	const go_1 = es2018$4;
+	const errors_1$7 = es2018$3;
+	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* () {
+	        if (count === 0)
+	            return;
+	        for (const element of iterable) {
+	            yield element;
+	            count--;
+	            if (count === 0)
+	                break;
+	        }
+	    });
+	}
+	take$1.take = take;
+
+	var tapAsync$1 = {};
+
+	tapAsync$1.tapAsync = void 0;
+	const types_1$c = es2018$2;
+	function tapAsync(iterable, fn) {
+	    if ((0, types_1$c.isAsyncIterable)(iterable)) {
+	        return tapAsyncIterable(iterable);
+	    }
+	    else {
+	        return tapIterable(iterable);
+	    }
+	    async function* tapIterable(iterable) {
+	        let index = 0;
+	        for (const element of iterable) {
+	            await fn(element, index);
+	            yield element;
+	            index++;
+	        }
+	    }
+	    async function* tapAsyncIterable(iterable) {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            await fn(element, index);
+	            yield element;
+	            index++;
+	        }
+	    }
+	}
+	tapAsync$1.tapAsync = tapAsync;
+
+	var tap$2 = {};
+
+	tap$2.tap = void 0;
+	function* tap$1(iterable, fn) {
+	    let index = 0;
+	    for (const element of iterable) {
+	        fn(element, index);
+	        yield element;
+	        index++;
+	    }
+	}
+	tap$2.tap = tap$1;
+
+	var toAsyncIterable$1 = {};
+
+	toAsyncIterable$1.toAsyncIterable = void 0;
+	async function* toAsyncIterable(iterable) {
+	    for (const value of iterable) {
+	        yield value;
+	    }
+	}
+	toAsyncIterable$1.toAsyncIterable = toAsyncIterable;
+
+	var transformAsync$1 = {};
+
+	transformAsync$1.transformAsync = void 0;
+	async function* transformAsync(iterable, transformer) {
+	    yield* transformer(iterable);
+	}
+	transformAsync$1.transformAsync = transformAsync;
+
+	var transform$1 = {};
+
+	transform$1.transform = void 0;
+	function* transform(iterable, transformer) {
+	    yield* transformer(iterable);
+	}
+	transform$1.transform = transform;
+
+	var uniqAsync$1 = {};
+
+	uniqAsync$1.uniqAsync = void 0;
+	async function* uniqAsync(iterable) {
+	    const bucket = new Set();
+	    for await (const element of iterable) {
+	        if (!bucket.has(element)) {
+	            yield element;
+	            bucket.add(element);
+	        }
+	    }
+	}
+	uniqAsync$1.uniqAsync = uniqAsync;
+
+	var uniqByAsync$1 = {};
+
+	uniqByAsync$1.uniqByAsync = void 0;
+	const types_1$b = es2018$2;
+	function uniqByAsync(iterable, fn) {
+	    if ((0, types_1$b.isAsyncIterable)(iterable)) {
+	        return uniqByAsyncIterable(iterable);
+	    }
+	    else {
+	        return uniqByIterable(iterable);
+	    }
+	    async function* uniqByAsyncIterable(iterable) {
+	        const bucket = new Set();
+	        let index = 0;
+	        for await (const element of iterable) {
+	            const result = await fn(element, index);
+	            if (!bucket.has(result)) {
+	                yield element;
+	                bucket.add(result);
+	            }
+	            index++;
+	        }
+	    }
+	    async function* uniqByIterable(iterable) {
+	        const bucket = new Set();
+	        let index = 0;
+	        for (const element of iterable) {
+	            const result = await fn(element, index);
+	            if (!bucket.has(result)) {
+	                yield element;
+	                bucket.add(result);
+	            }
+	            index++;
+	        }
+	    }
+	}
+	uniqByAsync$1.uniqByAsync = uniqByAsync;
+
+	var uniqBy$1 = {};
+
+	uniqBy$1.uniqBy = void 0;
+	function* uniqBy(iterable, fn) {
+	    const bucket = new Set();
+	    let index = 0;
+	    for (const element of iterable) {
+	        const result = fn(element, index);
+	        if (!bucket.has(result)) {
+	            yield element;
+	            bucket.add(result);
+	        }
+	        index++;
+	    }
+	}
+	uniqBy$1.uniqBy = uniqBy;
+
+	var uniq$1 = {};
+
+	uniq$1.uniq = void 0;
+	function* uniq(iterable) {
+	    const bucket = new Set();
+	    for (const element of iterable) {
+	        if (!bucket.has(element)) {
+	            yield element;
+	            bucket.add(element);
+	        }
+	    }
+	}
+	uniq$1.uniq = uniq;
+
+	var zipAsync$1 = {};
+
+	zipAsync$1.zipAsync = void 0;
+	const types_1$a = es2018$2;
+	var Kind;
+	(function (Kind) {
+	    Kind[Kind["Sync"] = 0] = "Sync";
+	    Kind[Kind["Async"] = 1] = "Async";
+	})(Kind || (Kind = {}));
+	function zipAsync(iterable, ...otherIterables) {
+	    return zipWithSize$1(iterable, ...otherIterables);
+	}
+	zipAsync$1.zipAsync = zipAsync;
+	async function* zipWithSize$1(...iterables) {
+	    var _a, _b, _c, _d;
+	    const length = iterables.length;
+	    const iterators = iterables.map(iterable => {
+	        if ((0, types_1$a.isAsyncIterable)(iterable)) {
+	            return [Kind.Async, iterable[Symbol.asyncIterator]()];
+	        }
+	        else {
+	            return [Kind.Sync, iterable[Symbol.iterator]()];
+	        }
+	    });
+	    const dones = iterators.map(() => false);
+	    try {
+	        while (true) {
+	            const result = new Array(length);
+	            for (let i = 0; i < length; i++) {
+	                const [kind, iterator] = iterators[i];
+	                let temp;
+	                if (kind === Kind.Async) {
+	                    temp = await iterator.next();
+	                }
+	                else {
+	                    temp = iterator.next();
+	                }
+	                if (temp.done) {
+	                    dones[i] = true;
+	                    return;
+	                }
+	                result[i] = temp.value;
+	            }
+	            yield result;
+	        }
+	    }
+	    finally {
+	        const undoneIterators = iterators.filter((_, i) => !dones[i]);
+	        for (const [kind, iterator] of undoneIterators) {
+	            if (kind === Kind.Async) {
+	                await ((_b = (_a = iterator).return) === null || _b === void 0 ? void 0 : _b.call(_a));
+	            }
+	            else {
+	                (_d = (_c = iterator).return) === null || _d === void 0 ? void 0 : _d.call(_c);
+	            }
+	        }
+	    }
+	}
+
+	var zip$1 = {};
+
+	zip$1.zip = void 0;
+	function zip(iterable, ...otherIterables) {
+	    return zipWithSize(iterable, ...otherIterables);
+	}
+	zip$1.zip = zip;
+	function* zipWithSize(...iterables) {
+	    const length = iterables.length;
+	    const iterators = iterables.map(iterable => iterable[Symbol.iterator]());
+	    const dones = iterators.map(() => false);
+	    try {
+	        while (true) {
+	            const result = new Array(length);
+	            for (let i = 0; i < length; i++) {
+	                const { value, done } = iterators[i].next();
+	                if (done) {
+	                    dones[i] = true;
+	                    return;
+	                }
+	                result[i] = value;
+	            }
+	            yield result;
+	        }
+	    }
+	    finally {
+	        const undoneIterators = iterators.filter((_, i) => !dones[i]);
+	        undoneIterators.forEach(x => { var _a; return (_a = x.return) === null || _a === void 0 ? void 0 : _a.call(x); });
+	    }
+	}
+
+	(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(chunkAsync$1, exports);
+	__exportStar(chunkByAsync$1, exports);
+	__exportStar(chunkBy$1, exports);
+	__exportStar(chunk$1, exports);
+	__exportStar(concatAsync$1, exports);
+	__exportStar(concat$2, exports);
+	__exportStar(dropAsync$1, exports);
+	__exportStar(dropRightAsync$1, exports);
+	__exportStar(dropRight$1, exports);
+	__exportStar(dropUntilAsync$1, exports);
+	__exportStar(dropUntil$1, exports);
+	__exportStar(drop$1, exports);
+	__exportStar(filterAsync$1, exports);
+	__exportStar(filter$1, exports);
+	__exportStar(flattenAsync$1, exports);
+	__exportStar(flattenByAsync$1, exports);
+	__exportStar(flattenBy$1, exports);
+	__exportStar(flattenDeepAsync$1, exports);
+	__exportStar(flattenDeep$1, exports);
+	__exportStar(flatten$1, exports);
+	__exportStar(mapAsync$1, exports);
+	__exportStar(map$1, exports);
+	__exportStar(repeatAsync$1, exports);
+	__exportStar(repeat$4, exports);
+	__exportStar(sliceAsync$1, exports);
+	__exportStar(slice$1, exports);
+	__exportStar(splitAsync$1, exports);
+	__exportStar(splitByAsync$1, exports);
+	__exportStar(splitBy$1, exports);
+	__exportStar(split$1, exports);
+	__exportStar(takeAsync$1, exports);
+	__exportStar(takeRightAsync$1, exports);
+	__exportStar(takeRight$1, exports);
+	__exportStar(takeUntilAsync$1, exports);
+	__exportStar(takeUntil$1, exports);
+	__exportStar(take$1, exports);
+	__exportStar(tapAsync$1, exports);
+	__exportStar(tap$2, exports);
+	__exportStar(toAsyncIterable$1, exports);
+	__exportStar(transformAsync$1, exports);
+	__exportStar(transform$1, exports);
+	__exportStar(uniqAsync$1, exports);
+	__exportStar(uniqByAsync$1, exports);
+	__exportStar(uniqBy$1, exports);
+	__exportStar(uniq$1, exports);
+	__exportStar(zipAsync$1, exports);
+	__exportStar(zip$1, exports);
+
+	}(middleware));
+
+	var output = {};
+
+	var consume$1 = {};
+
+	consume$1.consume = void 0;
+	function consume(iterable, consumer) {
+	    return consumer(iterable);
+	}
+	consume$1.consume = consume;
+
+	var eachAsync$1 = {};
+
+	eachAsync$1.eachAsync = void 0;
+	const types_1$9 = es2018$2;
+	function eachAsync(iterable, fn) {
+	    if ((0, types_1$9.isAsyncIterable)(iterable)) {
+	        return eachAsyncIterable(iterable);
+	    }
+	    else {
+	        return eachIterable(iterable);
+	    }
+	    async function eachAsyncIterable(iterable) {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            await fn(element, index);
+	            index++;
+	        }
+	    }
+	    async function eachIterable(iterable) {
+	        let index = 0;
+	        for (const element of iterable) {
+	            await fn(element, index);
+	            index++;
+	        }
+	    }
+	}
+	eachAsync$1.eachAsync = eachAsync;
+
+	var each$1 = {};
+
+	each$1.each = void 0;
+	function each(iterable, fn) {
+	    let index = 0;
+	    for (const element of iterable) {
+	        fn(element, index);
+	        index++;
+	    }
+	}
+	each$1.each = each;
+
+	var everyAsync$1 = {};
+
+	everyAsync$1.everyAsync = void 0;
+	const types_1$8 = es2018$2;
+	function everyAsync(iterable, predicate) {
+	    if ((0, types_1$8.isAsyncIterable)(iterable)) {
+	        return everyAsyncIterable(iterable);
+	    }
+	    else {
+	        return everyIterable(iterable);
+	    }
+	    async function everyIterable(iterable) {
+	        let index = 0;
+	        for (const element of iterable) {
+	            if (!await predicate(element, index))
+	                return false;
+	            index++;
+	        }
+	        return true;
+	    }
+	    async function everyAsyncIterable(iterable) {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            if (!await predicate(element, index))
+	                return false;
+	            index++;
+	        }
+	        return true;
+	    }
+	}
+	everyAsync$1.everyAsync = everyAsync;
+
+	var every$1 = {};
+
+	every$1.every = void 0;
+	function every(iterable, predicate) {
+	    let index = 0;
+	    for (const element of iterable) {
+	        if (!predicate(element, index))
+	            return false;
+	        index++;
+	    }
+	    return true;
+	}
+	every$1.every = every;
+
+	var findAsync$1 = {};
+
+	findAsync$1.findAsync = void 0;
+	const types_1$7 = es2018$2;
+	function findAsync(iterable, predicate) {
+	    if ((0, types_1$7.isAsyncIterable)(iterable)) {
+	        return findAsyncIterable(iterable);
+	    }
+	    else {
+	        return findIterable(iterable);
+	    }
+	    async function findIterable(iterable) {
+	        let index = 0;
+	        for (const element of iterable) {
+	            if (await predicate(element, index))
+	                return element;
+	            index++;
+	        }
+	        return undefined;
+	    }
+	    async function findAsyncIterable(iterable) {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            if (await predicate(element, index))
+	                return element;
+	            index++;
+	        }
+	        return undefined;
+	    }
+	}
+	findAsync$1.findAsync = findAsync;
+
+	var find$3 = {};
+
+	find$3.find = void 0;
+	function find$2(iterable, predicate) {
+	    let index = 0;
+	    for (const element of iterable) {
+	        if (predicate(element, index))
+	            return element;
+	        index++;
+	    }
+	    return undefined;
+	}
+	find$3.find = find$2;
+
+	var firstAsync$1 = {};
+
+	firstAsync$1.firstAsync = void 0;
+	async function firstAsync(iterable) {
+	    for await (const element of iterable) {
+	        return element;
+	    }
+	    return undefined;
+	}
+	firstAsync$1.firstAsync = firstAsync;
+
+	var first$1 = {};
+
+	first$1.first = void 0;
+	function first(iterable) {
+	    for (const element of iterable) {
+	        return element;
+	    }
+	    return undefined;
+	}
+	first$1.first = first;
+
+	var includesAsync$1 = {};
+
+	includesAsync$1.includesAsync = void 0;
+	async function includesAsync(iterable, value) {
+	    for await (const element of iterable) {
+	        if (element === value)
+	            return true;
+	    }
+	    return false;
+	}
+	includesAsync$1.includesAsync = includesAsync;
+
+	var includes$1 = {};
+
+	includes$1.includes = void 0;
+	function includes(iterable, value) {
+	    for (const element of iterable) {
+	        if (element === value)
+	            return true;
+	    }
+	    return false;
+	}
+	includes$1.includes = includes;
+
+	var matchAsync$1 = {};
+
+	matchAsync$1.matchAsync = void 0;
+	async function matchAsync(iterable, sequence) {
+	    const sequenceLength = sequence.length;
+	    let matchCount = 0;
+	    for await (const element of iterable) {
+	        if (element === sequence[matchCount])
+	            matchCount++;
+	        if (matchCount === sequenceLength)
+	            return true;
+	    }
+	    return false;
+	}
+	matchAsync$1.matchAsync = matchAsync;
+
+	var match$2 = {};
+
+	match$2.match = void 0;
+	function match$1(iterable, sequence) {
+	    const sequenceLength = sequence.length;
+	    let matchCount = 0;
+	    for (const element of iterable) {
+	        if (element === sequence[matchCount])
+	            matchCount++;
+	        if (matchCount === sequenceLength)
+	            return true;
+	    }
+	    return false;
+	}
+	match$2.match = match$1;
+
+	var reduceAsync$1 = {};
+
+	reduceAsync$1.reduceAsync = void 0;
+	const types_1$6 = es2018$2;
+	function reduceAsync(iterable, fn, initialValue) {
+	    if ((0, types_1$6.isUndefined)(initialValue)) {
+	        return reduceAsyncWithoutInitialValue(iterable, fn);
+	    }
+	    else {
+	        return reduceAsyncWithInitialValue(iterable, fn, initialValue);
+	    }
+	}
+	reduceAsync$1.reduceAsync = reduceAsync;
+	function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
+	    if ((0, types_1$6.isAsyncIterable)(iterable)) {
+	        return reduceAsyncIterable(iterable);
+	    }
+	    else {
+	        return reduceIterable(iterable);
+	    }
+	    async function reduceIterable(iterable) {
+	        let result = initialValue, index = 0;
+	        for (const currentValue of iterable) {
+	            result = await fn(result, currentValue, index++);
+	        }
+	        return result;
+	    }
+	    async function reduceAsyncIterable(iterable) {
+	        let result = initialValue, index = 0;
+	        for await (const currentValue of iterable) {
+	            result = await fn(result, currentValue, index++);
+	        }
+	        return result;
+	    }
+	}
+	function reduceAsyncWithoutInitialValue(iterable, fn) {
+	    if ((0, types_1$6.isAsyncIterable)(iterable)) {
+	        return reduceAsyncIterable(iterable);
+	    }
+	    else {
+	        return reduceIterable(iterable);
+	    }
+	    async function reduceAsyncIterable(iterable) {
+	        var _a;
+	        const iterator = iterable[Symbol.asyncIterator]();
+	        let done;
+	        try {
+	            let result = await readInitialValue(iterator);
+	            let index = 1;
+	            let value;
+	            while ({ value, done } = await iterator.next(), !done) {
+	                result = await fn(result, value, index++);
+	            }
+	            return result;
+	        }
+	        finally {
+	            if (!done)
+	                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+	        }
+	        async function readInitialValue(iterator) {
+	            const result = await iterator.next();
+	            if (result.done) {
+	                done = true;
+	                throw new Error('Reduce of empty iterable with no initial value');
+	            }
+	            return result.value;
+	        }
+	    }
+	    async function reduceIterable(iterable) {
+	        var _a;
+	        const iterator = iterable[Symbol.iterator]();
+	        let done;
+	        try {
+	            let result = readInitialValue(iterator);
+	            let index = 1;
+	            let value;
+	            while ({ value, done } = iterator.next(), !done) {
+	                result = await fn(result, value, index++);
+	            }
+	            return result;
+	        }
+	        finally {
+	            if (!done)
+	                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+	        }
+	        function readInitialValue(iterator) {
+	            const result = iterator.next();
+	            if (result.done) {
+	                done = true;
+	                throw new Error('Reduce of empty iterable with no initial value');
+	            }
+	            return result.value;
+	        }
+	    }
+	}
+
+	var reduce$1 = {};
+
+	reduce$1.reduce = void 0;
+	const types_1$5 = es2018$2;
+	function reduce(iterable, fn, initialValue) {
+	    if ((0, types_1$5.isUndefined)(initialValue)) {
+	        return reduceWithoutInitialValue(iterable, fn);
+	    }
+	    else {
+	        return reduceWithInitialValue(iterable, fn, initialValue);
+	    }
+	}
+	reduce$1.reduce = reduce;
+	function reduceWithInitialValue(iterable, fn, initialValue) {
+	    let result = initialValue, index = 0;
+	    for (const currentValue of iterable) {
+	        result = fn(result, currentValue, index++);
+	    }
+	    return result;
+	}
+	function reduceWithoutInitialValue(iterable, fn) {
+	    var _a;
+	    const iterator = iterable[Symbol.iterator]();
+	    let done;
+	    try {
+	        let result = readInitialValue(iterator);
+	        let index = 1;
+	        let value;
+	        while ({ value, done } = iterator.next(), !done) {
+	            result = fn(result, value, index++);
+	        }
+	        return result;
+	    }
+	    finally {
+	        if (!done)
+	            (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+	    }
+	    function readInitialValue(iterator) {
+	        const result = iterator.next();
+	        if (result.done) {
+	            done = true;
+	            throw new Error('Reduce of empty iterable with no initial value');
+	        }
+	        return result.value;
+	    }
+	}
+
+	var someAsync$1 = {};
+
+	someAsync$1.someAsync = void 0;
+	const types_1$4 = es2018$2;
+	function someAsync(iterable, predicate) {
+	    if ((0, types_1$4.isAsyncIterable)(iterable)) {
+	        return someAsyncIterable(iterable);
+	    }
+	    else {
+	        return someIterable(iterable);
+	    }
+	    async function someIterable(iterable) {
+	        let index = 0;
+	        for (const element of iterable) {
+	            if (await predicate(element, index))
+	                return true;
+	            index++;
+	        }
+	        return false;
+	    }
+	    async function someAsyncIterable(iterable) {
+	        let index = 0;
+	        for await (const element of iterable) {
+	            if (await predicate(element, index))
+	                return true;
+	            index++;
+	        }
+	        return false;
+	    }
+	}
+	someAsync$1.someAsync = someAsync;
+
+	var some$1 = {};
+
+	some$1.some = void 0;
+	function some(iterable, predicate) {
+	    let index = 0;
+	    for (const element of iterable) {
+	        if (predicate(element, index))
+	            return true;
+	        index++;
+	    }
+	    return false;
+	}
+	some$1.some = some;
+
+	var lastAsync$1 = {};
+
+	lastAsync$1.lastAsync = void 0;
+	async function lastAsync(iterable) {
+	    var _a;
+	    const iterator = iterable[Symbol.asyncIterator]();
+	    let done;
+	    try {
+	        let value;
+	        let result;
+	        while ({ value, done } = await iterator.next(), !done) {
+	            result = value;
+	        }
+	        return result;
+	    }
+	    finally {
+	        if (!done)
+	            await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+	    }
+	}
+	lastAsync$1.lastAsync = lastAsync;
+
+	var last$1 = {};
+
+	last$1.last = void 0;
+	function last(iterable) {
+	    var _a;
+	    const iterator = iterable[Symbol.iterator]();
+	    let done;
+	    try {
+	        let value;
+	        let result;
+	        while ({ value, done } = iterator.next(), !done) {
+	            result = value;
+	        }
+	        return result;
+	    }
+	    finally {
+	        if (!done)
+	            (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+	    }
+	}
+	last$1.last = last;
+
+	var toArrayAsync$1 = {};
+
+	toArrayAsync$1.toArrayAsync = void 0;
+	const consume_1$3 = consume$1;
+	function toArrayAsync(iterable) {
+	    return (0, consume_1$3.consume)(iterable, async (iterable) => {
+	        const result = [];
+	        for await (const element of iterable) {
+	            result.push(element);
+	        }
+	        return result;
+	    });
+	}
+	toArrayAsync$1.toArrayAsync = toArrayAsync;
+
+	var toArray$1 = {};
+
+	toArray$1.toArray = void 0;
+	const consume_1$2 = consume$1;
+	function toArray(iterable) {
+	    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
+	}
+	toArray$1.toArray = toArray;
+
+	var toSetAsync$1 = {};
+
+	toSetAsync$1.toSetAsync = void 0;
+	const consume_1$1 = consume$1;
+	function toSetAsync(iterable) {
+	    return (0, consume_1$1.consume)(iterable, async (iterable) => {
+	        const result = new Set();
+	        for await (const element of iterable) {
+	            result.add(element);
+	        }
+	        return result;
+	    });
+	}
+	toSetAsync$1.toSetAsync = toSetAsync;
+
+	var toSet$1 = {};
+
+	toSet$1.toSet = void 0;
+	const consume_1 = consume$1;
+	function toSet(iterable) {
+	    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
+	}
+	toSet$1.toSet = toSet;
+
+	(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(consume$1, exports);
+	__exportStar(eachAsync$1, exports);
+	__exportStar(each$1, exports);
+	__exportStar(everyAsync$1, exports);
+	__exportStar(every$1, exports);
+	__exportStar(findAsync$1, exports);
+	__exportStar(find$3, exports);
+	__exportStar(firstAsync$1, exports);
+	__exportStar(first$1, exports);
+	__exportStar(includesAsync$1, exports);
+	__exportStar(includes$1, exports);
+	__exportStar(matchAsync$1, exports);
+	__exportStar(match$2, exports);
+	__exportStar(reduceAsync$1, exports);
+	__exportStar(reduce$1, exports);
+	__exportStar(someAsync$1, exports);
+	__exportStar(some$1, exports);
+	__exportStar(lastAsync$1, exports);
+	__exportStar(last$1, exports);
+	__exportStar(toArrayAsync$1, exports);
+	__exportStar(toArray$1, exports);
+	__exportStar(toSetAsync$1, exports);
+	__exportStar(toSet$1, exports);
+
+	}(output));
+
+	(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(middleware, exports);
+	__exportStar(output, exports);
+
+	}(es2018$5));
+
+	unwrap$1.unwrap = void 0;
+	const flat_map_1 = flatMap$1;
+	const iterable_operator_1$2 = es2018$5;
+	function unwrap(node, predicate) {
+	    return (0, flat_map_1.flatMap)(node, node => {
+	        if (predicate(node)) {
+	            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];
+	        }
+	    });
+	}
+	unwrap$1.unwrap = unwrap;
+
+	var find$1 = {};
+
+	var findInDescendantNodes$1 = {};
+
+	var traverseDescendantNodes$1 = {};
+
+	traverseDescendantNodes$1.traverseDescendantNodes = void 0;
+	function* traverseDescendantNodes(node) {
+	    for (const childNode of node.childNodes) {
+	        yield childNode;
+	        yield* traverseDescendantNodes(childNode);
+	    }
+	}
+	traverseDescendantNodes$1.traverseDescendantNodes = traverseDescendantNodes;
+
+	findInDescendantNodes$1.findInDescendantNodes = void 0;
+	const traverse_descendant_nodes_1 = traverseDescendantNodes$1;
+	const iterable_operator_1$1 = es2018$5;
+	function findInDescendantNodes(node, predicate) {
+	    return (0, iterable_operator_1$1.find)((0, traverse_descendant_nodes_1.traverseDescendantNodes)(node), node => predicate(node));
+	}
+	findInDescendantNodes$1.findInDescendantNodes = findInDescendantNodes;
+
+	find$1.find = void 0;
+	const find_in_descendant_nodes_1 = findInDescendantNodes$1;
+	function find(node, predicate) {
+	    if (predicate(node))
+	        return node;
+	    return (0, find_in_descendant_nodes_1.findInDescendantNodes)(node, predicate);
+	}
+	find$1.find = find;
+
+	var parse$1 = {};
+
+	parse$1.parse = void 0;
+	function parse(html) {
+	    const div = document.createElement('div');
+	    div.innerHTML = html;
+	    return [...div.childNodes];
+	}
+	parse$1.parse = parse;
+
+	var stringify$1 = {};
+
+	stringify$1.stringify = void 0;
+	function stringify(nodes) {
+	    const div = document.createElement('div');
+	    nodes.forEach(x => div.append(x.cloneNode(true)));
+	    return div.innerHTML;
+	}
+	stringify$1.stringify = stringify;
+
+	var normalize$1 = {};
+
+	normalize$1.normalize = void 0;
+	const parse_1 = parse$1;
+	const stringify_1 = stringify$1;
+	function normalize(html) {
+	    return (0, stringify_1.stringify)((0, parse_1.parse)(html));
+	}
+	normalize$1.normalize = normalize;
+
+	var removeAttributes$1 = {};
+
+	removeAttributes$1.removeAttributes = void 0;
+	function removeAttributes(node, predicate) {
+	    if (node instanceof Element) {
+	        const attributeNames = Array.from(node.attributes).map(x => x.name);
+	        for (const name of attributeNames) {
+	            if (predicate(name)) {
+	                node.removeAttribute(name);
+	            }
+	        }
+	    }
+	}
+	removeAttributes$1.removeAttributes = removeAttributes;
+
+	var getBySelector$1 = {};
+
+	var isDocument$1 = {};
+
+	var nodeType = {};
+
+	(function (exports) {
+	exports.NodeType = void 0;
+	const nodeExists = 'Node' in globalThis;
+	(function (NodeType) {
+	    NodeType[NodeType["ELEMENT_NODE"] = nodeExists
+	        ? globalThis.Node.ELEMENT_NODE
+	        : 1] = "ELEMENT_NODE";
+	    NodeType[NodeType["ATTRIBUTE_NODE"] = nodeExists
+	        ? globalThis.Node.ATTRIBUTE_NODE
+	        : 2] = "ATTRIBUTE_NODE";
+	    NodeType[NodeType["TEXT_NODE"] = nodeExists
+	        ? globalThis.Node.TEXT_NODE
+	        : 3] = "TEXT_NODE";
+	    NodeType[NodeType["CDATA_SECTION_NODE"] = nodeExists
+	        ? globalThis.Node.CDATA_SECTION_NODE
+	        : 4] = "CDATA_SECTION_NODE";
+	    NodeType[NodeType["ENTITY_REFERENCE_NODE"] = nodeExists
+	        ? globalThis.Node.ENTITY_REFERENCE_NODE
+	        : 5] = "ENTITY_REFERENCE_NODE";
+	    NodeType[NodeType["ENTITY_NODE"] = nodeExists
+	        ? globalThis.Node.ENTITY_NODE
+	        : 6] = "ENTITY_NODE";
+	    NodeType[NodeType["PROCESSING_INSTRUCTION_NODE"] = nodeExists
+	        ? globalThis.Node.PROCESSING_INSTRUCTION_NODE
+	        : 7] = "PROCESSING_INSTRUCTION_NODE";
+	    NodeType[NodeType["COMMENT_NODE"] = nodeExists
+	        ? globalThis.Node.COMMENT_NODE
+	        : 8] = "COMMENT_NODE";
+	    NodeType[NodeType["DOCUMENT_NODE"] = nodeExists
+	        ? globalThis.Node.DOCUMENT_NODE
+	        : 9] = "DOCUMENT_NODE";
+	    NodeType[NodeType["DOCUMENT_TYPE_NODE"] = nodeExists
+	        ? globalThis.Node.DOCUMENT_TYPE_NODE
+	        : 10] = "DOCUMENT_TYPE_NODE";
+	    NodeType[NodeType["DOCUMENT_FRAGMENT_NODE"] = nodeExists
+	        ? globalThis.Node.DOCUMENT_FRAGMENT_NODE
+	        : 11] = "DOCUMENT_FRAGMENT_NODE";
+	    NodeType[NodeType["NOTATION_NODE"] = nodeExists
+	        ? globalThis.Node.NOTATION_NODE
+	        : 12] = "NOTATION_NODE";
+	})(exports.NodeType || (exports.NodeType = {}));
+
+	}(nodeType));
+
+	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.isRecord)(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.isRecord)(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 = ((0, is_element_1$3.isElement)(this) || (0, is_document_1$1.isDocument)(this)
+	        ? this
+	        : document);
+	    const results = root.querySelectorAll(selectors);
+	    if (results.length) {
+	        return Array.from(results);
+	    }
+	    else {
+	        throw new Error(`Could not find any elements matching ${selectors}`);
+	    }
+	}
+	getAllBySelector$1.getAllBySelector = getAllBySelector;
+
+	var traverseAncestorNodes$1 = {};
+
+	traverseAncestorNodes$1.traverseAncestorNodes = void 0;
+	function* traverseAncestorNodes(node) {
+	    const parentNode = node.parentNode;
+	    if (parentNode) {
+	        yield parentNode;
+	        yield* traverseAncestorNodes(parentNode);
+	    }
+	}
+	traverseAncestorNodes$1.traverseAncestorNodes = traverseAncestorNodes;
+
+	var findInAncestorNodes$1 = {};
+
+	findInAncestorNodes$1.findInAncestorNodes = void 0;
+	const traverse_ancestor_nodes_1 = traverseAncestorNodes$1;
+	const iterable_operator_1 = es2018$5;
+	function findInAncestorNodes(node, predicate) {
+	    return (0, iterable_operator_1.find)((0, traverse_ancestor_nodes_1.traverseAncestorNodes)(node), node => predicate(node));
+	}
+	findInAncestorNodes$1.findInAncestorNodes = findInAncestorNodes;
+
+	var findInFollowingSiblingNodes$1 = {};
+
+	findInFollowingSiblingNodes$1.findInFollowingSiblingNodes = void 0;
+	function findInFollowingSiblingNodes(node, predicate) {
+	    const nextNode = node.nextSibling;
+	    if (!nextNode)
+	        return undefined;
+	    if (predicate(nextNode)) {
+	        return nextNode;
+	    }
+	    else {
+	        return findInFollowingSiblingNodes(nextNode, predicate);
+	    }
+	}
+	findInFollowingSiblingNodes$1.findInFollowingSiblingNodes = findInFollowingSiblingNodes;
+
+	var findInPrecedingSiblingNodes$1 = {};
+
+	findInPrecedingSiblingNodes$1.findInPrecedingSiblingNodes = void 0;
+	function findInPrecedingSiblingNodes(node, predicate) {
+	    const previousNode = node.previousSibling;
+	    if (!previousNode)
+	        return undefined;
+	    if (predicate(previousNode)) {
+	        return previousNode;
+	    }
+	    else {
+	        return findInPrecedingSiblingNodes(previousNode, predicate);
+	    }
+	}
+	findInPrecedingSiblingNodes$1.findInPrecedingSiblingNodes = findInPrecedingSiblingNodes;
+
+	var parentNode$1 = {};
+
+	parentNode$1.parentNode = void 0;
+	const errors_1$6 = es2018$3;
+	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');
+	    return _parentNode(node, distance);
+	}
+	parentNode$1.parentNode = parentNode;
+	function _parentNode(node, distance) {
+	    const currentNode = node.parentNode;
+	    if (!currentNode)
+	        return undefined;
+	    if (distance === 1) {
+	        return currentNode;
+	    }
+	    else {
+	        return _parentNode(currentNode, distance - 1);
+	    }
+	}
+
+	var nextSibling$2 = {};
+
+	nextSibling$2.nextSibling = void 0;
+	const errors_1$5 = es2018$3;
+	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');
+	    return _nextSibling(node, distance);
+	}
+	nextSibling$2.nextSibling = nextSibling$1;
+	function _nextSibling(node, distance) {
+	    const currentNode = node.nextSibling;
+	    if (!currentNode)
+	        return undefined;
+	    if (distance === 1) {
+	        return currentNode;
+	    }
+	    else {
+	        return _nextSibling(currentNode, distance - 1);
+	    }
+	}
+
+	var previousSibling$1 = {};
+
+	previousSibling$1.previousSibling = void 0;
+	const errors_1$4 = es2018$3;
+	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);
+	    }
+	}
+
+	var nextElementSibling$2 = {};
+
+	nextElementSibling$2.nextElementSibling = void 0;
+	const is_element_1$2 = isElement$1;
+	const errors_1$3 = es2018$3;
+	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');
+	    return _nextElementSibling(node, distance);
+	}
+	nextElementSibling$2.nextElementSibling = nextElementSibling$1;
+	function _nextElementSibling(node, distance) {
+	    const currentNode = node.nextSibling;
+	    if (!currentNode)
+	        return undefined;
+	    if ((0, is_element_1$2.isElement)(currentNode)) {
+	        if (distance === 1) {
+	            return currentNode;
+	        }
+	        else {
+	            return _nextElementSibling(currentNode, distance - 1);
+	        }
+	    }
+	    else {
+	        return _nextElementSibling(currentNode, distance);
+	    }
+	}
+
+	var previousElementSibling$1 = {};
+
+	previousElementSibling$1.previousElementSibling = void 0;
+	const is_element_1$1 = isElement$1;
+	const errors_1$2 = es2018$3;
+	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;
+	        }
+	        else {
+	            return _previousElementSibling(currentNode, distance - 1);
+	        }
+	    }
+	    else {
+	        return _previousElementSibling(currentNode, distance);
+	    }
+	}
+
+	var isntDocument$1 = {};
+
+	isntDocument$1.isntDocument = void 0;
+	const is_document_1 = isDocument$1;
+	function isntDocument(val) {
+	    return !(0, is_document_1.isDocument)(val);
+	}
+	isntDocument$1.isntDocument = isntDocument;
+
+	var isntElement$1 = {};
+
+	isntElement$1.isntElement = void 0;
+	const is_element_1 = isElement$1;
+	function isntElement(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$2;
+	function isNode(val) {
+	    if ('Node' in globalThis && val instanceof Node)
+	        return true;
+	    return (0, types_1$1.isObject)(val) && 'nodeType' in val;
+	}
+	isNode$1.isNode = isNode;
+
+	var isntNode$1 = {};
+
+	isntNode$1.isntNode = void 0;
+	const is_node_1$1 = isNode$1;
+	function isntNode(val) {
+	    return !(0, is_node_1$1.isNode)(val);
+	}
+	isntNode$1.isntNode = isntNode;
+
+	var isTextNode$1 = {};
+
+	isTextNode$1.isTextNode = void 0;
+	const node_type_1 = nodeType;
+	const types_1 = es2018$2;
+	function isTextNode(val) {
+	    if ('Text' in globalThis && val instanceof Text)
+	        return true;
+	    return (0, types_1.isRecord)(val) && val.nodeType === node_type_1.NodeType.TEXT_NODE;
+	}
+	isTextNode$1.isTextNode = isTextNode;
+
+	var isntTextNode$1 = {};
+
+	isntTextNode$1.isntTextNode = void 0;
+	const is_text_node_1 = isTextNode$1;
+	function isntTextNode(val) {
+	    return !(0, is_text_node_1.isTextNode)(val);
+	}
+	isntTextNode$1.isntTextNode = isntTextNode;
+
+	var isParentNode$1 = {};
+
+	isParentNode$1.isParentNode = void 0;
+	const is_node_1 = isNode$1;
+	function isParentNode(val) {
+	    return (0, is_node_1.isNode)(val) && 'children' in val;
+	}
+	isParentNode$1.isParentNode = isParentNode;
+
+	var isntParentNode$1 = {};
+
+	isntParentNode$1.isntParentNode = void 0;
+	const is_parent_node_1 = isParentNode$1;
+	function isntParentNode(val) {
+	    return !(0, is_parent_node_1.isParentNode)(val);
+	}
+	isntParentNode$1.isntParentNode = isntParentNode;
+
+	var xpathResultType = {};
+
+	(function (exports) {
+	exports.XPathResultType = void 0;
+	const xpathResultExists = 'XPathResult' in globalThis;
+	(function (XPathResultType) {
+	    XPathResultType[XPathResultType["ANY_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.ANY_TYPE
+	        : 0] = "ANY_TYPE";
+	    XPathResultType[XPathResultType["NUMBER_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.NUMBER_TYPE
+	        : 1] = "NUMBER_TYPE";
+	    XPathResultType[XPathResultType["STRING_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.STRING_TYPE
+	        : 2] = "STRING_TYPE";
+	    XPathResultType[XPathResultType["BOOLEAN_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.BOOLEAN_TYPE
+	        : 3] = "BOOLEAN_TYPE";
+	    XPathResultType[XPathResultType["UNORDERED_NODE_ITERATOR_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.UNORDERED_NODE_ITERATOR_TYPE
+	        : 4] = "UNORDERED_NODE_ITERATOR_TYPE";
+	    XPathResultType[XPathResultType["ORDERED_NODE_ITERATOR_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.ORDERED_NODE_ITERATOR_TYPE
+	        : 5] = "ORDERED_NODE_ITERATOR_TYPE";
+	    XPathResultType[XPathResultType["UNORDERED_NODE_SNAPSHOT_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE
+	        : 6] = "UNORDERED_NODE_SNAPSHOT_TYPE";
+	    XPathResultType[XPathResultType["ORDERED_NODE_SNAPSHOT_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.ORDERED_NODE_SNAPSHOT_TYPE
+	        : 7] = "ORDERED_NODE_SNAPSHOT_TYPE";
+	    XPathResultType[XPathResultType["ANY_UNORDERED_NODE_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.ANY_UNORDERED_NODE_TYPE
+	        : 8] = "ANY_UNORDERED_NODE_TYPE";
+	    XPathResultType[XPathResultType["FIRST_ORDERED_NODE_TYPE"] = xpathResultExists
+	        ? globalThis.XPathResult.FIRST_ORDERED_NODE_TYPE
+	        : 9] = "FIRST_ORDERED_NODE_TYPE";
+	})(exports.XPathResultType || (exports.XPathResultType = {}));
+
+	}(xpathResultType));
+
+	var replaceBrWithNewline$1 = {};
+
+	replaceBrWithNewline$1.replaceBrWithNewline = void 0;
+	const map_1 = map$3;
+	function replaceBrWithNewline(node) {
+	    return (0, map_1.map)(node, node => {
+	        if (node.nodeName === 'BR') {
+	            return document.createTextNode('\n');
+	        }
+	        else {
+	            return node;
+	        }
+	    });
+	}
+	replaceBrWithNewline$1.replaceBrWithNewline = replaceBrWithNewline;
+
+	var isBefore$1 = {};
+
+	isBefore$1.isBefore = void 0;
+	function isBefore(subject, object) {
+	    if (subject.compareDocumentPosition(object) & Node.DOCUMENT_POSITION_FOLLOWING) {
+	        return true;
+	    }
+	    else {
+	        return false;
+	    }
+	}
+	isBefore$1.isBefore = isBefore;
+
+	var isAfter$1 = {};
+
+	isAfter$1.isAfter = void 0;
+	function isAfter(subject, object) {
+	    if (subject.compareDocumentPosition(object) & Node.DOCUMENT_POSITION_PRECEDING) {
+	        return true;
+	    }
+	    else {
+	        return false;
+	    }
+	}
+	isAfter$1.isAfter = isAfter;
+
+	(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(flatMap$1, exports);
+	__exportStar(map$3, exports);
+	__exportStar(filter$3, exports);
+	__exportStar(unwrap$1, exports);
+	__exportStar(find$1, exports);
+	__exportStar(parse$1, exports);
+	__exportStar(stringify$1, exports);
+	__exportStar(normalize$1, exports);
+	__exportStar(removeAllChildren$1, exports);
+	__exportStar(removeAttributes$1, exports);
+	__exportStar(getBySelector$1, exports);
+	__exportStar(getAllBySelector$1, exports);
+	__exportStar(traverseAncestorNodes$1, exports);
+	__exportStar(findInAncestorNodes$1, exports);
+	__exportStar(traverseDescendantNodes$1, exports);
+	__exportStar(findInDescendantNodes$1, exports);
+	__exportStar(findInFollowingSiblingNodes$1, exports);
+	__exportStar(findInPrecedingSiblingNodes$1, exports);
+	__exportStar(parentNode$1, exports);
+	__exportStar(nextSibling$2, exports);
+	__exportStar(previousSibling$1, exports);
+	__exportStar(nextElementSibling$2, exports);
+	__exportStar(previousElementSibling$1, exports);
+	__exportStar(isDocument$1, exports);
+	__exportStar(isntDocument$1, exports);
+	__exportStar(isElement$1, exports);
+	__exportStar(isntElement$1, exports);
+	__exportStar(isNode$1, exports);
+	__exportStar(isntNode$1, exports);
+	__exportStar(isTextNode$1, exports);
+	__exportStar(isntTextNode$1, exports);
+	__exportStar(isParentNode$1, exports);
+	__exportStar(isntParentNode$1, exports);
+	__exportStar(nodeType, exports);
+	__exportStar(xpathResultType, exports);
+	__exportStar(replaceBrWithNewline$1, exports);
+	__exportStar(isBefore$1, exports);
+	__exportStar(isAfter$1, exports);
+
+	}(es2018$6));
+
+	function matchOneByOne(context, source, ...matchers) {
+	    if (matchers.length === 0)
+	        return true;
+	    if (!source)
+	        return false;
+	    const [matcher, ...otherMatchers] = matchers;
+	    const result = Reflect.apply(matcher, context, [source]);
+	    // TerminalMatcher
+	    if (es2018$2.isBoolean(result)) {
+	        if (result) {
+	            const nextNode = context.next(source);
+	            return matchOneByOne(context, nextNode, ...otherMatchers);
+	        }
+	        else {
+	            return false;
+	        }
+	    }
+	    // 此处一定是成功匹配, 因为SkipMatcher在失败时会返回false.
+	    if (es2018$2.isNumber(result)) {
+	        const distance = result;
+	        const nextNode = context.next(source, distance);
+	        return matchOneByOne(context, nextNode, ...otherMatchers);
+	    }
+	    // SkipMatcher返回Iterable意味着存在多种可能性, 可能出现失败回溯.
+	    if (es2018$2.isIterable(result)) {
+	        for (const distance of result) {
+	            const nextNode = context.next(source, distance);
+	            if (matchOneByOne(context, nextNode, ...otherMatchers)) {
+	                return true;
+	            }
+	        }
+	        // 尝试了所有可能性, 未发现可以匹配的结果
+	        return false;
+	    }
+	    throw new Error('Unknown return value');
+	}
+
+	function nextSibling(node, distance = 1) {
+	    if (distance === 0)
+	        return node;
+	    return es2018$6.nextSibling(node, distance);
+	}
+
+	function match(node, ...matchers) {
+	    const document = es2018$6.isDocument(this) ? this : globalThis.document;
+	    const context = {
+	        document,
+	        collection: {},
+	        next: nextSibling
+	    };
+	    if (matchOneByOne(context, node, ...matchers)) {
+	        return context.collection;
+	    }
+	    else {
+	        return null;
+	    }
+	}
+
+	function nextElementSibling(node, distance = 1) {
+	    if (distance === 0)
+	        return node;
+	    return es2018$6.nextElementSibling(node, distance);
+	}
+
+	function matchElement(element, ...matchers) {
+	    const document = es2018$6.isDocument(this) ? this : globalThis.document;
+	    const context = {
+	        document,
+	        collection: {},
+	        next: nextElementSibling
+	    };
+	    if (matchOneByOne(context, element, ...matchers)) {
+	        return context.collection;
+	    }
+	    else {
+	        return null;
+	    }
+	}
+
+	function anyOf(...matchers) {
+	    return function (node) {
+	        return matchers.some(match => match.call(this, node));
+	    };
+	}
+
+	function merge(target, source) {
+	    for (const [key, value] of Object.entries(source)) {
+	        if (target[key]) {
+	            if (Array.isArray(target[key])) {
+	                if (Array.isArray(value)) {
+	                    target[key] = [...target[key], ...value];
+	                }
+	                else {
+	                    target[key] = [...target[key], value];
+	                }
+	            }
+	            else {
+	                if (Array.isArray(value)) {
+	                    target[key] = [target[key], ...value];
+	                }
+	                else {
+	                    target[key] = [target[key], value];
+	                }
+	            }
+	        }
+	        else {
+	            target[key] = value;
+	        }
+	    }
+	}
+
+	function childNodes(...matchers) {
+	    return function (node) {
+	        // 空matchers意味着"childNodes应该为空".
+	        if (matchers.length === 0) {
+	            return node.childNodes.length === 0;
+	        }
+	        if (node.childNodes.length === 0)
+	            return false;
+	        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);
+	        }
+	        return result;
+	    };
+	}
+
+	function children(...matchers) {
+	    return function (element) {
+	        // 空matchers意味着"children应该为空".
+	        if (matchers.length === 0) {
+	            return element.children.length === 0;
+	        }
+	        if (element.children.length === 0)
+	            return false;
+	        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);
+	        }
+	        return result;
+	    };
+	}
+
+	function concat(strings, values) {
+	    const result = [];
+	    for (let i = 0, len = values.length; i < len; i++) {
+	        result.push(strings[i]);
+	        result.push(values[i]);
+	    }
+	    result.push(strings[strings.length - 1]);
+	    return result;
+	}
+
+	function css(...args) {
+	    if (es2018$2.isString(args[0])) {
+	        const [selector] = args;
+	        return (element) => element.matches(selector);
+	    }
+	    else {
+	        const [strings, ...values] = args;
+	        const selector = concat(strings, values).join('');
+	        return css(selector);
+	    }
+	}
+
+	function element(...args) {
+	    if (Array.isArray(args[0])) {
+	        const [strings, ...values] = args;
+	        const name = concat(strings, values).join('');
+	        return (...matchers) => element(name, ...matchers);
+	    }
+	    if (es2018$2.isString(args[0])) {
+	        const [name, ...matchers] = args;
+	        return function (_element) {
+	            const result = element(...matchers).call(this, _element);
+	            if (result) {
+	                merge(this.collection, { [name]: _element });
+	            }
+	            return result;
+	        };
+	    }
+	    const [...matchers] = args;
+	    return function (element) {
+	        if (es2018$6.isntElement(element))
+	            return false;
+	        if (matchers.length === 0)
+	            return true;
+	        return matchers.every(match => match.call(this, element));
+	    };
+	}
+
+	var es2018$1 = {};
+
+	var of$1 = {};
+
+	of$1.of = void 0;
+	function* of(val) {
+	    yield val;
+	}
+	of$1.of = of;
+
+	var repeat$2 = {};
+
+	repeat$2.repeat = void 0;
+	const errors_1$1 = es2018$3;
+	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* () {
+	        while (times-- > 0) {
+	            yield val;
+	        }
+	    })();
+	}
+	repeat$2.repeat = repeat$1;
+
+	var countdown$1 = {};
+
+	countdown$1.countdown = void 0;
+	function* countdown(begin, end) {
+	    if (begin < end)
+	        return;
+	    for (let i = begin; i >= end; i--) {
+	        yield i;
+	    }
+	}
+	countdown$1.countdown = countdown;
+
+	var countup$1 = {};
+
+	countup$1.countup = void 0;
+	function* countup(begin, end) {
+	    if (begin > end)
+	        return;
+	    for (let i = begin; i <= end; i++) {
+	        yield i;
+	    }
+	}
+	countup$1.countup = countup;
+
+	var range$1 = {};
+
+	range$1.range = void 0;
+	const errors_1 = es2018$3;
+	function range(start, end, step = 1) {
+	    (0, errors_1.assert)(step > 0, 'step parameter must be greater than 0');
+	    return rangeByUnsignedStep(start, end, step);
+	}
+	range$1.range = range;
+	function* rangeByUnsignedStep(start, end, step) {
+	    if (start < end) {
+	        for (let i = start; i < end; i += step) {
+	            yield i;
+	        }
+	    }
+	    else {
+	        for (let i = start; i > end; i -= step) {
+	            yield i;
+	        }
+	    }
+	}
+
+	var stringifyJsonStream = {};
+
+	stringifyJsonStream.stringifyJSONStream = void 0;
+	function* stringifyJSONStream(iterable) {
+	    var _a;
+	    const iter = iterable[Symbol.iterator]();
+	    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);
+	    }
+	}
+	stringifyJsonStream.stringifyJSONStream = stringifyJSONStream;
+
+	var stringifyJsonStreamAsync = {};
+
+	stringifyJsonStreamAsync.stringifyJSONStreamAsync = void 0;
+	async function* stringifyJSONStreamAsync(asyncIterable) {
+	    var _a;
+	    const iter = asyncIterable[Symbol.asyncIterator]();
+	    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));
+	    }
+	}
+	stringifyJsonStreamAsync.stringifyJSONStreamAsync = stringifyJSONStreamAsync;
+
+	var stringifyNdjsonStream = {};
+
+	stringifyNdjsonStream.stringifyNDJSONStream = void 0;
+	function* stringifyNDJSONStream(iterable) {
+	    var _a;
+	    const iter = iterable[Symbol.iterator]();
+	    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;
+
+	var stringifyNdjsonStreamAsync = {};
+
+	stringifyNdjsonStreamAsync.stringifyNDJSONStreamAsync = void 0;
+	async function* stringifyNDJSONStreamAsync(asyncIterable) {
+	    var _a;
+	    const iter = asyncIterable[Symbol.asyncIterator]();
+	    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;
+
+	var sse$1 = {};
+
+	sse$1.sse = void 0;
+	function* sse(message) {
+	    if (message.event)
+	        yield `event: ${message.event}\n`;
+	    for (const line of message.data.split('\n')) {
+	        yield `data: ${line}\n`;
+	    }
+	    if (message.id)
+	        yield `id: ${message.id}\n`;
+	    if (message.retry)
+	        yield `retry: ${message.retry}\n`;
+	    yield '\n';
+	}
+	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;
+
+	(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(of$1, exports);
+	__exportStar(repeat$2, exports);
+	__exportStar(countdown$1, exports);
+	__exportStar(countup$1, exports);
+	__exportStar(range$1, exports);
+	__exportStar(stringifyJsonStream, exports);
+	__exportStar(stringifyJsonStreamAsync, exports);
+	__exportStar(stringifyNdjsonStream, exports);
+	__exportStar(stringifyNdjsonStreamAsync, exports);
+	__exportStar(sse$1, exports);
+	__exportStar(reusableIterable, exports);
+	__exportStar(reusableAsyncIterable, exports);
+
+	}(es2018$1));
+
+	/**
+	 * @returns {number} 返回值为成功匹配的元素个数, 当此值等于ubound时, 代表匹配成功.
+	 */
+	function matchMultiple(node, ubound, matcher) {
+	    let currentNode = node;
+	    for (const round of es2018$1.countup(1, ubound)) {
+	        if (!currentNode)
+	            return round - 1;
+	        const result = matcher.call(this, currentNode);
+	        if (result) {
+	            currentNode = this.next(currentNode);
+	        }
+	        else {
+	            return round - 1;
+	        }
+	    }
+	    return ubound;
+	}
+
+	var Range;
+	(function (Range) {
+	    Range[Range["Min"] = 0] = "Min";
+	    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');
+	    return function* (node) {
+	        if (options.greedy) {
+	            let ubound = max;
+	            while (true) {
+	                const round = matchMultiple.call(this, node, ubound, matcher);
+	                if (round < min)
+	                    break;
+	                yield round;
+	                ubound = round - 1;
+	                if (ubound < min)
+	                    break;
+	            }
+	        }
+	        else {
+	            for (const ubound of es2018$1.countup(min, max)) {
+	                const result = matchMultiple.call(this, node, ubound, matcher);
+	                // 如果匹配的节点数量少于ubound, 说明匹配失败, 即使尝试更长的匹配也不会成功.
+	                if (result < ubound)
+	                    break;
+	                if (result === ubound)
+	                    yield ubound;
+	            }
+	        }
+	    };
+	}
+
+	function node(...args) {
+	    if (Array.isArray(args[0])) {
+	        const [strings, ...values] = args;
+	        const name = concat(strings, values).join('');
+	        return (...matchers) => node(name, ...matchers);
+	    }
+	    if (es2018$2.isString(args[0])) {
+	        const [name, ...matchers] = args;
+	        return function (_node) {
+	            const result = node(...matchers).call(this, _node);
+	            if (result) {
+	                merge(this.collection, { [name]: _node });
+	            }
+	            return result;
+	        };
+	    }
+	    const [...matchers] = args;
+	    return function (node) {
+	        if (matchers.length === 0)
+	            return true;
+	        return matchers.every(match => match.call(this, node));
+	    };
+	}
+
+	function optional(matcher) {
+	    return multiple([0, 1], matcher, { greedy: true });
+	}
+
+	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');
+	    return function (node) {
+	        const result = matchMultiple.call(this, node, times, matcher);
+	        if (result === times) {
+	            return times;
+	        }
+	        else {
+	            return false;
+	        }
+	    };
+	}
+
+	function tap(matcher, callback) {
+	    return function (node) {
+	        const result = matcher.call(this, node);
+	        callback(result);
+	        return result;
+	    };
+	}
+
+	function textContentEquals(text, { caseSensitive = true, trim = false } = {}) {
+	    return (node) => {
+	        if (es2018$2.isNull(node.textContent))
+	            return false;
+	        let textContent = node.textContent;
+	        if (!caseSensitive) {
+	            textContent = textContent.toLowerCase();
+	            text = text.toLowerCase();
+	        }
+	        if (trim)
+	            textContent = textContent.trim();
+	        return textContent === text;
+	    };
+	}
+
+	function textContentIncludes(searchString, { caseSensitive = true, trim = false } = {}) {
+	    return (node) => {
+	        if (es2018$2.isNull(node.textContent))
+	            return false;
+	        let textContent = node.textContent;
+	        if (!caseSensitive) {
+	            textContent = textContent.toLowerCase();
+	            searchString = searchString.toLowerCase();
+	        }
+	        if (trim)
+	            textContent = textContent.trim();
+	        return textContent.includes(searchString);
+	    };
+	}
+
+	function textContentMatches(pattern, { trim = false } = {}) {
+	    return (node) => {
+	        if (es2018$2.isNull(node.textContent))
+	            return false;
+	        let textContent = node.textContent;
+	        if (trim)
+	            textContent = textContent.trim();
+	        return pattern.test(textContent);
+	    };
+	}
+
+	function textNode(...args) {
+	    if (Array.isArray(args[0])) {
+	        const [strings, ...values] = args;
+	        const name = concat(strings, values).join('');
+	        return (...matchers) => textNode(name, ...matchers);
+	    }
+	    if (es2018$2.isString(args[0])) {
+	        const [name, ...matchers] = args;
+	        return function (node) {
+	            const result = textNode(...matchers).call(this, node);
+	            if (result) {
+	                merge(this.collection, { [name]: node });
+	            }
+	            return result;
+	        };
+	    }
+	    const [...matchers] = args;
+	    return function (node) {
+	        if (es2018$6.isntTextNode(node))
+	            return false;
+	        if (matchers.length === 0)
+	            return true;
+	        return matchers.every(match => match.call(this, node));
+	    };
+	}
+
+	const UNORDERED_NODE_ITERATOR_TYPE = 'XPathResult' in globalThis
+	    ? XPathResult.UNORDERED_NODE_ITERATOR_TYPE
+	    : 4;
+	function xpath(...args) {
+	    if (es2018$2.isString(args[0])) {
+	        const [expression] = args;
+	        es2018$3.assert(expression.startsWith('//*'), 'XPath expressions must start with "//*"');
+	        return function (node) {
+	            return xpathMatches(this.document, expression, node);
+	        };
+	    }
+	    else {
+	        const [strings, ...values] = args;
+	        const expression = concat(strings, values).join('');
+	        return xpath(expression);
+	    }
+	}
+	function xpathMatches(document, expression, node) {
+	    const iterator = document.evaluate(expression, node, null, UNORDERED_NODE_ITERATOR_TYPE, null);
+	    let value;
+	    while ((value = iterator.iterateNext()) !== null) {
+	        if (value === node)
+	            return true;
+	    }
+	    return false;
+	}
+
+	exports.anyOf = anyOf;
+	exports.childNodes = childNodes;
+	exports.children = children;
+	exports.css = css;
+	exports.element = element;
+	exports.match = match;
+	exports.matchElement = matchElement;
+	exports.multiple = multiple;
+	exports.node = node;
+	exports.optional = optional;
+	exports.repeat = repeat;
+	exports.tap = tap;
+	exports.textContentEquals = textContentEquals;
+	exports.textContentIncludes = textContentIncludes;
+	exports.textContentMatches = textContentMatches;
+	exports.textNode = textNode;
+	exports.xpath = xpath;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.umd.js.map