@catbee/utils 2.0.0-next.0 → 2.0.0

package/object/index.mjs

@@ -0,0 +1,360 @@
+/*
+ * The MIT License
+ * 
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/object/object.utils.ts
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isObject, "isObject");
+function isObjEmpty(obj) {
+  return isObject(obj) && Object.keys(obj).length === 0;
+}
+__name(isObjEmpty, "isObjEmpty");
+function pick(obj, keys) {
+  return Object.fromEntries(keys.map((key) => [
+    key,
+    obj[key]
+  ]));
+}
+__name(pick, "pick");
+function omit(obj, keys) {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
+}
+__name(omit, "omit");
+function deepObjMerge(target, ...sources) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  for (const s of sources) {
+    target = mergeInto(target, s, seen);
+  }
+  return target;
+}
+__name(deepObjMerge, "deepObjMerge");
+function mergeInto(t, s, seen) {
+  if (s === void 0) return t;
+  if (typeof s === "function" || typeof s === "symbol") return s;
+  if (Array.isArray(s)) {
+    const cloned = deepClone(s);
+    seen.set(s, cloned);
+    return cloned;
+  }
+  if (s && typeof s === "object") {
+    if (seen.has(s)) return seen.get(s);
+    if (s instanceof Date || s instanceof Map || s instanceof Set || s instanceof RegExp || s instanceof ArrayBuffer || ArrayBuffer.isView(s)) {
+      const cloned = deepClone(s);
+      seen.set(s, cloned);
+      return cloned;
+    }
+    if (!t || typeof t !== "object") {
+      t = Object.create(Object.getPrototypeOf(s));
+    }
+    seen.set(s, t);
+    for (const key of Reflect.ownKeys(s)) {
+      if (key === "__proto__") continue;
+      const sv = s[key];
+      if (sv === void 0) continue;
+      t[key] = mergeInto(t[key], sv, seen);
+    }
+    return t;
+  }
+  return s;
+}
+__name(mergeInto, "mergeInto");
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  if (Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+__name(isPlainObject, "isPlainObject");
+function flattenObject(obj, prefix = "") {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const newKey = prefix ? `${prefix}.${key}` : key;
+    if (key === "__proto__") return acc;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      Object.assign(acc, flattenObject(value, newKey));
+    } else {
+      acc[newKey] = value;
+    }
+    return acc;
+  }, {});
+}
+__name(flattenObject, "flattenObject");
+function getValueByPath(obj, path) {
+  if (!obj || typeof obj !== "object") return void 0;
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  return parts.reduce((acc, key) => acc?.[key], obj);
+}
+__name(getValueByPath, "getValueByPath");
+function ensureNextContainer(curr, nextIsIndex) {
+  if (curr === void 0 || typeof curr !== "object" || curr === null) {
+    return nextIsIndex ? [] : /* @__PURE__ */ Object.create(null);
+  }
+  return curr;
+}
+__name(ensureNextContainer, "ensureNextContainer");
+function setValueByPath(obj, path, value) {
+  if (!obj || typeof obj !== "object") return obj;
+  const clone = deepClone(obj);
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  if (parts.length === 0) return clone;
+  const forbiddenKeys = /* @__PURE__ */ new Set([
+    "__proto__",
+    "prototype",
+    "constructor"
+  ]);
+  let current = clone;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const key = parts[i];
+    if (forbiddenKeys.has(key)) return clone;
+    const nextKey = parts[i + 1];
+    const nextIsIndex = !Number.isNaN(Number(nextKey));
+    current[key] = ensureNextContainer(current[key], nextIsIndex);
+    current = current[key];
+  }
+  const finalKey = parts.at(-1);
+  if (forbiddenKeys.has(finalKey)) return clone;
+  current[finalKey] = value;
+  return clone;
+}
+__name(setValueByPath, "setValueByPath");
+function isEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null || typeof a !== "object" || typeof b !== "object") return false;
+  if (a instanceof Date && b instanceof Date) return equalDates(a, b);
+  if (a instanceof RegExp && b instanceof RegExp) return equalRegExp(a, b);
+  if (a instanceof Set && b instanceof Set) return equalSet(a, b);
+  if (a instanceof Map && b instanceof Map) return equalMap(a, b);
+  if (a instanceof ArrayBuffer && b instanceof ArrayBuffer) return equalArrayBuffer(a, b);
+  if (Array.isArray(a) && Array.isArray(b)) return equalArray(a, b);
+  return equalPlainObjects(a, b);
+}
+__name(isEqual, "isEqual");
+function equalDates(a, b) {
+  return a.getTime() === b.getTime();
+}
+__name(equalDates, "equalDates");
+function equalRegExp(a, b) {
+  return a.source === b.source && a.flags === b.flags;
+}
+__name(equalRegExp, "equalRegExp");
+function equalSet(a, b) {
+  if (a.size !== b.size) return false;
+  for (const v of a) if (!b.has(v)) return false;
+  return true;
+}
+__name(equalSet, "equalSet");
+function equalMap(a, b) {
+  if (a.size !== b.size) return false;
+  for (const [k, v] of a) {
+    if (!b.has(k)) return false;
+    if (!isEqual(v, b.get(k))) return false;
+  }
+  return true;
+}
+__name(equalMap, "equalMap");
+function equalArrayBuffer(a, b) {
+  return isEqual(new Uint8Array(a), new Uint8Array(b));
+}
+__name(equalArrayBuffer, "equalArrayBuffer");
+function equalArray(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (!isEqual(a[i], b[i])) return false;
+  return true;
+}
+__name(equalArray, "equalArray");
+function equalPlainObjects(a, b) {
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    if (!Object.hasOwn(b, key)) return false;
+    if (!isEqual(a[key], b[key])) return false;
+  }
+  return true;
+}
+__name(equalPlainObjects, "equalPlainObjects");
+function filterObject(obj, predicate) {
+  return Object.fromEntries(Object.entries(obj).filter(([key, value]) => predicate(value, key, obj)));
+}
+__name(filterObject, "filterObject");
+function mapObject(obj, mapFn) {
+  return Object.fromEntries(Object.entries(obj).map(([key, value]) => [
+    key,
+    mapFn(value, key, obj)
+  ]));
+}
+__name(mapObject, "mapObject");
+function _deepClone(value, seen) {
+  if (typeof value === "function" || typeof value === "symbol") return value;
+  if (value === null || typeof value !== "object") return value;
+  if (seen.has(value)) return seen.get(value);
+  if (Array.isArray(value)) return cloneArray(value, seen);
+  if (value instanceof Date) return cloneDate(value);
+  if (value instanceof Map) return cloneMap(value, seen);
+  if (value instanceof Set) return cloneSet(value, seen);
+  if (value instanceof RegExp) return cloneRegExp(value);
+  if (ArrayBuffer.isView(value)) return cloneArrayBufferView(value, seen);
+  if (value instanceof ArrayBuffer) return cloneArrayBuffer(value, seen);
+  return cloneObject(value, seen);
+}
+__name(_deepClone, "_deepClone");
+function cloneArray(arr, seen) {
+  const result = [];
+  seen.set(arr, result);
+  for (const item of arr) result.push(_deepClone(item, seen));
+  return result;
+}
+__name(cloneArray, "cloneArray");
+function cloneDate(d) {
+  const r = new Date(d.getTime());
+  return r;
+}
+__name(cloneDate, "cloneDate");
+function cloneMap(m, seen) {
+  const result = /* @__PURE__ */ new Map();
+  seen.set(m, result);
+  for (const [k, v] of m) result.set(_deepClone(k, seen), _deepClone(v, seen));
+  return result;
+}
+__name(cloneMap, "cloneMap");
+function cloneSet(s, seen) {
+  const result = /* @__PURE__ */ new Set();
+  seen.set(s, result);
+  for (const v of s) result.add(_deepClone(v, seen));
+  return result;
+}
+__name(cloneSet, "cloneSet");
+function cloneRegExp(r) {
+  const result = new RegExp(r.source, r.flags);
+  return result;
+}
+__name(cloneRegExp, "cloneRegExp");
+function cloneArrayBufferView(view, seen) {
+  if (view instanceof DataView) {
+    const buf2 = _deepClone(view.buffer, seen);
+    const clone2 = new DataView(buf2, view.byteOffset, view.byteLength);
+    seen.set(view, clone2);
+    return clone2;
+  }
+  const typed = view;
+  const buf = _deepClone(typed.buffer, seen);
+  const clone = new typed.constructor(buf, typed.byteOffset, typed.length);
+  seen.set(view, clone);
+  return clone;
+}
+__name(cloneArrayBufferView, "cloneArrayBufferView");
+function cloneArrayBuffer(buf, seen) {
+  const result = buf.slice(0);
+  seen.set(buf, result);
+  return result;
+}
+__name(cloneArrayBuffer, "cloneArrayBuffer");
+function cloneObject(obj, seen) {
+  const result = Object.create(Object.getPrototypeOf(obj));
+  seen.set(obj, result);
+  for (const key of Reflect.ownKeys(obj)) {
+    const desc = Object.getOwnPropertyDescriptor(obj, key);
+    if (desc?.get || desc?.set) {
+      Object.defineProperty(result, key, {
+        get: desc.get,
+        set: desc.set,
+        enumerable: desc.enumerable,
+        configurable: desc.configurable
+      });
+    } else {
+      Object.defineProperty(result, key, {
+        value: _deepClone(obj[key], seen),
+        writable: desc?.writable ?? true,
+        enumerable: desc?.enumerable ?? true,
+        configurable: desc?.configurable ?? true
+      });
+    }
+  }
+  return result;
+}
+__name(cloneObject, "cloneObject");
+function deepClone(value) {
+  const seen = /* @__PURE__ */ new WeakMap();
+  return _deepClone(value, seen);
+}
+__name(deepClone, "deepClone");
+function deepFreeze(obj) {
+  Object.freeze(obj);
+  for (const key of Reflect.ownKeys(obj)) {
+    const val = obj[key];
+    if (isObject(val) && !Object.isFrozen(val)) {
+      deepFreeze(val);
+    }
+  }
+  return obj;
+}
+__name(deepFreeze, "deepFreeze");
+function getAllPaths(obj, parentPath = "") {
+  if (!isObject(obj)) return [];
+  return Object.entries(obj).flatMap(([key, value]) => {
+    const currentPath = parentPath ? `${parentPath}.${key}` : key;
+    if (isObject(value)) {
+      return [
+        currentPath,
+        ...getAllPaths(value, currentPath)
+      ];
+    }
+    return [
+      currentPath
+    ];
+  });
+}
+__name(getAllPaths, "getAllPaths");
+function invert(obj) {
+  if (!isObject(obj)) return {};
+  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [
+    String(v),
+    k
+  ]));
+}
+__name(invert, "invert");
+function invertBy(obj, keyFn) {
+  if (!isObject(obj)) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const newKey = keyFn(value);
+    if (!result[newKey]) result[newKey] = [];
+    result[newKey].push(key);
+  }
+  return result;
+}
+__name(invertBy, "invertBy");
+function transform(obj, fn) {
+  if (!isObject(obj)) return {};
+  return Object.fromEntries(Object.entries(obj).map(([k, v]) => [
+    k,
+    fn(v, k)
+  ]));
+}
+__name(transform, "transform");
+
+export { deepClone, deepFreeze, deepObjMerge, filterObject, flattenObject, getAllPaths, getValueByPath, invert, invertBy, isEqual, isObjEmpty, isObject, isPlainObject, mapObject, omit, pick, setValueByPath, transform };

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@catbee/utils",
-  "version": "2.0.0-next.0",
+  "version": "2.0.0",
   "description": "A modular, production-grade utility toolkit for Node.js and TypeScript, designed for robust, scalable applications (including Express-based services). All utilities are tree-shakable and can be imported independently.",
   "publishConfig": {
     "access": "public"
   },
