@blackglory/structures 0.6.3 → 0.6.6

package/dist/es2018/index.mjs

@@ -2,6 +2,9 @@ class Box {
     constructor(value) {
         this.value = value;
     }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
     set(value) {
         this.value = value;
     }
@@ -10,10 +13,629 @@ class Box {
     }
 }
 
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+var es2018$e = {};
+
+var array$2 = {};
+
+array$2.isntEmptyArray = array$2.isEmptyArray = array$2.isntArray = array$2.isArray = void 0;
+function isArray$2(val) {
+    return Array.isArray(val);
+}
+array$2.isArray = isArray$2;
+function isntArray$2(val) {
+    return !isArray$2(val);
+}
+array$2.isntArray = isntArray$2;
+function isEmptyArray$2(val) {
+    return val.length === 0;
+}
+array$2.isEmptyArray = isEmptyArray$2;
+function isntEmptyArray$2(val) {
+    return val.length !== 0;
+}
+array$2.isntEmptyArray = isntEmptyArray$2;
+
+var asyncIterable$2 = {};
+
+var _null$2 = {};
+
+_null$2.isntNull = _null$2.isNull = void 0;
+function isNull$2(val) {
+    return val === null;
+}
+_null$2.isNull = isNull$2;
+function isntNull$2(val) {
+    return !isNull$2(val);
+}
+_null$2.isntNull = isntNull$2;
+
+var _undefined$2 = {};
+
+_undefined$2.isntUndefined = _undefined$2.isUndefined = void 0;
+function isUndefined$2(val) {
+    return val === undefined;
+}
+_undefined$2.isUndefined = isUndefined$2;
+function isntUndefined$2(val) {
+    return !isUndefined$2(val);
+}
+_undefined$2.isntUndefined = isntUndefined$2;
+
+var _function$2 = {};
+
+_function$2.isntFunction = _function$2.isFunction = void 0;
+function isFunction$3(val) {
+    return typeof val === 'function';
+}
+_function$2.isFunction = isFunction$3;
+function isntFunction$2(val) {
+    return !isFunction$3(val);
+}
+_function$2.isntFunction = isntFunction$2;
+
+asyncIterable$2.isntAsyncIterable = asyncIterable$2.isAsyncIterable = void 0;
+const null_1$7 = _null$2;
+const undefined_1$6 = _undefined$2;
+const function_1$5 = _function$2;
+function isAsyncIterable$2(val) {
+    return (0, null_1$7.isntNull)(val)
+        && (0, undefined_1$6.isntUndefined)(val)
+        && (0, function_1$5.isFunction)(val[Symbol.asyncIterator]);
+}
+asyncIterable$2.isAsyncIterable = isAsyncIterable$2;
+function isntAsyncIterable$2(val) {
+    return !isAsyncIterable$2(val);
+}
+asyncIterable$2.isntAsyncIterable = isntAsyncIterable$2;
+
+var bigint$2 = {};
+
+bigint$2.isntBigInt = bigint$2.isBigInt = void 0;
+function isBigInt$2(val) {
+    return typeof val === 'bigint';
+}
+bigint$2.isBigInt = isBigInt$2;
+function isntBigInt$2(val) {
+    return !isBigInt$2(val);
+}
+bigint$2.isntBigInt = isntBigInt$2;
+
+var boolean$2 = {};
+
+boolean$2.isntBoolean = boolean$2.isBoolean = void 0;
+function isBoolean$2(val) {
+    return typeof val === 'boolean';
+}
+boolean$2.isBoolean = isBoolean$2;
+function isntBoolean$2(val) {
+    return !isBoolean$2(val);
+}
+boolean$2.isntBoolean = isntBoolean$2;
+
+var char$2 = {};
+
+var string$2 = {};
+
+string$2.isntString = string$2.isString = void 0;
+function isString$2(val) {
+    return typeof val === 'string';
+}
+string$2.isString = isString$2;
+function isntString$2(val) {
+    return !isString$2(val);
+}
+string$2.isntString = isntString$2;
+
+char$2.isntChar = char$2.isChar = void 0;
+const string_1$5 = string$2;
+function isChar$2(val) {
+    return (0, string_1$5.isString)(val)
+        && val.length === 1;
+}
+char$2.isChar = isChar$2;
+function isntChar$2(val) {
+    return !isChar$2(val);
+}
+char$2.isntChar = isntChar$2;
+
+var date$2 = {};
+
+date$2.isntDate = date$2.isDate = void 0;
+function isDate$2(val) {
+    return val instanceof Date;
+}
+date$2.isDate = isDate$2;
+function isntDate$2(val) {
+    return !isDate$2(val);
+}
+date$2.isntDate = isntDate$2;
+
+var _enum$2 = {};
+
+_enum$2.inEnum = void 0;
+function inEnum$2(val, _enum) {
+    return Object.values(_enum).includes(val);
+}
+_enum$2.inEnum = inEnum$2;
+
+var error$2 = {};
+
+error$2.isntError = error$2.isError = void 0;
+function isError$2(val) {
+    return val instanceof Error;
+}
+error$2.isError = isError$2;
+function isntError$2(val) {
+    return !isError$2(val);
+}
+error$2.isntError = isntError$2;
+
+var falsy$2 = {};
+
+falsy$2.isntFalsy = falsy$2.isFalsy = void 0;
+function isFalsy$2(val) {
+    return !val;
+}
+falsy$2.isFalsy = isFalsy$2;
+function isntFalsy$2(val) {
+    return !isFalsy$2(val);
+}
+falsy$2.isntFalsy = isntFalsy$2;
+
+var iterable$2 = {};
+
+iterable$2.isntIterable = iterable$2.isIterable = void 0;
+const null_1$6 = _null$2;
+const undefined_1$5 = _undefined$2;
+const function_1$4 = _function$2;
+function isIterable$2(val) {
+    return (0, null_1$6.isntNull)(val)
+        && (0, undefined_1$5.isntUndefined)(val)
+        && (0, function_1$4.isFunction)(val[Symbol.iterator]);
+}
+iterable$2.isIterable = isIterable$2;
+function isntIterable$2(val) {
+    return !isIterable$2(val);
+}
+iterable$2.isntIterable = isntIterable$2;
+
+var json$2 = {};
+
+var number$2 = {};
+
+number$2.isntNaN = number$2.isNaN = number$2.isNegativeInfinity = number$2.isPositiveInfinity = number$2.isFinite = number$2.isntNumber = number$2.isNumber = void 0;
+function isNumber$2(val) {
+    return typeof val === 'number';
+}
+number$2.isNumber = isNumber$2;
+function isntNumber$2(val) {
+    return !isNumber$2(val);
+}
+number$2.isntNumber = isntNumber$2;
+function isFinite$1(val) {
+    return Number.isFinite(val);
+}
+number$2.isFinite = isFinite$1;
+function isPositiveInfinity$1(val) {
+    return val === Infinity;
+}
+number$2.isPositiveInfinity = isPositiveInfinity$1;
+function isNegativeInfinity$1(val) {
+    return val === -Infinity;
+}
+number$2.isNegativeInfinity = isNegativeInfinity$1;
+function isNaN$1(val) {
+    return Number.isNaN(val);
+}
+number$2.isNaN = isNaN$1;
+function isntNaN$1(val) {
+    return !isNaN$1(val);
+}
+number$2.isntNaN = isntNaN$1;
+
+var object$2 = {};
+
+/** Detect free variable `global` from Node.js. */
+
+var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+
+var _freeGlobal = freeGlobal$1;
+
+var freeGlobal = _freeGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root$1 = freeGlobal || freeSelf || Function('return this')();
+
+var _root = root$1;
+
+var root = _root;
+
+/** Built-in value references. */
+var Symbol$3 = root.Symbol;
+
+var _Symbol = Symbol$3;
+
+var Symbol$2 = _Symbol;
+
+/** Used for built-in method references. */
+var objectProto$3 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString$1 = objectProto$3.toString;
+
+/** Built-in value references. */
+var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$2.call(value, symToStringTag$1),
+      tag = value[symToStringTag$1];
+
+  try {
+    value[symToStringTag$1] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+
+var _getRawTag = getRawTag$1;
+
+/** Used for built-in method references. */
+
+var objectProto$2 = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto$2.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString$2(value) {
+  return nativeObjectToString.call(value);
+}
+
+var _objectToString = objectToString$2;
+
+var Symbol$1 = _Symbol,
+    getRawTag = _getRawTag,
+    objectToString$1 = _objectToString;
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+    undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag$1(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return (symToStringTag && symToStringTag in Object(value))
+    ? getRawTag(value)
+    : objectToString$1(value);
+}
+
+var _baseGetTag = baseGetTag$1;
+
+/**
+ * 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$2(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+
+var _overArg = overArg$2;
+
+var overArg$1 = _overArg;
+
+/** Built-in value references. */
+var getPrototype$2 = overArg$1(Object.getPrototypeOf, Object);
+
+var _getPrototype = getPrototype$2;
+
+/**
+ * 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$2(value) {
+  return value != null && typeof value == 'object';
+}
+
+var isObjectLike_1 = isObjectLike$2;
+
+var baseGetTag = _baseGetTag,
+    getPrototype$1 = _getPrototype,
+    isObjectLike$1 = isObjectLike_1;
+
+/** `Object#toString` result references. */
+var objectTag$1 = '[object Object]';
+
+/** Used for built-in method references. */
+var funcProto$1 = Function.prototype,
+    objectProto$1 = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString$1 = funcProto$1.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString$1 = funcToString$1.call(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$4(value) {
+  if (!isObjectLike$1(value) || baseGetTag(value) != objectTag$1) {
+    return false;
+  }
+  var proto = getPrototype$1(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty$1.call(proto, 'constructor') && proto.constructor;
+  return typeof Ctor == 'function' && Ctor instanceof Ctor &&
+    funcToString$1.call(Ctor) == objectCtorString$1;
+}
+
+var isPlainObject_1$2 = isPlainObject$4;
+
+var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};object$2.isntEmptyObject = object$2.isEmptyObject = object$2.isntPlainObject = object$2.isPlainObject = object$2.isntObject = object$2.isObject = void 0;
+const isPlainObject_1$1 = __importDefault$2(isPlainObject_1$2);
+function isObject$2(val) {
+    return val !== null
+        && typeof val === 'object';
+}
+object$2.isObject = isObject$2;
+function isntObject$2(val) {
+    return !isObject$2(val);
+}
+object$2.isntObject = isntObject$2;
+function isPlainObject$3(val) {
+    return (0, isPlainObject_1$1.default)(val);
+}
+object$2.isPlainObject = isPlainObject$3;
+function isntPlainObject$2(val) {
+    return !isPlainObject$3(val);
+}
+object$2.isntPlainObject = isntPlainObject$2;
+function isEmptyObject$2(val) {
+    return Object.keys(val).length === 0;
+}
+object$2.isEmptyObject = isEmptyObject$2;
+function isntEmptyObject$2(val) {
+    return Object.keys(val).length !== 0;
+}
+object$2.isntEmptyObject = isntEmptyObject$2;
+
+json$2.isntJsonable = json$2.isJsonable = json$2.isntJson = json$2.isJson = void 0;
+const null_1$5 = _null$2;
+const boolean_1$1 = boolean$2;
+const string_1$4 = string$2;
+const number_1$2 = number$2;
+const array_1$2 = array$2;
+const object_1$4 = object$2;
+function isJson$2(val) {
+    return (0, null_1$5.isNull)(val)
+        || (0, boolean_1$1.isBoolean)(val)
+        || (0, string_1$4.isString)(val)
+        || (0, number_1$2.isNumber)(val)
+        || ((0, array_1$2.isArray)(val) && val.every(isJson$2))
+        || ((0, object_1$4.isPlainObject)(val) && Object.values(val).every(isJson$2));
+}
+json$2.isJson = isJson$2;
+function isntJson$2(val) {
+    return !isJson$2(val);
+}
+json$2.isntJson = isntJson$2;
+function isJsonable$1(val) {
+    try {
+        JSON.stringify(val);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+json$2.isJsonable = isJsonable$1;
+function isntJsonable$1(val) {
+    return !isntJsonable$1();
+}
+json$2.isntJsonable = isntJsonable$1;
+
+var promise$1 = {};
+
+promise$1.isPromiseLike = promise$1.isntPromiseLike = promise$1.isntPromise = promise$1.isPromise = void 0;
+const object_1$3 = object$2;
+const function_1$3 = _function$2;
+function isPromise$1(val) {
+    return val instanceof Promise;
+}
+promise$1.isPromise = isPromise$1;
+function isntPromise$1(val) {
+    return !isPromise$1(val);
+}
+promise$1.isntPromise = isntPromise$1;
+function isntPromiseLike$1(val) {
+    return !isPromiseLike$1(val);
+}
+promise$1.isntPromiseLike = isntPromiseLike$1;
+function isPromiseLike$1(val) {
+    return (0, object_1$3.isObject)(val)
+        && (0, function_1$3.isFunction)(val.then);
+}
+promise$1.isPromiseLike = isPromiseLike$1;
+
+var url$2 = {};
+
+url$2.isAbsoluteURL = void 0;
+function isAbsoluteURL$2(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+url$2.isAbsoluteURL = isAbsoluteURL$2;
+
+var regexp = {};
+
+regexp.isntRegExp = regexp.isRegExp = void 0;
+function isRegExp(val) {
+    return val instanceof RegExp;
+}
+regexp.isRegExp = isRegExp;
+function isntRegExp(val) {
+    return !isRegExp(val);
+}
+regexp.isntRegExp = isntRegExp;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};__exportStar(array$2, exports);
+	__exportStar(asyncIterable$2, exports);
+	__exportStar(bigint$2, exports);
+	__exportStar(boolean$2, exports);
+	__exportStar(char$2, exports);
+	__exportStar(date$2, exports);
+	__exportStar(_enum$2, exports);
+	__exportStar(error$2, exports);
+	__exportStar(falsy$2, exports);
+	__exportStar(_function$2, exports);
+	__exportStar(iterable$2, exports);
+	__exportStar(json$2, exports);
+	__exportStar(_null$2, exports);
+	__exportStar(number$2, exports);
+	__exportStar(object$2, exports);
+	__exportStar(promise$1, exports);
+	__exportStar(string$2, exports);
+	__exportStar(_undefined$2, exports);
+	__exportStar(url$2, exports);
+	__exportStar(regexp, exports);
+	
+} (es2018$e));
+
 function convertConsToArray([value, next]) {
-    if (next === null)
+    if (es2018$e.isNull(next)) {
         return [value];
-    return [value, ...convertConsToArray(next)];
+    }
+    else {
+        return [value, ...convertConsToArray(next)];
+    }
 }
 function convertArrayToCons([value, ...next]) {
     return [value, next.length ? convertArrayToCons(next) : null];
@@ -147,8 +769,6 @@ class Queue {
     }
 }
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
 var es2018$d = {};
 
 var customError$2 = {};
@@ -494,7 +1114,7 @@ var object$1 = {};
  */
 
 /** `Object#toString` result references. */
-var objectTag$1 = '[object Object]';
+var objectTag = '[object Object]';
 
 /**
  * Checks if `value` is a host object in IE < 9.
@@ -523,34 +1143,34 @@ function isHostObject(value) {
  * @param {Function} transform The argument transform.
  * @returns {Function} Returns the new function.
  */
-function overArg$2(func, transform) {
+function overArg(func, transform) {
   return function(arg) {
     return func(transform(arg));
   };
 }
 
 /** Used for built-in method references. */
-var funcProto$1 = Function.prototype,
-    objectProto$3 = Object.prototype;
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
 
 /** Used to resolve the decompiled source of functions. */
-var funcToString$1 = funcProto$1.toString;
+var funcToString = funcProto.toString;
 
 /** Used to check objects for own properties. */
-var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+var hasOwnProperty = objectProto.hasOwnProperty;
 
 /** Used to infer the `Object` constructor. */
-var objectCtorString$1 = funcToString$1.call(Object);
+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$2 = objectProto$3.toString;
+var objectToString = objectProto.toString;
 
 /** Built-in value references. */
-var getPrototype$2 = overArg$2(Object.getPrototypeOf, Object);
+var getPrototype = overArg(Object.getPrototypeOf, Object);
 
 /**
  * Checks if `value` is object-like. A value is object-like if it's not `null`
@@ -576,7 +1196,7 @@ var getPrototype$2 = overArg$2(Object.getPrototypeOf, Object);
  * _.isObjectLike(null);
  * // => false
  */
-function isObjectLike$2(value) {
+function isObjectLike(value) {
   return !!value && typeof value == 'object';
 }
 
@@ -608,21 +1228,21 @@ function isObjectLike$2(value) {
  * _.isPlainObject(Object.create(null));
  * // => true
  */
-function isPlainObject$3(value) {
-  if (!isObjectLike$2(value) ||
-      objectToString$2.call(value) != objectTag$1 || isHostObject(value)) {
+function isPlainObject$2(value) {
+  if (!isObjectLike(value) ||
+      objectToString.call(value) != objectTag || isHostObject(value)) {
     return false;
   }
-  var proto = getPrototype$2(value);
+  var proto = getPrototype(value);
   if (proto === null) {
     return true;
   }
-  var Ctor = hasOwnProperty$2.call(proto, 'constructor') && proto.constructor;
+  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
   return (typeof Ctor == 'function' &&
-    Ctor instanceof Ctor && funcToString$1.call(Ctor) == objectCtorString$1);
+    Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);
 }
 
-var lodash_isplainobject = isPlainObject$3;
+var lodash_isplainobject = isPlainObject$2;
 
 var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -637,12 +1257,12 @@ function isntObject$1(val) {
     return !isObject$1(val);
 }
 object$1.isntObject = isntObject$1;
-function isPlainObject$2(val) {
+function isPlainObject$1(val) {
     return (0, lodash_isplainobject_1.default)(val);
 }
-object$1.isPlainObject = isPlainObject$2;
+object$1.isPlainObject = isPlainObject$1;
 function isntPlainObject$1(val) {
-    return !isPlainObject$2(val);
+    return !isPlainObject$1(val);
 }
 object$1.isntPlainObject = isntPlainObject$1;
 function isEmptyObject$1(val) {
@@ -4796,388 +5416,147 @@ bigint.isBigInt = isBigInt;
 function isntBigInt(val) {
     return !isBigInt(val);
 }
-bigint.isntBigInt = isntBigInt;
-
-var boolean = {};
-
-boolean.isntBoolean = boolean.isBoolean = void 0;
-function isBoolean(val) {
-    return typeof val === 'boolean';
-}
-boolean.isBoolean = isBoolean;
-function isntBoolean(val) {
-    return !isBoolean(val);
-}
-boolean.isntBoolean = isntBoolean;
-
-var char = {};
-
-var string = {};
-
-string.isntString = string.isString = void 0;
-function isString(val) {
-    return typeof val === 'string';
-}
-string.isString = isString;
-function isntString(val) {
-    return !isString(val);
-}
-string.isntString = isntString;
-
-char.isntChar = char.isChar = void 0;
-const string_1$1 = string;
-function isChar(val) {
-    return (0, string_1$1.isString)(val)
-        && val.length === 1;
-}
-char.isChar = isChar;
-function isntChar(val) {
-    return !isChar(val);
-}
-char.isntChar = isntChar;
-
-var date = {};
-
-date.isntDate = date.isDate = void 0;
-function isDate(val) {
-    return val instanceof Date;
-}
-date.isDate = isDate;
-function isntDate(val) {
-    return !isDate(val);
-}
-date.isntDate = isntDate;
-
-var _enum = {};
-
-_enum.inEnum = void 0;
-function inEnum(val, _enum) {
-    return Object.values(_enum).includes(val);
-}
-_enum.inEnum = inEnum;
-
-var error = {};
-
-error.isntError = error.isError = void 0;
-function isError(val) {
-    return val instanceof Error;
-}
-error.isError = isError;
-function isntError(val) {
-    return !isError(val);
-}
-error.isntError = isntError;
-
-var falsy = {};
-
-falsy.isntFalsy = falsy.isFalsy = void 0;
-function isFalsy(val) {
-    return !val;
-}
-falsy.isFalsy = isFalsy;
-function isntFalsy(val) {
-    return !isFalsy(val);
-}
-falsy.isntFalsy = isntFalsy;
-
-var iterable = {};
-
-iterable.isntIterable = iterable.isIterable = void 0;
-const null_1$1 = _null;
-const undefined_1 = _undefined;
-const function_1$1 = _function;
-function isIterable(val) {
-    return (0, null_1$1.isntNull)(val)
-        && (0, undefined_1.isntUndefined)(val)
-        && (0, function_1$1.isFunction)(val[Symbol.iterator]);
-}
-iterable.isIterable = isIterable;
-function isntIterable(val) {
-    return !isIterable(val);
-}
-iterable.isntIterable = isntIterable;
-
-var json = {};
-
-var number = {};
-
-number.isntNaN = number.isNaN = number.isNegativeInfinity = number.isPositiveInfinity = number.isFinite = number.isntNumber = number.isNumber = void 0;
-function isNumber(val) {
-    return typeof val === 'number';
-}
-number.isNumber = isNumber;
-function isntNumber(val) {
-    return !isNumber(val);
-}
-number.isntNumber = isntNumber;
-function isFinite(val) {
-    return Number.isFinite(val);
-}
-number.isFinite = isFinite;
-function isPositiveInfinity(val) {
-    return val === Infinity;
-}
-number.isPositiveInfinity = isPositiveInfinity;
-function isNegativeInfinity(val) {
-    return val === -Infinity;
-}
-number.isNegativeInfinity = isNegativeInfinity;
-function isNaN(val) {
-    return Number.isNaN(val);
-}
-number.isNaN = isNaN;
-function isntNaN(val) {
-    return !isNaN(val);
-}
-number.isntNaN = isntNaN;
-
-var object = {};
-
-/** Detect free variable `global` from Node.js. */
-
-var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
-
-var _freeGlobal = freeGlobal$1;
-
-var freeGlobal = _freeGlobal;
-
-/** Detect free variable `self`. */
-var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
-
-/** Used as a reference to the global object. */
-var root$1 = freeGlobal || freeSelf || Function('return this')();
-
-var _root = root$1;
-
-var root = _root;
-
-/** Built-in value references. */
-var Symbol$3 = root.Symbol;
-
-var _Symbol = Symbol$3;
-
-var Symbol$2 = _Symbol;
-
-/** Used for built-in method references. */
-var objectProto$2 = Object.prototype;
-
-/** Used to check objects for own properties. */
-var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
-
-/**
- * Used to resolve the
- * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
- * of values.
- */
-var nativeObjectToString$1 = objectProto$2.toString;
-
-/** Built-in value references. */
-var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined;
-
-/**
- * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
- *
- * @private
- * @param {*} value The value to query.
- * @returns {string} Returns the raw `toStringTag`.
- */
-function getRawTag$1(value) {
-  var isOwn = hasOwnProperty$1.call(value, symToStringTag$1),
-      tag = value[symToStringTag$1];
-
-  try {
-    value[symToStringTag$1] = undefined;
-    var unmasked = true;
-  } catch (e) {}
-
-  var result = nativeObjectToString$1.call(value);
-  if (unmasked) {
-    if (isOwn) {
-      value[symToStringTag$1] = tag;
-    } else {
-      delete value[symToStringTag$1];
-    }
-  }
-  return result;
-}
-
-var _getRawTag = getRawTag$1;
-
-/** Used for built-in method references. */
-
-var objectProto$1 = Object.prototype;
-
-/**
- * Used to resolve the
- * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
- * of values.
- */
-var nativeObjectToString = objectProto$1.toString;
-
-/**
- * Converts `value` to a string using `Object.prototype.toString`.
- *
- * @private
- * @param {*} value The value to convert.
- * @returns {string} Returns the converted string.
- */
-function objectToString$1(value) {
-  return nativeObjectToString.call(value);
-}
-
-var _objectToString = objectToString$1;
-
-var Symbol$1 = _Symbol,
-    getRawTag = _getRawTag,
-    objectToString = _objectToString;
-
-/** `Object#toString` result references. */
-var nullTag = '[object Null]',
-    undefinedTag = '[object Undefined]';
-
-/** Built-in value references. */
-var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;
-
-/**
- * The base implementation of `getTag` without fallbacks for buggy environments.
- *
- * @private
- * @param {*} value The value to query.
- * @returns {string} Returns the `toStringTag`.
- */
-function baseGetTag$1(value) {
-  if (value == null) {
-    return value === undefined ? undefinedTag : nullTag;
-  }
-  return (symToStringTag && symToStringTag in Object(value))
-    ? getRawTag(value)
-    : objectToString(value);
+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 _baseGetTag = baseGetTag$1;
+var char = {};
 
-/**
- * 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.
- */
+var string = {};
 
-function overArg$1(func, transform) {
-  return function(arg) {
-    return func(transform(arg));
-  };
+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;
 
-var _overArg = overArg$1;
-
-var overArg = _overArg;
+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;
 
-/** Built-in value references. */
-var getPrototype$1 = overArg(Object.getPrototypeOf, Object);
+var date = {};
 
-var _getPrototype = getPrototype$1;
+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;
 
-/**
- * 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
- */
+var _enum = {};
 
-function isObjectLike$1(value) {
-  return value != null && typeof value == 'object';
+_enum.inEnum = void 0;
+function inEnum(val, _enum) {
+    return Object.values(_enum).includes(val);
 }
+_enum.inEnum = inEnum;
 
-var isObjectLike_1 = isObjectLike$1;
+var error = {};
 
-var baseGetTag = _baseGetTag,
-    getPrototype = _getPrototype,
-    isObjectLike = isObjectLike_1;
+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;
 
-/** `Object#toString` result references. */
-var objectTag = '[object Object]';
+var falsy = {};
 
-/** Used for built-in method references. */
-var funcProto = Function.prototype,
-    objectProto = Object.prototype;
+falsy.isntFalsy = falsy.isFalsy = void 0;
+function isFalsy(val) {
+    return !val;
+}
+falsy.isFalsy = isFalsy;
+function isntFalsy(val) {
+    return !isFalsy(val);
+}
+falsy.isntFalsy = isntFalsy;
 
-/** Used to resolve the decompiled source of functions. */
-var funcToString = funcProto.toString;
+var iterable = {};
 
-/** Used to check objects for own properties. */
-var hasOwnProperty = objectProto.hasOwnProperty;
+iterable.isntIterable = iterable.isIterable = void 0;
+const null_1$1 = _null;
+const undefined_1 = _undefined;
+const function_1$1 = _function;
+function isIterable(val) {
+    return (0, null_1$1.isntNull)(val)
+        && (0, undefined_1.isntUndefined)(val)
+        && (0, function_1$1.isFunction)(val[Symbol.iterator]);
+}
+iterable.isIterable = isIterable;
+function isntIterable(val) {
+    return !isIterable(val);
+}
+iterable.isntIterable = isntIterable;
 
-/** Used to infer the `Object` constructor. */
-var objectCtorString = funcToString.call(Object);
+var json = {};
 
-/**
- * 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(value) || baseGetTag(value) != objectTag) {
-    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 number = {};
+
+number.isntNaN = number.isNaN = number.isNegativeInfinity = number.isPositiveInfinity = number.isFinite = number.isntNumber = number.isNumber = void 0;
+function isNumber(val) {
+    return typeof val === 'number';
+}
+number.isNumber = isNumber;
+function isntNumber(val) {
+    return !isNumber(val);
+}
+number.isntNumber = isntNumber;
+function isFinite(val) {
+    return Number.isFinite(val);
+}
+number.isFinite = isFinite;
+function isPositiveInfinity(val) {
+    return val === Infinity;
+}
+number.isPositiveInfinity = isPositiveInfinity;
+function isNegativeInfinity(val) {
+    return val === -Infinity;
 }
+number.isNegativeInfinity = isNegativeInfinity;
+function isNaN(val) {
+    return Number.isNaN(val);
+}
+number.isNaN = isNaN;
+function isntNaN(val) {
+    return !isNaN(val);
+}
+number.isntNaN = isntNaN;
 
-var isPlainObject_1$1 = isPlainObject$1;
+var object = {};
 
 var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
-const isPlainObject_1 = __importDefault(isPlainObject_1$1);
+const isPlainObject_1 = __importDefault(isPlainObject_1$2);
 function isObject(val) {
     return val !== null
         && typeof val === 'object';
@@ -7563,7 +7942,7 @@ class TrieMap {
         function* dfs(node, paths) {
             for (const [path, childNode] of node.children) {
                 const newPaths = [...paths, path];
-                if (es2018$2.isntUndefined(childNode.value)) {
+                if (es2018$e.isntUndefined(childNode.value)) {
                     yield [newPaths, childNode.value];
                 }
                 yield* dfs(childNode, newPaths);
@@ -7641,6 +8020,9 @@ class FiniteStateMachine {
         this.schema = schema;
         this._state = initialState;
     }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
     get state() {
         return this._state;
     }
@@ -9239,6 +9621,9 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
         super(...arguments);
         this.stateChanges = new Subject();
     }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
     observeStateChanges() {
         return this.stateChanges;
     }
@@ -9250,7 +9635,7 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
         super.send(event);
         const newState = this.state;
         this.stateChanges.next({ event, oldState, newState });
-        if (es2018$2.isEmptyObject(this.schema[newState])) {
+        if (es2018$e.isEmptyObject(this.schema[newState])) {
             this.stateChanges.complete();
         }
     }
@@ -9261,6 +9646,9 @@ class SparseSet {
         this.values = [];
         this.valueToValueIndex = [];
     }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
     *[Symbol.iterator]() {
         for (const value of this.values) {
             yield value;
@@ -9268,7 +9656,7 @@ class SparseSet {
     }
     has(value) {
         // 跟一般的实现不同, 不需要访问values数组.
-        return this.valueToValueIndex[value] !== undefined;
+        return es2018$e.isntUndefined(this.valueToValueIndex[value]);
     }
     add(value) {
         if (!this.has(value)) {
@@ -9291,5 +9679,122 @@ class SparseSet {
     }
 }
 
-export { BadEventError, Box, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SparseSet, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
+// 相关提案: https://github.com/tc39/proposal-resizablearraybuffer
+class DynamicTypedArray {
+    constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
+        this.typedArrayConstructor = typedArrayConstructor;
+        this._length = 0;
+        es2018$d.assert(Number.isInteger(capacity), 'capacity must be an integer');
+        es2018$d.assert(capacity >= 0, 'capacity must be greater than or equal to 0');
+        es2018$d.assert(growthFactor > 1, 'growthFactory must be greater than or equal to 1');
+        this.array = new typedArrayConstructor(capacity);
+        this.growthFactor = growthFactor;
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+    /**
+     * 数组当前的容量.
+     */
+    get capacity() {
+        return this.array.length;
+    }
+    /**
+     * 数组逻辑上的长度, 总是小于或等于capacity.
+     */
+    get length() {
+        return this._length;
+    }
+    set(index, value) {
+        if (index >= this.capacity) {
+            const newCapacity = computeNewCapacity(this.capacity, index + 1, this.growthFactor);
+            this.resize(newCapacity);
+        }
+        if (index >= this._length) {
+            this._length = index + 1;
+        }
+        this.array[index] = value;
+    }
+    get(index) {
+        return index < this._length
+            ? this.array[index]
+            : undefined;
+    }
+    push(...values) {
+        const newLength = this._length + values.length;
+        if (newLength > this.capacity) {
+            const newCapacity = computeNewCapacity(this.capacity, newLength, this.growthFactor);
+            this.resize(newCapacity);
+        }
+        for (const value of values) {
+            this.array[this._length++] = value;
+        }
+    }
+    pop() {
+        if (this._length > 0) {
+            const value = this.array[this._length - 1];
+            this._length--;
+            const newCapacity = computeNewCapacity(this.capacity, this.length, this.growthFactor);
+            this.resize(newCapacity);
+            return value;
+        }
+        else {
+            return undefined;
+        }
+    }
+    resize(newCapacity) {
+        if (this.array.length === newCapacity) {
+            return;
+        }
+        else if (this.array.length < newCapacity) {
+            const newArray = new this.typedArrayConstructor(newCapacity);
+            newArray.set(this.array);
+            this.array = newArray;
+        }
+        else if (this.array.length > newCapacity) {
+            const newArray = new this.typedArrayConstructor(newCapacity);
+            // 不需要的部分将被舍弃.
+            for (let i = newCapacity; i--;) {
+                newArray[i] = this.array[i];
+            }
+            this.array = newArray;
+        }
+    }
+}
+function computeNewCapacity(oldCapacity, targetLength, growthFactor) {
+    if (oldCapacity === targetLength) {
+        return targetLength;
+    }
+    else if (oldCapacity < targetLength) {
+        // 增加容量以适配targetLength
+        let newCapacity = Math.max(oldCapacity, 1);
+        while (newCapacity < targetLength) {
+            newCapacity *= growthFactor;
+        }
+        return Math.floor(newCapacity);
+    }
+    else {
+        // 尝试减少容量以适配targetLength
+        // `targetLength = 0`是特殊情况,
+        // 此时无论怎么将oldCapacity除以growthFactory几次, 都不可能得到比targetLength小的结果.
+        if (targetLength === 0) {
+            return 0;
+        }
+        else {
+            let newCapacity = oldCapacity;
+            while (true) {
+                const temp = newCapacity / growthFactor;
+                if (temp < targetLength) {
+                    break;
+                }
+                else {
+                    newCapacity = temp;
+                }
+            }
+            return Math.floor(newCapacity);
+        }
+    }
+}
+
+export { BadEventError, Box, DynamicTypedArray, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SparseSet, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
 //# sourceMappingURL=index.mjs.map