@aiszlab/relax 1.2.37 → 1.2.39

package/dist/hooks/use-refs.js

@@ -0,0 +1,25 @@
+import { useMemo } from 'react';
+import { isFunction } from '../is/is-function.js';
+
+var mount = function mount(ref, trigger) {
+  if (isFunction(ref)) {
+    ref(trigger);
+    return;
+  }
+  ref.current = trigger;
+};
+var useRefs = function useRefs() {
+  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+    refs[_key] = arguments[_key];
+  }
+  return useMemo(function () {
+    return function (trigger) {
+      refs.forEach(function (ref) {
+        if (!ref) return;
+        mount(ref, trigger);
+      });
+    };
+  }, refs);
+};
+
+export { useRefs };

package/dist/hooks/use-scroll-locker.js

@@ -0,0 +1,92 @@
+import { createClass as _createClass, classPrivateFieldGet2 as _classPrivateFieldGet2, classPrivateFieldSet2 as _classPrivateFieldSet2, classCallCheck as _classCallCheck, classPrivateFieldInitSpec as _classPrivateFieldInitSpec } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { useLayoutEffect } from 'react';
+import { isOverflow } from '../is/is-overflow.js';
+import { setStyle } from '../utils/set-style.js';
+
+var _barSize = /*#__PURE__*/new WeakMap();
+var _locked = /*#__PURE__*/new WeakMap();
+var ScrollLocker = /*#__PURE__*/function () {
+  function ScrollLocker() {
+    var _scrollLocker$_;
+    _classCallCheck(this, ScrollLocker);
+    // bar size
+    _classPrivateFieldInitSpec(this, _barSize, null);
+    // locked elements, with previous styles
+    _classPrivateFieldInitSpec(this, _locked, new Map());
+    return (_scrollLocker$_ = _scrollLocker._) !== null && _scrollLocker$_ !== void 0 ? _scrollLocker$_ : _scrollLocker._ = this;
+  }
+  return _createClass(ScrollLocker, [{
+    key: "barSize",
+    get: function get() {
+      if (_classPrivateFieldGet2(_barSize, this)) return _classPrivateFieldGet2(_barSize, this);
+      // how to calculate dom scroll bar size
+      // create a backend dom element, set force scrollable
+      var _target = document.createElement('div');
+      _target.attributeStyleMap.set('position', 'absolute');
+      _target.attributeStyleMap.set('left', '0');
+      _target.attributeStyleMap.set('top', '0');
+      _target.attributeStyleMap.set('width', '100vw');
+      _target.attributeStyleMap.set('height', '100vh');
+      _target.attributeStyleMap.set('overflow', 'scroll');
+      // calculate, then clear
+      document.body.appendChild(_target);
+      _classPrivateFieldSet2(_barSize, this, {
+        width: _target.offsetWidth - _target.clientWidth,
+        height: _target.offsetHeight - _target.clientHeight
+      });
+      document.body.removeChild(_target);
+      return _classPrivateFieldGet2(_barSize, this);
+    }
+  }, {
+    key: "isOverflow",
+    get: function get() {
+      return isOverflow();
+    }
+  }, {
+    key: "lock",
+    value: function lock() {
+      var element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document.body;
+      // if locked, do not lock again
+      if (_classPrivateFieldGet2(_locked, this).has(element)) return;
+      // if target is not scrollable, do not lock
+      if (!isOverflow(element)) return;
+      _classPrivateFieldGet2(_locked, this).set(element, setStyle(element, {
+        overflow: 'hidden',
+        width: "calc(100% - ".concat(this.barSize.width, "px)")
+      }));
+    }
+  }, {
+    key: "unlock",
+    value: function unlock() {
+      var element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document.body;
+      // not locked, no need to unlock
+      if (!_classPrivateFieldGet2(_locked, this).has(element)) return;
+      // reset style, in lock, some styled are setted
+      setStyle(element, _classPrivateFieldGet2(_locked, this).get(element));
+      _classPrivateFieldGet2(_locked, this)["delete"](element);
+    }
+  }]);
+}();
+/**
+ * @description
+ * hooks
+ */
+// singleton mode
+var _scrollLocker = {
+  _: null
+};
+var useScrollLocker = function useScrollLocker(isLock) {
+  useLayoutEffect(function () {
+    var scrollLocker = new ScrollLocker();
+    if (!!isLock) {
+      scrollLocker.lock(document.body);
+    } else {
+      scrollLocker.unlock(document.body);
+    }
+    return function () {
+      scrollLocker.unlock(document.body);
+    };
+  }, [!!isLock]);
+};
+
+export { useScrollLocker };

package/dist/hooks/use-scrollable.js

@@ -0,0 +1,43 @@
+import { useRef, useCallback } from 'react';
+import { scrollTo } from '../dom/scroll-to.js';
+
+/**
+ * @description
+ * scrollable hook
+ */
+var useScrollable = function useScrollable() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$direction = _ref.direction,
+    direction = _ref$direction === void 0 ? 'vertical' : _ref$direction;
+  var targetRef = useRef(null);
+  var triggerRefs = useRef(new Map());
+  var scrollTo$1 = useCallback(function (to) {
+    var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    var target = targetRef.current;
+    if (!target) return;
+    // use animated scroll
+    scrollTo(target, to, {
+      duration: duration,
+      direction: direction
+    });
+  }, [direction]);
+  var to = useCallback(function (key) {
+    var trigger = triggerRefs.current.get(key);
+    if (!trigger) return 0;
+    // different direction, use different property
+    return direction === 'vertical' ? trigger.offsetTop : trigger.offsetLeft;
+  }, [direction]);
+  /// set trigger
+  var setTrigger = useCallback(function (key, trigger) {
+    triggerRefs.current.set(key, trigger);
+  }, []);
+  return {
+    targetRef: targetRef,
+    triggerRefs: triggerRefs,
+    scrollTo: scrollTo$1,
+    to: to,
+    setTrigger: setTrigger
+  };
+};
+
+export { useScrollable };

