@jblib/is 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -2,14 +2,26 @@ import { isArray } from "./is-array.js";
 import { isBoolean } from "./is-boolean.js";
 import { isDate } from "./is-date.js";
 import { isDefined } from "./is-defined.js";
+import { isEmptyArray } from "./is-empty-array.js";
 import { isEmptyObject } from "./is-empty-object.js";
 import { isError } from "./is-error.js";
+import { isFalsy } from "./is-falsy.js";
 import { isFunction } from "./is-function.js";
+import { isMap } from "./is-map.js";
+import { isNegativeNumber } from "./is-negative-number.js";
 import { isNil } from "./is-nil.js";
 import { isNonEmptyArray } from "./is-non-empty-array.js";
+import { isNull } from "./is-null.js";
 import { isNumber } from "./is-number.js";
 import { isObject } from "./is-object.js";
 import { isPlainObject } from "./is-plain-object.js";
+import { isPositiveNumber } from "./is-positive-number.js";
 import { isPrimitive } from "./is-primitive.js";
+import { isPromise } from "./is-promise.js";
+import { isRegExp } from "./is-reg-exp.js";
+import { isSet } from "./is-set.js";
 import { isString } from "./is-string.js";
-export { isArray, isBoolean, isDate, isDefined, isEmptyObject, isError, isFunction, isNil, isNonEmptyArray, isNumber, isObject, isPlainObject, isPrimitive, isString };
+import { isSymbol } from "./is-symbol.js";
+import { isTruthy } from "./is-truthy.js";
+import { isUndefined } from "./is-undefined.js";
+export { isArray, isBoolean, isDate, isDefined, isEmptyArray, isEmptyObject, isError, isFalsy, isFunction, isMap, isNegativeNumber, isNil, isNonEmptyArray, isNull, isNumber, isObject, isPlainObject, isPositiveNumber, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTruthy, isUndefined };

package/dist/index.js

@@ -2,15 +2,27 @@ import { isArray } from "./is-array.js";
 import { isBoolean } from "./is-boolean.js";
 import { isDate } from "./is-date.js";
 import { isDefined } from "./is-defined.js";
+import { isEmptyArray } from "./is-empty-array.js";
 import { isPlainObject } from "./is-plain-object.js";
 import { isEmptyObject } from "./is-empty-object.js";
 import { isError } from "./is-error.js";
+import { isFalsy } from "./is-falsy.js";
 import { isFunction } from "./is-function.js";
+import { isMap } from "./is-map.js";
+import { isNegativeNumber } from "./is-negative-number.js";
 import { isNil } from "./is-nil.js";
 import { isNonEmptyArray } from "./is-non-empty-array.js";
+import { isNull } from "./is-null.js";
 import { isNumber } from "./is-number.js";
 import { isObject } from "./is-object.js";
+import { isPositiveNumber } from "./is-positive-number.js";
 import { isPrimitive } from "./is-primitive.js";
+import { isPromise } from "./is-promise.js";
+import { isRegExp } from "./is-reg-exp.js";
+import { isSet } from "./is-set.js";
 import { isString } from "./is-string.js";
+import { isSymbol } from "./is-symbol.js";
+import { isTruthy } from "./is-truthy.js";
+import { isUndefined } from "./is-undefined.js";
 
-export { isArray, isBoolean, isDate, isDefined, isEmptyObject, isError, isFunction, isNil, isNonEmptyArray, isNumber, isObject, isPlainObject, isPrimitive, isString };
+export { isArray, isBoolean, isDate, isDefined, isEmptyArray, isEmptyObject, isError, isFalsy, isFunction, isMap, isNegativeNumber, isNil, isNonEmptyArray, isNull, isNumber, isObject, isPlainObject, isPositiveNumber, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isTruthy, isUndefined };

package/dist/is-empty-array.d.ts

@@ -0,0 +1,19 @@
+//#region src/is-empty-array.d.ts
+/**
+ * isEmptyArray checks if the value is an empty array.
+ *
+ * @param v value to check.
+ * @returns {v is unknown[]} returns true if v is an empty array or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isEmptyArray([]) // true
+ * isEmptyArray([1, 2, 3]) // false
+ * isEmptyArray('hello') // false
+ * isEmptyArray({}) // false
+ * ```
+ */
+declare const isEmptyArray: (v: unknown) => v is unknown[];
+//#endregion
+export { isEmptyArray };
+//# sourceMappingURL=is-empty-array.d.ts.map

