@stryke/types 0.0.1

package/dist/type-checks/index.d.ts

@@ -0,0 +1,41 @@
+export * from "./get-object-tag";
+export * from "./is-array-like";
+export * from "./is-async-iterable";
+export * from "./is-bigint";
+export * from "./is-boolean";
+export * from "./is-buffer";
+export * from "./is-collection";
+export * from "./is-date";
+export * from "./is-deep-key";
+export * from "./is-empty";
+export * from "./is-empty-object";
+export * from "./is-empty-string";
+export * from "./is-equal";
+export * from "./is-error";
+export * from "./is-file-result";
+export * from "./is-float";
+export * from "./is-function";
+export * from "./is-integer";
+export * from "./is-mergeable-object";
+export * from "./is-not-empty";
+export * from "./is-null";
+export * from "./is-number";
+export * from "./is-object";
+export * from "./is-object-index";
+export * from "./is-plain-object";
+export * from "./is-primitive";
+export * from "./is-promise";
+export * from "./is-react-element";
+export * from "./is-ref";
+export * from "./is-regexp";
+export * from "./is-select-option";
+export * from "./is-set";
+export * from "./is-set-object";
+export * from "./is-set-string";
+export * from "./is-string";
+export * from "./is-symbol";
+export * from "./is-typed";
+export * from "./is-typed-array";
+export * from "./is-undefined";
+export * from "./property-exists";
+export * from "./type-detect";

package/dist/type-checks/index.mjs

@@ -0,0 +1 @@
+export*from"./get-object-tag";export*from"./is-array-like";export*from"./is-async-iterable";export*from"./is-bigint";export*from"./is-boolean";export*from"./is-buffer";export*from"./is-collection";export*from"./is-date";export*from"./is-deep-key";export*from"./is-empty";export*from"./is-empty-object";export*from"./is-empty-string";export*from"./is-equal";export*from"./is-error";export*from"./is-file-result";export*from"./is-float";export*from"./is-function";export*from"./is-integer";export*from"./is-mergeable-object";export*from"./is-not-empty";export*from"./is-null";export*from"./is-number";export*from"./is-object";export*from"./is-object-index";export*from"./is-plain-object";export*from"./is-primitive";export*from"./is-promise";export*from"./is-react-element";export*from"./is-ref";export*from"./is-regexp";export*from"./is-select-option";export*from"./is-set";export*from"./is-set-object";export*from"./is-set-string";export*from"./is-string";export*from"./is-symbol";export*from"./is-typed";export*from"./is-typed-array";export*from"./is-undefined";export*from"./property-exists";export*from"./type-detect";

package/dist/type-checks/is-array-like.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isArrayLike = void 0;
+var _isEmpty = require("./is-empty.cjs");
+var _isNumber = require("./is-number.cjs");
+var _isObject = require("./is-object.cjs");
+const isArrayLike = t => (0, _isObject.isObject)(t) && !(0, _isEmpty.isEmpty)(t) && "length" in t && (0, _isNumber.isNumber)(t.length) && (t.length === 0 || t.length > 0 && Object.prototype.hasOwnProperty.call(t, t.length - 1));
+exports.isArrayLike = isArrayLike;

package/dist/type-checks/is-array-like.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if the provided value's type is "array-like"
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the object provided is "array-like"
+ */
+export declare const isArrayLike: (value: any) => boolean;

package/dist/type-checks/is-array-like.mjs

@@ -0,0 +1 @@
+import{isEmpty as r}from"./is-empty";import{isNumber as o}from"./is-number";import{isObject as n}from"./is-object";export const isArrayLike=t=>n(t)&&!r(t)&&"length"in t&&o(t.length)&&(t.length===0||t.length>0&&Object.prototype.hasOwnProperty.call(t,t.length-1));

package/dist/type-checks/is-async-iterable.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAsyncIterable = void 0;
+var _isNull = require("./is-null.cjs");
+var _isObject = require("./is-object.cjs");
+const isAsyncIterable = n => (0, _isObject.isObject)(n) && !(0, _isNull.isNull)(n) && Symbol.asyncIterator in n;
+exports.isAsyncIterable = isAsyncIterable;

