@aiszlab/relax 1.2.38 → 1.2.39

package/dist/hooks/use-throttle-callback.js

@@ -1,21 +1,30 @@
 import { useRef, useEffect, useMemo } from 'react';
-import { throttle } from '../utils/throttle.js';
+import { throttle } from '../utils/throttle/index.js';
 import { useEvent } from './use-event.js';
 import { isFunction } from '../is/is-function.js';
 import { useDefault } from './use-default.js';
 
-const useThrottler = (debouncer) => {
-    const _debouncer = useMemo(() => {
-        return isFunction(debouncer) ? { callback: debouncer, pipeable: null } : debouncer;
-    }, [debouncer]);
-    return {
-        callback: useEvent((...args) => {
-            return _debouncer.callback(...args);
-        }),
-        pipeable: useEvent((...args) => {
-            return _debouncer.pipeable?.(...args) ?? args;
-        })
-    };
+var useThrottler = function useThrottler(throttler) {
+  var _useMemo = useMemo(function () {
+      return isFunction(throttler) ? {
+        callback: throttler,
+        pipe: null
+      } : throttler;
+    }, [throttler]),
+    callback = _useMemo.callback,
+    pipe = _useMemo.pipe;
+  return {
+    callback: useEvent(function () {
+      return callback.apply(void 0, arguments);
+    }),
+    pipe: useEvent(function () {
+      var _pipe;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return (_pipe = pipe === null || pipe === void 0 ? void 0 : pipe.apply(void 0, args)) !== null && _pipe !== void 0 ? _pipe : args;
+    })
+  };
 };
 /**
  * @author murukal
@@ -24,34 +33,51 @@ const useThrottler = (debouncer) => {
  * throttle callback
  *
  * @param callback
- * @param duration number
+ * @param wait number
  * @description
- * The duration time (in milliseconds) until the throttle function is called.
+ * The wait time (in milliseconds) until the throttle function is called.
  * default 1000
  *
  * @example
  * 1000
  */
-const useThrottleCallback = (throttler, duration = 1000) => {
-    const throttled = useRef(null);
-    const { callback, pipeable } = useThrottler(throttler);
-    useEffect(() => {
-        const _throttled = throttle({
-            callback,
-            pipeable
-        }, duration);
-        throttled.current = _throttled;
-        // dispose
-        return () => {
-            _throttled.abort();
-            throttled.current = null;
-        };
-    }, [duration]);
-    return useDefault(() => ({
-        next: (...args) => throttled.current?.next(...args),
-        flush: () => throttled.current?.flush(),
-        abort: () => throttled.current?.abort()
-    }));
+var useThrottleCallback = function useThrottleCallback(throttler) {
+  var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;
+  var throttled = useRef(null);
+  var _useThrottler = useThrottler(throttler),
+    callback = _useThrottler.callback,
+    pipe = _useThrottler.pipe;
+  useEffect(function () {
+    var _throttled = throttle({
+      callback: callback,
+      pipe: pipe
+    }, wait);
+    throttled.current = _throttled;
+    // dispose
+    return function () {
+      _throttled.abort();
+      throttled.current = null;
+    };
+  }, [wait]);
+  return useDefault(function () {
+    return {
+      next: function next() {
+        var _throttled$current;
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return (_throttled$current = throttled.current) === null || _throttled$current === void 0 ? void 0 : _throttled$current.next.apply(_throttled$current, args);
+      },
+      flush: function flush() {
+        var _throttled$current2;
+        return (_throttled$current2 = throttled.current) === null || _throttled$current2 === void 0 ? void 0 : _throttled$current2.flush();
+      },
+      abort: function abort() {
+        var _throttled$current3;
+        return (_throttled$current3 = throttled.current) === null || _throttled$current3 === void 0 ? void 0 : _throttled$current3.abort();
+      }
+    };
+  });
 };
 
 export { useThrottleCallback };

package/dist/hooks/use-timeout.js

@@ -6,15 +6,14 @@ import { useEffect } from 'react';
  * @description
  * timeout effect
  */
-const useTimeout = (handler, wait) => {
-    useEffect(() => {
-        const timer = setTimeout(handler, wait);
-        return () => {
-            if (!timer)
-                return;
-            clearTimeout(timer);
-        };
-    }, [wait]);
+var useTimeout = function useTimeout(handler, wait) {
+  useEffect(function () {
+    var timer = setTimeout(handler, wait);
+    return function () {
+      if (!timer) return;
+      clearTimeout(timer);
+    };
+  }, [wait]);
 };
 
 export { useTimeout };

package/dist/hooks/use-toggleable.js

@@ -1,145 +1,186 @@
+import { objectWithoutProperties as _objectWithoutProperties, slicedToArray as _slicedToArray, createClass as _createClass, classPrivateFieldGet2 as _classPrivateFieldGet2, classCallCheck as _classCallCheck, classPrivateFieldInitSpec as _classPrivateFieldInitSpec, classPrivateFieldSet2 as _classPrivateFieldSet2 } from '../_virtual/_rollupPluginBabelHelpers.js';
 import { useMemo, useCallback } from 'react';
 import { useControlledState } from './use-controlled-state.js';
 
-class Tree {
-    #groupedLeaves;
-    constructor() {
-        this.#groupedLeaves = new Map();
+var _excluded = ["onToggle"];
+var _groupedLeaves = /*#__PURE__*/new WeakMap();
+var Tree = /*#__PURE__*/function () {
+  function Tree() {
+    _classCallCheck(this, Tree);
+    _classPrivateFieldInitSpec(this, _groupedLeaves, void 0);
+    _classPrivateFieldSet2(_groupedLeaves, this, new Map());
+  }
+  return _createClass(Tree, [{
+    key: "groupedLeaves",
+    get: function get() {
+      return _classPrivateFieldGet2(_groupedLeaves, this);
     }
-    get groupedLeaves() {
-        return this.#groupedLeaves;
+  }, {
+    key: "grow",
+    value: function grow(toggleableKey) {
+      // create leaf, leaf will auto trigger tree collect callback
+      new Leaf({
+        key: toggleableKey.key,
+        parent: null,
+        belongTo: this
+      }).grow(toggleableKey.children);
+      return this;
     }
-    grow(toggleableKey) {
-        // create leaf, leaf will auto trigger tree collect callback
-        new Leaf({
-            key: toggleableKey.key,
-            parent: null,
-            belongTo: this
-        }).grow(toggleableKey.children);
-        return this;
+  }, {
+    key: "collect",
+    value: function collect(leaf) {
+      _classPrivateFieldGet2(_groupedLeaves, this).has(leaf.key) ? _classPrivateFieldGet2(_groupedLeaves, this).get(leaf.key).add(leaf) : _classPrivateFieldGet2(_groupedLeaves, this).set(leaf.key, new Set([leaf]));
     }
-    collect(leaf) {
-        this.#groupedLeaves.has(leaf.key)
-            ? this.#groupedLeaves.get(leaf.key).add(leaf)
-            : this.#groupedLeaves.set(leaf.key, new Set([leaf]));
+  }, {
+    key: "toggle",
+    value: function toggle(key, toggledKeys) {
+      var hasToggled = toggledKeys.has(key);
+      var _isToggled = !hasToggled;
+      return this.toggleBy(key, _isToggled, toggledKeys);
     }
-    toggle(key, toggledKeys) {
-        const hasToggled = toggledKeys.has(key);
-        const _isToggled = !hasToggled;
-        return this.toggleBy(key, _isToggled, toggledKeys);
-    }
-    toggleBy(key, isToggled, toggledKeys) {
-        return Array.from(this.#groupedLeaves.get(key) ?? []).reduce((prev, leaf) => {
-            // deep fall, add or remove child key
-            const fell = leaf.fall(isToggled, prev);
-            // deep rise, add or remove parent key
-            const rised = leaf.rise(fell);
-            return rised;
-        }, new Set(toggledKeys));
+  }, {
+    key: "toggleBy",
+    value: function toggleBy(key, isToggled, toggledKeys) {
+      var _classPrivateFieldGet2$1;
+      return Array.from((_classPrivateFieldGet2$1 = _classPrivateFieldGet2(_groupedLeaves, this).get(key)) !== null && _classPrivateFieldGet2$1 !== void 0 ? _classPrivateFieldGet2$1 : []).reduce(function (prev, leaf) {
+        // deep fall, add or remove child key
+        var fell = leaf.fall(isToggled, prev);
+        // deep rise, add or remove parent key
+        var rised = leaf.rise(fell);
+        return rised;
+      }, new Set(toggledKeys));
     }
-}
-class Leaf {
-    #key;
-    #belongTo;
-    #parent;
-    #children;
-    constructor(props) {
-        this.#key = props.key;
-        this.#parent = props.parent;
-        this.#belongTo = props.belongTo;
-        this.#children = [];
-        // when leaf has grew, let tree collect leaf
-        this.#belongTo.collect(this);
+  }]);
+}();
+var _key = /*#__PURE__*/new WeakMap();
+var _belongTo = /*#__PURE__*/new WeakMap();
+var _parent = /*#__PURE__*/new WeakMap();
+var _children = /*#__PURE__*/new WeakMap();
+var Leaf = /*#__PURE__*/function () {
+  function Leaf(props) {
+    _classCallCheck(this, Leaf);
+    _classPrivateFieldInitSpec(this, _key, void 0);
+    _classPrivateFieldInitSpec(this, _belongTo, void 0);
+    _classPrivateFieldInitSpec(this, _parent, void 0);
+    _classPrivateFieldInitSpec(this, _children, void 0);
+    _classPrivateFieldSet2(_key, this, props.key);
+    _classPrivateFieldSet2(_parent, this, props.parent);
+    _classPrivateFieldSet2(_belongTo, this, props.belongTo);
+    _classPrivateFieldSet2(_children, this, []);
+    // when leaf has grew, let tree collect leaf
+    _classPrivateFieldGet2(_belongTo, this).collect(this);
+  }
+  return _createClass(Leaf, [{
+    key: "key",
+    get: function get() {
+      return _classPrivateFieldGet2(_key, this);
     }
-    get key() {
-        return this.#key;
+  }, {
+    key: "grow",
+    value: function grow() {
+      var _this = this;
+      var toggleableKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+      if (toggleableKeys.length > 0) {
+        toggleableKeys.forEach(function (_toggleableKey) {
+          var child = new Leaf({
+            key: _toggleableKey.key,
+            parent: _this,
+            belongTo: _classPrivateFieldGet2(_belongTo, _this)
+          }).grow(_toggleableKey.children);
+          _classPrivateFieldGet2(_children, _this).push(child);
+        });
+      }
+      return this;
     }
-    grow(toggleableKeys = []) {
-        if (toggleableKeys.length > 0) {
-            toggleableKeys.forEach((_toggleableKey) => {
-                const child = new Leaf({
-                    key: _toggleableKey.key,
-                    parent: this,
-                    belongTo: this.#belongTo
-                }).grow(_toggleableKey.children);
-                this.#children.push(child);
-            });
-        }
-        return this;
+  }, {
+    key: "rise",
+    value: function rise(toggledKeys) {
+      // if current key is toggled or children is all toggled
+      // just add current key into toggled keys
+      // else remove current key
+      var isToggled = toggledKeys.has(_classPrivateFieldGet2(_key, this)) || _classPrivateFieldGet2(_children, this).every(function (child) {
+        return toggledKeys.has(child.key);
+      });
+      var rised = new Set(toggledKeys);
+      if (isToggled) {
+        rised.add(_classPrivateFieldGet2(_key, this));
+      } else {
+        rised["delete"](_classPrivateFieldGet2(_key, this));
+      }
+      if (_classPrivateFieldGet2(_parent, this)) {
+        return _classPrivateFieldGet2(_parent, this).rise(rised);
+      }
+      return rised;
     }
-    rise(toggledKeys) {
-        // if current key is toggled or children is all toggled
-        // just add current key into toggled keys
-        // else remove current key
-        const isToggled = toggledKeys.has(this.#key) || this.#children.every((child) => toggledKeys.has(child.key));
-        const rised = new Set(toggledKeys);
+  }, {
+    key: "fall",
+    value: function fall(isToggled, toggledKeys) {
+      var _this2 = this;
+      return _classPrivateFieldGet2(_children, this).reduce(function (prev, leaf) {
+        // deep loop, remove or add key
+        var fell = leaf.fall(isToggled, prev);
+        // toggle true, add key
+        // toggle false, remove key
         if (isToggled) {
-            rised.add(this.#key);
-        }
-        else {
-            rised.delete(this.#key);
+          fell.add(_classPrivateFieldGet2(_key, _this2));
+        } else {
+          fell["delete"](_classPrivateFieldGet2(_key, _this2));
         }
-        if (this.#parent) {
-            return this.#parent.rise(rised);
-        }
-        return rised;
+        return fell;
+      }, new Set(toggledKeys));
     }
-    fall(isToggled, toggledKeys) {
-        return this.#children.reduce((prev, leaf) => {
-            // deep loop, remove or add key
-            const fell = leaf.fall(isToggled, prev);
-            // toggle true, add key
-            // toggle false, remove key
-            if (isToggled) {
-                fell.add(this.#key);
-            }
-            else {
-                fell.delete(this.#key);
-            }
-            return fell;
-        }, new Set(toggledKeys));
-    }
-}
+  }]);
+}();
 /**
  * @description
  * toggle able
  */
-const useToggleable = (toggleableKeys, { onToggle, ...options } = {}) => {
-    /// re-create tree when toggleable keys changed
-    const tree = useMemo(() => {
-        return toggleableKeys.reduce((_tree, toggleable) => {
-            return _tree.grow(toggleable);
-        }, new Tree());
-    }, [toggleableKeys]);
-    /// use controlled state to record toggled keys
-    const [_toggledKeys, _setToggledKeys] = useControlledState(options.toggledKeys, {
-        defaultState: () => {
-            return options.isDefaultToggled
-                ? Array.from(Array.from(tree.groupedLeaves.values()).reduce((prev, leaves) => {
-                    leaves.forEach((leaf) => prev.add(leaf.key));
-                    return prev;
-                }, new Set()))
-                : [];
-        }
-    });
-    /// use set for toggled keys to make it read-only
-    const readableToggledKeys = useMemo(() => new Set(_toggledKeys), [_toggledKeys]);
-    /// check current key is toggled
-    const isToggled = useCallback((key) => !readableToggledKeys || readableToggledKeys.has(key), [readableToggledKeys]);
-    /// toggle one key
-    const toggle = useCallback((key) => {
-        // get new toggled keys by toggle current key
-        const _toggledKeys = Array.from(tree.toggle(key, readableToggledKeys));
-        // set state
-        _setToggledKeys(_toggledKeys);
-        // trigger on toggle callback
-        onToggle?.(_toggledKeys);
-    }, [tree, readableToggledKeys, _setToggledKeys, onToggle]);
-    return {
-        toggledKeys: readableToggledKeys,
-        isToggled,
-        toggle
-    };
+var useToggleable = function useToggleable(toggleableKeys) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    onToggle = _ref.onToggle,
+    options = _objectWithoutProperties(_ref, _excluded);
+  /// re-create tree when toggleable keys changed
+  var tree = useMemo(function () {
+    return toggleableKeys.reduce(function (_tree, toggleable) {
+      return _tree.grow(toggleable);
+    }, new Tree());
+  }, [toggleableKeys]);
+  /// use controlled state to record toggled keys
+  var _useControlledState = useControlledState(options.toggledKeys, {
+      defaultState: function defaultState() {
+        return options.isDefaultToggled ? Array.from(Array.from(tree.groupedLeaves.values()).reduce(function (prev, leaves) {
+          leaves.forEach(function (leaf) {
+            return prev.add(leaf.key);
+          });
+          return prev;
+        }, new Set())) : [];
+      }
+    }),
+    _useControlledState2 = _slicedToArray(_useControlledState, 2),
+    _toggledKeys = _useControlledState2[0],
+    _setToggledKeys = _useControlledState2[1];
+  /// use set for toggled keys to make it read-only
+  var readableToggledKeys = useMemo(function () {
+    return new Set(_toggledKeys);
+  }, [_toggledKeys]);
+  /// check current key is toggled
+  var isToggled = useCallback(function (key) {
+    return !readableToggledKeys || readableToggledKeys.has(key);
+  }, [readableToggledKeys]);
+  /// toggle one key
+  var toggle = useCallback(function (key) {
+    // get new toggled keys by toggle current key
+    var _toggledKeys = Array.from(tree.toggle(key, readableToggledKeys));
+    // set state
+    _setToggledKeys(_toggledKeys);
+    // trigger on toggle callback
+    onToggle === null || onToggle === void 0 || onToggle(_toggledKeys);
+  }, [tree, readableToggledKeys, _setToggledKeys, onToggle]);
+  return {
+    toggledKeys: readableToggledKeys,
+    isToggled: isToggled,
+    toggle: toggle
+  };
 };
 
 export { useToggleable };

package/dist/hooks/use-update-effect.js

@@ -1,20 +1,19 @@
 import { useRef, useEffect } from 'react';
 import { useMounted } from './use-mounted.js';
-import { effect } from '../utils/effect.js';
+import { effect } from '../utils/effect/index.js';
 
-const useUpdateEffect = (callback, deps) => {
-    const isMounted = useRef(false);
-    useEffect(() => {
-        if (!isMounted.current)
-            return;
-        return effect(callback);
-    }, deps);
-    useMounted(() => {
-        isMounted.current = true;
-        return () => {
-            isMounted.current = false;
-        };
-    });
+var useUpdateEffect = function useUpdateEffect(callback, deps) {
+  var isMounted = useRef(false);
+  useEffect(function () {
+    if (!isMounted.current) return;
+    return effect(callback);
+  }, deps);
+  useMounted(function () {
+    isMounted.current = true;
+    return function () {
+      isMounted.current = false;
+    };
+  });
 };
 
 export { useUpdateEffect };

package/dist/index.d.ts

@@ -52,3 +52,4 @@ export { chain } from './utils/chain';
 export { debounce } from './utils/debounce';
 export { toArray } from './utils/to-array';
 export { toFunction } from './utils/to-function';
+export { exclude } from './utils/exclude';

package/dist/index.js

@@ -31,12 +31,13 @@ export { isMobile } from './is/is-mobile.js';
 export { isOverflow } from './is/is-overflow.js';
 export { isStyleElement } from './is/is-style-element.js';
 export { isFunction } from './is/is-function.js';
-export { isThenable } from './is/is-thenable.js';
-export { effect } from './utils/effect.js';
+export { isThenable } from './is/is-thenable/index.js';
+export { effect } from './utils/effect/index.js';
 export { unique, uniqueBy } from './utils/unique.js';
 export { range } from './utils/range.js';
-export { clamp } from './utils/clamp.js';
-export { chain } from './utils/chain.js';
-export { debounce } from './utils/debounce.js';
-export { toArray } from './utils/to-array.js';
+export { clamp } from './utils/clamp/index.js';
+export { chain } from './utils/chain/index.js';
+export { debounce } from './utils/debounce/index.js';
+export { toArray } from './utils/to-array/index.js';
 export { toFunction } from './utils/to-function.js';
+export { exclude } from './utils/exclude/index.js';

package/dist/is/is-array.js

@@ -2,8 +2,8 @@
  * @description
  * is array
  */
-const isArray = (value) => {
-    return Array.isArray(value);
+var isArray = function isArray(value) {
+  return Array.isArray(value);
 };
 
 export { isArray };

package/dist/is/is-complex.js

@@ -1,9 +1,11 @@
+import { typeof as _typeof } from '../_virtual/_rollupPluginBabelHelpers.js';
+
 /**
  * @description
  * complex
  */
-const isComplex = (value) => {
-    return typeof value === 'object' || typeof value === 'function';
+var isComplex = function isComplex(value) {
+  return _typeof(value) === 'object' || typeof value === 'function';
 };
 
 export { isComplex };

package/dist/is/is-dom-usable.js

@@ -2,8 +2,8 @@
  * @description
  * if there is dom
  */
-const isDomUsable = () => {
-    return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+var isDomUsable = function isDomUsable() {
+  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
 };
 
 export { isDomUsable };

package/dist/is/is-empty.js

@@ -1,3 +1,4 @@
+import { typeof as _typeof } from '../_virtual/_rollupPluginBabelHelpers.js';
 import { isVoid } from './is-void.js';
 import { isArray } from './is-array.js';
 
@@ -7,19 +8,18 @@ import { isArray } from './is-array.js';
  * @description
  * is empty
  */
-const isEmpty = (value) => {
-    // null or undefined
-    if (isVoid(value))
-        return true;
-    // object
-    if (typeof value === 'object') {
-        return Object.keys(value).length === 0;
-    }
-    // array
-    if (isArray(value)) {
-        return value.length === 0;
-    }
-    return !!value;
+var isEmpty = function isEmpty(value) {
+  // null or undefined
+  if (isVoid(value)) return true;
+  // object
+  if (_typeof(value) === 'object') {
+    return Object.keys(value).length === 0;
+  }
+  // array
+  if (isArray(value)) {
+    return value.length === 0;
+  }
+  return !!value;
 };
 
 export { isEmpty };

package/dist/is/is-function.js

@@ -2,8 +2,8 @@
  * @description
  * if is function
  */
-const isFunction = (value) => {
-    return typeof value === 'function';
+var isFunction = function isFunction(value) {
+  return typeof value === 'function';
 };
 
 export { isFunction };

package/dist/is/is-mobile.js

@@ -2,15 +2,12 @@
  * @description
  * is mobile
  */
-const isMobile = () => {
-    if (typeof navigator === 'undefined' || typeof window === 'undefined') {
-        return false;
-    }
-    const agent = navigator.userAgent ||
-        navigator.vendor ||
-        window.opera;
-    return (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(agent) ||
-        /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(agent?.substring(0, 4)));
+var isMobile = function isMobile() {
+  if (typeof navigator === 'undefined' || typeof window === 'undefined') {
+    return false;
+  }
+  var agent = navigator.userAgent || navigator.vendor || window.opera;
+  return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(agent) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(agent === null || agent === void 0 ? void 0 : agent.substring(0, 4));
 };
 
 export { isMobile };

package/dist/is/is-null.js

@@ -2,8 +2,8 @@
  * @description
  * is null
  */
-const isNull = (value) => {
-    return value === null;
+var isNull = function isNull(value) {
+  return value === null;
 };
 
 export { isNull };