package/dist/is-empty-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-array.d.ts","names":[],"sources":["../src/is-empty-array.ts"],"mappings":";;;;;;;;;;;;;;;cAcM,YAAA,GAAgB,CAAA,cAAa,CAAA"}

package/dist/is-empty-array.js

@@ -0,0 +1,20 @@
+//#region src/is-empty-array.ts
+/**
+* isEmptyArray checks if the value is an empty array.
+*
+* @param v value to check.
+* @returns {v is unknown[]} returns true if v is an empty array or otherwise false.
+*
+* @example
+* ```ts
+* isEmptyArray([]) // true
+* isEmptyArray([1, 2, 3]) // false
+* isEmptyArray('hello') // false
+* isEmptyArray({}) // false
+* ```
+*/
+const isEmptyArray = (v) => Array.isArray(v) && v.length === 0;
+
+//#endregion
+export { isEmptyArray };
+//# sourceMappingURL=is-empty-array.js.map

package/dist/is-empty-array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-empty-array.js","names":[],"sources":["../src/is-empty-array.ts"],"sourcesContent":["/**\n * isEmptyArray checks if the value is an empty array.\n *\n * @param v value to check.\n * @returns {v is unknown[]} returns true if v is an empty array or otherwise false.\n *\n * @example\n * ```ts\n * isEmptyArray([]) // true\n * isEmptyArray([1, 2, 3]) // false\n * isEmptyArray('hello') // false\n * isEmptyArray({}) // false\n * ```\n */\nconst isEmptyArray = (v: unknown): v is unknown[] => Array.isArray(v) && v.length === 0\n\nexport { isEmptyArray }\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAM,gBAAgB,MAA+B,MAAM,QAAQ,EAAE,IAAI,EAAE,WAAW"}

package/dist/is-falsy.d.ts

@@ -0,0 +1,30 @@
+//#region src/is-falsy.d.ts
+type Falsy = false | 0 | 0n | '' | null | undefined;
+/**
+ * isFalsy checks if a value is falsy.
+ * A value is considered falsy if it is false, 0, 0n, '', null, or undefined.
+ * Useful for type narrowing in conditional statements.
+ * See isTruthy for the opposite of isFalsy.
+ *
+ * @param v value to check.
+ * @returns {v is Extract<T, Falsy>} returns true if v is falsy or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isFalsy(false) // true
+ * isFalsy(0) // true
+ * isFalsy(0n) // true
+ * isFalsy('') // true
+ * isFalsy(null) // true
+ * isFalsy(undefined) // true
+ * isFalsy(true) // false
+ * isFalsy(1) // false
+ * isFalsy('hello') // false
+ * isFalsy([]) // false
+ * isFalsy({}) // false
+ * ```
+ */
+declare const isFalsy: <T>(v: T) => v is Extract<T, Falsy>;
+//#endregion
+export { type Falsy, isFalsy };
+//# sourceMappingURL=is-falsy.d.ts.map

package/dist/is-falsy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-falsy.d.ts","names":[],"sources":["../src/is-falsy.ts"],"mappings":";KAAK,KAAA;;;;;;AAAK;;;;;;;;;;;;;;;;;;;cA0BJ,OAAA,MAAc,CAAA,EAAG,CAAA,KAAI,CAAA,IAAK,OAAA,CAAQ,CAAA,EAAG,KAAA"}

package/dist/is-falsy.js

@@ -0,0 +1,30 @@
+//#region src/is-falsy.ts
+/**
+* isFalsy checks if a value is falsy.
+* A value is considered falsy if it is false, 0, 0n, '', null, or undefined.
+* Useful for type narrowing in conditional statements.
+* See isTruthy for the opposite of isFalsy.
+*
+* @param v value to check.
+* @returns {v is Extract<T, Falsy>} returns true if v is falsy or otherwise false.
+*
+* @example
+* ```ts
+* isFalsy(false) // true
+* isFalsy(0) // true
+* isFalsy(0n) // true
+* isFalsy('') // true
+* isFalsy(null) // true
+* isFalsy(undefined) // true
+* isFalsy(true) // false
+* isFalsy(1) // false
+* isFalsy('hello') // false
+* isFalsy([]) // false
+* isFalsy({}) // false
+* ```
+*/
+const isFalsy = (v) => !v;
+
+//#endregion
+export { isFalsy };
+//# sourceMappingURL=is-falsy.js.map

