@aiszlab/relax 2.0.3 → 2.0.5

package/dist/class-name/normalize.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var _createForOfIteratorHelper = require('@babel/runtime/helpers/createForOfIteratorHelper');
 var isString = require('../is/is-string.cjs');
 
@@ -11,13 +10,12 @@ function normalize() {
   }
   for (var _i = 0, _classNames2 = classNames; _i < _classNames2.length; _i++) {
     var _classNames = _classNames2[_i];
-    if (!isString.isString(_classNames)) return;
+    if (!isString.isString(_classNames)) continue;
     var _iterator = _createForOfIteratorHelper(_classNames.matchAll(/\S+/g)),
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _step$value = _slicedToArray(_step.value, 1),
-          className = _step$value[0];
+        var className = _step.value[0];
         values.add(className);
       }
     } catch (err) {

package/dist/class-name/normalize.d.ts

@@ -1,2 +1,3 @@
-declare function normalize(...classNames: string[]): string[] | undefined;
+import type { Partialable } from "../types";
+declare function normalize(...classNames: Partialable<string>[]): string[];
 export { normalize };

package/dist/class-name/normalize.mjs

@@ -1,4 +1,3 @@
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _createForOfIteratorHelper from '@babel/runtime/helpers/createForOfIteratorHelper';
 import { isString } from '../is/is-string.mjs';
 
@@ -9,13 +8,12 @@ function normalize() {
   }
   for (var _i = 0, _classNames2 = classNames; _i < _classNames2.length; _i++) {
     var _classNames = _classNames2[_i];
-    if (!isString(_classNames)) return;
+    if (!isString(_classNames)) continue;
     var _iterator = _createForOfIteratorHelper(_classNames.matchAll(/\S+/g)),
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var _step$value = _slicedToArray(_step.value, 1),
-          className = _step$value[0];
+        var className = _step.value[0];
         values.add(className);
       }
     } catch (err) {

package/dist/decimal/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @description divide
+ */
+export declare function divide(a: number, b: number): number;

package/dist/hooks/use-click-away.d.ts

@@ -1,8 +1,8 @@
-import { type MutableRefObject } from "react";
+import { type RefObject } from "react";
 import { type Containable } from "../dom";
 import type { Nullable, Arrayable } from "@aiszlab/relax/types";
 /**
  * @description
  * click away
  */
-export declare const useClickAway: (onClickAway: (event: MouseEvent) => void, target: Arrayable<MutableRefObject<Nullable<Containable>> | false>) => void;
+export declare const useClickAway: (onClickAway: (event: MouseEvent) => void, target: Arrayable<RefObject<Nullable<Containable>> | false>) => void;

package/dist/hooks/use-lazy-ref.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var react = require('react');
+
+/**
+ * in react, ref always need a initial value
+ * but can not be a function
+ * so we create a lazy ref to get a value getter
+ */
+function useLazyRef(getter) {
+  var ref = react.useRef(null);
+  return function () {
+    var _ref$current;
+    return (_ref$current = ref.current) !== null && _ref$current !== void 0 ? _ref$current : ref.current = getter();
+  };
+}
+
+exports.useLazyRef = useLazyRef;

package/dist/hooks/use-lazy-ref.d.ts

@@ -0,0 +1,7 @@
+/**
+ * in react, ref always need a initial value
+ * but can not be a function
+ * so we create a lazy ref to get a value getter
+ */
+declare function useLazyRef<T>(getter: () => T): () => T;
+export { useLazyRef };

package/dist/hooks/use-lazy-ref.mjs

@@ -0,0 +1,16 @@
+import { useRef } from 'react';
+
+/**
+ * in react, ref always need a initial value
+ * but can not be a function
+ * so we create a lazy ref to get a value getter
+ */
+function useLazyRef(getter) {
+  var ref = useRef(null);
+  return function () {
+    var _ref$current;
+    return (_ref$current = ref.current) !== null && _ref$current !== void 0 ? _ref$current : ref.current = getter();
+  };
+}
+
+export { useLazyRef };

package/dist/hooks/use-media-query.cjs

@@ -3,7 +3,7 @@
 var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
 var react = require('react');
 var toArray = require('../utils/to-array.cjs');
-var replace = require('../utils/replace.cjs');
+var replaceAt = require('../utils/replace/replace-at.cjs');
 
 var useMediaQuery = function useMediaQuery(query) {
   var _query = react.useMemo(function () {
@@ -21,7 +21,7 @@ var useMediaQuery = function useMediaQuery(query) {
     setValue = _useState2[1];
   var onMediaQueryChange = react.useCallback(function (event, index) {
     setValue(function (prev) {
-      return replace.replace(prev, event.matches, index);
+      return replaceAt.replaceAt(prev, index, event.matches);
     });
   }, []);
   react.useEffect(function () {

package/dist/hooks/use-media-query.mjs

@@ -1,7 +1,7 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import { useMemo, useState, useCallback, useEffect } from 'react';
 import { toArray } from '../utils/to-array.mjs';
-import { replace } from '../utils/replace.mjs';
+import { replaceAt } from '../utils/replace/replace-at.mjs';
 
 var useMediaQuery = function useMediaQuery(query) {
   var _query = useMemo(function () {
@@ -19,7 +19,7 @@ var useMediaQuery = function useMediaQuery(query) {
     setValue = _useState2[1];
   var onMediaQueryChange = useCallback(function (event, index) {
     setValue(function (prev) {
-      return replace(prev, event.matches, index);
+      return replaceAt(prev, index, event.matches);
     });
   }, []);
   useEffect(function () {

package/dist/index.cjs

@@ -40,6 +40,7 @@ var useEventSource = require('./hooks/use-event-source.cjs');
 var useResize = require('./hooks/use-resize.cjs');
 var useDraggable = require('./hooks/use-draggable.cjs');
 var useAsyncEffect = require('./hooks/use-async-effect.cjs');
+var useLazyRef = require('./hooks/use-lazy-ref.cjs');
 var isRefable = require('./is/is-refable.cjs');
 var isUndefined = require('./is/is-undefined.cjs');
 var isNull = require('./is/is-null.cjs');
@@ -71,7 +72,6 @@ var throttle = require('./utils/throttle.cjs');
 var clone = require('./utils/clone.cjs');
 var toggle = require('./utils/toggle.cjs');
 var taggedTemplateLiterals = require('./utils/tagged-template-literals.cjs');
-var replace = require('./utils/replace.cjs');
 var first = require('./utils/first.cjs');
 var last = require('./utils/last.cjs');
 var merge = require('./utils/merge.cjs');
@@ -79,6 +79,11 @@ var max = require('./utils/max.cjs');
 var min = require('./utils/min.cjs');
 var load = require('./utils/load.cjs');
 var at = require('./utils/at.cjs');
+var pick = require('./utils/pick.cjs');
+var get = require('./utils/get.cjs');
+var set = require('./utils/set.cjs');
+var replace = require('./utils/replace/replace.cjs');
+var replaceAt = require('./utils/replace/replace-at.cjs');
 
 
 
@@ -122,6 +127,7 @@ exports.useEventSource = useEventSource.useEventSource;
 exports.useResize = useResize.useResize;
 exports.useDraggable = useDraggable.useDraggable;
 exports.useAsyncEffect = useAsyncEffect.useAsyncEffect;
+exports.useLazyRef = useLazyRef.useLazyRef;
 exports.isRefable = isRefable.isRefable;
 exports.isUndefined = isUndefined.isUndefined;
 exports.isNull = isNull.isNull;
@@ -153,7 +159,6 @@ exports.throttle = throttle.throttle;
 exports.clone = clone.clone;
 exports.toggle = toggle.toggle;
 exports.taggedTemplateLiterals = taggedTemplateLiterals.taggedTemplateLiterals;
-exports.replace = replace.replace;
 exports.first = first.first;
 exports.last = last.last;
 exports.merge = merge.merge;
@@ -161,3 +166,8 @@ exports.max = max.max;
 exports.min = min.min;
 exports.load = load.load;
 exports.at = at.at;
+exports.pick = pick.pick;
+exports.get = get.get;
+exports.set = set.set;
+exports.replace = replace.replace;
+exports.replaceAt = replaceAt.replaceAt;

package/dist/index.d.ts

@@ -42,6 +42,7 @@ export { useEventSource } from "./hooks/use-event-source";
 export { useResize } from "./hooks/use-resize";
 export { useDraggable } from "./hooks/use-draggable";
 export { useAsyncEffect } from "./hooks/use-async-effect";
+export { useLazyRef } from "./hooks/use-lazy-ref";
 /**
  * @description
  * is
@@ -81,7 +82,7 @@ export { throttle } from "./utils/throttle";
 export { clone } from "./utils/clone";
 export { toggle } from "./utils/toggle";
 export { taggedTemplateLiterals } from "./utils/tagged-template-literals";
-export { replace } from "./utils/replace";
+export { replace, replaceAt } from "./utils/replace";
 export { first } from "./utils/first";
 export { last } from "./utils/last";
 export { merge } from "./utils/merge";
@@ -89,3 +90,6 @@ export { max } from "./utils/max";
 export { min } from "./utils/min";
 export { load } from "./utils/load";
 export { at } from "./utils/at";
+export { pick } from "./utils/pick";
+export { get } from "./utils/get";
+export { set } from "./utils/set";

package/dist/index.mjs

@@ -38,6 +38,7 @@ export { useEventSource } from './hooks/use-event-source.mjs';
 export { useResize } from './hooks/use-resize.mjs';
 export { useDraggable } from './hooks/use-draggable.mjs';
 export { useAsyncEffect } from './hooks/use-async-effect.mjs';
+export { useLazyRef } from './hooks/use-lazy-ref.mjs';
 export { isRefable } from './is/is-refable.mjs';
 export { isUndefined } from './is/is-undefined.mjs';
 export { isNull } from './is/is-null.mjs';
@@ -69,7 +70,6 @@ export { throttle } from './utils/throttle.mjs';
 export { clone } from './utils/clone.mjs';
 export { toggle } from './utils/toggle.mjs';
 export { taggedTemplateLiterals } from './utils/tagged-template-literals.mjs';
-export { replace } from './utils/replace.mjs';
 export { first } from './utils/first.mjs';
 export { last } from './utils/last.mjs';
 export { merge } from './utils/merge.mjs';
@@ -77,3 +77,8 @@ export { max } from './utils/max.mjs';
 export { min } from './utils/min.mjs';
 export { load } from './utils/load.mjs';
 export { at } from './utils/at.mjs';
+export { pick } from './utils/pick.mjs';
+export { get } from './utils/get.mjs';
+export { set } from './utils/set.mjs';
+export { replace } from './utils/replace/replace.mjs';
+export { replaceAt } from './utils/replace/replace-at.mjs';

package/dist/is/is-deep-key.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+
+/**
+ * Checks if a given key is a deep key.
+ *
+ * A deep key is a string that contains a dot (.) or square brackets with a property accessor.
+ *
+ * @param {PropertyKey} key - The key to check.
+ * @returns {boolean} - Returns true if the key is a deep key, otherwise false.
+ *
+ * Examples:
+ *
+ * isDeepKey('a.b') // true
+ * isDeepKey('a[b]') // true
+ * isDeepKey('a') // false
+ * isDeepKey(123) // false
+ * isDeepKey('a.b.c') // true
+ * isDeepKey('a[b][c]') // true
+ */
+function isDeepKey(key) {
+  switch (_typeof(key)) {
+    case "number":
+    case "symbol":
+      {
+        return false;
+      }
+    case "string":
+      {
+        var _deepKeys = new Set([".", "[", "]"]);
+        for (var index = 0; index < key.length; index++) {
+          if (_deepKeys.has(key[index])) {
+            return true;
+          }
+        }
+        return false;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+}
+
+exports.isDeepKey = isDeepKey;

package/dist/is/is-deep-key.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Checks if a given key is a deep key.
+ *
+ * A deep key is a string that contains a dot (.) or square brackets with a property accessor.
+ *
+ * @param {PropertyKey} key - The key to check.
+ * @returns {boolean} - Returns true if the key is a deep key, otherwise false.
+ *
+ * Examples:
+ *
+ * isDeepKey('a.b') // true
+ * isDeepKey('a[b]') // true
+ * isDeepKey('a') // false
+ * isDeepKey(123) // false
+ * isDeepKey('a.b.c') // true
+ * isDeepKey('a[b][c]') // true
+ */
+export declare function isDeepKey(key: PropertyKey): boolean;

package/dist/is/is-deep-key.mjs

@@ -0,0 +1,44 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+
+/**
+ * Checks if a given key is a deep key.
+ *
+ * A deep key is a string that contains a dot (.) or square brackets with a property accessor.
+ *
+ * @param {PropertyKey} key - The key to check.
+ * @returns {boolean} - Returns true if the key is a deep key, otherwise false.
+ *
+ * Examples:
+ *
+ * isDeepKey('a.b') // true
+ * isDeepKey('a[b]') // true
+ * isDeepKey('a') // false
+ * isDeepKey(123) // false
+ * isDeepKey('a.b.c') // true
+ * isDeepKey('a[b][c]') // true
+ */
+function isDeepKey(key) {
+  switch (_typeof(key)) {
+    case "number":
+    case "symbol":
+      {
+        return false;
+      }
+    case "string":
+      {
+        var _deepKeys = new Set([".", "[", "]"]);
+        for (var index = 0; index < key.length; index++) {
+          if (_deepKeys.has(key[index])) {
+            return true;
+          }
+        }
+        return false;
+      }
+    default:
+      {
+        return false;
+      }
+  }
+}
+
+export { isDeepKey };

package/dist/is/is-iterable.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var isFunction = require('./is-function.cjs');
+
+/**
+ * is iterable
+ */
+function isIterable(value) {
+  return isFunction.isFunction(value === null || value === void 0 ? void 0 : value[Symbol.iterator]);
+}
+
+exports.isIterable = isIterable;

package/dist/is/is-iterable.d.ts

@@ -0,0 +1,5 @@
+/**
+ * is iterable
+ */
+declare function isIterable(value: unknown): value is Iterable<unknown>;
+export { isIterable };

package/dist/is/is-iterable.mjs

@@ -0,0 +1,10 @@
+import { isFunction } from './is-function.mjs';
+
+/**
+ * is iterable
+ */
+function isIterable(value) {
+  return isFunction(value === null || value === void 0 ? void 0 : value[Symbol.iterator]);
+}
+
+export { isIterable };

package/dist/is/is-key.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+var isArray = require('./is-array.cjs');
+var isBoolean = require('./is-boolean.cjs');
+var isNull = require('./is-null.cjs');
+var isNumber = require('./is-number.cjs');
+var isObject = require('./is-object.cjs');
+var isString = require('./is-string.cjs');
+var isSymbol = require('./is-symbol.cjs');
+
+/**  Matches any deep property path. (e.g. `a.b[0].c`)*/
+var _IS_DEEP_KEY = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+/**  Matches any word character (alphanumeric & underscore).*/
+var _IS_PLAIN_KEY = /^\w*$/;
+/**
+ * Checks if `value` is a property name and not a property path. (It's ok that the `value` is not in the keys of the `object`)
+ * @param {unknown} value The value to check.
+ * @param {unknown} object The object to query.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ *
+ * @example
+ * isKey('a', { a: 1 });
+ * // => true
+ *
+ * isKey('a.b', { a: { b: 2 } });
+ * // => false
+ */
+function isKey(value, object) {
+  if (isArray.isArray(value) || isObject.isObject(value)) {
+    return false;
+  }
+  if (isNumber.isNumber(value) || isBoolean.isBoolean(value) || isNull.isNull(value) || isSymbol.isSymbol(value)) {
+    return true;
+  }
+  return isString.isString(value) && (_IS_PLAIN_KEY.test(value) || !_IS_DEEP_KEY.test(value)) || object != null && Object.hasOwn(object, value);
+}
+
+exports.isKey = isKey;

package/dist/is/is-key.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Checks if `value` is a property name and not a property path. (It's ok that the `value` is not in the keys of the `object`)
+ * @param {unknown} value The value to check.
+ * @param {unknown} object The object to query.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ *
+ * @example
+ * isKey('a', { a: 1 });
+ * // => true
+ *
+ * isKey('a.b', { a: { b: 2 } });
+ * // => false
+ */
+export declare function isKey(value?: unknown, object?: unknown): value is PropertyKey;

package/dist/is/is-key.mjs

@@ -0,0 +1,36 @@
+import { isArray } from './is-array.mjs';
+import { isBoolean } from './is-boolean.mjs';
+import { isNull } from './is-null.mjs';
+import { isNumber } from './is-number.mjs';
+import { isObject } from './is-object.mjs';
+import { isString } from './is-string.mjs';
+import { isSymbol } from './is-symbol.mjs';
+
+/**  Matches any deep property path. (e.g. `a.b[0].c`)*/
+var _IS_DEEP_KEY = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+/**  Matches any word character (alphanumeric & underscore).*/
+var _IS_PLAIN_KEY = /^\w*$/;
+/**
+ * Checks if `value` is a property name and not a property path. (It's ok that the `value` is not in the keys of the `object`)
+ * @param {unknown} value The value to check.
+ * @param {unknown} object The object to query.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ *
+ * @example
+ * isKey('a', { a: 1 });
+ * // => true
+ *
+ * isKey('a.b', { a: { b: 2 } });
+ * // => false
+ */
+function isKey(value, object) {
+  if (isArray(value) || isObject(value)) {
+    return false;
+  }
+  if (isNumber(value) || isBoolean(value) || isNull(value) || isSymbol(value)) {
+    return true;
+  }
+  return isString(value) && (_IS_PLAIN_KEY.test(value) || !_IS_DEEP_KEY.test(value)) || object != null && Object.hasOwn(object, value);
+}
+
+export { isKey };

package/dist/is/is-object.cjs

@@ -1,13 +1,34 @@
 'use strict';
 
 var _typeof = require('@babel/runtime/helpers/typeof');
+var isFunction = require('./is-function.cjs');
+var isNull = require('./is-null.cjs');
 
 /**
- * @description
- * is object
+ * Checks if the given value is an object. An object is a value that is
+ * not a primitive type (string, number, boolean, symbol, null, or undefined).
+ *
+ * This function tests whether the provided value is an object or not.
+ * It returns `true` if the value is an object, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object value.
+ *
+ * @param {unknown} value - The value to check if it is an object.
+ * @returns {value is object} `true` if the value is an object, `false` otherwise.
+ *
+ * @example
+ * const value1 = {};
+ * const value2 = [1, 2, 3];
+ * const value3 = () => {};
+ * const value4 = null;
+ *
+ * console.log(isObject(value1)); // true
+ * console.log(isObject(value2)); // true
+ * console.log(isObject(value3)); // true
+ * console.log(isObject(value4)); // false
  */
-var isObject = function isObject(value) {
-  return !!value && _typeof(value) === "object";
-};
+function isObject(value) {
+  return !isNull.isNull(value) && (_typeof(value) === "object" || isFunction.isFunction(value));
+}
 
 exports.isObject = isObject;

package/dist/is/is-object.d.ts

@@ -1,6 +1,24 @@
 /**
- * @description
- * is object
+ * Checks if the given value is an object. An object is a value that is
+ * not a primitive type (string, number, boolean, symbol, null, or undefined).
+ *
+ * This function tests whether the provided value is an object or not.
+ * It returns `true` if the value is an object, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object value.
+ *
+ * @param {unknown} value - The value to check if it is an object.
+ * @returns {value is object} `true` if the value is an object, `false` otherwise.
+ *
+ * @example
+ * const value1 = {};
+ * const value2 = [1, 2, 3];
+ * const value3 = () => {};
+ * const value4 = null;
+ *
+ * console.log(isObject(value1)); // true
+ * console.log(isObject(value2)); // true
+ * console.log(isObject(value3)); // true
+ * console.log(isObject(value4)); // false
  */
-declare const isObject: (value: unknown) => value is Object;
-export { isObject };
+export declare function isObject(value?: unknown): value is object;

package/dist/is/is-object.mjs

@@ -1,11 +1,32 @@
 import _typeof from '@babel/runtime/helpers/typeof';
+import { isFunction } from './is-function.mjs';
+import { isNull } from './is-null.mjs';
 
 /**
- * @description
- * is object
+ * Checks if the given value is an object. An object is a value that is
+ * not a primitive type (string, number, boolean, symbol, null, or undefined).
+ *
+ * This function tests whether the provided value is an object or not.
+ * It returns `true` if the value is an object, and `false` otherwise.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to an object value.
+ *
+ * @param {unknown} value - The value to check if it is an object.
+ * @returns {value is object} `true` if the value is an object, `false` otherwise.
+ *
+ * @example
+ * const value1 = {};
+ * const value2 = [1, 2, 3];
+ * const value3 = () => {};
+ * const value4 = null;
+ *
+ * console.log(isObject(value1)); // true
+ * console.log(isObject(value2)); // true
+ * console.log(isObject(value3)); // true
+ * console.log(isObject(value4)); // false
  */
-var isObject = function isObject(value) {
-  return !!value && _typeof(value) === "object";
-};
+function isObject(value) {
+  return !isNull(value) && (_typeof(value) === "object" || isFunction(value));
+}
 
 export { isObject };

package/dist/is/is-symbol.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var _typeof = require('@babel/runtime/helpers/typeof');
+
+/**
+ * Check whether a value is a symbol.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ * isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return _typeof(value) === "symbol" || value instanceof Symbol;
+}
+
+exports.isSymbol = isSymbol;

package/dist/is/is-symbol.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Check whether a value is a symbol.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ * isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * isSymbol('abc');
+ * // => false
+ */
+export declare function isSymbol(value?: unknown): value is symbol;

package/dist/is/is-symbol.mjs

@@ -0,0 +1,21 @@
+import _typeof from '@babel/runtime/helpers/typeof';
+
+/**
+ * Check whether a value is a symbol.
+ *
+ * This function can also serve as a type predicate in TypeScript, narrowing the type of the argument to `symbol`.
+ *
+ * @param {unknown} value The value to check.
+ * @returns {value is symbol} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ * isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * isSymbol('abc');
+ * // => false
+ */
+function isSymbol(value) {
+  return _typeof(value) === "symbol" || value instanceof Symbol;
+}
+
+export { isSymbol };