@jblib/is 0.0.6 → 0.0.7

package/dist/index.d.ts

@@ -2,17 +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";
+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, isNegativeNumber, isNil, isNonEmptyArray, isNumber, isObject, isPlainObject, isPositiveNumber, isPrimitive, isString, isUndefined };
+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,18 +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, isNegativeNumber, isNil, isNonEmptyArray, isNumber, isObject, isPlainObject, isPositiveNumber, isPrimitive, isString, isUndefined };
+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-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-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"}

package/dist/is-truthy.js

@@ -0,0 +1,30 @@
+//#region src/is-truthy.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
+* ```
+*/
+const isTruthy = (v) => !!v;
+
+//#endregion
+export { isTruthy };
+//# sourceMappingURL=is-truthy.js.map

package/dist/is-truthy.js.map

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

package/dist/is-undefined.js

@@ -14,7 +14,7 @@
 * isUndefined([]) // false
 * ```
 */
-const isUndefined = (v) => typeof v === "undefined";
+const isUndefined = (v) => v === void 0;
 
 //#endregion
 export { isUndefined };

package/dist/is-undefined.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jblib/is",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "is, condition checks",
   "type": "module",
   "devDependencies": {

package/src/index.ts

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

package/src/is-empty-array.spec.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { isEmptyArray } from './is-empty-array.js'
+
+describe('is empty array', () => {
+  it('should return true for empty arrays', () => {
+    expect(isEmptyArray([])).toBe(true)
+  })
+
+  it('should return false for non-empty arrays', () => {
+    expect(isEmptyArray([1, 2, 3])).toBe(false)
+  })
+
+  it('should return false for non-arrays', () => {
+    expect(isEmptyArray('hello')).toBe(false)
+    expect(isEmptyArray({})).toBe(false)
+    expect(isEmptyArray(123)).toBe(false)
+    expect(isEmptyArray(null)).toBe(false)
+    expect(isEmptyArray(undefined)).toBe(false)
+  })
+})

package/src/is-empty-array.ts

@@ -0,0 +1,17 @@
+/**
+ * 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: unknown): v is unknown[] => Array.isArray(v) && v.length === 0
+
+export { isEmptyArray }

package/src/is-falsy.spec.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+
+import { isFalsy } from './is-falsy.js'
+
+describe('is falsy', () => {
+  it('should return true for falsy values', () => {
+    expect(isFalsy(false)).toBe(true)
+    expect(isFalsy(0)).toBe(true)
+    expect(isFalsy(0n)).toBe(true)
+    expect(isFalsy('')).toBe(true)
+    expect(isFalsy(null)).toBe(true)
+    expect(isFalsy(undefined)).toBe(true)
+  })
+
+  it('should return false for non-falsy values', () => {
+    expect(isFalsy(true)).toBe(false)
+    expect(isFalsy(1)).toBe(false)
+    expect(isFalsy('hello')).toBe(false)
+    expect(isFalsy([])).toBe(false)
+    expect(isFalsy({})).toBe(false)
+  })
+})

package/src/is-falsy.ts

@@ -0,0 +1,31 @@
+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
+ * ```
+ */
+const isFalsy = <T>(v: T): v is Extract<T, Falsy> => !v
+
+export type { Falsy }
+
+export { isFalsy }

package/src/is-map.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import { isMap } from './is-map.js'
+
+describe('is map', () => {
+  it('should return true for maps', () => {
+    expect(isMap(new Map())).toBe(true)
+  })
+
+  it('should return false for non-maps', () => {
+    expect(isMap(123)).toBe(false)
+    expect(isMap({})).toBe(false)
+    expect(isMap([])).toBe(false)
+    expect(isMap(null)).toBe(false)
+    expect(isMap(undefined)).toBe(false)
+  })
+})

package/src/is-map.ts

@@ -0,0 +1,18 @@
+/**
+ * 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: unknown): v is Map<unknown, unknown> => v instanceof Map
+
+export { isMap }

package/src/is-null.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import { isNull } from './is-null.js'
+
+describe('is null', () => {
+  it('should return true for null values', () => {
+    expect(isNull(null)).toBe(true)
+  })
+
+  it('should return false for non-null values', () => {
+    expect(isNull([])).toBe(false)
+    expect(isNull('hello')).toBe(false)
+    expect(isNull({})).toBe(false)
+    expect(isNull(123)).toBe(false)
+    expect(isNull(undefined)).toBe(false)
+  })
+})

package/src/is-null.ts

@@ -0,0 +1,18 @@
+/**
+ * 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: unknown): v is null => v === null
+
+export { isNull }

package/src/is-promise.spec.ts

@@ -0,0 +1,27 @@
+import { describe, expect, it } from 'vitest'
+
+import { isPromise } from './is-promise.js'
+
+describe('is promise', () => {
+  it('should return true for promises', () => {
+    expect(
+      isPromise({
+        then: () => {
+          void 0
+        },
+        catch: () => {
+          void 0
+        },
+      }),
+    ).toBe(true)
+    expect(isPromise(Promise.resolve())).toBe(true)
+  })
+
+  it('should return false for non-promises', () => {
+    expect(isPromise(123)).toBe(false)
+    expect(isPromise({})).toBe(false)
+    expect(isPromise([])).toBe(false)
+    expect(isPromise(null)).toBe(false)
+    expect(isPromise(undefined)).toBe(false)
+  })
+})

package/src/is-promise.ts

@@ -0,0 +1,22 @@
+/**
+ * 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: unknown): v is Promise<unknown> =>
+  typeof v === 'object' &&
+  v !== null &&
+  typeof (v as Promise<unknown>).then === 'function' &&
+  typeof (v as Promise<unknown>).catch === 'function'
+
+export { isPromise }

package/src/is-reg-exp.spec.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+
+import { isRegExp } from './is-reg-exp.js'
+
+describe('is reg exp', () => {
+  it('should return true for regexp values', () => {
+    expect(isRegExp(/abc/)).toBe(true)
+    expect(isRegExp(new RegExp('abc'))).toBe(true)
+  })
+
+  it('should return false for non-regexp values', () => {
+    expect(isRegExp('abc')).toBe(false)
+    expect(isRegExp(123)).toBe(false)
+    expect(isRegExp({})).toBe(false)
+    expect(isRegExp([])).toBe(false)
+    expect(isRegExp(null)).toBe(false)
+    expect(isRegExp(undefined)).toBe(false)
+  })
+})

package/src/is-reg-exp.ts

@@ -0,0 +1,21 @@
+/**
+ * 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: unknown): v is RegExp => v instanceof RegExp
+
+export { isRegExp }

package/src/is-set.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import { isSet } from './is-set.js'
+
+describe('is set', () => {
+  it('should return true for sets', () => {
+    expect(isSet(new Set())).toBe(true)
+  })
+
+  it('should return false for non-sets', () => {
+    expect(isSet(123)).toBe(false)
+    expect(isSet({})).toBe(false)
+    expect(isSet([])).toBe(false)
+    expect(isSet(null)).toBe(false)
+    expect(isSet(undefined)).toBe(false)
+  })
+})

package/src/is-set.ts

@@ -0,0 +1,18 @@
+/**
+ * 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: unknown): v is Set<unknown> => v instanceof Set
+
+export { isSet }

package/src/is-symbol.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+
+import { isSymbol } from './is-symbol.js'
+
+describe('is symbol', () => {
+  it('should return true for symbols', () => {
+    expect(isSymbol(Symbol('foo'))).toBe(true)
+  })
+
+  it('should return false for non-symbols', () => {
+    expect(isSymbol(123)).toBe(false)
+    expect(isSymbol('hello')).toBe(false)
+    expect(isSymbol({})).toBe(false)
+    expect(isSymbol([])).toBe(false)
+    expect(isSymbol(null)).toBe(false)
+    expect(isSymbol(undefined)).toBe(false)
+  })
+})

package/src/is-symbol.ts

@@ -0,0 +1,18 @@
+/**
+ * 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: unknown): v is symbol => typeof v === 'symbol'
+
+export { isSymbol }

package/src/is-truthy.spec.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest'
+
+import { isTruthy } from './is-truthy.js'
+
+describe('is truthy', () => {
+  it('should return true for truthy values', () => {
+    expect(isTruthy(true)).toBe(true)
+    expect(isTruthy(1)).toBe(true)
+    expect(isTruthy('hello')).toBe(true)
+    expect(isTruthy([])).toBe(true)
+    expect(isTruthy({})).toBe(true)
+  })
+
+  it('should return false for non-truthy values', () => {
+    expect(isTruthy(false)).toBe(false)
+    expect(isTruthy(0)).toBe(false)
+    expect(isTruthy(0n)).toBe(false)
+    expect(isTruthy('')).toBe(false)
+    expect(isTruthy(null)).toBe(false)
+    expect(isTruthy(undefined)).toBe(false)
+  })
+})

package/src/is-truthy.ts

@@ -0,0 +1,29 @@
+import { type Falsy } from './is-falsy.js'
+
+/**
+ * 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
+ * ```
+ */
+const isTruthy = <T>(v: T): v is Exclude<T, Falsy> => !!v
+
+export { isTruthy }

package/src/is-undefined.ts

@@ -13,6 +13,6 @@
  * isUndefined([]) // false
  * ```
  */
-const isUndefined = (v: unknown): v is undefined => typeof v === 'undefined'
+const isUndefined = (v: unknown): v is undefined => v === undefined
 
 export { isUndefined }