package/dist/is-falsy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-falsy.js","names":[],"sources":["../src/is-falsy.ts"],"sourcesContent":["type Falsy = false | 0 | 0n | '' | null | undefined\n\n/**\n * isFalsy checks if a value is falsy.\n * A value is considered falsy if it is false, 0, 0n, '', null, or undefined.\n * Useful for type narrowing in conditional statements.\n * See isTruthy for the opposite of isFalsy.\n *\n * @param v value to check.\n * @returns {v is Extract<T, Falsy>} returns true if v is falsy or otherwise false.\n *\n * @example\n * ```ts\n * isFalsy(false) // true\n * isFalsy(0) // true\n * isFalsy(0n) // true\n * isFalsy('') // true\n * isFalsy(null) // true\n * isFalsy(undefined) // true\n * isFalsy(true) // false\n * isFalsy(1) // false\n * isFalsy('hello') // false\n * isFalsy([]) // false\n * isFalsy({}) // false\n * ```\n */\nconst isFalsy = <T>(v: T): v is Extract<T, Falsy> => !v\n\nexport type { Falsy }\n\nexport { isFalsy }\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,MAAM,WAAc,MAAiC,CAAC"}

package/dist/is-map.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-map.d.ts
+/**
+ * isMap checks if a value is a Map.
+ *
+ * @param v value to check.
+ * @returns {v is Map<unknown, unknown>} returns true if v is a Map or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isMap(new Map()) // true
+ * isMap(new Set()) // false
+ * isMap([]) // false
+ * isMap({}) // false
+ * isMap('hello') // false
+ * ```
+ */
+declare const isMap: (v: unknown) => v is Map<unknown, unknown>;
+//#endregion
+export { isMap };
+//# sourceMappingURL=is-map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-map.d.ts","names":[],"sources":["../src/is-map.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,KAAA,GAAS,CAAA,cAAa,CAAA,IAAK,GAAA"}

package/dist/is-map.js

@@ -0,0 +1,21 @@
+//#region src/is-map.ts
+/**
+* isMap checks if a value is a Map.
+*
+* @param v value to check.
+* @returns {v is Map<unknown, unknown>} returns true if v is a Map or otherwise false.
+*
+* @example
+* ```ts
+* isMap(new Map()) // true
+* isMap(new Set()) // false
+* isMap([]) // false
+* isMap({}) // false
+* isMap('hello') // false
+* ```
+*/
+const isMap = (v) => v instanceof Map;
+
+//#endregion
+export { isMap };
+//# sourceMappingURL=is-map.js.map

package/dist/is-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-map.js","names":[],"sources":["../src/is-map.ts"],"sourcesContent":["/**\n * isMap checks if a value is a Map.\n *\n * @param v value to check.\n * @returns {v is Map<unknown, unknown>} returns true if v is a Map or otherwise false.\n *\n * @example\n * ```ts\n * isMap(new Map()) // true\n * isMap(new Set()) // false\n * isMap([]) // false\n * isMap({}) // false\n * isMap('hello') // false\n * ```\n */\nconst isMap = (v: unknown): v is Map<unknown, unknown> => v instanceof Map\n\nexport { isMap }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,SAAS,MAA2C,aAAa"}

package/dist/is-negative-number.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-negative-number.d.ts
+/**
+ * isNegativeNumber checks if a value is a negative number.
+ * Note that zero is not considered a negative number.
+ *
+ * @param v value to check.
+ * @returns {v is number} returns true if v is a negative number or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNegativeNumber(-5) // true
+ * isNegativeNumber(5) // false
+ * isNegativeNumber(0) // false
+ * isNegativeNumber('hello') // false
+ * ```
+ */
+declare const isNegativeNumber: (v: unknown) => v is number;
+//#endregion
+export { isNegativeNumber };
+//# sourceMappingURL=is-negative-number.d.ts.map

