@blackglory/match 0.3.4 → 0.3.5

package/dist/es2015/index.mjs

@@ -1,6 +1,6 @@
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var es2018$8 = {};
+var es2018$7 = {};
 
 var flatMap$1 = {};
 
@@ -81,21 +81,21 @@ filter$3.filter = filter$2;
 
 var unwrap$1 = {};
 
-var es2018$7 = {};
+var es2018$6 = {};
 
 var middleware = {};
 
 var chunkAsync$1 = {};
 
-var es2018$6 = {};
+var es2018$5 = {};
 
-var go$3 = {};
+var go$1 = {};
 
-go$3.go = void 0;
-function go$2(fn) {
+go$1.go = void 0;
+function go(fn) {
     return fn();
 }
-go$3.go = go$2;
+go$1.go = go;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -107,11 +107,11 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(go$3, exports);
+};__exportStar(go$1, exports);
 
-}(es2018$6));
+}(es2018$5));
 
-var es2018$5 = {};
+var es2018$4 = {};
 
 var customError = {};
 
@@ -189,11 +189,11 @@ __exportStar(normalize$3, exports);
 __exportStar(refute$1, exports);
 __exportStar(assert$1, exports);
 
-}(es2018$5));
+}(es2018$4));
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$g = es2018$6;
-const errors_1$m = es2018$5;
+const go_1$g = es2018$5;
+const errors_1$m = es2018$4;
 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');
@@ -214,7 +214,7 @@ chunkAsync$1.chunkAsync = chunkAsync;
 
 var chunkByAsync$1 = {};
 
-var es2018$4 = {};
+var es2018$3 = {};
 
 var array$1 = {};
 
@@ -411,10 +411,10 @@ function isntObject$1(val) {
     return !isObject$2(val);
 }
 object$1.isntObject = isntObject$1;
