@ls-stack/utils 2.2.0 → 2.4.0

package/dist/{chunk-3PXKYWJF.js → chunk-KBFP7INB.js}

@@ -1,3 +1,6 @@
+import {
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
 import {
   isObject
 } from "./chunk-4UGSP3L3.js";
@@ -47,15 +50,15 @@ function err(error) {
       if (error instanceof Error) {
         throw error;
       }
-      throw normalizeError(error);
+      throw unknownToError(error);
     },
     mapOk: returnResult,
     mapErr: errMap,
     mapOkAndErr
   };
 }
-function unknownToError(error) {
-  return err(normalizeError(error));
+function unknownToResultError(error) {
+  return err(unknownToError(error));
 }
 async function asyncUnwrap(result) {
   const unwrapped = await result;
@@ -65,7 +68,7 @@ async function asyncUnwrap(result) {
   if (unwrapped.error instanceof Error) {
     throw unwrapped.error;
   }
-  throw normalizeError(unwrapped.error);
+  throw unknownToError(unwrapped.error);
 }
 function asyncMap(resultPromise) {
   return {
@@ -89,7 +92,7 @@ function asyncMap(resultPromise) {
 var Result = {
   ok,
   err,
-  unknownToError,
+  unknownToError: unknownToResultError,
   asyncUnwrap,
   asyncMap
 };
@@ -98,7 +101,7 @@ function resultify(fn, errorNormalizer) {
     return ok(fn());
   } catch (error) {
     return err(
-      errorNormalizer ? errorNormalizer(error) : normalizeError(error)
+      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
     );
   }
 }
@@ -107,11 +110,11 @@ async function asyncResultify(fn, errorNormalizer) {
     return ok(await fn());
   } catch (error) {
     return err(
-      errorNormalizer ? errorNormalizer(error) : normalizeError(error)
+      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
     );
   }
 }
-function normalizeError(error) {
+function unknownToError(error) {
   if (error instanceof Error) return error;
   if (typeof error === "string") {
     return new Error(error);
@@ -122,15 +125,14 @@ function normalizeError(error) {
       { cause: error }
     );
   }
-  return new Error(safeJsonStringify(error) ?? "unknown", { cause: error });
+  return new Error(safeJsonStringify(error) ?? "unknown", {
+    cause: error
+  });
 }
-function safeJsonStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (_) {
-    return null;
-  }
+function normalizeError(error) {
+  return unknownToError(error);
 }
+var safeJsonStringify2 = safeJsonStringify;
 function createTypedResult() {
   return {
     ok,
@@ -142,7 +144,8 @@ export {
   Result,
   resultify,
   asyncResultify,
+  unknownToError,
   normalizeError,
-  safeJsonStringify,
+  safeJsonStringify2 as safeJsonStringify,
   createTypedResult
 };

package/dist/chunk-VAAMRG4K.js

@@ -0,0 +1,20 @@
+// src/safeJson.ts
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return void 0;
+  }
+}
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch (_) {
+    return void 0;
+  }
+}
+
+export {
+  safeJsonStringify,
+  safeJsonParse
+};

package/dist/main.d.ts

@@ -18,6 +18,7 @@
 ///<reference path="promiseUtils.d.ts" />
 ///<reference path="rsResult.d.ts" />
 ///<reference path="runShellCmd.d.ts" />
+///<reference path="safeJson.d.ts" />
 ///<reference path="shallowEqual.d.ts" />
 ///<reference path="sleep.d.ts" />
 ///<reference path="stringUtils.d.ts" />

package/dist/parallelAsyncCalls.cjs

@@ -34,6 +34,15 @@ function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/safeJson.ts
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return void 0;
+  }
+}
+
 // src/rsResult.ts
 function okUnwrapOr() {
   return this.value;
@@ -79,15 +88,15 @@ function err(error) {
       if (error instanceof Error) {
         throw error;
       }
-      throw normalizeError(error);
+      throw unknownToError(error);
     },
     mapOk: returnResult,
     mapErr: errMap,
     mapOkAndErr
   };
 }
