@blackglory/structures 0.6.4 → 0.6.7

package/dist/es2015/index.umd.js

@@ -8,6 +8,9 @@
         constructor(value) {
             this.value = value;
         }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
         set(value) {
             this.value = value;
         }
@@ -16,10 +19,629 @@
         }
     }
 
+    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];
@@ -153,8 +775,6 @@
         }
     }
 
-    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
     var es2018$d = {};
 
     var customError$2 = {};
@@ -500,7 +1120,7 @@
      */
 
     /** `Object#toString` result references. */
-    var objectTag$1 = '[object Object]';
+    var objectTag = '[object Object]';
 
     /**
      * Checks if `value` is a host object in IE < 9.
@@ -529,34 +1149,34 @@
      * @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`
@@ -582,7 +1202,7 @@
      * _.isObjectLike(null);
      * // => false
      */
-    function isObjectLike$2(value) {
+    function isObjectLike(value) {
       return !!value && typeof value == 'object';
     }
 
@@ -614,21 +1234,21 @@
      * _.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 };
@@ -643,12 +1263,12 @@
         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) {
@@ -4803,387 +5423,146 @@
         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);
+
+    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';
@@ -7569,7 +7948,7 @@
             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);
@@ -7647,6 +8026,9 @@
             this.schema = schema;
             this._state = initialState;
         }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
         get state() {
             return this._state;
         }
@@ -9245,6 +9627,9 @@
             super(...arguments);
             this.stateChanges = new Subject();
         }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
         observeStateChanges() {
             return this.stateChanges;
         }
@@ -9256,7 +9641,7 @@
             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();
             }
         }
@@ -9267,6 +9652,9 @@
             this.values = [];
             this.valueToValueIndex = [];
         }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
         *[Symbol.iterator]() {
             for (const value of this.values) {
                 yield value;
@@ -9274,7 +9662,7 @@
         }
         has(value) {
             // 跟一般的实现不同, 不需要访问values数组.
-            return es2018$2.isntUndefined(this.valueToValueIndex[value]);
+            return es2018$e.isntUndefined(this.valueToValueIndex[value]);
         }
         add(value) {
             if (!this.has(value)) {
@@ -9297,8 +9685,129 @@
         }
     }
 
+    // 相关提案: 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 internalTypedArray() {
+            return this.array;
+        }
+        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);
+            }
+        }
+    }
+
     exports.BadEventError = BadEventError;
     exports.Box = Box;
+    exports.DynamicTypedArray = DynamicTypedArray;
     exports.Emitter = Emitter;
     exports.ExpirableMap = ExpirableMap;
     exports.FiniteStateMachine = FiniteStateMachine;