@naturalcycles/js-lib 14.101.0 → 14.104.0

package/dist-esm/error/assert.js

@@ -18,7 +18,10 @@ import { AppError } from './app.error';
 export function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
-        throw new AssertionError(message || 'see stacktrace', Object.assign({ userFriendly: true }, errorData));
+        throw new AssertionError(message || 'see stacktrace', {
+            userFriendly: true,
+            ...errorData,
+        });
     }
 }
 /**
@@ -36,7 +39,10 @@ export function _assertEquals(actual, expected, message, errorData) {
         ]
             .filter(Boolean)
             .join('\n');
-        throw new AssertionError(msg, Object.assign({ userFriendly: true }, errorData));
+        throw new AssertionError(msg, {
+            userFriendly: true,
+            ...errorData,
+        });
     }
 }
 /**
@@ -54,7 +60,10 @@ export function _assertDeepEquals(actual, expected, message, errorData) {
         ]
             .filter(Boolean)
             .join('\n');
-        throw new AssertionError(msg, Object.assign({ userFriendly: true }, errorData));
+        throw new AssertionError(msg, {
+            userFriendly: true,
+            ...errorData,
+        });
     }
 }
 export function _assertIsError(err, message) {

package/dist-esm/error/error.util.js

@@ -21,9 +21,8 @@ export function _anyToError(o, errorClass = Error, opt) {
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
 export function _anyToErrorObject(o, opt) {
-    var _a;
     if (o instanceof Error) {
-        return _errorToErrorObject(o, (_a = opt === null || opt === void 0 ? void 0 : opt.includeErrorStack) !== null && _a !== void 0 ? _a : true);
+        return _errorToErrorObject(o, opt?.includeErrorStack ?? true);
     }
     o = _jsonParseIfPossible(o);
     if (_isHttpErrorResponse(o)) {
@@ -36,7 +35,10 @@ export function _anyToErrorObject(o, opt) {
     // so, fair to return `data: {}` in the end
     // Also we're sure it includes no "error name", e.g no `Error: ...`,
     // so, fair to include `name: 'Error'`
-    const message = _stringifyAny(o, Object.assign({ includeErrorData: true }, opt));
+    const message = _stringifyAny(o, {
+        includeErrorData: true,
+        ...opt,
+    });
     return {
         name: 'Error',
         message,
@@ -47,7 +49,7 @@ export function _errorToErrorObject(e, includeErrorStack = true) {
     const obj = {
         name: e.name,
         message: e.message,
-        data: Object.assign({}, e.data), // empty by default
+        data: { ...e.data }, // empty by default
     };
     if (includeErrorStack) {
         obj.stack = e.stack;
@@ -81,14 +83,13 @@ export function _errorObjectToError(o, errorClass = Error) {
     return err;
 }
 export function _isHttpErrorResponse(o) {
-    return _isHttpErrorObject(o === null || o === void 0 ? void 0 : o.error);
+    return _isHttpErrorObject(o?.error);
 }
 export function _isHttpErrorObject(o) {
-    var _a;
     return (!!o &&
         typeof o.name === 'string' &&
         typeof o.message === 'string' &&
-        typeof ((_a = o.data) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 'number');
+        typeof o.data?.httpStatusCode === 'number');
 }
 /**
  * Note: any instance of AppError is also automatically an ErrorObject

package/dist-esm/error/tryCatch.js

@@ -29,7 +29,7 @@ export function _tryCatch(fn, opt = {}) {
                 try {
                     return await onError(_anyToError(err)); // eslint-disable-line @typescript-eslint/return-await
                 }
-                catch (_a) { }
+                catch { }
             }
             // returns undefined, but doesn't rethrow
         }

package/dist-esm/index.js

@@ -47,6 +47,7 @@ export * from './string/json.util';
 export * from './string/string.util';
 import { _stringifyAny } from './string/stringifyAny';
 export * from './time/time.util';
+export * from './is.util';
 import { END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues, } from './types';
 export * from './unit/size.util';
 import { is } from './vendor/is';

package/dist-esm/is.util.js

@@ -0,0 +1,59 @@
+export const _isNull = (v) => v === null;
+export const _isUndefined = (v) => typeof v === 'undefined';
+export const _isNullish = (v) => typeof v === 'undefined' || v === null;
+export const _isNotNullish = (v) => v !== undefined && v !== null;
+/**
+ * Same as Boolean, but with correct type output.
+ * Related:
+ * https://github.com/microsoft/TypeScript/issues/16655
+ * https://www.karltarvas.com/2021/03/11/typescript-array-filter-boolean.html
+ *
+ * @example
+ *
+ * [1, 2, undefined].filter(_isTruthy)
+ * // => [1, 2]
+ */
+export const _isTruthy = (v) => !!v;
+export const _isFalsy = (v) => !v;
+/**
+ * Returns true if item is Object, not null and not Array.
+ */
+export function _isObject(item) {
+    return (typeof item === 'object' && item !== null && !Array.isArray(item)) || false;
+}
+export function _isPrimitive(v) {
+    return (v === null ||
+        v === undefined ||
+        typeof v === 'number' ||
+        typeof v === 'boolean' ||
+        typeof v === 'string' ||
+        typeof v === 'bigint' ||
+        typeof v === 'symbol');
+}
+export function _isEmptyObject(obj) {
+    return obj && obj.constructor === Object && Object.keys(obj).length === 0;
+}
+/**
+ * Object is considered empty if it's one of:
+ * undefined
+ * null
+ * '' (empty string)
+ * [] (empty array)
+ * {} (empty object)
+ * new Map() (empty Map)
+ * new Set() (empty Set)
+ */
+export function _isEmpty(obj) {
+    if (obj === undefined || obj === null)
+        return true;
+    if (typeof obj === 'string' || Array.isArray(obj)) {
+        return obj.length === 0;
+    }
+    if (obj instanceof Map || obj instanceof Set) {
+        return obj.size === 0;
+    }
+    if (typeof obj === 'object') {
+        return Object.keys(obj).length === 0;
+    }
+    return false;
+}