package/dist/type-checks/is-async-iterable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if the provided value's type is `AsyncIterable`
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the object provided is `AsyncIterable`
+ */
+export declare const isAsyncIterable: (value: unknown) => value is AsyncIterable<unknown>;

package/dist/type-checks/is-async-iterable.mjs

@@ -0,0 +1 @@
+import{isNull as r}from"./is-null";import{isObject as o}from"./is-object";export const isAsyncIterable=n=>o(n)&&!r(n)&&Symbol.asyncIterator in n;

package/dist/type-checks/is-bigint.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBigInt = void 0;
+var _getObjectTag = require("./get-object-tag.cjs");
+const isBigInt = t => typeof t == "bigint" || (0, _getObjectTag.getObjectTag)(t) == "[object BigInt]";
+exports.isBigInt = isBigInt;

package/dist/type-checks/is-bigint.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if `value` is classified as a `bigint` object.
+ *
+ * @example
+ * ```typescript
+ * isDate(37n)
+ * // => true
+ *
+ * isBigInt(37)
+ * // => false
+ * ```
+ *
+ * @param value - The obj to check.
+ * @returns Returns `true` if `value` is a bigint object, else `false`.
+ */
+export declare const isBigInt: (value: unknown) => value is bigint;

package/dist/type-checks/is-bigint.mjs

@@ -0,0 +1 @@
+import{getObjectTag as i}from"./get-object-tag";export const isBigInt=t=>typeof t=="bigint"||i(t)=="[object BigInt]";

package/dist/type-checks/is-boolean.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBoolean = void 0;
+const isBoolean = o => {
+  try {
+    return o instanceof Boolean || typeof o == "boolean" || !!o === o;
+  } catch {
+    return !1;
+  }
+};
+exports.isBoolean = isBoolean;

package/dist/type-checks/is-boolean.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if the provided value's type is `boolean`
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `boolean`
+ */
+export declare const isBoolean: (value: unknown) => value is boolean;

package/dist/type-checks/is-boolean.mjs

@@ -0,0 +1 @@
+export const isBoolean=o=>{try{return o instanceof Boolean||typeof o=="boolean"||!!o===o}catch{return!1}};

package/dist/type-checks/is-buffer.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBufferExists = exports.isBuffer = void 0;
+const isBufferExists = exports.isBufferExists = typeof Buffer < "u",
+  isBuffer = exports.isBuffer = isBufferExists ? Buffer.isBuffer.bind(Buffer) : function (e) {
+    return !1;
+  };

package/dist/type-checks/is-buffer.d.ts

@@ -0,0 +1,5 @@
+export declare const isBufferExists: boolean;
+/**
+ * Check if the provided value's type is `Buffer`
+ */
+export declare const isBuffer: typeof Buffer.isBuffer;

package/dist/type-checks/is-buffer.mjs

@@ -0,0 +1 @@
+export const isBufferExists=typeof Buffer<"u",isBuffer=isBufferExists?Buffer.isBuffer.bind(Buffer):function(e){return!1};

package/dist/type-checks/is-collection.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isCollection = isCollection;
+var _typeDetect = require("./type-detect.cjs");
+const o = new Set(["Arguments", "Array", "Map", "Object", "Set"]);
+function isCollection(t) {
+  return o.has((0, _typeDetect.typeDetect)(t));
+}

package/dist/type-checks/is-collection.d.ts

@@ -0,0 +1,8 @@
+import { Collection } from "../utility-types/base";
+/**
+ * Check if the provided value's type is `Collection`
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `Collection`
+ */
+export declare function isCollection(value: any): value is Collection;

package/dist/type-checks/is-collection.mjs

@@ -0,0 +1 @@
+import{typeDetect as e}from"./type-detect";const o=new Set(["Arguments","Array","Map","Object","Set"]);export function isCollection(t){return o.has(e(t))}

package/dist/type-checks/is-date.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDate = void 0;
+var _getObjectTag = require("./get-object-tag.cjs");
+var _isPlainObject = require("./is-plain-object.cjs");
+const isDate = t => (0, _isPlainObject.isObjectLike)(t) && (0, _getObjectTag.getObjectTag)(t) == "[object Date]";
+exports.isDate = isDate;

