@ls-stack/utils 3.12.3 → 3.14.0

package/lib/parallelAsyncCalls.js

@@ -4,7 +4,8 @@ import {
 import {
   invariant,
   isObject
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/parallelAsyncCalls.ts
 import { Result, unknownToError } from "t-result";

package/lib/saferTyping.d.cts

@@ -1,5 +1,10 @@
 /** Use this only when you have 100% of certainty that this will not break the types */
 type __LEGIT_ANY__ = any;
+type __LEGIT_ANY_FUNCTION__ = (...params: any) => __LEGIT_ANY__;
+/**
+ * An empty object type, equivalent to `{}` but with safer typing
+ */
+type EmptyObject = Record<string, never>;
 /**
  * Cast a value to `any` type. Use this when you have legit usage of `any` casting.
  *
@@ -23,5 +28,10 @@ declare function __REFINE_CAST__<T>(value: T): <R extends T>() => R;
 declare function __FIX_THIS_CASTING__<T>(value: unknown): T;
 type __FIX_THIS_TYPING__ = any;
 declare function __FIX_THIS_TYPING__(value: unknown): __LEGIT_ANY__;
+/**
+ * Any type that is not a primitive (number, string, boolean, null, undefined, symbol, bigint, ...)
+ * Equivalent to `object` type
+ */
+type AnyNonPrimitiveValue = object;
 
-export { __FIX_THIS_CASTING__, __FIX_THIS_TYPING__, __LEGIT_ANY_CAST__, type __LEGIT_ANY__, __LEGIT_CAST__, __REFINE_CAST__ };
+export { type AnyNonPrimitiveValue, type EmptyObject, __FIX_THIS_CASTING__, __FIX_THIS_TYPING__, __LEGIT_ANY_CAST__, type __LEGIT_ANY_FUNCTION__, type __LEGIT_ANY__, __LEGIT_CAST__, __REFINE_CAST__ };

package/lib/saferTyping.d.ts

@@ -1,5 +1,10 @@
 /** Use this only when you have 100% of certainty that this will not break the types */
 type __LEGIT_ANY__ = any;
+type __LEGIT_ANY_FUNCTION__ = (...params: any) => __LEGIT_ANY__;
+/**
+ * An empty object type, equivalent to `{}` but with safer typing
+ */
+type EmptyObject = Record<string, never>;
 /**
  * Cast a value to `any` type. Use this when you have legit usage of `any` casting.
  *
@@ -23,5 +28,10 @@ declare function __REFINE_CAST__<T>(value: T): <R extends T>() => R;
 declare function __FIX_THIS_CASTING__<T>(value: unknown): T;
 type __FIX_THIS_TYPING__ = any;
 declare function __FIX_THIS_TYPING__(value: unknown): __LEGIT_ANY__;
+/**
+ * Any type that is not a primitive (number, string, boolean, null, undefined, symbol, bigint, ...)
+ * Equivalent to `object` type
+ */
+type AnyNonPrimitiveValue = object;
 
-export { __FIX_THIS_CASTING__, __FIX_THIS_TYPING__, __LEGIT_ANY_CAST__, type __LEGIT_ANY__, __LEGIT_CAST__, __REFINE_CAST__ };
+export { type AnyNonPrimitiveValue, type EmptyObject, __FIX_THIS_CASTING__, __FIX_THIS_TYPING__, __LEGIT_ANY_CAST__, type __LEGIT_ANY_FUNCTION__, type __LEGIT_ANY__, __LEGIT_CAST__, __REFINE_CAST__ };

package/lib/serializeXML.js

@@ -1,7 +1,8 @@
 import {
   filterAndMap
-} from "./chunk-UTFE4P3P.js";
-import "./chunk-3XCS7FVO.js";
+} from "./chunk-DMW5Q4T2.js";
+import "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/serializeXML.ts
 var XML_TAG_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9._-]*$/;

package/lib/testUtils.cjs

@@ -26,11 +26,14 @@ __export(testUtils_exports, {
 });
 module.exports = __toCommonJS(testUtils_exports);
 