package/dist/is-negative-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-negative-number.d.ts","names":[],"sources":["../src/is-negative-number.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,gBAAA,GAAoB,CAAA,cAAa,CAAA"}

package/dist/is-negative-number.js

@@ -0,0 +1,23 @@
+//#region src/is-negative-number.ts
+/**
+* isNegativeNumber checks if a value is a negative number.
+* Note that zero is not considered a negative number.
+*
+* @param v value to check.
+* @returns {v is number} returns true if v is a negative number or otherwise false.
+*
+* @example
+* ```ts
+* isNegativeNumber(-5) // true
+* isNegativeNumber(5) // false
+* isNegativeNumber(0) // false
+* isNegativeNumber('hello') // false
+* ```
+*/
+const isNegativeNumber = (v) => {
+	return typeof v === "number" && v < 0;
+};
+
+//#endregion
+export { isNegativeNumber };
+//# sourceMappingURL=is-negative-number.js.map

package/dist/is-negative-number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-negative-number.js","names":[],"sources":["../src/is-negative-number.ts"],"sourcesContent":["/**\n * isNegativeNumber checks if a value is a negative number.\n * Note that zero is not considered a negative number.\n *\n * @param v value to check.\n * @returns {v is number} returns true if v is a negative number or otherwise false.\n *\n * @example\n * ```ts\n * isNegativeNumber(-5) // true\n * isNegativeNumber(5) // false\n * isNegativeNumber(0) // false\n * isNegativeNumber('hello') // false\n * ```\n */\nconst isNegativeNumber = (v: unknown): v is number => {\n  return typeof v === 'number' && v < 0\n}\n\nexport { isNegativeNumber }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,oBAAoB,MAA4B;AACpD,QAAO,OAAO,MAAM,YAAY,IAAI"}

package/dist/is-null.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-null.d.ts
+/**
+ * isNull checks if a value is null.
+ *
+ * @param v value to check.
+ * @returns {v is null} returns true if v is null or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNull(null) // true
+ * isNull('hello') // false
+ * isNull(123) // false
+ * isNull({}) // false
+ * isNull([]) // false
+ * ```
+ */
+declare const isNull: (v: unknown) => v is null;
+//#endregion
+export { isNull };
+//# sourceMappingURL=is-null.d.ts.map

package/dist/is-null.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-null.d.ts","names":[],"sources":["../src/is-null.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,MAAA,GAAU,CAAA,cAAa,CAAA"}

package/dist/is-null.js

@@ -0,0 +1,21 @@
+//#region src/is-null.ts
+/**
+* isNull checks if a value is null.
+*
+* @param v value to check.
+* @returns {v is null} returns true if v is null or otherwise false.
+*
+* @example
+* ```ts
+* isNull(null) // true
+* isNull('hello') // false
+* isNull(123) // false
+* isNull({}) // false
+* isNull([]) // false
+* ```
+*/
+const isNull = (v) => v === null;
+
+//#endregion
+export { isNull };
+//# sourceMappingURL=is-null.js.map

package/dist/is-null.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-null.js","names":[],"sources":["../src/is-null.ts"],"sourcesContent":["/**\n * isNull checks if a value is null.\n *\n * @param v value to check.\n * @returns {v is null} returns true if v is null or otherwise false.\n *\n * @example\n * ```ts\n * isNull(null) // true\n * isNull('hello') // false\n * isNull(123) // false\n * isNull({}) // false\n * isNull([]) // false\n * ```\n */\nconst isNull = (v: unknown): v is null => v === null\n\nexport { isNull }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,UAAU,MAA0B,MAAM"}

package/dist/is-positive-number.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-positive-number.d.ts
+/**
+ * isPositiveNumber checks if a value is a positive number.
+ * Note that zero is not considered a positive number.
+ *
+ * @param value value to check.
+ * @returns {value is number} returns true if value is a positive number or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPositiveNumber(5) // true
+ * isPositiveNumber(-5) // false
+ * isPositiveNumber(0) // false
+ * isPositiveNumber('hello') // false
+ * ```
+ */
+declare const isPositiveNumber: (value: unknown) => value is number;
+//#endregion
+export { isPositiveNumber };
+//# sourceMappingURL=is-positive-number.d.ts.map

package/dist/is-positive-number.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-positive-number.d.ts","names":[],"sources":["../src/is-positive-number.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,gBAAA,GAAoB,KAAA,cAAiB,KAAA"}