package/dist/type-checks/is-date.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Checks if `value` is classified as a `Date` object.
+ *
+ * @example
+ * ```typescript
+ * isDate(new Date)
+ * // => true
+ *
+ * isDate('Mon April 23 2012')
+ * // => false
+ * ```
+ *
+ * @param value - The value to check.
+ * @returns Returns `true` if `obj` is a date object, else `false`.
+ */
+export declare const isDate: (value: unknown) => value is Date;

package/dist/type-checks/is-date.mjs

@@ -0,0 +1 @@
+import{getObjectTag as e}from"./get-object-tag";import{isObjectLike as o}from"./is-plain-object";export const isDate=t=>o(t)&&e(t)=="[object Date]";

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isDeepKey = isDeepKey;
+exports.isKeyOrDeepKey = isKeyOrDeepKey;
+function isDeepKey(e) {
+  switch (typeof e) {
+    case "number":
+    case "symbol":
+      return !1;
+    case "string":
+      return e.includes(".") || e.includes("[") || e.includes("]");
+  }
+}
+function isKeyOrDeepKey(e) {
+  switch (typeof e) {
+    case "number":
+      return !0;
+    case "symbol":
+      return !1;
+    case "string":
+      return !0;
+  }
+}

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

@@ -0,0 +1,35 @@
+import { DeepKey } from "../utility-types/object";
+/**
+ * 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.
+ *
+ * @example
+ * isDeepKey('a.b') // true
+ * isDeepKey('a[b]') // true
+ * isDeepKey('a') // false
+ * isDeepKey(123) // false
+ * isDeepKey('a.b.c') // true
+ * isDeepKey('a[b][c]') // true
+ *
+ * @param key - The key to check.
+ * @returns Returns true if the key is a deep key, otherwise false.
+ */
+export declare function isDeepKey(key: PropertyKey): key is DeepKey<any>;
+/**
+ * Checks if a given key is a deep key or normal (shallow key).
+ *
+ * A deep key is a string that contains a dot (.) or square brackets with a property accessor.
+ *
+ * @example
+ * isDeepKey('a.b') // true
+ * isDeepKey('a[b]') // true
+ * isDeepKey('a') // true
+ * isDeepKey(123) // false
+ * isDeepKey('a.b.c') // true
+ * isDeepKey('a[b][c]') // true
+ *
+ * @param key - The key to check.
+ * @returns Returns true if the key is a deep key, otherwise false.
+ */
+export declare function isKeyOrDeepKey(key: PropertyKey): key is DeepKey<any>;

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

@@ -0,0 +1 @@
+export function isDeepKey(e){switch(typeof e){case"number":case"symbol":return!1;case"string":return e.includes(".")||e.includes("[")||e.includes("]")}}export function isKeyOrDeepKey(e){switch(typeof e){case"number":return!0;case"symbol":return!1;case"string":return!0}}

package/dist/type-checks/is-empty-object.cjs

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEmptyOrEmptyObject = exports.isEmptyObject = void 0;
+var _isEmpty = require("./is-empty.cjs");
+const isEmptyObject = t => {
+    try {
+      return !!t || Object.keys(t ?? {}).length === 0;
+    } catch {
+      return !0;
+    }
+  },
+  isEmptyOrEmptyObject = t => {
+    try {
+      return (0, _isEmpty.isEmpty)(t) || isEmptyObject(t);
+    } catch {
+      return !0;
+    }
+  };
+exports.isEmptyOrEmptyObject = isEmptyOrEmptyObject;
+exports.isEmptyObject = isEmptyObject;

package/dist/type-checks/is-empty-object.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Check if the provided value's type is `{}`
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `{}`
+ */
+export declare const isEmptyObject: (value: unknown) => value is {};
+/**
+ * Check if the provided value's type is `null` or `undefined` or `{}`
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `null` or `undefined` or `{}`
+ */
+export declare const isEmptyOrEmptyObject: (value: unknown) => boolean;

package/dist/type-checks/is-empty-object.mjs