package/dist-esm/json-schema/jsonSchema.util.js

@@ -6,7 +6,6 @@ import { _filterNullishValues } from '../object/object.util';
  * API similar to Object.assign(s1, s2)
  */
 export function mergeJsonSchemaObjects(s1, s2) {
-    var _a, _b;
     // Merge `properties`
     Object.entries(s2.properties).forEach(([k, v]) => {
         ;
@@ -18,8 +17,8 @@ export function mergeJsonSchemaObjects(s1, s2) {
         s1.patternProperties[k] = v;
     });
     s1.propertyNames = s2.propertyNames || s1.propertyNames;
-    s1.minProperties = (_a = s2.minProperties) !== null && _a !== void 0 ? _a : s1.minProperties;
-    s1.maxProperties = (_b = s2.maxProperties) !== null && _b !== void 0 ? _b : s1.maxProperties;
+    s1.minProperties = s2.minProperties ?? s1.minProperties;
+    s1.maxProperties = s2.maxProperties ?? s1.maxProperties;
     // Merge `required`
     s1.required.push(...s2.required);
     s1.required = _uniq(s1.required).sort();

package/dist-esm/json-schema/jsonSchemaBuilder.js

@@ -47,6 +47,9 @@ export const jsonSchema = {
     unixTimestamp() {
         return new JsonSchemaNumberBuilder().unixTimestamp();
     },
+    unixTimestamp2000() {
+        return new JsonSchemaNumberBuilder().unixTimestamp2000();
+    },
     // string types
     string() {
         return new JsonSchemaStringBuilder();
@@ -163,7 +166,9 @@ export class JsonSchemaNumberBuilder extends JsonSchemaAnyBuilder {
         this.float = () => this.format('float');
         this.double = () => this.format('double');
         this.unixTimestamp = () => this.format('unixTimestamp');
+        this.unixTimestamp2000 = () => this.format('unixTimestamp2000');
         this.unixTimestampMillis = () => this.format('unixTimestampMillis');
+        this.unixTimestampMillis2000 = () => this.format('unixTimestampMillis2000');
         this.utcOffset = () => this.format('utcOffset');
         this.utcOffsetHours = () => this.format('utcOffsetHours');
     }
@@ -245,12 +250,11 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
         return this;
     }
     transformModify(t, add) {
-        var _a;
         if (add) {
             this.schema.transform = _uniq([...(this.schema.transform || []), t]);
         }
         else {
-            this.schema.transform = (_a = this.schema.transform) === null || _a === void 0 ? void 0 : _a.filter(s => s !== t);
+            this.schema.transform = this.schema.transform?.filter(s => s !== t);
         }
         return this;
     }
@@ -304,8 +308,8 @@ export class JsonSchemaObjectBuilder extends JsonSchemaAnyBuilder {
     baseDBEntity(idType = 'string') {
         Object.assign(this.schema.properties, {
             id: { type: idType },
-            created: { type: 'number', format: 'unixTimestamp' },
-            updated: { type: 'number', format: 'unixTimestamp' },
+            created: { type: 'number', format: 'unixTimestamp2000' },
+            updated: { type: 'number', format: 'unixTimestamp2000' },
         });
         return this;
     }

package/dist-esm/json-schema/jsonSchemas.js

@@ -1,11 +1,11 @@
 import { jsonSchema } from './jsonSchemaBuilder';
 export const baseDBEntityJsonSchema = jsonSchema.object({
     id: jsonSchema.string().optional(),
-    created: jsonSchema.unixTimestamp().optional(),
-    updated: jsonSchema.unixTimestamp().optional(),
+    created: jsonSchema.unixTimestamp2000().optional(),
+    updated: jsonSchema.unixTimestamp2000().optional(),
 });
 export const savedDBEntityJsonSchema = jsonSchema.object({
     id: jsonSchema.string(),
-    created: jsonSchema.unixTimestamp(),
-    updated: jsonSchema.unixTimestamp(),
+    created: jsonSchema.unixTimestamp2000(),
+    updated: jsonSchema.unixTimestamp2000(),
 });

package/dist-esm/math/math.util.js

@@ -14,7 +14,7 @@ export function _average(values) {
  * Same as _average, but safely returns null if input array is empty or nullish.
  */
 export function _averageOrNull(values) {
-    return (values === null || values === void 0 ? void 0 : values.length) ? values.reduce((a, b) => a + b) / values.length : null;
+    return values?.length ? values.reduce((a, b) => a + b) / values.length : null;
 }
 /**
  * valuesArray and weightsArray length is expected to be the same.

package/dist-esm/object/object.util.js

@@ -1,3 +1,4 @@
+import { _isEmpty, _isObject } from '../is.util';
 /**
  * Returns clone of `obj` with only `props` preserved.
  * Opposite of Omit.
@@ -28,7 +29,7 @@ export function _omit(obj, props, mutate = false) {
     return props.reduce((r, prop) => {
         delete r[prop];
         return r;
-    }, mutate ? obj : Object.assign({}, obj));
+    }, mutate ? obj : { ...obj });
 }
 /**
  * Returns object with filtered keys from `props` array.
@@ -75,7 +76,7 @@ export function _filterObject(obj, predicate, mutate = false) {
         if (!predicate(k, r[k], obj))
             delete r[k];
         return r;
-    }, mutate ? obj : Object.assign({}, obj));
+    }, mutate ? obj : { ...obj });
 }
 /**
  * var users = {
@@ -136,8 +137,7 @@ export function _mapObject(obj, mapper) {
     }, {});
 }
 export function _findKeyByValue(obj, v) {
-    var _a;
-    return (_a = Object.entries(obj).find(([_, value]) => value === v)) === null || _a === void 0 ? void 0 : _a[0];
+    return Object.entries(obj).find(([_, value]) => value === v)?.[0];
 }
 export function _objectNullValuesToUndefined(obj, mutate = false) {
     return _mapValues(obj, (_k, v) => (v === null ? undefined : v), mutate);
@@ -148,46 +148,6 @@ export function _objectNullValuesToUndefined(obj, mutate = false) {
 export function _deepCopy(o) {
     return JSON.parse(JSON.stringify(o));
 }
-/**
- * Returns true if item is Object, not null and not Array.
- */
-export function _isObject(item) {
-    return (typeof item === 'object' && item !== null && !Array.isArray(item)) || false;
-}
-export function _isPrimitive(v) {
-    return (v === null ||
-        v === undefined ||
-        typeof v === 'number' ||
-        typeof v === 'boolean' ||
-        typeof v === 'string');
-}
-export function _isEmptyObject(obj) {
-    return obj && obj.constructor === Object && Object.keys(obj).length === 0;
-}
-/**
- * Object is considered empty if it's one of:
- * undefined
- * null
- * '' (empty string)
- * [] (empty array)
- * {} (empty object)
- * new Map() (empty Map)
- * new Set() (empty Set)
- */
-export function _isEmpty(obj) {
-    if (obj === undefined || obj === null)
-        return true;
-    if (typeof obj === 'string' || Array.isArray(obj)) {
-        return obj.length === 0;
-    }
-    if (obj instanceof Map || obj instanceof Set) {
-        return obj.size === 0;
-    }
-    if (typeof obj === 'object') {
-        return Object.keys(obj).length === 0;
-    }
-    return false;
-}
 /**
  * Returns `undefined` if it's empty (according to `_isEmpty()` specification),
  * otherwise returns the original object.

package/dist-esm/object/sortObjectDeep.js

@@ -1,4 +1,4 @@
-import { _isObject } from './object.util';
+import { _isObject } from '..';
 /**
  * based on: https://github.com/IndigoUnited/js-deep-sort-object
  */

package/dist-esm/promise/pMap.js

@@ -6,7 +6,6 @@ Improvements:
 - Included Typescript typings (no need for @types/p-map)
 - Compatible with pProps (that had typings issues)
  */
-import { __asyncValues } from "tslib";
 import { END, ErrorMode, SKIP } from '..';
 import { AggregatedError } from './AggregatedError';
 /**
@@ -36,7 +35,6 @@ import { AggregatedError } from './AggregatedError';
  * })();
  */
 export async function pMap(iterable, mapper, opt = {}) {
-    var e_1, _a;
     const ret = [];
     // const iterator = iterable[Symbol.iterator]()
     const items = [...iterable];
@@ -50,33 +48,23 @@ export async function pMap(iterable, mapper, opt = {}) {
     let currentIndex = 0;
     // Special cases that are able to preserve async stack traces
     if (concurrency === 1) {
-        try {
-            // Special case for concurrency == 1
-            for (var items_1 = __asyncValues(items), items_1_1; items_1_1 = await items_1.next(), !items_1_1.done;) {
-                const item = items_1_1.value;
-                try {
-                    const r = await mapper(item, currentIndex++);
-                    if (r === END)
-                        break;
-                    if (r !== SKIP)
-                        ret.push(r);
-                }
-                catch (err) {
-                    if (errorMode === ErrorMode.THROW_IMMEDIATELY)
-                        throw err;
-                    if (errorMode === ErrorMode.THROW_AGGREGATED) {
-                        errors.push(err);
-                    }
-                    // otherwise, suppress completely
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
+        // Special case for concurrency == 1
+        for await (const item of items) {
             try {
-                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) await _a.call(items_1);
+                const r = await mapper(item, currentIndex++);
+                if (r === END)
+                    break;
+                if (r !== SKIP)
+                    ret.push(r);
+            }
+            catch (err) {
+                if (errorMode === ErrorMode.THROW_IMMEDIATELY)
+                    throw err;
+                if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                    errors.push(err);
+                }
+                // otherwise, suppress completely
             }
-            finally { if (e_1) throw e_1.error; }
         }
         if (errors.length) {
             throw new AggregatedError(errors, ret);

package/dist-esm/promise/pQueue.js

@@ -13,9 +13,14 @@ export class PQueue {
         this.inFlight = 0;
         this.queue = [];
         this.onIdleListeners = [];
-        this.cfg = Object.assign({ 
+        this.cfg = {
             // concurrency: Number.MAX_SAFE_INTEGER,
-            errorMode: ErrorMode.THROW_IMMEDIATELY, logger: console, debug: false, resolveOn: 'finish' }, cfg);
+            errorMode: ErrorMode.THROW_IMMEDIATELY,
+            logger: console,
+            debug: false,
+            resolveOn: 'finish',
+            ...cfg,
+        };
         if (!cfg.debug) {
             this.debug = () => { };
         }

package/dist-esm/promise/pRetry.js

@@ -72,7 +72,10 @@ export async function pRetry(fn, opt = {}) {
                         });
                     }
                     ;
-                    err.data = Object.assign(Object.assign({}, err.data), opt.errorData);
+                    err.data = {
+                        ...err.data,
+                        ...opt.errorData,
+                    };
                     reject(err);
                 }
                 else {

package/dist-esm/promise/pTimeout.js

@@ -32,7 +32,10 @@ export async function pTimeout(promise, opt) {
                 catch (err) {
                     if (fakeError)
                         err.stack = fakeError.stack; // keep original stack
-                    err.data = Object.assign(Object.assign({}, err.data), opt.errorData);
+                    err.data = {
+                        ...err.data,
+                        ...opt.errorData,
+                    };
                     reject(err);
                 }
                 return;

package/dist-esm/string/json.util.js

@@ -10,7 +10,7 @@ export function _jsonParseIfPossible(obj, reviver) {
         try {
             return JSON.parse(obj, reviver);
         }
-        catch (_a) { }
+        catch { }
     }
     return obj;
 }

package/dist-esm/string/safeJsonStringify.js

@@ -8,7 +8,7 @@ export function _safeJsonStringify(obj, replacer, spaces, cycleReplacer) {
         // Try native first (as it's ~3 times faster)
         return JSON.stringify(obj, replacer, spaces);
     }
-    catch (_a) {
+    catch {
         // Native failed - resort to the "safe" serializer
         return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
     }

package/dist-esm/string/stringifyAny.js

@@ -85,7 +85,7 @@ export function _stringifyAny(obj, opt = {}) {
             const { stringifyFn = _safeJsonStringify } = opt;
             s = stringifyFn(obj, undefined, 2);
         }
-        catch (_a) {
+        catch {
             s = String(obj); // fallback
         }
     }

package/dist-esm/vendor/is.js

@@ -138,15 +138,15 @@ is.array = (value, assertion) => {
     }
     return value.every(assertion);
 };
-is.buffer = (value) => { var _a, _b, _c; return (_c = (_b = (_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.isBuffer) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : false; };
+is.buffer = (value) => value?.constructor?.isBuffer?.(value) ?? false;
 is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
 is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
-is.iterable = (value) => is.function_(value === null || value === void 0 ? void 0 : value[Symbol.iterator]);
-is.asyncIterable = (value) => is.function_(value === null || value === void 0 ? void 0 : value[Symbol.asyncIterator]);
+is.iterable = (value) => is.function_(value?.[Symbol.iterator]);
+is.asyncIterable = (value) => is.function_(value?.[Symbol.asyncIterator]);
 is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
 is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
 is.nativePromise = (value) => isObjectOfType('Promise')(value);
-const hasPromiseAPI = (value) => is.function_(value === null || value === void 0 ? void 0 : value.then) && is.function_(value === null || value === void 0 ? void 0 : value.catch);
+const hasPromiseAPI = (value) => is.function_(value?.then) && is.function_(value?.catch);
 is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
 is.generatorFunction = isObjectOfType('GeneratorFunction');
 is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
@@ -184,7 +184,7 @@ is.urlString = (value) => {
         new URL(value); // eslint-disable-line no-new
         return true;
     }
-    catch (_a) {
+    catch {
         return false;
     }
 };
@@ -235,14 +235,13 @@ is.domElement = (value) => {
         DOM_PROPERTIES_TO_CHECK.every(property => property in value));
 };
 is.observable = (value) => {
-    var _a, _b, _c, _d;
     if (!value) {
         return false;
     }
-    if (value === ((_b = (_a = value)[Symbol.observable]) === null || _b === void 0 ? void 0 : _b.call(_a))) {
+    if (value === value[Symbol.observable]?.()) {
         return true;
     }
-    if (value === ((_d = (_c = value)['@@observable']) === null || _d === void 0 ? void 0 : _d.call(_c))) {
+    if (value === value['@@observable']?.()) {
         return true;
     }
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.101.0",
+  "version": "14.104.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/array/array.util.ts

@@ -1,5 +1,6 @@
+import { _isNotNullish } from '../is.util'
 import { RecursiveArray } from '../lodash.types'
-import { Mapper, Predicate, StringMap } from '../types'
+import { FalsyValue, Mapper, Predicate, StringMap } from '../types'
 
 /**
  * Creates an array of elements split into groups the length of size. If collection can’t be split evenly, the
@@ -216,6 +217,9 @@ export function _difference<T>(source: T[], ...diffs: T[][]): T[] {
   return diffs.reduce((a, b) => a.filter(c => !b.includes(c)), source)
 }
 
+/**
+ * Returns the sum of items, or 0 for empty array.
+ */
 export function _sum(items: number[]): number {
   return items.reduce((sum, n) => sum + n, 0)
 }
@@ -242,7 +246,7 @@ export function _sumBy<T>(items: T[], mapper: Mapper<T, number | undefined>): nu
  */
 export function _mapToObject<T, V>(
   array: T[],
-  mapper: (item: T) => [key: any, value: V] | undefined | null | false | 0 | void,
+  mapper: (item: T) => [key: any, value: V] | FalsyValue,
 ): StringMap<V> {
   const m: StringMap<V> = {}
 
@@ -288,22 +292,32 @@ export function _lastOrUndefined<T>(array: T[]): T | undefined {
   return array[array.length - 1]
 }
 
-export function _minOrUndefined<T>(array: T[]): T | undefined {
-  if (!array.length) return
-  return _min(array)
+export function _minOrUndefined<T>(array: T[]): NonNullable<T> | undefined {
+  const a = array.filter(_isNotNullish)
+  if (!a.length) return
+  return _min(a)
 }
 
-export function _min<T>(array: T[]): T {
-  if (!array.length) throw new Error('_min called on empty array')
-  return array.reduce((min, item) => (min <= item ? min : item))
+/**
+ * Filters out nullish values (undefined and null).
+ */
+export function _min<T>(array: T[]): NonNullable<T> {
+  const a = array.filter(_isNotNullish)
+  if (!a.length) throw new Error('_min called on empty array')
+  return a.reduce((min, item) => (min <= item ? min : item))
 }
 
-export function _maxOrUndefined<T>(array: T[]): T | undefined {
-  if (!array.length) return
-  return _max(array)
+export function _maxOrUndefined<T>(array: T[]): NonNullable<T> | undefined {
+  const a = array.filter(_isNotNullish)
+  if (!a.length) return
+  return _max(a)
 }
 
-export function _max<T>(array: T[]): T {
-  if (!array.length) throw new Error('_max called on empty array')
-  return array.reduce((max, item) => (max >= item ? max : item))
+/**
+ * Filters out nullish values (undefined and null).
+ */
+export function _max<T>(array: T[]): NonNullable<T> {
+  const a = array.filter(_isNotNullish)
+  if (!a.length) throw new Error('_max called on empty array')
+  return a.reduce((max, item) => (max >= item ? max : item))
 }

package/src/decorators/memo.util.ts

@@ -1,4 +1,4 @@
-import { _isPrimitive } from '../object/object.util'
+import { _isPrimitive } from '..'
 import { Promisable } from '../typeFest'
 
 export type MemoSerializer = (args: any[]) => any

package/src/index.ts

@@ -83,6 +83,8 @@ export * from './string/json.util'
 export * from './string/string.util'
 import { JsonStringifyFunction, StringifyAnyOptions, _stringifyAny } from './string/stringifyAny'
 export * from './time/time.util'
+export * from './is.util'
+
 import {
   Class,
   ConditionalExcept,
@@ -129,6 +131,8 @@ import {
   AbortableAsyncPredicate,
   AbortableAsyncMapper,
   AbortablePredicate,
+  NullishValue,
+  FalsyValue,
   END,
   SKIP,
   _noop,
@@ -224,6 +228,8 @@ export type {
   IsoDateString,
   IsoDateTimeString,
   Reviver,
+  FalsyValue,
+  NullishValue,
   PMapOptions,
   Mapper,
   AsyncMapper,