-function unknownToError(error) {
-  return err(normalizeError(error));
+function unknownToResultError(error) {
+  return err(unknownToError(error));
 }
 async function asyncUnwrap(result) {
   const unwrapped = await result;
@@ -97,7 +106,7 @@ async function asyncUnwrap(result) {
   if (unwrapped.error instanceof Error) {
     throw unwrapped.error;
   }
-  throw normalizeError(unwrapped.error);
+  throw unknownToError(unwrapped.error);
 }
 function asyncMap(resultPromise) {
   return {
@@ -121,11 +130,11 @@ function asyncMap(resultPromise) {
 var Result = {
   ok,
   err,
-  unknownToError,
+  unknownToError: unknownToResultError,
   asyncUnwrap,
   asyncMap
 };
-function normalizeError(error) {
+function unknownToError(error) {
   if (error instanceof Error) return error;
   if (typeof error === "string") {
     return new Error(error);
@@ -136,14 +145,9 @@ function normalizeError(error) {
       { cause: error }
     );
   }
-  return new Error(safeJsonStringify(error) ?? "unknown", { cause: error });
-}
-function safeJsonStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (_) {
-    return null;
-  }
+  return new Error(safeJsonStringify(error) ?? "unknown", {
+    cause: error
+  });
 }
 
 // src/sleep.ts
@@ -241,7 +245,7 @@ var ParallelAsyncResultCalls = class {
           } catch (exception) {
             throw {
               metadata: call.metadata,
-              error: normalizeError(exception)
+              error: unknownToError(exception)
             };
           }
         })

package/dist/parallelAsyncCalls.d.cts

@@ -1,4 +1,5 @@
 import { Result } from './rsResult.cjs';
+import './safeJson.cjs';
 
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {

package/dist/parallelAsyncCalls.d.ts

@@ -1,4 +1,5 @@
 import { Result } from './rsResult.js';
+import './safeJson.js';
 
 type ValidMetadata = string | number | boolean | Record<string, unknown>;
 type TupleRunAllSuccess<T> = T extends () => Promise<Result<infer V>> ? Succeeded<V, undefined> : T extends {

package/dist/parallelAsyncCalls.js

@@ -1,7 +1,8 @@
 import {
   Result,
-  normalizeError
-} from "./chunk-3PXKYWJF.js";
+  unknownToError
+} from "./chunk-KBFP7INB.js";
+import "./chunk-VAAMRG4K.js";
 import {
   sleep
 } from "./chunk-5DZT3Z5Z.js";
@@ -100,7 +101,7 @@ var ParallelAsyncResultCalls = class {
           } catch (exception) {
             throw {
               metadata: call.metadata,
-              error: normalizeError(exception)
+              error: unknownToError(exception)
             };
           }
         })

package/dist/rsResult.cjs

@@ -25,7 +25,8 @@ __export(rsResult_exports, {
   createTypedResult: () => createTypedResult,
   normalizeError: () => normalizeError,
   resultify: () => resultify,
-  safeJsonStringify: () => safeJsonStringify
+  safeJsonStringify: () => safeJsonStringify2,
+  unknownToError: () => unknownToError
 });
 module.exports = __toCommonJS(rsResult_exports);
 
@@ -34,6 +35,15 @@ function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/safeJson.ts
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return void 0;
+  }
+}
+
 // src/rsResult.ts
 function okUnwrapOr() {
   return this.value;
@@ -79,15 +89,15 @@ function err(error) {
       if (error instanceof Error) {
         throw error;
       }
-      throw normalizeError(error);
+      throw unknownToError(error);
     },
     mapOk: returnResult,
     mapErr: errMap,
     mapOkAndErr
   };
 }