@@ -0,0 +1 @@
+import{isEmpty as r}from"./is-empty";export const isEmptyObject=t=>{try{return!!t||Object.keys(t??{}).length===0}catch{return!0}},isEmptyOrEmptyObject=t=>{try{return r(t)||isEmptyObject(t)}catch{return!0}};

package/dist/type-checks/is-empty-string.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEmptyString = void 0;
+var _base = require("../utility-types/base.cjs");
+var _isString = require("./is-string.cjs");
+const isEmptyString = r => {
+  try {
+    return (0, _isString.isString)(r) && r === _base.EMPTY_STRING;
+  } catch {
+    return !1;
+  }
+};
+exports.isEmptyString = isEmptyString;

package/dist/type-checks/is-empty-string.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Determine if the type is string and is empty
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `""`
+ */
+export declare const isEmptyString: (value: unknown) => value is string;

package/dist/type-checks/is-empty-string.mjs

@@ -0,0 +1 @@
+import{EMPTY_STRING as t}from"../utility-types/base";import{isString as n}from"./is-string";export const isEmptyString=r=>{try{return n(r)&&r===t}catch{return!1}};

package/dist/type-checks/is-empty.cjs

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEmptyAnything = exports.isEmpty = void 0;
+var _isDate = require("./is-date.cjs");
+var _isFunction = require("./is-function.cjs");
+var _isNull = require("./is-null.cjs");
+var _isNumber = require("./is-number.cjs");
+var _isSymbol = require("./is-symbol.cjs");
+var _isUndefined = require("./is-undefined.cjs");
+const isEmpty = r => {
+    try {
+      return (0, _isUndefined.isUndefined)(r) || (0, _isNull.isNull)(r);
+    } catch {
+      return !1;
+    }
+  },
+  isEmptyAnything = r => {
+    if (r === !0 || r === !1 || r == null) return !0;
+    if ((0, _isNumber.isNumber)(r)) return r === 0;
+    if ((0, _isDate.isDate)(r)) return Number.isNaN(r.getTime());
+    if ((0, _isFunction.isFunction)(r) || (0, _isSymbol.isSymbol)(r)) return !1;
+    const {
+      length: n
+    } = r;
+    if ((0, _isNumber.isNumber)(n)) return n === 0;
+    const {
+      size: i
+    } = r;
+    return (0, _isNumber.isNumber)(i) ? i === 0 : Object.keys(r).length === 0;
+  };
+exports.isEmptyAnything = isEmptyAnything;
+exports.isEmpty = isEmpty;

package/dist/type-checks/is-empty.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Check if the provided value's type is `null` or `undefined`
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `null` or `undefined`
+ */
+export declare const isEmpty: (value: unknown) => boolean;
+export declare const isEmptyAnything: (value: any) => boolean;

package/dist/type-checks/is-empty.mjs

@@ -0,0 +1 @@
+import{isDate as e}from"./is-date";import{isFunction as o}from"./is-function";import{isNull as s}from"./is-null";import{isNumber as t}from"./is-number";import{isSymbol as f}from"./is-symbol";import{isUndefined as m}from"./is-undefined";export const isEmpty=r=>{try{return m(r)||s(r)}catch{return!1}},isEmptyAnything=r=>{if(r===!0||r===!1||r==null)return!0;if(t(r))return r===0;if(e(r))return Number.isNaN(r.getTime());if(o(r)||f(r))return!1;const{length:n}=r;if(t(n))return n===0;const{size:i}=r;return t(i)?i===0:Object.keys(r).length===0};

package/dist/type-checks/is-equal.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isEqual = void 0;
+const isEqual = (t, e) => {
+  if (Object.is(t, e)) return !0;
+  if (t instanceof Date && e instanceof Date) return t.getTime() === e.getTime();
+  if (t instanceof RegExp && e instanceof RegExp) return t.toString() === e.toString();
+  if (typeof t != "object" || t === null || typeof e != "object" || e === null) return !1;
+  const o = Reflect.ownKeys(t),
+    s = Reflect.ownKeys(e);
+  if (o.length !== s.length) return !1;
+  for (const n of o) if (!Reflect.has(e, n) || !isEqual(t[n], e[n])) return !1;
+  return !0;
+};
+exports.isEqual = isEqual;