package/dist/hooks/use-throttle-callback.d.ts

@@ -7,12 +7,12 @@ import { type Callable } from './use-event';
  * 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
  */
-export declare const useThrottleCallback: <T extends Callable, R extends unknown[] = Parameters<T>>(throttler: T | Throttler<T, R>, duration?: number) => Throttled<T>;
+export declare const useThrottleCallback: <T extends Callable, R extends unknown[] = Parameters<T>>(throttler: T | Throttler<T, R>, wait?: number) => Throttled<T>;

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

@@ -0,0 +1,83 @@
+import { useRef, useEffect, useMemo } from 'react';
+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';
+
+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
+ *
+ * @description
+ * throttle callback
+ *
+ * @param callback
+ * @param wait number
+ * @description
+ * The wait time (in milliseconds) until the throttle function is called.
+ * default 1000
+ *
+ * @example
+ * 1000
+ */
+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

@@ -0,0 +1,19 @@
+import { useEffect } from 'react';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * timeout effect
+ */
+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

@@ -0,0 +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';
+
+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);
+    }
+  }, {
+    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;
+    }
+  }, {
+    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]));
+    }
+  }, {
+    key: "toggle",
+    value: function toggle(key, toggledKeys) {
+      var hasToggled = toggledKeys.has(key);
+      var _isToggled = !hasToggled;
+      return this.toggleBy(key, _isToggled, 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));
+    }
+  }]);
+}();
+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);
+    }
+  }, {
+    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;
+    }
+  }, {
+    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;
+    }
+  }, {
+    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) {
+          fell.add(_classPrivateFieldGet2(_key, _this2));
+        } else {
+          fell["delete"](_classPrivateFieldGet2(_key, _this2));
+        }
+        return fell;
+      }, new Set(toggledKeys));
+    }
+  }]);
+}();
+/**
+ * @description
+ * toggle able
+ */
+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

@@ -0,0 +1,19 @@
+import { useRef, useEffect } from 'react';
+import { useMounted } from './use-mounted.js';
+import { effect } from '../utils/effect/index.js';
+
+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

@@ -0,0 +1,43 @@
+export { useBoolean } from './hooks/use-boolean.js';
+export { useDebounceCallback } from './hooks/use-debounce-callback.js';
+export { useThrottleCallback } from './hooks/use-throttle-callback.js';
+export { useImageLoader } from './hooks/use-image-loader.js';
+export { useMount } from './hooks/use-mount.js';
+export { useMounted } from './hooks/use-mounted.js';
+export { useTimeout } from './hooks/use-timeout.js';
+export { useControlledState } from './hooks/use-controlled-state.js';
+export { useDefault } from './hooks/use-default.js';
+export { useScrollLocker } from './hooks/use-scroll-locker.js';
+export { useForceUpdate } from './hooks/use-force-update.js';
+export { useScrollable } from './hooks/use-scrollable.js';
+export { useRefs } from './hooks/use-refs.js';
+export { useToggleable } from './hooks/use-toggleable.js';
+export { useEvent } from './hooks/use-event.js';
+export { useUpdateEffect } from './hooks/use-update-effect.js';
+export { useCounter } from './hooks/use-counter.js';
+export { useHover } from './hooks/use-hover.js';
+export { useFocus } from './hooks/use-focus.js';
+export { useMemorable } from './hooks/use-memorable.js';
+export { isRefable } from './is/is-refable.js';
+export { isUndefined } from './is/is-undefined.js';
+export { isStateGetter } from './is/is-state-getter.js';
+export { isNull } from './is/is-null.js';
+export { isVoid } from './is/is-void.js';
+export { isArray } from './is/is-array.js';
+export { isComplex } from './is/is-complex.js';
+export { isEmpty } from './is/is-empty.js';
+export { isDomUsable } from './is/is-dom-usable.js';
+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/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/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

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is array
+ */
+var isArray = function isArray(value) {
+  return Array.isArray(value);
+};
+
+export { isArray };

package/dist/is/is-complex.js

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

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

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

package/dist/is/is-empty.js

@@ -0,0 +1,25 @@
+import { typeof as _typeof } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { isVoid } from './is-void.js';
+import { isArray } from './is-array.js';
+
+/**
+ * @author murukal
+ *
+ * @description
+ * is empty
+ */
+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

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * if is function
+ */
+var isFunction = function isFunction(value) {
+  return typeof value === 'function';
+};
+
+export { isFunction };

package/dist/is/is-mobile.js

@@ -0,0 +1,13 @@
+/**
+ * @description
+ * is mobile
+ */
+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

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * is null
+ */
+var isNull = function isNull(value) {
+  return value === null;
+};
+
+export { isNull };

package/dist/is/is-overflow.js

@@ -0,0 +1,14 @@
+/**
+ * @description
+ * if is overflow
+ */
+function isOverflow() {
+  var element = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document.body;
+  if (element === document.body) {
+    return document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight) && window.innerWidth > document.body.offsetWidth;
+  }
+  // not body
+  return element.scrollHeight > element.clientHeight;
+}
+
+export { isOverflow };