-  "main": "index.cjs",
-  "module": "index.mjs",
-  "types": "index.d.ts",
   "author": "Hari G <harig@catbee.in>",
   "maintainers": [
     "Hari G <harig@catbee.in>",
@@ -23,8 +20,7 @@
   },
   "license": "MIT",
   "dependencies": {
-    "pino": "^10.1.0",
-    "reflect-metadata": "^0.2.2"
+    "pino": "^10.1.0"
   },
   "optionalDependencies": {
     "@scalar/express-api-reference": "^0.8.30",
@@ -36,7 +32,8 @@
     "express-rate-limit": "^8.2.1",
     "helmet": "^8.1.0",
     "pino-pretty": "^13.1.3",
-    "prom-client": "^15.1.3"
+    "prom-client": "^15.1.3",
+    "reflect-metadata": "^0.2.2"
   },
   "peerDependencies": {
     "express": "^5.1.0"
@@ -49,6 +46,9 @@
   "engines": {
     "node": ">=18.4"
   },
+  "main": "index.cjs",
+  "module": "index.mjs",
+  "types": "index.d.ts",
   "files": [
     "**/*.mjs",
     "**/*.cjs",
@@ -57,6 +57,24 @@
     "LICENSE",
     "README.md"
   ],
+  "keywords": [
+    "catbee",
+    "catbee-utils",
+    "utils",
+    "utilities",
+    "helper",
+    "helpers",
+    "tools",
+    "typescript",
+    "nodejs",
+    "node",
+    "esm",
+    "commonjs",
+    "express",
+    "expressjs",
+    "express-server",
+    "developer-tools"
+  ],
   "exports": {
     ".": {
       "import": "./index.mjs",
@@ -98,15 +116,15 @@
       "require": "./date/index.cjs",
       "types": "./date/index.d.ts"
     },
-    "./decorators": {
-      "import": "./decorators/index.mjs",
-      "require": "./decorators/index.cjs",
-      "types": "./decorators/index.d.ts"
+    "./decorator": {
+      "import": "./decorator/index.mjs",
+      "require": "./decorator/index.cjs",
+      "types": "./decorator/index.d.ts"
     },
-    "./dir": {
-      "import": "./dir/index.mjs",
-      "require": "./dir/index.cjs",
-      "types": "./dir/index.d.ts"
+    "./directory": {
+      "import": "./directory/index.mjs",
+      "require": "./directory/index.cjs",
+      "types": "./directory/index.d.ts"
     },
     "./env": {
       "import": "./env/index.mjs",
@@ -143,10 +161,10 @@
       "require": "./middleware/index.cjs",
       "types": "./middleware/index.d.ts"
     },
-    "./obj": {
-      "import": "./obj/index.mjs",
-      "require": "./obj/index.cjs",
-      "types": "./obj/index.d.ts"
+    "./object": {
+      "import": "./object/index.mjs",
+      "require": "./object/index.cjs",
+      "types": "./object/index.d.ts"
     },
     "./performance": {
       "import": "./performance/index.mjs",
@@ -193,10 +211,10 @@
       "require": "./url/index.cjs",
       "types": "./url/index.d.ts"
     },
-    "./validate": {
-      "import": "./validate/index.mjs",
-      "require": "./validate/index.cjs",
-      "types": "./validate/index.d.ts"
+    "./validation": {
+      "import": "./validation/index.mjs",
+      "require": "./validation/index.cjs",
+      "types": "./validation/index.d.ts"
     }
   }
 }

package/performance/index.cjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -193,15 +193,15 @@ function memoize(fn, options = {}) {
 __name(memoize, "memoize");
 function trackMemoryUsage(fn, options = {}) {
   const { log = false, label = fn.name || "anonymous function" } = options;
-  if (global.gc) {
-    global.gc();
+  if (globalThis.gc) {
+    globalThis.gc();
   }
   const beforeMemory = process.memoryUsage();
   const result = fn();
   const afterMemory = process.memoryUsage();
   const diff = {};
   for (const key in afterMemory) {
-    if (Object.prototype.hasOwnProperty.call(afterMemory, key)) {
+    if (Object.hasOwn(afterMemory, key)) {
       diff[key] = afterMemory[key] - beforeMemory[key];
     }
   }

package/performance/index.d.ts

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -22,4 +22,141 @@
  * SOFTWARE.
  */
 
-export * from './performance.utils';
+/**
+ * Options for timing function execution.
+ */
+interface TimingOptions {
+    /** Optional label for the timing (defaults to function name) */
+    label?: string;
+    /** Whether to log the timing (default: false) */
+    log?: boolean;
+    /** Log level to use if logging is enabled (default: 'debug') */
+    logLevel?: 'trace' | 'debug' | 'info' | 'warn' | 'error';
+}
+/**
+ * Result of a timing operation.
+ */
+interface TimingResult {
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Duration in seconds */
+    durationSec: number;
+    /** Start timestamp */
+    startTime: number;
+    /** End timestamp */
+    endTime: number;
+    /** Label used for the timing */
+    label: string;
+}
+/**
+ * Measure the execution time of a synchronous function.
+ *
+ * @param fn - Function to measure
+ * @param options - Timing options
+ * @returns Result containing the return value and timing information
+ *
+ * @example
+ * ```typescript
+ * const { result, timing } = timeSync(() => {
+ *   // Some expensive operation
+ *   return computeResult();
+ * }, { label: 'Computation', log: true });
+ *
+ * console.log(`Result: ${result}, took ${timing.durationMs}ms`);
+ * ```
+ */
+declare function timeSync<T>(fn: () => T, options?: TimingOptions): {
+    result: T;
+    timing: TimingResult;
+};
+/**
+ * Measure the execution time of an asynchronous function.
+ *
+ * @param fn - Async function to measure
+ * @param options - Timing options
+ * @returns Promise resolving to result and timing information
+ *
+ * @example
+ * ```typescript
+ * const { result, timing } = await timeAsync(async () => {
+ *   // Some expensive async operation
+ *   const data = await fetchData();
+ *   return processData(data);
+ * }, { label: 'API Request', log: true });
+ *
+ * console.log(`Fetched ${result.length} items in ${timing.durationSec.toFixed(2)}s`);
+ * ```
+ */
+declare function timeAsync<T>(fn: () => Promise<T>, options?: TimingOptions): Promise<{
+    result: T;
+    timing: TimingResult;
+}>;
+/**
+ * Create a timing decorator for class methods.
+ *
+ * @param options - Timing options
+ * @returns Method decorator
+ *
+ * @example
+ * ```typescript
+ * class DataService {
+ *   @timed({ log: true, logLevel: 'info' })
+ *   async fetchData() {
+ *     // ...implementation
+ *   }
+ * }
+ * ```
+ */
+declare function timed(options?: TimingOptions): (target: any, propertyKeyOrContext: string | symbol | any, descriptor?: PropertyDescriptor) => void;
+/**
+ * Memoize function results with optional TTL and max cache size.
+ *
+ * @param fn - Function to memoize
+ * @param options - Memoization options
+ * @returns Memoized function
+ *
+ * @example
+ * ```typescript
+ * // Cache results for 30 seconds, with a maximum of 100 entries
+ * const cachedFetch = memoize(
+ *   async (url) => {
+ *     const response = await fetch(url);
+ *     return response.json();
+ *   },
+ *   { ttl: 30000, maxSize: 100, cacheKey: (url) => url }
+ * );
+ * ```
+ */
+declare function memoize<T, Args extends any[]>(fn: (...args: Args) => T, options?: {
+    /** Time-to-live in milliseconds (default: indefinite) */
+    ttl?: number;
+    /** Maximum cache size (default: unlimited) */
+    maxSize?: number;
+    /** Function to generate a cache key from arguments */
+    cacheKey?: (...args: Args) => string;
+    /** Auto-cleanup interval in milliseconds (default: disabled) */
+    autoCleanupMs?: number;
+}): (...args: Args) => T;
+/**
+ * Track memory usage for a function execution.
+ *
+ * @param fn - Function to track
+ * @param options - Memory tracking options
+ * @returns Result and memory usage information
+ */
+declare function trackMemoryUsage<T>(fn: () => T, options?: {
+    /** Whether to log the memory usage (default: false) */
+    log?: boolean;
+    /** Label for the memory tracking (default: function name) */
+    label?: string;
+}): {
+    result: T;
+    memoryUsage: {
+        before: NodeJS.MemoryUsage;
+        after: NodeJS.MemoryUsage;
+        diff: Record<string, number>;
+    };
+};
+
+export { memoize, timeAsync, timeSync, timed, trackMemoryUsage };
+export type { TimingOptions, TimingResult };

package/performance/index.mjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -191,15 +191,15 @@ function memoize(fn, options = {}) {
 __name(memoize, "memoize");
 function trackMemoryUsage(fn, options = {}) {
   const { log = false, label = fn.name || "anonymous function" } = options;
-  if (global.gc) {
-    global.gc();
+  if (globalThis.gc) {
+    globalThis.gc();
   }
   const beforeMemory = process.memoryUsage();
   const result = fn();
   const afterMemory = process.memoryUsage();
   const diff = {};
   for (const key in afterMemory) {
-    if (Object.prototype.hasOwnProperty.call(afterMemory, key)) {
+    if (Object.hasOwn(afterMemory, key)) {
       diff[key] = afterMemory[key] - beforeMemory[key];
     }
   }