-// src/assertions.ts
+// src/typeGuards.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/assertions.ts
+var isObject2 = isObject;
+
 // src/arrayUtils.ts
 function filterAndMap(array, mapFilter) {
   const result = [];
@@ -175,7 +178,7 @@ function createLoggerStore({
     startTime = Date.now();
   }
   function add(render) {
-    if (!isObject(render)) {
+    if (!isObject2(render)) {
       for (const [i, r] of render.entries()) {
         logs.push({
           i: i + 1,

package/lib/testUtils.js

@@ -14,10 +14,11 @@ import {
 import {
   arrayWithPrevAndIndex,
   filterAndMap
-} from "./chunk-UTFE4P3P.js";
+} from "./chunk-DMW5Q4T2.js";
 import {
   isObject
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/testUtils.ts
 function createLoggerStore({

package/lib/tsResult.cjs

@@ -28,7 +28,7 @@ __export(tsResult_exports, {
 });
 module.exports = __toCommonJS(tsResult_exports);
 
-// src/assertions.ts
+// src/typeGuards.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -39,6 +39,11 @@ function isPromise(value) {
   return isObject(value) && "then" in value && isFunction(value.then);
 }
 
+// src/assertions.ts
+var isFunction2 = isFunction;
+var isObject2 = isObject;
+var isPromise2 = isPromise;
+
 // src/safeJson.ts
 function safeJsonStringify(value) {
   try {
@@ -163,7 +168,7 @@ var Result = {
   getOkErr
 };
 function resultify(fn, errorNormalizer) {
-  if (!isFunction(fn)) {
+  if (!isFunction2(fn)) {
     return fn.then((value) => ok(value)).catch(
       (error) => err(
         errorNormalizer ? errorNormalizer(error) : unknownToError(error)
@@ -172,7 +177,7 @@ function resultify(fn, errorNormalizer) {
   }
   try {
     const result = fn();
-    if (isPromise(result)) {
+    if (isPromise2(result)) {
       return result.then((value) => ok(value)).catch(
         (error) => err(
           errorNormalizer ? errorNormalizer(error) : unknownToError(error)
@@ -191,7 +196,7 @@ function unknownToError(error) {
   if (typeof error === "string") {
     return new Error(error);
   }
-  if (isObject(error)) {
+  if (isObject2(error)) {
     return new Error(
       "message" in error && error.message && typeof error.message === "string" ? error.message : safeJsonStringify(error) ?? "unknown",
       { cause: error }

package/lib/tsResult.js

@@ -5,7 +5,8 @@ import {
   isFunction,
   isObject,
   isPromise
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 
 // src/tsResult.ts
 function okUnwrapOr() {

package/lib/typeGuards.cjs

@@ -0,0 +1,65 @@
+"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/typeGuards.ts
+var typeGuards_exports = {};
+__export(typeGuards_exports, {
+  arrayHasAtLeastXItems: () => arrayHasAtLeastXItems,
+  isFunction: () => isFunction,
+  isNonEmptyArray: () => isNonEmptyArray,
+  isObject: () => isObject,
+  isPlainObject: () => isPlainObject,
+  isPromise: () => isPromise
+});
+module.exports = __toCommonJS(typeGuards_exports);
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isPromise(value) {
+  return isObject(value) && "then" in value && isFunction(value.then);
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") return false;
+  const proto = Object.getPrototypeOf(value);
+  if (proto === null) {
+    return true;
+  }
+  const Ctor = Object.hasOwnProperty.call(proto, "constructor") && proto.constructor;
+  if (Ctor === Object) return true;
+  const objectCtorString = Object.prototype.constructor.toString();
+  return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
+}
+function isNonEmptyArray(value) {
+  return value.length > 0;
+}
+function arrayHasAtLeastXItems(array, minLength) {
+  return array.length >= minLength;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  arrayHasAtLeastXItems,
+  isFunction,
+  isNonEmptyArray,
+  isObject,
+  isPlainObject,
+  isPromise
+});

package/lib/typeGuards.d.cts

@@ -0,0 +1,109 @@
+/**
+ * Type guard to check if a value is a plain object (not null, not an array).
+ *
+ * Returns true if the value is an object that is not null and not an array.
+ * This is useful for distinguishing between objects and other types.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isObject(value)) {
+ *   // TypeScript knows value is Record<string, unknown>
+ *   console.log(value.someProperty);
+ * }
+ *
+ * isObject({});           // true
+ * isObject({ a: 1 });     // true
+ * isObject(null);         // false
+ * isObject([]);           // false
+ * isObject('string');     // false
+ * ```
+ */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard to check if a value is a function.
+ *
+ * Returns true if the value is a function of any kind (regular function,
+ * arrow function, method, constructor, etc.).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a function, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isFunction(value)) {
+ *   // TypeScript knows value is (...args: any[]) => any
+ *   const result = value();
+ * }
+ *
+ * isFunction(() => {});           // true
+ * isFunction(function() {});      // true
+ * isFunction(Math.max);           // true
+ * isFunction('string');           // false
+ * isFunction({});                 // false
+ * ```
+ */
+declare function isFunction(value: unknown): value is (...args: any[]) => any;
+/**
+ * Type guard to check if a value is a Promise or thenable object.
+ *
+ * Returns true if the value is an object with a `then` method that is a function.
+ * This covers both native Promises and thenable objects that implement the
+ * Promise interface.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Promise or thenable, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isPromise(value)) {
+ *   // TypeScript knows value is Promise<unknown>
+ *   const result = await value;
+ * }
+ *
+ * isPromise(Promise.resolve());           // true
+ * isPromise(new Promise(() => {}));       // true
+ * isPromise({ then: () => {} });          // true
+ * isPromise({ then: 'not a function' });  // false
+ * isPromise('string');                    // false
+ * ```
+ */
+declare function isPromise(value: unknown): value is Promise<unknown>;
+/**
+ * Type guard to check if a value is a plain object (created by Object literal or Object constructor).
+ *
+ * Returns true if the value is a plain object - an object created by the Object
+ * constructor or object literal syntax. This excludes instances of classes,
+ * built-in objects like Date, RegExp, etc.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isPlainObject(value)) {
+ *   // TypeScript knows value is Record<string, unknown>
+ *   console.log(Object.keys(value));
+ * }
+ *
+ * isPlainObject({});                    // true
+ * isPlainObject({ a: 1 });              // true
+ * isPlainObject(Object.create(null));   // true
+ * isPlainObject(new Date());            // false
+ * isPlainObject(/regex/);               // false
+ * isPlainObject(new MyClass());         // false
+ * isPlainObject([]);                    // false
+ * ```
+ */
+declare function isPlainObject(value: any): value is Record<string, unknown>;
+type NonEmptyArray<T> = [T, ...T[]];
+declare function isNonEmptyArray<T>(value: T[] | readonly T[]): value is NonEmptyArray<T>;
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 1): array is [T, ...T[]];
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 2): array is [T, T, ...T[]];
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 3): array is [T, T, T, ...T[]];
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 4): array is [T, T, T, T, ...T[]];
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 5): array is [T, T, T, T, T, ...T[]];
+
+export { type NonEmptyArray, arrayHasAtLeastXItems, isFunction, isNonEmptyArray, isObject, isPlainObject, isPromise };

package/lib/typeGuards.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Type guard to check if a value is a plain object (not null, not an array).
+ *
+ * Returns true if the value is an object that is not null and not an array.
+ * This is useful for distinguishing between objects and other types.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isObject(value)) {
+ *   // TypeScript knows value is Record<string, unknown>
+ *   console.log(value.someProperty);
+ * }
+ *
+ * isObject({});           // true
+ * isObject({ a: 1 });     // true
+ * isObject(null);         // false
+ * isObject([]);           // false
+ * isObject('string');     // false
+ * ```
+ */
+declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard to check if a value is a function.
+ *
+ * Returns true if the value is a function of any kind (regular function,
+ * arrow function, method, constructor, etc.).
+ *
+ * @param value - The value to check
+ * @returns True if the value is a function, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isFunction(value)) {
+ *   // TypeScript knows value is (...args: any[]) => any
+ *   const result = value();
+ * }
+ *
+ * isFunction(() => {});           // true
+ * isFunction(function() {});      // true
+ * isFunction(Math.max);           // true
+ * isFunction('string');           // false
+ * isFunction({});                 // false
+ * ```
+ */
+declare function isFunction(value: unknown): value is (...args: any[]) => any;
+/**
+ * Type guard to check if a value is a Promise or thenable object.
+ *
+ * Returns true if the value is an object with a `then` method that is a function.
+ * This covers both native Promises and thenable objects that implement the
+ * Promise interface.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a Promise or thenable, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isPromise(value)) {
+ *   // TypeScript knows value is Promise<unknown>
+ *   const result = await value;
+ * }
+ *
+ * isPromise(Promise.resolve());           // true
+ * isPromise(new Promise(() => {}));       // true
+ * isPromise({ then: () => {} });          // true
+ * isPromise({ then: 'not a function' });  // false
+ * isPromise('string');                    // false
+ * ```
+ */
+declare function isPromise(value: unknown): value is Promise<unknown>;
+/**
+ * Type guard to check if a value is a plain object (created by Object literal or Object constructor).
+ *
+ * Returns true if the value is a plain object - an object created by the Object
+ * constructor or object literal syntax. This excludes instances of classes,
+ * built-in objects like Date, RegExp, etc.
+ *
+ * @param value - The value to check
+ * @returns True if the value is a plain object, false otherwise
+ *
+ * @example
+ * ```typescript
+ * if (isPlainObject(value)) {
+ *   // TypeScript knows value is Record<string, unknown>
+ *   console.log(Object.keys(value));
+ * }
+ *
+ * isPlainObject({});                    // true
+ * isPlainObject({ a: 1 });              // true
+ * isPlainObject(Object.create(null));   // true
+ * isPlainObject(new Date());            // false
+ * isPlainObject(/regex/);               // false
+ * isPlainObject(new MyClass());         // false
+ * isPlainObject([]);                    // false
+ * ```
+ */
+declare function isPlainObject(value: any): value is Record<string, unknown>;
+type NonEmptyArray<T> = [T, ...T[]];
+declare function isNonEmptyArray<T>(value: T[] | readonly T[]): value is NonEmptyArray<T>;
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 1): array is [T, ...T[]];
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 2): array is [T, T, ...T[]];
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 3): array is [T, T, T, ...T[]];
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 4): array is [T, T, T, T, ...T[]];
+declare function arrayHasAtLeastXItems<T>(array: T[], minLength: 5): array is [T, T, T, T, T, ...T[]];
+
+export { type NonEmptyArray, arrayHasAtLeastXItems, isFunction, isNonEmptyArray, isObject, isPlainObject, isPromise };

package/lib/typeGuards.js

@@ -0,0 +1,16 @@
+import {
+  arrayHasAtLeastXItems,
+  isFunction,
+  isNonEmptyArray,
+  isObject,
+  isPlainObject,
+  isPromise
+} from "./chunk-SSKW673U.js";
+export {
+  arrayHasAtLeastXItems,
+  isFunction,
+  isNonEmptyArray,
+  isObject,
+  isPlainObject,
+  isPromise
+};

package/lib/yamlStringify.cjs

@@ -24,7 +24,7 @@ __export(yamlStringify_exports, {
 });
 module.exports = __toCommonJS(yamlStringify_exports);
 
-// src/assertions.ts
+// src/typeGuards.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -40,6 +40,10 @@ function isPlainObject(value) {
   return typeof Ctor == "function" && Function.toString.call(Ctor) === objectCtorString;
 }
 
+// src/assertions.ts
+var isObject2 = isObject;
+var isPlainObject2 = isPlainObject;
+
 // src/conversions.ts
 function bytesToHumanReadable(bytes) {
   if (bytes < 1024) {
@@ -70,7 +74,7 @@ function yamlStringify(obj, {
   maxDepth = 50,
   addRootObjSpaces = "beforeAndAfter"
 } = {}) {
-  if (isObject(obj) || Array.isArray(obj) || typeof obj === "function") {
+  if (isObject2(obj) || Array.isArray(obj) || typeof obj === "function") {
     return `${stringifyValue(obj, "", maxLineLength, !!showUndefined, maxDepth, 0, addRootObjSpaces)}
 `;
   }
@@ -79,7 +83,7 @@ function yamlStringify(obj, {
 function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, depth, addObjSpaces) {
   let result = "";
   const childIndent = `${indent}  `;
-  if (isPlainObject(value)) {
+  if (isPlainObject2(value)) {
     if (Object.keys(value).length === 0) {
       return "{}";
     }
@@ -106,7 +110,7 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
         depth + 1,
         addObjSpaces
       );
-      if (!afterSpaceWasAdded && indent === "" && isObject(objVal) && prevValue && (addObjSpaces === "before" || addObjSpaces === "beforeAndAfter")) {
+      if (!afterSpaceWasAdded && indent === "" && isObject2(objVal) && prevValue && (addObjSpaces === "before" || addObjSpaces === "beforeAndAfter")) {
         result += "\n";
       }
       if (Array.isArray(objVal)) {
@@ -117,7 +121,7 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
           result += `${indent}${key}:
 `;
         }
-      } else if (isObject(objVal)) {
+      } else if (isObject2(objVal)) {
         if (Object.keys(objVal).length === 0) {
           result += `${indent}${key}: `;
         } else {
@@ -130,7 +134,7 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
       result += valueString;
       result += "\n";
       if (indent === "") {
-        if (isObject(objVal)) {
+        if (isObject2(objVal)) {
           if (addObjSpaces === "after" || addObjSpaces === "beforeAndAfter") {
             result += "\n";
             afterSpaceWasAdded = true;
@@ -180,7 +184,7 @@ function stringifyValue(value, indent, maxLineLength, showUndefined, maxDepth, d
           item = `{max depth reached}`;
         }
         result += `${indent}- `;
-        if (Array.isArray(item) || isObject(item)) {
+        if (Array.isArray(item) || isObject2(item)) {
           let arrayString = stringifyValue(
             item,
             childIndent,
@@ -227,8 +231,12 @@ ${indent}${line}
         }
       }
     } else {
-      if (value.includes("'")) {
+      if (value.includes("'") && !value.includes('"')) {
         result += `"${value}"`;
+      } else if (value.includes('"') && !value.includes("'")) {
+        result += `'${value}'`;
+      } else if (value.includes("'") && value.includes('"')) {
+        result += `"${value.replace(/"/g, '\\"')}"`;
       } else {
         result += `'${value}'`;
       }
@@ -255,7 +263,7 @@ ${indent}${line}
   return JSON.stringify(value);
 }
 function normalizeValue(value) {
-  if (value === null || isPlainObject(value) || Array.isArray(value)) {
+  if (value === null || isPlainObject2(value) || Array.isArray(value)) {
     return null;
   }
   if (value instanceof Map) {

package/lib/yamlStringify.js

@@ -4,7 +4,8 @@ import {
 import {
   isObject,
   isPlainObject
-} from "./chunk-3XCS7FVO.js";
+} from "./chunk-WS4WEVHU.js";
+import "./chunk-SSKW673U.js";
 import {
   bytesToHumanReadable
 } from "./chunk-IATIXMCE.js";
@@ -173,8 +174,12 @@ ${indent}${line}
         }
       }
     } else {
-      if (value.includes("'")) {
+      if (value.includes("'") && !value.includes('"')) {
         result += `"${value}"`;
+      } else if (value.includes('"') && !value.includes("'")) {
+        result += `'${value}'`;
+      } else if (value.includes("'") && value.includes('"')) {
+        result += `"${value.replace(/"/g, '\\"')}"`;
       } else {
         result += `'${value}'`;
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "3.12.3",
+  "version": "3.14.0",
   "license": "MIT",
   "files": [
     "lib"
@@ -74,6 +74,10 @@
       "import": "./lib/exhaustiveMatch.js",
       "require": "./lib/exhaustiveMatch.cjs"
     },
+    "./getCompositeKey": {
+      "import": "./lib/getCompositeKey.js",
+      "require": "./lib/getCompositeKey.cjs"
+    },
     "./getValueStableKey": {
       "import": "./lib/getValueStableKey.js",
       "require": "./lib/getValueStableKey.cjs"
@@ -146,6 +150,10 @@
       "import": "./lib/tsResult.js",
       "require": "./lib/tsResult.cjs"
     },
+    "./typeGuards": {
+      "import": "./lib/typeGuards.js",
+      "require": "./lib/typeGuards.cjs"
+    },
     "./typingFnUtils": {
       "import": "./lib/typingFnUtils.js",
       "require": "./lib/typingFnUtils.cjs"