package/dist/is-positive-number.js

@@ -0,0 +1,23 @@
+//#region src/is-positive-number.ts
+/**
+* isPositiveNumber checks if a value is a positive number.
+* Note that zero is not considered a positive number.
+*
+* @param value value to check.
+* @returns {value is number} returns true if value is a positive number or otherwise false.
+*
+* @example
+* ```ts
+* isPositiveNumber(5) // true
+* isPositiveNumber(-5) // false
+* isPositiveNumber(0) // false
+* isPositiveNumber('hello') // false
+* ```
+*/
+const isPositiveNumber = (value) => {
+	return typeof value === "number" && value > 0;
+};
+
+//#endregion
+export { isPositiveNumber };
+//# sourceMappingURL=is-positive-number.js.map

package/dist/is-positive-number.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-positive-number.js","names":[],"sources":["../src/is-positive-number.ts"],"sourcesContent":["/**\n * isPositiveNumber checks if a value is a positive number.\n * Note that zero is not considered a positive number.\n *\n * @param value value to check.\n * @returns {value is number} returns true if value is a positive number or otherwise false.\n *\n * @example\n * ```ts\n * isPositiveNumber(5) // true\n * isPositiveNumber(-5) // false\n * isPositiveNumber(0) // false\n * isPositiveNumber('hello') // false\n * ```\n */\nconst isPositiveNumber = (value: unknown): value is number => {\n  return typeof value === 'number' && value > 0\n}\n\nexport { isPositiveNumber }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,oBAAoB,UAAoC;AAC5D,QAAO,OAAO,UAAU,YAAY,QAAQ"}

package/dist/is-promise.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-promise.d.ts
+/**
+ * isPromise checks if a value is a Promise.
+ *
+ * @param v value to check.
+ * @returns {v is Promise<unknown>} returns true if v is a Promise or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPromise(Promise.resolve()) // true
+ * isPromise(new Set()) // false
+ * isPromise([]) // false
+ * isPromise({}) // false
+ * isPromise('hello') // false
+ * ```
+ */
+declare const isPromise: (v: unknown) => v is Promise<unknown>;
+//#endregion
+export { isPromise };
+//# sourceMappingURL=is-promise.d.ts.map

package/dist/is-promise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-promise.d.ts","names":[],"sources":["../src/is-promise.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,SAAA,GAAa,CAAA,cAAa,CAAA,IAAK,OAAA"}

package/dist/is-promise.js

@@ -0,0 +1,21 @@
+//#region src/is-promise.ts
+/**
+* isPromise checks if a value is a Promise.
+*
+* @param v value to check.
+* @returns {v is Promise<unknown>} returns true if v is a Promise or otherwise false.
+*
+* @example
+* ```ts
+* isPromise(Promise.resolve()) // true
+* isPromise(new Set()) // false
+* isPromise([]) // false
+* isPromise({}) // false
+* isPromise('hello') // false
+* ```
+*/
+const isPromise = (v) => typeof v === "object" && v !== null && typeof v.then === "function" && typeof v.catch === "function";
+
+//#endregion
+export { isPromise };
+//# sourceMappingURL=is-promise.js.map

package/dist/is-promise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-promise.js","names":[],"sources":["../src/is-promise.ts"],"sourcesContent":["/**\n * isPromise checks if a value is a Promise.\n *\n * @param v value to check.\n * @returns {v is Promise<unknown>} returns true if v is a Promise or otherwise false.\n *\n * @example\n * ```ts\n * isPromise(Promise.resolve()) // true\n * isPromise(new Set()) // false\n * isPromise([]) // false\n * isPromise({}) // false\n * isPromise('hello') // false\n * ```\n */\nconst isPromise = (v: unknown): v is Promise<unknown> =>\n  typeof v === 'object' &&\n  v !== null &&\n  typeof (v as Promise<unknown>).then === 'function' &&\n  typeof (v as Promise<unknown>).catch === 'function'\n\nexport { isPromise }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,aAAa,MACjB,OAAO,MAAM,YACb,MAAM,QACN,OAAQ,EAAuB,SAAS,cACxC,OAAQ,EAAuB,UAAU"}

package/dist/is-reg-exp.d.ts