package/dist/type-checks/is-equal.d.ts

@@ -0,0 +1 @@
+export declare const isEqual: <TType>(x: TType, y: TType) => boolean;

package/dist/type-checks/is-equal.mjs

@@ -0,0 +1 @@
+export const isEqual=(t,e)=>{if(Object.is(t,e))return!0;if(t instanceof Date&&e instanceof Date)return t.getTime()===e.getTime();if(t instanceof RegExp&&e instanceof RegExp)return t.toString()===e.toString();if(typeof t!="object"||t===null||typeof e!="object"||e===null)return!1;const o=Reflect.ownKeys(t),s=Reflect.ownKeys(e);if(o.length!==s.length)return!1;for(const n of o)if(!Reflect.has(e,n)||!isEqual(t[n],e[n]))return!1;return!0};

package/dist/type-checks/is-error.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isError = void 0;
+var _getObjectTag = require("./get-object-tag.cjs");
+var _isObject = require("./is-object.cjs");
+var _isPlainObject = require("./is-plain-object.cjs");
+const isError = r => {
+  if (!(0, _isObject.isObject)(r)) return !1;
+  const t = (0, _getObjectTag.getObjectTag)(r);
+  return t === "[object Error]" || t === "[object DOMException]" || typeof r?.message == "string" && typeof r?.name == "string" && !(0, _isPlainObject.isPlainObject)(r);
+};
+exports.isError = isError;

package/dist/type-checks/is-error.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Checks if `obj` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,
+ * `SyntaxError`, `TypeError`, or `URIError` object.
+ *
+ * @example
+ * ```typescript
+ * isError(new Error)
+ * // => true
+ *
+ * isError(Error)
+ * // => false
+ * ```
+ *
+ * @param obj - The obj to check.
+ * @returns Returns `true` if `obj` is an error object, else `false`.
+ */
+export declare const isError: (obj: unknown) => obj is Error;

package/dist/type-checks/is-error.mjs

@@ -0,0 +1 @@
+import{getObjectTag as o}from"./get-object-tag";import{isObject as e}from"./is-object";import{isPlainObject as s}from"./is-plain-object";export const isError=r=>{if(!e(r))return!1;const t=o(r);return t==="[object Error]"||t==="[object DOMException]"||typeof r?.message=="string"&&typeof r?.name=="string"&&!s(r)};

package/dist/type-checks/is-file-result.cjs

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isFileResult = void 0;
+var _file = require("../utility-types/file.cjs");
+var _isSetObject = require("./is-set-object.cjs");
+var _isSetString = require("./is-set-string.cjs");
+const isFileResult = t => (0, _isSetObject.isSetObject)(t) && "status" in t && Object.values(_file.FileStatus).includes(t.status) && ((0, _isSetString.isSetString)(t?.uri) || (0, _isSetObject.isSetObject)(t?.file));
+exports.isFileResult = isFileResult;

package/dist/type-checks/is-file-result.d.ts

@@ -0,0 +1,8 @@
+import { FileResult } from "../utility-types/file";
+/**
+ * Check if the provided value is a `FileResult` object
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is a `FileResult` object
+ */
+export declare const isFileResult: (value: any) => value is FileResult;

package/dist/type-checks/is-file-result.mjs

@@ -0,0 +1 @@
+import{FileStatus as i}from"../utility-types/file";import{isSetObject as s}from"./is-set-object";import{isSetString as e}from"./is-set-string";export const isFileResult=t=>s(t)&&"status"in t&&Object.values(i).includes(t.status)&&(e(t?.uri)||s(t?.file));

package/dist/type-checks/is-float.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isFloat = void 0;
+var _isNumber = require("./is-number.cjs");
+const isFloat = o => (0, _isNumber.isNumber)(o) && o % 1 !== 0;
+exports.isFloat = isFloat;

package/dist/type-checks/is-float.d.ts

@@ -0,0 +1,8 @@
+import { Float } from "../utility-types/number";
+/**
+ * Check if the provided value's type is a float
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `number` and is a float
+ */
+export declare const isFloat: <T extends number>(value: T) => value is Float<T>;