-function isRecord$1(val) {
+function isRecord(val) {
     return isObject$2(val);
 }
-object$1.isRecord = isRecord$1;
+object$1.isRecord = isRecord;
 function isEmptyObject$1(val) {
     return Object.keys(val).length === 0;
 }
@@ -476,7 +476,7 @@ function isJsonRpcSuccess$1(val) {
     return (0, object_1$1.isRecord)(val)
         && (0, string_1$2.isString)(val.jsonrpc)
         && (0, string_1$2.isString)(val.id)
-        && (0, undefined_1$3.isntUndefined)(val.result);
+        && 'result' in val;
 }
 jsonRpc$1.isJsonRpcSuccess = isJsonRpcSuccess$1;
 function isntJsonRpcSuccess$1(val) {
@@ -563,10 +563,10 @@ __exportStar(string$1, exports);
 __exportStar(_undefined$1, exports);
 __exportStar(url$1, exports);
 
-}(es2018$4));
+}(es2018$3));
 
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$l = es2018$4;
+const types_1$l = es2018$3;
 function chunkByAsync(iterable, predicate) {
     if ((0, types_1$l.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
@@ -627,8 +627,8 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$f = es2018$6;
-const errors_1$l = es2018$5;
+const go_1$f = es2018$5;
+const errors_1$l = es2018$4;
 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');
@@ -650,8 +650,8 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$k = es2018$4;
-const go_1$e = es2018$6;
+const types_1$k = es2018$3;
+const go_1$e = es2018$5;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$e.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -673,7 +673,7 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$2 = {};
 
 concat$2.concat = void 0;
-const go_1$d = es2018$6;
+const go_1$d = es2018$5;
 function concat$1(iterable, ...otherIterables) {
     return (0, go_1$d.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -702,9 +702,9 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$c = es2018$6;
+const go_1$c = es2018$5;
 const utils_1$3 = utils;
-const errors_1$k = es2018$5;
+const errors_1$k = es2018$4;
 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');
@@ -737,9 +737,9 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$b = es2018$6;
+const go_1$b = es2018$5;
 const utils_1$2 = utils;
-const errors_1$j = es2018$5;
+const errors_1$j = es2018$4;
 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');
@@ -765,9 +765,9 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$a = es2018$6;
+const go_1$a = es2018$5;
 const utils_1$1 = utils;
-const errors_1$i = es2018$5;
+const errors_1$i = es2018$4;
 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');
@@ -783,7 +783,7 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$j = es2018$4;
+const types_1$j = es2018$3;
 function dropUntilAsync(iterable, predicate) {
     if ((0, types_1$j.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
@@ -865,9 +865,9 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$9 = es2018$6;
+const go_1$9 = es2018$5;
 const utils_1 = utils;
-const errors_1$h = es2018$5;
+const errors_1$h = es2018$4;
 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');
@@ -900,7 +900,7 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$i = es2018$4;
+const types_1$i = es2018$3;
 function filterAsync(iterable, predicate) {
     if ((0, types_1$i.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
@@ -947,7 +947,7 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$h = es2018$4;
+const types_1$h = es2018$3;
 function flattenByAsync(iterable, predicate) {
     if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
@@ -987,7 +987,7 @@ function isFiniteIterable$1(val) {
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$g = es2018$5;
+const errors_1$g = es2018$4;
 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');
@@ -1005,7 +1005,7 @@ flattenAsync$1.flattenAsync = flattenAsync;
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$g = es2018$4;
+const types_1$g = es2018$3;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1028,7 +1028,7 @@ var flattenDeep$1 = {};
 
 flattenDeep$1.flattenDeep = void 0;
 const flatten_by_1 = flattenBy$1;
-const errors_1$f = es2018$5;
+const errors_1$f = es2018$4;
 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');
@@ -1048,7 +1048,7 @@ flatten$1.flatten = flatten;
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$f = es2018$4;
+const types_1$f = es2018$3;
 function mapAsync(iterable, fn) {
     if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
@@ -1088,8 +1088,8 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$8 = es2018$6;
-const errors_1$e = es2018$5;
+const go_1$8 = es2018$5;
+const errors_1$e = es2018$4;
 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');
@@ -1123,8 +1123,8 @@ function isProduction$1() {
 var repeat$4 = {};
 
 repeat$4.repeat = void 0;
-const go_1$7 = es2018$6;
-const errors_1$d = es2018$5;
+const go_1$7 = es2018$5;
+const errors_1$d = es2018$4;
 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');
@@ -1158,8 +1158,8 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$6 = es2018$6;
-const errors_1$c = es2018$5;
+const go_1$6 = es2018$5;
+const errors_1$c = es2018$4;
 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');
@@ -1181,8 +1181,8 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$5 = es2018$6;
-const errors_1$b = es2018$5;
+const go_1$5 = es2018$5;
+const errors_1$b = es2018$4;
 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');
@@ -1222,7 +1222,7 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$e = es2018$4;
+const types_1$e = es2018$3;
 function splitByAsync(iterable, predicate) {
     if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
@@ -1304,8 +1304,8 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$4 = es2018$6;
-const errors_1$a = es2018$5;
+const go_1$4 = es2018$5;
+const errors_1$a = es2018$4;
 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');
@@ -1325,8 +1325,8 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$3 = es2018$6;
-const errors_1$9 = es2018$5;
+const go_1$3 = es2018$5;
+const errors_1$9 = es2018$4;
 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');
@@ -1355,8 +1355,8 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$2 = es2018$6;
-const errors_1$8 = es2018$5;
+const go_1$2 = es2018$5;
+const errors_1$8 = es2018$4;
 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');
@@ -1385,7 +1385,7 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$d = es2018$4;
+const types_1$d = es2018$3;
 function takeUntilAsync(iterable, predicate) {
     if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
@@ -1431,8 +1431,8 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1$1 = es2018$6;
-const errors_1$7 = es2018$5;
+const go_1$1 = es2018$5;
+const errors_1$7 = es2018$4;
 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');
@@ -1452,7 +1452,7 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$c = es2018$4;
+const types_1$c = es2018$3;
 function tapAsync(iterable, fn) {
     if ((0, types_1$c.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
@@ -1535,7 +1535,7 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$b = es2018$4;
+const types_1$b = es2018$3;
 function uniqByAsync(iterable, fn) {
     if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
@@ -1604,7 +1604,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$a = es2018$4;
+const types_1$a = es2018$3;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -1764,7 +1764,7 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$9 = es2018$4;
+const types_1$9 = es2018$3;
 function eachAsync(iterable, fn) {
     if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
@@ -1804,7 +1804,7 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$8 = es2018$4;
+const types_1$8 = es2018$3;
 function everyAsync(iterable, predicate) {
     if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
@@ -1850,7 +1850,7 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$7 = es2018$4;
+const types_1$7 = es2018$3;
 function findAsync(iterable, predicate) {
     if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
@@ -1974,7 +1974,7 @@ match$2.match = match$1;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$6 = es2018$4;
+const types_1$6 = es2018$3;
 function reduceAsync(iterable, fn, initialValue) {
     if ((0, types_1$6.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
@@ -2070,7 +2070,7 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$5 = es2018$4;
+const types_1$5 = es2018$3;
 function reduce(iterable, fn, initialValue) {
     if ((0, types_1$5.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
@@ -2117,7 +2117,7 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1$4 = es2018$4;
+const types_1$4 = es2018$3;
 function someAsync(iterable, predicate) {
     if ((0, types_1$4.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
@@ -2301,11 +2301,11 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 };__exportStar(middleware, exports);
 __exportStar(output, exports);
 
-}(es2018$7));
+}(es2018$6));
 
 unwrap$1.unwrap = void 0;
 const flat_map_1 = flatMap$1;
-const iterable_operator_1$2 = es2018$7;
+const iterable_operator_1$2 = es2018$6;
 function unwrap(node, predicate) {
     return (0, flat_map_1.flatMap)(node, node => {
         if (predicate(node)) {
@@ -2335,7 +2335,7 @@ traverseDescendantNodes$1.traverseDescendantNodes = traverseDescendantNodes;
 
 findInDescendantNodes$1.findInDescendantNodes = void 0;
 const traverse_descendant_nodes_1 = traverseDescendantNodes$1;
-const iterable_operator_1$1 = es2018$7;
+const iterable_operator_1$1 = es2018$6;
 function findInDescendantNodes(node, predicate) {
     return (0, iterable_operator_1$1.find)((0, traverse_descendant_nodes_1.traverseDescendantNodes)(node), node => predicate(node));
 }
@@ -2445,7 +2445,7 @@ const nodeExists = 'Node' in globalThis;
 
 }(nodeType));
 
-var es2018$3 = {};
+var es2018$2 = {};
 
 var array = {};
 
@@ -2633,19 +2633,167 @@ var jsonRpc = {};
 
 var object = {};
 
-object.isntEmptyObject = object.isEmptyObject = object.isRecord = object.isntObject = object.isObject = void 0;
+/**
+ * lodash (Custom Build) <https://lodash.com/>
+ * Build: `lodash modularize exports="npm" -o ./`
+ * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+ * Released under MIT license <https://lodash.com/license>
+ * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+ * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ */
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/**
+ * Checks if `value` is a host object in IE < 9.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+ */
+function isHostObject(value) {
+  // Many host objects are `Object` objects that can coerce to strings
+  // despite having improperly defined `toString` methods.
+  var result = false;
+  if (value != null && typeof value.toString != 'function') {
+    try {
+      result = !!(value + '');
+    } catch (e) {}
+  }
+  return result;
+}
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto$1 = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto$1.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var objectToString$1 = objectProto$1.toString;
+
+/** Built-in value references. */
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike$1(value) {
+  return !!value && typeof value == 'object';
+}
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject$1(value) {
+  if (!isObjectLike$1(value) ||
+      objectToString$1.call(value) != objectTag || isHostObject(value)) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+  return (typeof Ctor == 'function' &&
+    Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);
+}
+
+var lodash_isplainobject = isPlainObject$1;
+
+var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
+const lodash_isplainobject_1 = __importDefault$1(lodash_isplainobject);
 function isObject$1(val) {
-    return val !== null && typeof val === 'object';
+    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);
+function isPlainObject(val) {
+    return (0, lodash_isplainobject_1.default)(val);
 }
-object.isRecord = isRecord;
+object.isPlainObject = isPlainObject;
+function isntPlainObject(val) {
+    return !isPlainObject(val);
+}
+object.isntPlainObject = isntPlainObject;
 function isEmptyObject(val) {
     return Object.keys(val).length === 0;
 }
@@ -2680,7 +2828,7 @@ function isJsonRpcParams(val) {
     return (0, array_1.isArray)(val) || (0, object_1.isObject)(val);
 }
 function isJsonRpcNotification(val) {
-    return (0, object_1.isRecord)(val)
+    return (0, object_1.isPlainObject)(val)
         && (0, string_1.isString)(val.jsonrpc)
         && (0, string_1.isString)(val.method)
         && (0, undefined_1.isUndefined)(val.id)
@@ -2692,7 +2840,7 @@ function isntJsonRpcNotification(val) {
 }
 jsonRpc.isntJsonRpcNotification = isntJsonRpcNotification;
 function isJsonRpcRequest(val) {
-    return (0, object_1.isRecord)(val)
+    return (0, object_1.isPlainObject)(val)
         && (0, string_1.isString)(val.jsonrpc)
         && (0, string_1.isString)(val.method)
         && isJsonRpcId(val.id)
@@ -2704,7 +2852,7 @@ function isntJsonRpcRequest(val) {
 }
 jsonRpc.isntJsonRpcRequest = isntJsonRpcRequest;
 function isJsonRpcSuccess(val) {
-    return (0, object_1.isRecord)(val)
+    return (0, object_1.isPlainObject)(val)
         && (0, string_1.isString)(val.jsonrpc)
         && (0, string_1.isString)(val.id)
         && 'result' in val;
@@ -2715,7 +2863,7 @@ function isntJsonRpcSuccess(val) {
 }
 jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
 function isJsonRpcError(val) {
-    return (0, object_1.isRecord)(val)
+    return (0, object_1.isPlainObject)(val)
         && (0, string_1.isString)(val.jsonrpc)
         && isJsonRpcId(val.id)
         && isJsonRpcErrorObject(val.error);
@@ -2726,7 +2874,7 @@ function isntJsonRpcError(val) {
 }
 jsonRpc.isntJsonRpcError = isntJsonRpcError;
 function isJsonRpcErrorObject(val) {
-    return (0, object_1.isRecord)(val)
+    return (0, object_1.isPlainObject)(val)
         && (0, number_1.isNumber)(val.code)
         && (0, string_1.isString)(val.message)
         && ((0, undefined_1.isUndefined)(val.data) || (0, object_1.isObject)(val.data));
@@ -2794,15 +2942,16 @@ __exportStar(string, exports);
 __exportStar(_undefined, exports);
 __exportStar(url, exports);
 
-}(es2018$3));
+}(es2018$2));
 
 isDocument$1.isDocument = void 0;
 const node_type_1$2 = nodeType;
-const types_1$3 = es2018$3;
+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;
+    return (0, types_1$3.isObject)(val)
+        && val.nodeType === node_type_1$2.NodeType.DOCUMENT_NODE;
 }
 isDocument$1.isDocument = isDocument;
 
@@ -2810,11 +2959,12 @@ var isElement$1 = {};
 
 isElement$1.isElement = void 0;
 const node_type_1$1 = nodeType;
-const types_1$2 = es2018$3;
+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;
+    return (0, types_1$2.isObject)(val)
+        && val.nodeType === node_type_1$1.NodeType.ELEMENT_NODE;
 }
 isElement$1.isElement = isElement;
 
@@ -2870,7 +3020,7 @@ var findInAncestorNodes$1 = {};
 
 findInAncestorNodes$1.findInAncestorNodes = void 0;
 const traverse_ancestor_nodes_1 = traverseAncestorNodes$1;
-const iterable_operator_1 = es2018$7;
+const iterable_operator_1 = es2018$6;
 function findInAncestorNodes(node, predicate) {
     return (0, iterable_operator_1.find)((0, traverse_ancestor_nodes_1.traverseAncestorNodes)(node), node => predicate(node));
 }
@@ -2911,7 +3061,7 @@ findInPrecedingSiblingNodes$1.findInPrecedingSiblingNodes = findInPrecedingSibli
 var parentNode$1 = {};
 
 parentNode$1.parentNode = void 0;
-const errors_1$6 = es2018$5;
+const errors_1$6 = es2018$4;
 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');
@@ -2933,7 +3083,7 @@ function _parentNode(node, distance) {
 var nextSibling$2 = {};
 
 nextSibling$2.nextSibling = void 0;
-const errors_1$5 = es2018$5;
+const errors_1$5 = es2018$4;
 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');
@@ -2955,7 +3105,7 @@ function _nextSibling(node, distance) {
 var previousSibling$1 = {};
 
 previousSibling$1.previousSibling = void 0;
-const errors_1$4 = es2018$5;
+const errors_1$4 = es2018$4;
 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');
@@ -2978,7 +3128,7 @@ var nextElementSibling$2 = {};
 
 nextElementSibling$2.nextElementSibling = void 0;
 const is_element_1$2 = isElement$1;
-const errors_1$3 = es2018$5;
+const errors_1$3 = es2018$4;
 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');
@@ -3006,7 +3156,7 @@ var previousElementSibling$1 = {};
 
 previousElementSibling$1.previousElementSibling = void 0;
 const is_element_1$1 = isElement$1;
-const errors_1$2 = es2018$5;
+const errors_1$2 = es2018$4;
 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');
@@ -3051,7 +3201,7 @@ isntElement$1.isntElement = isntElement;
 var isNode$1 = {};
 
 isNode$1.isNode = void 0;
-const types_1$1 = es2018$3;
+const types_1$1 = es2018$2;
 function isNode(val) {
     if ('Node' in globalThis && val instanceof Node)
         return true;
@@ -3072,11 +3222,12 @@ var isTextNode$1 = {};
 
 isTextNode$1.isTextNode = void 0;
 const node_type_1 = nodeType;
-const types_1 = es2018$3;
+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;
+    return (0, types_1.isObject)(val)
+        && val.nodeType === node_type_1.NodeType.TEXT_NODE;
 }
 isTextNode$1.isTextNode = isTextNode;
 
@@ -3238,7 +3389,7 @@ __exportStar(replaceBrWithNewline$1, exports);
 __exportStar(isBefore$1, exports);
 __exportStar(isAfter$1, exports);
 
-}(es2018$8));
+}(es2018$7));
 
 function matchOneByOne(context, source, ...matchers) {
     if (matchers.length === 0)
@@ -3280,11 +3431,11 @@ function matchOneByOne(context, source, ...matchers) {
 function nextSibling(node, distance = 1) {
     if (distance === 0)
         return node;
-    return es2018$8.nextSibling(node, distance);
+    return es2018$7.nextSibling(node, distance);
 }
 
 function match(node, ...matchers) {
-    const document = es2018$8.isDocument(this) ? this : globalThis.document;
+    const document = es2018$7.isDocument(this) ? this : globalThis.document;
     const context = {
         document,
         collection: {},
@@ -3301,11 +3452,11 @@ function match(node, ...matchers) {
 function nextElementSibling(node, distance = 1) {
     if (distance === 0)
         return node;
-    return es2018$8.nextElementSibling(node, distance);
+    return es2018$7.nextElementSibling(node, distance);
 }
 
 function matchElement(element, ...matchers) {
-    const document = es2018$8.isDocument(this) ? this : globalThis.document;
+    const document = es2018$7.isDocument(this) ? this : globalThis.document;
     const context = {
         document,
         collection: {},
@@ -3325,7 +3476,7 @@ function anyOf(...matchers) {
     };
 }
 
-function merge(target, source) {
+function mergeInPlace(target, source) {
     for (const [key, value] of Object.entries(source)) {
         if (target[key]) {
             if (es2018$3.isArray(target[key])) {
@@ -3362,7 +3513,7 @@ function childNodes(...matchers) {
         const context = Object.assign(Object.assign({}, this), { collection: {}, next: nextSibling });
         const result = matchOneByOne(context, node.childNodes[0], ...matchers);
         if (result) {
-            merge(this.collection, context.collection);
+            mergeInPlace(this.collection, context.collection);
         }
         return result;
     };
@@ -3379,7 +3530,7 @@ function children(...matchers) {
         const context = Object.assign(Object.assign({}, this), { collection: {}, next: nextElementSibling });
         const result = matchOneByOne(context, element.children[0], ...matchers);
         if (result) {
-            merge(this.collection, context.collection);
+            mergeInPlace(this.collection, context.collection);
         }
         return result;
     };
@@ -3418,14 +3569,14 @@ function element(...args) {
         return function (_element) {
             const result = element(...matchers).call(this, _element);
             if (result) {
-                merge(this.collection, { [name]: _element });
+                mergeInPlace(this.collection, { [name]: _element });
             }
             return result;
         };
     }
     const [...matchers] = args;
     return function (element) {
-        if (es2018$8.isntElement(element))
+        if (es2018$7.isntElement(element))
             return false;
         if (matchers.length === 0)
             return true;
@@ -3433,7 +3584,7 @@ function element(...args) {
     };
 }
 
-var es2018$2 = {};
+var es2018$1 = {};
 
 var of$1 = {};
 
@@ -3445,33 +3596,9 @@ of$1.of = of;
 
 var repeat$2 = {};
 
-var es2018$1 = {};
-
-var go$1 = {};
-
-go$1.go = void 0;
-function go(fn) {
-    return fn();
-}
-go$1.go = go;
-
-(function (exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(go$1, exports);
-
-}(es2018$1));
-
 repeat$2.repeat = void 0;
-const errors_1$1 = es2018$5;
-const go_1 = es2018$1;
+const errors_1$1 = es2018$4;
+const go_1 = es2018$5;
 function repeat$1(val, times = Infinity) {
     (0, errors_1$1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     return (0, go_1.go)(function* () {
@@ -3509,7 +3636,7 @@ countup$1.countup = countup;
 var range$1 = {};
 
 range$1.range = void 0;
-const errors_1 = es2018$5;
+const errors_1 = es2018$4;
 function range(start, end, step = 1) {
     (0, errors_1.assert)(step > 0, 'step parameter must be greater than 0');
     return rangeByUnsignedStep(start, end, step);
@@ -4113,14 +4240,14 @@ __exportStar(reusableIterable, exports);
 __exportStar(reusableAsyncIterable, exports);
 __exportStar(timestampBasedId$1, exports);
 
-}(es2018$2));
+}(es2018$1));
 
 /**
  * @returns {number} 返回值为成功匹配的元素个数, 当此值等于ubound时, 代表匹配成功.
  */
 function matchMultiple(node, ubound, matcher) {
     let currentNode = node;
-    for (const round of es2018$2.countup(1, ubound)) {
+    for (const round of es2018$1.countup(1, ubound)) {
         if (!currentNode)
             return round - 1;
         const result = matcher.call(this, currentNode);
@@ -4140,10 +4267,10 @@ var Range;
     Range[Range["Max"] = 1] = "Max";
 })(Range || (Range = {}));
 function multiple([min, max], matcher, options = { greedy: true }) {
-    es2018$5.assert(Number.isInteger(min), 'parameter min must be an integer');
-    es2018$5.assert(Number.isInteger(max) || max === Infinity, 'parameter max must be an integer or Infinity');
-    es2018$5.assert(min >= 0, 'parameter min must be greater than or equal to 0');
-    es2018$5.assert(min <= max, 'parameter max must be greater than or equal to min');
+    es2018$4.assert(Number.isInteger(min), 'parameter min must be an integer');
+    es2018$4.assert(Number.isInteger(max) || max === Infinity, 'parameter max must be an integer or Infinity');
+    es2018$4.assert(min >= 0, 'parameter min must be greater than or equal to 0');
+    es2018$4.assert(min <= max, 'parameter max must be greater than or equal to min');
     return function* (node) {
         if (options.greedy) {
             let ubound = max;
@@ -4158,7 +4285,7 @@ function multiple([min, max], matcher, options = { greedy: true }) {
             }
         }
         else {
-            for (const ubound of es2018$2.countup(min, max)) {
+            for (const ubound of es2018$1.countup(min, max)) {
                 const result = matchMultiple.call(this, node, ubound, matcher);
                 // 如果匹配的节点数量少于ubound, 说明匹配失败, 即使尝试更长的匹配也不会成功.
                 if (result < ubound)
@@ -4181,7 +4308,7 @@ function node(...args) {
         return function (_node) {
             const result = node(...matchers).call(this, _node);
             if (result) {
-                merge(this.collection, { [name]: _node });
+                mergeInPlace(this.collection, { [name]: _node });
             }
             return result;
         };
@@ -4199,8 +4326,8 @@ function optional(matcher) {
 }
 
 function repeat(times, matcher) {
-    es2018$5.assert(Number.isInteger(times), 'parameter times must be an integer');
-    es2018$5.assert(times >= 0, 'parameter number must be greater than or equal to 0');
+    es2018$4.assert(Number.isInteger(times), 'parameter times must be an integer');
+    es2018$4.assert(times >= 0, 'parameter number must be greater than or equal to 0');
     return function (node) {
         const result = matchMultiple.call(this, node, times, matcher);
         if (result === times) {
@@ -4272,14 +4399,14 @@ function textNode(...args) {
         return function (node) {
             const result = textNode(...matchers).call(this, node);
             if (result) {
-                merge(this.collection, { [name]: node });
+                mergeInPlace(this.collection, { [name]: node });
             }
             return result;
         };
     }
     const [...matchers] = args;
     return function (node) {
-        if (es2018$8.isntTextNode(node))
+        if (es2018$7.isntTextNode(node))
             return false;
         if (matchers.length === 0)
             return true;
@@ -4293,7 +4420,7 @@ const UNORDERED_NODE_ITERATOR_TYPE = 'XPathResult' in globalThis
 function xpath(...args) {
     if (es2018$3.isString(args[0])) {
         const [expression] = args;
-        es2018$5.assert(expression.startsWith('//*'), 'XPath expressions must start with "//*"');
+        es2018$4.assert(expression.startsWith('//*'), 'XPath expressions must start with "//*"');
         return function (node) {
             return xpathMatches(this.document, expression, node);
         };