@@ -0,0 +1,23 @@
+//#region src/is-reg-exp.d.ts
+/**
+ * isRegExp checks if a value is a regular expression.
+ *
+ * @param v value to check.
+ * @returns {v is RegExp} returns true if v is a RegExp or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isRegExp(/abc/) // true
+ * isRegExp(new RegExp('abc')) // true
+ * isRegExp('abc') // false
+ * isRegExp(123) // false
+ * isRegExp({}) // false
+ * isRegExp([]) // false
+ * isRegExp(null) // false
+ * isRegExp(undefined) // false
+ * ```
+ */
+declare const isRegExp: (v: unknown) => v is RegExp;
+//#endregion
+export { isRegExp };
+//# sourceMappingURL=is-reg-exp.d.ts.map

package/dist/is-reg-exp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-reg-exp.d.ts","names":[],"sources":["../src/is-reg-exp.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAkBM,QAAA,GAAY,CAAA,cAAa,CAAA,IAAK,MAAA"}

package/dist/is-reg-exp.js

@@ -0,0 +1,24 @@
+//#region src/is-reg-exp.ts
+/**
+* isRegExp checks if a value is a regular expression.
+*
+* @param v value to check.
+* @returns {v is RegExp} returns true if v is a RegExp or otherwise false.
+*
+* @example
+* ```ts
+* isRegExp(/abc/) // true
+* isRegExp(new RegExp('abc')) // true
+* isRegExp('abc') // false
+* isRegExp(123) // false
+* isRegExp({}) // false
+* isRegExp([]) // false
+* isRegExp(null) // false
+* isRegExp(undefined) // false
+* ```
+*/
+const isRegExp = (v) => v instanceof RegExp;
+
+//#endregion
+export { isRegExp };
+//# sourceMappingURL=is-reg-exp.js.map

package/dist/is-reg-exp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-reg-exp.js","names":[],"sources":["../src/is-reg-exp.ts"],"sourcesContent":["/**\n * isRegExp checks if a value is a regular expression.\n *\n * @param v value to check.\n * @returns {v is RegExp} returns true if v is a RegExp or otherwise false.\n *\n * @example\n * ```ts\n * isRegExp(/abc/) // true\n * isRegExp(new RegExp('abc')) // true\n * isRegExp('abc') // false\n * isRegExp(123) // false\n * isRegExp({}) // false\n * isRegExp([]) // false\n * isRegExp(null) // false\n * isRegExp(undefined) // false\n * ```\n */\nconst isRegExp = (v: unknown): v is RegExp => v instanceof RegExp\n\nexport { isRegExp }\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAkBA,MAAM,YAAY,MAA4B,aAAa"}

package/dist/is-set.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-set.d.ts
+/**
+ * isSet checks if a value is a Set.
+ *
+ * @param v value to check.
+ * @returns {v is Set<unknown>} returns true if v is a Set or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isSet(new Set()) // true
+ * isSet(new Map()) // false
+ * isSet([]) // false
+ * isSet({}) // false
+ * isSet('hello') // false
+ * ```
+ */
+declare const isSet: (v: unknown) => v is Set<unknown>;
+//#endregion
+export { isSet };
+//# sourceMappingURL=is-set.d.ts.map

package/dist/is-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-set.d.ts","names":[],"sources":["../src/is-set.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,KAAA,GAAS,CAAA,cAAa,CAAA,IAAK,GAAA"}

package/dist/is-set.js

@@ -0,0 +1,21 @@
+//#region src/is-set.ts
+/**
+* isSet checks if a value is a Set.
+*
+* @param v value to check.
+* @returns {v is Set<unknown>} returns true if v is a Set or otherwise false.
+*
+* @example
+* ```ts
+* isSet(new Set()) // true
+* isSet(new Map()) // false
+* isSet([]) // false
+* isSet({}) // false
+* isSet('hello') // false
+* ```
+*/
+const isSet = (v) => v instanceof Set;
+
+//#endregion
+export { isSet };
+//# sourceMappingURL=is-set.js.map