package/dist/type-checks/is-float.mjs

@@ -0,0 +1 @@
+import{isNumber as t}from"./is-number";export const isFloat=o=>t(o)&&o%1!==0;

package/dist/type-checks/is-function.cjs

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isAsyncFunction = isAsyncFunction;
+exports.isFunction = void 0;
+exports.isSyncFunction = isSyncFunction;
+var _getObjectTag = require("./get-object-tag.cjs");
+function isSyncFunction(n) {
+  return (0, _getObjectTag.getObjectTag)(n) === "[object Function]";
+}
+function isAsyncFunction(n) {
+  return (0, _getObjectTag.getObjectTag)(n) === "[object AsyncFunction]";
+}
+const isFunction = n => {
+  try {
+    return n instanceof Function || typeof n == "function" || !!(n?.constructor && n?.call && n?.apply) || isSyncFunction(n) || isAsyncFunction(n);
+  } catch {
+    return !1;
+  }
+};
+exports.isFunction = isFunction;

package/dist/type-checks/is-function.d.ts

@@ -0,0 +1,10 @@
+import { AnyFunction } from "../utility-types/base";
+export declare function isSyncFunction(value?: any): value is AnyFunction;
+export declare function isAsyncFunction(value?: any): value is AnyFunction;
+/**
+ * Check if the provided value's type is `Function`
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `Function`
+ */
+export declare const isFunction: (value: unknown) => value is AnyFunction;

package/dist/type-checks/is-function.mjs

@@ -0,0 +1 @@
+import{getObjectTag as t}from"./get-object-tag";export function isSyncFunction(n){return t(n)==="[object Function]"}export function isAsyncFunction(n){return t(n)==="[object AsyncFunction]"}export const isFunction=n=>{try{return n instanceof Function||typeof n=="function"||!!(n?.constructor&&n?.call&&n?.apply)||isSyncFunction(n)||isAsyncFunction(n)}catch{return!1}};

package/dist/type-checks/is-integer.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isInteger = void 0;
+var _isNumber = require("./is-number.cjs");
+var _isString = require("./is-string.cjs");
+const isInteger = r => (0, _isNumber.isNumber)(r) && !(0, _isString.isString)(r) && r % 1 === 0;
+exports.isInteger = isInteger;

package/dist/type-checks/is-integer.d.ts

@@ -0,0 +1,8 @@
+import { Integer } from "../utility-types/number";
+/**
+ * Check if the provided value's type is an integer
+ *
+ * @param value - The value to type check
+ * @returns An indicator specifying if the value provided is of type `number` and is an integer
+ */
+export declare const isInteger: <T extends number>(value: T) => value is Integer<T>;

package/dist/type-checks/is-integer.mjs

@@ -0,0 +1 @@
+import{isNumber as e}from"./is-number";import{isString as t}from"./is-string";export const isInteger=r=>e(r)&&!t(r)&&r%1===0;

package/dist/type-checks/is-mergeable-object.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMergeableObject = void 0;
+var _isNonNullObject = require("./is-non-null-object.cjs");
+var _isReactElement = require("./is-react-element.cjs");
+const n = t => {
+  const e = Object.prototype.toString.call(t);
+  return e === "[object RegExp]" || e === "[object Date]" || (0, _isReactElement.isReactElement)(t);
+};
+const isMergeableObject = t => (0, _isNonNullObject.isNonNullObject)(t) && !n(t);
+exports.isMergeableObject = isMergeableObject;

package/dist/type-checks/is-mergeable-object.d.ts

@@ -0,0 +1 @@
+export declare const isMergeableObject: (value: any) => boolean;

package/dist/type-checks/is-mergeable-object.mjs

@@ -0,0 +1 @@
+import{isNonNullObject as o}from"./is-non-null-object";import{isReactElement as r}from"./is-react-element";const n=t=>{const e=Object.prototype.toString.call(t);return e==="[object RegExp]"||e==="[object Date]"||r(t)};export const isMergeableObject=t=>o(t)&&!n(t);