-function unknownToError(error) {
-  return err(normalizeError(error));
+function unknownToResultError(error) {
+  return err(unknownToError(error));
 }
 async function asyncUnwrap(result) {
   const unwrapped = await result;
@@ -97,7 +107,7 @@ async function asyncUnwrap(result) {
   if (unwrapped.error instanceof Error) {
     throw unwrapped.error;
   }
-  throw normalizeError(unwrapped.error);
+  throw unknownToError(unwrapped.error);
 }
 function asyncMap(resultPromise) {
   return {
@@ -121,7 +131,7 @@ function asyncMap(resultPromise) {
 var Result = {
   ok,
   err,
-  unknownToError,
+  unknownToError: unknownToResultError,
   asyncUnwrap,
   asyncMap
 };
@@ -130,7 +140,7 @@ function resultify(fn, errorNormalizer) {
     return ok(fn());
   } catch (error) {
     return err(
-      errorNormalizer ? errorNormalizer(error) : normalizeError(error)
+      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
     );
   }
 }
@@ -139,11 +149,11 @@ async function asyncResultify(fn, errorNormalizer) {
     return ok(await fn());
   } catch (error) {
     return err(
-      errorNormalizer ? errorNormalizer(error) : normalizeError(error)
+      errorNormalizer ? errorNormalizer(error) : unknownToError(error)
     );
   }
 }
-function normalizeError(error) {
+function unknownToError(error) {
   if (error instanceof Error) return error;
   if (typeof error === "string") {
     return new Error(error);
@@ -154,15 +164,14 @@ function normalizeError(error) {
       { cause: error }
     );
   }
-  return new Error(safeJsonStringify(error) ?? "unknown", { cause: error });
+  return new Error(safeJsonStringify(error) ?? "unknown", {
+    cause: error
+  });
 }
-function safeJsonStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch (_) {
-    return null;
-  }
+function normalizeError(error) {
+  return unknownToError(error);
 }
+var safeJsonStringify2 = safeJsonStringify;
 function createTypedResult() {
   return {
     ok,
@@ -176,5 +185,6 @@ function createTypedResult() {
   createTypedResult,
   normalizeError,
   resultify,
-  safeJsonStringify
+  safeJsonStringify,
+  unknownToError
 });

package/dist/rsResult.d.cts

@@ -1,3 +1,5 @@
+import { safeJsonStringify as safeJsonStringify$1 } from './safeJson.cjs';
+
 type Ok<T> = {
     ok: true;
     error: false;
@@ -27,7 +29,7 @@ declare function ok(): OkResult<void, any>;
 declare function ok<T>(value: T): OkResult<T, any>;
 type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T, E>;
 declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
-declare function unknownToError(error: unknown): ErrResult<Error, any>;
+declare function unknownToResultError(error: unknown): ErrResult<Error, any>;
 /** Unwraps a promise result */
 declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
 declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
@@ -64,7 +66,7 @@ type Result<T, E extends ResultValidErrors = Error> = OkResult<T, E, T> | ErrRes
 declare const Result: {
     ok: typeof ok;
     err: typeof err;
-    unknownToError: typeof unknownToError;
+    unknownToError: typeof unknownToResultError;
     asyncUnwrap: typeof asyncUnwrap;
     asyncMap: typeof asyncMap;
 };
@@ -72,12 +74,36 @@ declare const Result: {
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
 /** transform a async function in a result function */
 declare function asyncResultify<T, E extends Error = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+/**
+ * Converts an unknown error value into an Error object.
+ *
+ * @param error - The unknown value to convert to an Error
+ * @returns An Error object
+ *
+ * @example
+ * try {
+ *   // some code that might throw
+ * } catch (err) {
+ *   const error = unknownToError(err); // Guaranteed to be Error instance
+ * }
+ *
+ * The function handles different error types:
+ * - Returns the error directly if it's already an Error instance
+ * - Converts strings into Error objects using the string as the message
+ * - For objects, tries to extract a message property or stringifies the object
+ * - For other values, stringifies them or uses 'unknown' as fallback
+ *
+ * The original error value is preserved as the `cause` property of the returned Error.
+ */
+declare function unknownToError(error: unknown): Error;
+/** @deprecated use unknownToError instead, this will be removed in the next major version */
 declare function normalizeError(error: unknown): Error;
-declare function safeJsonStringify(value: unknown): string | null;
+/** @deprecated use safeJsonStringify from `@ls-stack/utils/safeJson` instead, this will be removed in the next major version */
+declare const safeJsonStringify: typeof safeJsonStringify$1;
 type TypedResult<T, E extends ResultValidErrors = Error> = {
     ok: (value: T) => OkResult<T, E, T>;
     err: (error: E) => ErrResult<E, T>;
 };
 declare function createTypedResult<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
 
-export { Result, type TypedResult, asyncResultify, createTypedResult, normalizeError, resultify, safeJsonStringify };
+export { Result, type TypedResult, asyncResultify, createTypedResult, normalizeError, resultify, safeJsonStringify, unknownToError };

package/dist/rsResult.d.ts

@@ -1,3 +1,5 @@
+import { safeJsonStringify as safeJsonStringify$1 } from './safeJson.js';
+
 type Ok<T> = {
     ok: true;
     error: false;
@@ -27,7 +29,7 @@ declare function ok(): OkResult<void, any>;
 declare function ok<T>(value: T): OkResult<T, any>;
 type ErrResult<E extends ResultValidErrors, T = any> = Err<E> & ResultMethods<T, E>;
 declare function err<E extends ResultValidErrors>(error: E): ErrResult<E>;
-declare function unknownToError(error: unknown): ErrResult<Error, any>;
+declare function unknownToResultError(error: unknown): ErrResult<Error, any>;
 /** Unwraps a promise result */
 declare function asyncUnwrap<T>(result: Promise<Result<T, ResultValidErrors>>): Promise<T>;
 declare function asyncMap<T, E extends ResultValidErrors>(resultPromise: Promise<Result<T, E>>): {
@@ -64,7 +66,7 @@ type Result<T, E extends ResultValidErrors = Error> = OkResult<T, E, T> | ErrRes
 declare const Result: {
     ok: typeof ok;
     err: typeof err;
-    unknownToError: typeof unknownToError;
+    unknownToError: typeof unknownToResultError;
     asyncUnwrap: typeof asyncUnwrap;
     asyncMap: typeof asyncMap;
 };
@@ -72,12 +74,36 @@ declare const Result: {
 declare function resultify<T, E extends ResultValidErrors = Error>(fn: () => T, errorNormalizer?: (err: unknown) => E): Result<T, E>;
 /** transform a async function in a result function */
 declare function asyncResultify<T, E extends Error = Error>(fn: () => Promise<T>, errorNormalizer?: (err: unknown) => E): Promise<Result<Awaited<T>, E>>;
+/**
+ * Converts an unknown error value into an Error object.
+ *
+ * @param error - The unknown value to convert to an Error
+ * @returns An Error object
+ *
+ * @example
+ * try {
+ *   // some code that might throw
+ * } catch (err) {
+ *   const error = unknownToError(err); // Guaranteed to be Error instance
+ * }
+ *
+ * The function handles different error types:
+ * - Returns the error directly if it's already an Error instance
+ * - Converts strings into Error objects using the string as the message
+ * - For objects, tries to extract a message property or stringifies the object
+ * - For other values, stringifies them or uses 'unknown' as fallback
+ *
+ * The original error value is preserved as the `cause` property of the returned Error.
+ */
+declare function unknownToError(error: unknown): Error;
+/** @deprecated use unknownToError instead, this will be removed in the next major version */
 declare function normalizeError(error: unknown): Error;
-declare function safeJsonStringify(value: unknown): string | null;
+/** @deprecated use safeJsonStringify from `@ls-stack/utils/safeJson` instead, this will be removed in the next major version */
+declare const safeJsonStringify: typeof safeJsonStringify$1;
 type TypedResult<T, E extends ResultValidErrors = Error> = {
     ok: (value: T) => OkResult<T, E, T>;
     err: (error: E) => ErrResult<E, T>;
 };
 declare function createTypedResult<T, E extends ResultValidErrors = Error>(): TypedResult<T, E>;
 
-export { Result, type TypedResult, asyncResultify, createTypedResult, normalizeError, resultify, safeJsonStringify };
+export { Result, type TypedResult, asyncResultify, createTypedResult, normalizeError, resultify, safeJsonStringify, unknownToError };

package/dist/rsResult.js

@@ -4,8 +4,10 @@ import {
   createTypedResult,
   normalizeError,
   resultify,
-  safeJsonStringify
-} from "./chunk-3PXKYWJF.js";
+  safeJsonStringify,
+  unknownToError
+} from "./chunk-KBFP7INB.js";
+import "./chunk-VAAMRG4K.js";
 import "./chunk-4UGSP3L3.js";
 export {
   Result,
@@ -13,5 +15,6 @@ export {
   createTypedResult,
   normalizeError,
   resultify,
-  safeJsonStringify
+  safeJsonStringify,
+  unknownToError
 };

package/dist/safeJson.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/safeJson.ts
+var safeJson_exports = {};
+__export(safeJson_exports, {
+  safeJsonParse: () => safeJsonParse,
+  safeJsonStringify: () => safeJsonStringify
+});
+module.exports = __toCommonJS(safeJson_exports);
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return void 0;
+  }
+}
+function safeJsonParse(value) {
+  try {
+    return JSON.parse(value);
+  } catch (_) {
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  safeJsonParse,
+  safeJsonStringify
+});

package/dist/safeJson.d.cts

@@ -0,0 +1,6 @@
+/** JSON.stringify can throw if the value is circular or contains functions, this function catches those errors and returns undefined */
+declare function safeJsonStringify(value: unknown): string | undefined;
+/** JSON.parse can throw if the value is not valid JSON, this function catches those errors and returns undefined */
+declare function safeJsonParse(value: string): any;
+
+export { safeJsonParse, safeJsonStringify };

package/dist/safeJson.d.ts

@@ -0,0 +1,6 @@
+/** JSON.stringify can throw if the value is circular or contains functions, this function catches those errors and returns undefined */
+declare function safeJsonStringify(value: unknown): string | undefined;
+/** JSON.parse can throw if the value is not valid JSON, this function catches those errors and returns undefined */
+declare function safeJsonParse(value: string): any;
+
+export { safeJsonParse, safeJsonStringify };

package/dist/safeJson.js

@@ -0,0 +1,8 @@
+import {
+  safeJsonParse,
+  safeJsonStringify
+} from "./chunk-VAAMRG4K.js";
+export {
+  safeJsonParse,
+  safeJsonStringify
+};

package/dist/typingFnUtils.cjs

@@ -22,6 +22,8 @@ var typingFnUtils_exports = {};
 __export(typingFnUtils_exports, {
   asNonPartial: () => asNonPartial,
   asType: () => asType,
+  isObjKey: () => isObjKey,
+  isSubTypeOf: () => isSubTypeOf,
   narrowStringToUnion: () => narrowStringToUnion,
   typedObjectEntries: () => typedObjectEntries,
   typedObjectKeys: () => typedObjectKeys
@@ -45,10 +47,18 @@ function narrowStringToUnion(key, union) {
   }
   return void 0;
 }
+function isSubTypeOf() {
+  return void 0;
+}
+function isObjKey(key, obj) {
+  return typeof key === "string" && key in obj;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   asNonPartial,
   asType,
+  isObjKey,
+  isSubTypeOf,
   narrowStringToUnion,
   typedObjectEntries,
   typedObjectKeys

package/dist/typingFnUtils.d.cts

@@ -11,5 +11,17 @@ declare function typedObjectKeys<T extends Record<string, unknown>>(obj: T): (ke
 declare function asType<T = unknown>(value: T): T;
 /** narrow a string to a union of strings */
 declare function narrowStringToUnion<const T extends string>(key: string | undefined | null, union: T[]): T | undefined;
+/**
+ * Type helper to check if a type is a subtype of another type.
+ *
+ * @template BaseType - The base type to check against
+ * @template SubType - The type that should extend BaseType
+ * @returns {unknown} Returns undefined, only used for type checking
+ */
+declare function isSubTypeOf<BaseType, SubType extends BaseType>(): unknown;
+/**
+ * Type helper to narrow a string to a key of an object.
+ */
+declare function isObjKey<T extends Record<string, unknown>>(key: unknown, obj: T): key is keyof T;
 
-export { asNonPartial, asType, narrowStringToUnion, typedObjectEntries, typedObjectKeys };
+export { asNonPartial, asType, isObjKey, isSubTypeOf, narrowStringToUnion, typedObjectEntries, typedObjectKeys };

package/dist/typingFnUtils.d.ts

@@ -11,5 +11,17 @@ declare function typedObjectKeys<T extends Record<string, unknown>>(obj: T): (ke
 declare function asType<T = unknown>(value: T): T;
 /** narrow a string to a union of strings */
 declare function narrowStringToUnion<const T extends string>(key: string | undefined | null, union: T[]): T | undefined;
+/**
+ * Type helper to check if a type is a subtype of another type.
+ *
+ * @template BaseType - The base type to check against
+ * @template SubType - The type that should extend BaseType
+ * @returns {unknown} Returns undefined, only used for type checking
+ */
+declare function isSubTypeOf<BaseType, SubType extends BaseType>(): unknown;
+/**
+ * Type helper to narrow a string to a key of an object.
+ */
+declare function isObjKey<T extends Record<string, unknown>>(key: unknown, obj: T): key is keyof T;
 
-export { asNonPartial, asType, narrowStringToUnion, typedObjectEntries, typedObjectKeys };
+export { asNonPartial, asType, isObjKey, isSubTypeOf, narrowStringToUnion, typedObjectEntries, typedObjectKeys };

package/dist/typingFnUtils.js

@@ -17,9 +17,17 @@ function narrowStringToUnion(key, union) {
   }
   return void 0;
 }
+function isSubTypeOf() {
+  return void 0;
+}
+function isObjKey(key, obj) {
+  return typeof key === "string" && key in obj;
+}
 export {
   asNonPartial,
   asType,
+  isObjKey,
+  isSubTypeOf,
   narrowStringToUnion,
   typedObjectEntries,
   typedObjectKeys

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "license": "MIT",
   "files": [
     "dist"
@@ -119,6 +119,11 @@
       "types": "./dist/runShellCmd.d.ts",
       "require": "./dist/runShellCmd.cjs"
     },
+    "./safeJson": {
+      "import": "./dist/safeJson.js",
+      "types": "./dist/safeJson.d.ts",
+      "require": "./dist/safeJson.cjs"
+    },
     "./shallowEqual": {
       "import": "./dist/shallowEqual.js",
       "types": "./dist/shallowEqual.d.ts",
@@ -167,23 +172,23 @@
     "@ls-stack/extended-lint": "^0.20.1",
     "@types/eslint": "^9.6.1",
     "@types/eslint__js": "^8.42.3",
-    "@types/node": "^22.10.2",
-    "@typescript-eslint/eslint-plugin": "^8.18.1",
-    "@typescript-eslint/parser": "^8.18.1",
-    "@vitest/ui": "^2.1.8",
+    "@types/node": "^22.10.9",
+    "@typescript-eslint/eslint-plugin": "^8.21.0",
+    "@typescript-eslint/parser": "^8.21.0",
+    "@vitest/ui": "^3.0.4",
     "dequal": "^2.0.3",
-    "eslint": "^9.17.0",
+    "eslint": "^9.18.0",
     "eslint-plugin-unicorn": "^56.0.1",
     "eslint-plugin-vitest": "^0.5.4",
-    "mitata": "^1.0.21",
+    "mitata": "^1.0.32",
     "prettier": "3.4.2",
     "prettier-plugin-organize-imports": "^4.1.0",
     "tsm": "^2.3.0",
     "tsup": "^8.3.5",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^8.18.1",
-    "vite": "^6.0.5",
-    "vitest": "^2.1.8"
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.21.0",
+    "vite": "^6.0.11",
+    "vitest": "^3.0.4"
   },
   "typesVersions": {
     "*": {
@@ -247,6 +252,9 @@
       "runShellCmd": [
         "./dist/runShellCmd.d.ts"
       ],
+      "safeJson": [
+        "./dist/safeJson.d.ts"
+      ],
       "shallowEqual": [
         "./dist/shallowEqual.d.ts"
       ],