package/dist/is-set.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-set.js","names":[],"sources":["../src/is-set.ts"],"sourcesContent":["/**\n * isSet checks if a value is a Set.\n *\n * @param v value to check.\n * @returns {v is Set<unknown>} returns true if v is a Set or otherwise false.\n *\n * @example\n * ```ts\n * isSet(new Set()) // true\n * isSet(new Map()) // false\n * isSet([]) // false\n * isSet({}) // false\n * isSet('hello') // false\n * ```\n */\nconst isSet = (v: unknown): v is Set<unknown> => v instanceof Set\n\nexport { isSet }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,SAAS,MAAkC,aAAa"}

package/dist/is-symbol.d.ts

@@ -0,0 +1,20 @@
+//#region src/is-symbol.d.ts
+/**
+ * isSymbol checks if a value is a symbol.
+ *
+ * @param v value to check.
+ * @returns {v is symbol} returns true if v is a symbol or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isSymbol(Symbol('foo')) // true
+ * isSymbol('hello') // false
+ * isSymbol(123) // false
+ * isSymbol({}) // false
+ * isSymbol([]) // false
+ * ```
+ */
+declare const isSymbol: (v: unknown) => v is symbol;
+//#endregion
+export { isSymbol };
+//# sourceMappingURL=is-symbol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-symbol.d.ts","names":[],"sources":["../src/is-symbol.ts"],"mappings":";;;;;;;;;;;;;;;;cAeM,QAAA,GAAY,CAAA,cAAa,CAAA"}

package/dist/is-symbol.js

@@ -0,0 +1,21 @@
+//#region src/is-symbol.ts
+/**
+* isSymbol checks if a value is a symbol.
+*
+* @param v value to check.
+* @returns {v is symbol} returns true if v is a symbol or otherwise false.
+*
+* @example
+* ```ts
+* isSymbol(Symbol('foo')) // true
+* isSymbol('hello') // false
+* isSymbol(123) // false
+* isSymbol({}) // false
+* isSymbol([]) // false
+* ```
+*/
+const isSymbol = (v) => typeof v === "symbol";
+
+//#endregion
+export { isSymbol };
+//# sourceMappingURL=is-symbol.js.map

package/dist/is-symbol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-symbol.js","names":[],"sources":["../src/is-symbol.ts"],"sourcesContent":["/**\n * isSymbol checks if a value is a symbol.\n *\n * @param v value to check.\n * @returns {v is symbol} returns true if v is a symbol or otherwise false.\n *\n * @example\n * ```ts\n * isSymbol(Symbol('foo')) // true\n * isSymbol('hello') // false\n * isSymbol(123) // false\n * isSymbol({}) // false\n * isSymbol([]) // false\n * ```\n */\nconst isSymbol = (v: unknown): v is symbol => typeof v === 'symbol'\n\nexport { isSymbol }\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAM,YAAY,MAA4B,OAAO,MAAM"}

package/dist/is-truthy.d.ts

@@ -0,0 +1,31 @@
+import { Falsy } from "./is-falsy.js";
+
+//#region src/is-truthy.d.ts
+/**
+ * isTruthy checks if a value is truthy. A value is considered truthy if it is not falsy.
+ * Falsy values are false, 0, 0n, '', null, and undefined.
+ * Useful for type narrowing in conditional statements.
+ * See isFalsy for the opposite of isTruthy.
+ *
+ * @param v value to check.
+ * @returns {v is Exclude<T, Falsy>} returns true if v is truthy or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isTruthy(true) // true
+ * isTruthy(1) // true
+ * isTruthy('hello') // true
+ * isTruthy([]) // true
+ * isTruthy({}) // true
+ * isTruthy(false) // false
+ * isTruthy(0) // false
+ * isTruthy(0n) // false
+ * isTruthy('') // false
+ * isTruthy(null) // false
+ * isTruthy(undefined) // false
+ * ```
+ */
+declare const isTruthy: <T>(v: T) => v is Exclude<T, Falsy>;
+//#endregion
+export { isTruthy };
+//# sourceMappingURL=is-truthy.d.ts.map

package/dist/is-truthy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-truthy.d.ts","names":[],"sources":["../src/is-truthy.ts"],"mappings":";;;;;AAA0C;;;;;;;;;;;;;;;;;;;;;;cA0BpC,QAAA,MAAe,CAAA,EAAG,CAAA,KAAI,CAAA,IAAK,OAAA,CAAQ,CAAA,EAAG,KAAA"}