@domql/utils 2.29.64 → 2.29.66

package/object.js

@@ -1,6 +1,6 @@
-"use strict";
+'use strict'
 
-import { window } from "./globals.js";
+import { window } from './globals.js'
 import {
   isFunction,
   isObjectLike,
@@ -10,12 +10,12 @@ import {
   is,
   isUndefined,
   isDate,
-  isNull,
-} from "./types.js";
-import { mergeAndCloneIfArray, mergeArray } from "./array.js";
-import { stringIncludesAny } from "./string.js";
-import { isDOMNode } from "./node.js";
-import { isNotProduction } from "./env.js";
+  isNull
+} from './types.js'
+import { mergeAndCloneIfArray, mergeArray } from './array.js'
+import { stringIncludesAny } from './string.js'
+import { isDOMNode } from './node.js'
+import { isNotProduction } from './env.js'
 
 /**
  * Executes a function with the specified context and parameters.
@@ -31,7 +31,7 @@ import { isNotProduction } from "./env.js";
  * @returns {any|Promise} - The result or a Promise to the result
  */
 export function exec(param, element, state, context) {
-  if (!element) element = this;
+  if (!element) element = this
   if (isFunction(param)) {
     try {
       // Call the function with the specified context and parameters
@@ -40,77 +40,77 @@ export function exec(param, element, state, context) {
         element,
         state || element.state,
         context || element.context
-      );
+      )
 
       // Handle promises
-      if (result && typeof result.then === "function") {
+      if (result && typeof result.then === 'function') {
         // This magic allows the function to be awaited if called with await
         // but still work reasonably when called without await
-        return result;
+        return result
       }
-      return result;
+      return result
     } catch (e) {
-      element.log(param);
-      element.warn("Error executing function", e);
+      element.log(param)
+      element.warn('Error executing function', e)
     }
   }
-  return param;
+  return param
 }
 
 export const map = (obj, extention, element) => {
   for (const e in extention) {
-    obj[e] = exec(extention[e], element);
+    obj[e] = exec(extention[e], element)
   }
-};
+}
 
 export const merge = (element, obj, excludeFrom = []) => {
   for (const e in obj) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, e);
-    if (!hasOwnProperty || excludeFrom.includes(e) || e.startsWith("__"))
-      continue;
-    const elementProp = element[e];
-    const objProp = obj[e];
+    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, e)
+    if (!hasOwnProperty || excludeFrom.includes(e) || e.startsWith('__'))
+      continue
+    const elementProp = element[e]
+    const objProp = obj[e]
     if (elementProp === undefined) {
-      element[e] = objProp;
+      element[e] = objProp
     }
   }
-  return element;
-};
+  return element
+}
 
 export const deepMerge = (element, extend, excludeFrom = []) => {
   for (const e in extend) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(extend, e);
-    if (!hasOwnProperty || excludeFrom.includes(e) || e.startsWith("__"))
-      continue;
-    const elementProp = element[e];
-    const extendProp = extend[e];
+    const hasOwnProperty = Object.prototype.hasOwnProperty.call(extend, e)
+    if (!hasOwnProperty || excludeFrom.includes(e) || e.startsWith('__'))
+      continue
+    const elementProp = element[e]
+    const extendProp = extend[e]
     if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
-      deepMerge(elementProp, extendProp, excludeFrom);
+      deepMerge(elementProp, extendProp, excludeFrom)
     } else if (elementProp === undefined) {
-      element[e] = extendProp;
+      element[e] = extendProp
     }
   }
-  return element;
-};
+  return element
+}
 
 export const clone = (obj, excludeFrom = []) => {
-  const o = {};
+  const o = {}
   for (const prop in obj) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, prop);
-    if (!hasOwnProperty || excludeFrom.includes(prop) || prop.startsWith("__"))
-      continue;
-    o[prop] = obj[prop];
+    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, prop)
+    if (!hasOwnProperty || excludeFrom.includes(prop) || prop.startsWith('__'))
+      continue
+    o[prop] = obj[prop]
   }
-  return o;
-};
+  return o
+}
 
 // Merge array, but exclude keys listed in 'excl'z
 export const mergeArrayExclude = (arr, exclude = []) => {
   return arr.reduce(
     (acc, curr) => deepMerge(acc, deepClone(curr, { exclude })),
     {}
-  );
-};
+  )
+}
 /**
  * Enhanced deep clone function that combines features from multiple implementations
  * @param {any} obj - Object to clone
@@ -130,19 +130,19 @@ export const deepClone = (obj, options = {}) => {
     cleanNull = false,
     window: targetWindow,
     visited = new WeakMap(),
-    handleExtend = false,
-  } = options;
+    handleExtend = false
+  } = options
 
-  const contentWindow = targetWindow || window || globalThis;
+  const contentWindow = targetWindow || window || globalThis
 
   // Handle non-object types and special cases
   if (!isObjectLike(obj) || isDOMNode(obj)) {
-    return obj;
+    return obj
   }
 
   // Handle circular references
   if (visited.has(obj)) {
-    return visited.get(obj);
+    return visited.get(obj)
   }
 
   // Create appropriate container based on type and window context
@@ -152,249 +152,249 @@ export const deepClone = (obj, options = {}) => {
       : new contentWindow.Object()
     : isArray(obj)
       ? []
-      : {};
+      : {}
 
   // Store the clone to handle circular references
-  visited.set(obj, clone);
+  visited.set(obj, clone)
 
   // Clone properties
   for (const key in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue
 
     // Skip excluded properties
-    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__")
-      continue;
+    if (exclude.includes(key) || key.startsWith('__') || key === '__proto__')
+      continue
 
-    const value = obj[key];
+    const value = obj[key]
 
     // Skip based on cleanup options
     if ((cleanUndefined && isUndefined(value)) || (cleanNull && isNull(value)))
-      continue;
+      continue
 
     // Handle special cases
     if (isDOMNode(value)) {
-      clone[key] = value;
-      continue;
+      clone[key] = value
+      continue
     }
 
     // Handle 'extend' array if enabled
-    if (handleExtend && key === "extend" && isArray(value)) {
-      clone[key] = mergeArray(value, exclude);
-      continue;
+    if (handleExtend && key === 'extend' && isArray(value)) {
+      clone[key] = mergeArray(value, exclude)
+      continue
     }
 
     // Handle functions in cross-frame scenario
     if (isFunction(value) && options.window) {
-      clone[key] = contentWindow.eval("(" + value.toString() + ")");
-      continue;
+      clone[key] = contentWindow.eval('(' + value.toString() + ')')
+      continue
     }
 
     // Recursively clone objects
     if (isObjectLike(value)) {
-      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue
 
       clone[key] = deepClone(value, {
         ...options,
-        visited,
-      });
+        visited
+      })
     } else {
-      clone[key] = value;
+      clone[key] = value
     }
   }
 
-  return clone;
-};
+  return clone
+}
 
 /**
  * Stringify object
  */
 export const deepStringify = (obj, stringified = {}) => {
   if (obj.node || obj.__ref || obj.parent || obj.__element || obj.parse) {
-    (obj.__element || obj.parent?.__element).warn(
-      "Trying to clone element or state at",
+    ;(obj.__element || obj.parent?.__element).warn(
+      'Trying to clone element or state at',
       obj
-    );
-    obj = obj.parse?.();
+    )
+    obj = obj.parse?.()
   }
 
   for (const prop in obj) {
-    const objProp = obj[prop];
+    const objProp = obj[prop]
     if (isFunction(objProp)) {
-      stringified[prop] = objProp.toString();
+      stringified[prop] = objProp.toString()
     } else if (isObject(objProp)) {
-      stringified[prop] = {};
-      deepStringify(objProp, stringified[prop]);
+      stringified[prop] = {}
+      deepStringify(objProp, stringified[prop])
     } else if (isArray(objProp)) {
-      stringified[prop] = [];
+      stringified[prop] = []
       objProp.forEach((v, i) => {
         if (isObject(v)) {
-          stringified[prop][i] = {};
-          deepStringify(v, stringified[prop][i]);
+          stringified[prop][i] = {}
+          deepStringify(v, stringified[prop][i])
         } else if (isFunction(v)) {
-          stringified[prop][i] = v.toString();
+          stringified[prop][i] = v.toString()
         } else {
-          stringified[prop][i] = v;
+          stringified[prop][i] = v
         }
-      });
+      })
     } else {
-      stringified[prop] = objProp;
+      stringified[prop] = objProp
     }
   }
-  return stringified;
-};
+  return stringified
+}
 
-const MAX_DEPTH = 100; // Adjust this value as needed
+const MAX_DEPTH = 100 // Adjust this value as needed
 export const deepStringifyWithMaxDepth = (
   obj,
   stringified = {},
   depth = 0,
-  path = ""
+  path = ''
 ) => {
   if (depth > MAX_DEPTH) {
     console.warn(
       `Maximum depth exceeded at path: ${path}. Possible circular reference.`
-    );
-    return "[MAX_DEPTH_EXCEEDED]";
+    )
+    return '[MAX_DEPTH_EXCEEDED]'
   }
 
   for (const prop in obj) {
-    const currentPath = path ? `${path}.${prop}` : prop;
-    const objProp = obj[prop];
+    const currentPath = path ? `${path}.${prop}` : prop
+    const objProp = obj[prop]
 
     if (isFunction(objProp)) {
-      stringified[prop] = objProp.toString();
+      stringified[prop] = objProp.toString()
     } else if (isObject(objProp)) {
-      stringified[prop] = {};
+      stringified[prop] = {}
       deepStringifyWithMaxDepth(
         objProp,
         stringified[prop],
         depth + 1,
         currentPath
-      );
+      )
     } else if (isArray(objProp)) {
-      stringified[prop] = [];
+      stringified[prop] = []
       objProp.forEach((v, i) => {
-        const itemPath = `${currentPath}[${i}]`;
+        const itemPath = `${currentPath}[${i}]`
         if (isObject(v)) {
-          stringified[prop][i] = {};
+          stringified[prop][i] = {}
           deepStringifyWithMaxDepth(
             v,
             stringified[prop][i],
             depth + 1,
             itemPath
-          );
+          )
         } else if (isFunction(v)) {
-          stringified[prop][i] = v.toString();
+          stringified[prop][i] = v.toString()
         } else {
-          stringified[prop][i] = v;
+          stringified[prop][i] = v
         }
-      });
+      })
     } else {
-      stringified[prop] = objProp;
+      stringified[prop] = objProp
     }
   }
-  return stringified;
-};
+  return stringified
+}
 
 export const objectToString = (obj = {}, indent = 0) => {
   // Handle empty object case
-  if (obj === null || typeof obj !== "object") {
-    return String(obj);
+  if (obj === null || typeof obj !== 'object') {
+    return String(obj)
   }
 
   // Handle empty object case
   if (Object.keys(obj).length === 0) {
-    return "{}";
+    return '{}'
   }
 
-  const spaces = "  ".repeat(indent);
-  let str = "{\n";
+  const spaces = '  '.repeat(indent)
+  let str = '{\n'
 
   for (const [key, value] of Object.entries(obj)) {
     const keyNotAllowdChars = stringIncludesAny(key, [
-      "&",
-      "*",
-      "-",
-      ":",
-      "%",
-      "{",
-      "}",
-      ">",
-      "<",
-      "@",
-      ".",
-      "/",
-      "!",
-      " ",
-    ]);
-    const stringedKey = keyNotAllowdChars ? `'${key}'` : key;
-    str += `${spaces}  ${stringedKey}: `;
+      '&',
+      '*',
+      '-',
+      ':',
+      '%',
+      '{',
+      '}',
+      '>',
+      '<',
+      '@',
+      '.',
+      '/',
+      '!',
+      ' '
+    ])
+    const stringedKey = keyNotAllowdChars ? `'${key}'` : key
+    str += `${spaces}  ${stringedKey}: `
 
     if (isArray(value)) {
-      str += "[\n";
+      str += '[\n'
       for (const element of value) {
         if (isObjectLike(element) && element !== null) {
-          str += `${spaces}    ${objectToString(element, indent + 2)},\n`;
+          str += `${spaces}    ${objectToString(element, indent + 2)},\n`
         } else if (isString(element)) {
-          str += `${spaces}    '${element}',\n`;
+          str += `${spaces}    '${element}',\n`
         } else {
-          str += `${spaces}    ${element},\n`;
+          str += `${spaces}    ${element},\n`
         }
       }
-      str += `${spaces}  ]`;
+      str += `${spaces}  ]`
     } else if (isObjectLike(value)) {
-      str += objectToString(value, indent + 1);
+      str += objectToString(value, indent + 1)
     } else if (isString(value)) {
-      str += stringIncludesAny(value, ["\n", "'"])
+      str += stringIncludesAny(value, ['\n', "'"])
         ? `\`${value}\``
-        : `'${value}'`;
+        : `'${value}'`
     } else {
-      str += value;
+      str += value
     }
 
-    str += ",\n";
+    str += ',\n'
   }
 
-  str += `${spaces}}`;
-  return str;
-};
+  str += `${spaces}}`
+  return str
+}
 
 /**
  * Stringify object
  */
 export const detachFunctionsFromObject = (obj, detached = {}) => {
   for (const prop in obj) {
-    const objProp = obj[prop];
-    if (isFunction(objProp)) continue;
+    const objProp = obj[prop]
+    if (isFunction(objProp)) continue
     else if (isObject(objProp)) {
-      detached[prop] = {};
-      deepStringify(objProp, detached[prop]);
+      detached[prop] = {}
+      deepStringify(objProp, detached[prop])
     } else if (isArray(objProp)) {
-      detached[prop] = [];
+      detached[prop] = []
       objProp.forEach((v, i) => {
-        if (isFunction(v)) return;
+        if (isFunction(v)) return
         if (isObject(v)) {
-          detached[prop][i] = {};
-          detachFunctionsFromObject(v, detached[prop][i]);
+          detached[prop][i] = {}
+          detachFunctionsFromObject(v, detached[prop][i])
         } else {
-          detached[prop][i] = v;
+          detached[prop][i] = v
         }
-      });
+      })
     } else {
-      detached[prop] = objProp;
+      detached[prop] = objProp
     }
   }
-  return detached;
-};
+  return detached
+}
 
 export const hasFunction = (str) => {
-  if (!str) return false;
+  if (!str) return false
 
-  const trimmed = str.trim().replace(/\n\s*/g, " ").trim();
+  const trimmed = str.trim().replace(/\n\s*/g, ' ').trim()
 
-  if (trimmed === "") return false;
-  if (trimmed === "{}") return false;
-  if (trimmed === "[]") return false;
+  if (trimmed === '') return false
+  if (trimmed === '{}') return false
+  if (trimmed === '[]') return false
 
   const patterns = [
     /^\(\s*\{[^}]*\}\s*\)\s*=>/,
@@ -402,211 +402,211 @@ export const hasFunction = (str) => {
     /^function[\s(]/,
     /^async\s+/,
     /^\(\s*function/,
-    /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/,
-  ];
+    /^[a-zA-Z_$][a-zA-Z0-9_$]*\s*=>/
+  ]
 
-  const isClass = str.startsWith("class");
-  const isFunction = patterns.some((pattern) => pattern.test(trimmed));
-  const isObjectLiteral = trimmed.startsWith("{") && !trimmed.includes("=>");
-  const isArrayLiteral = trimmed.startsWith("[");
-  const isJSONLike = /^["[{]/.test(trimmed) && !trimmed.includes("=>");
+  const isClass = str.startsWith('class')
+  const isFunction = patterns.some((pattern) => pattern.test(trimmed))
+  const isObjectLiteral = trimmed.startsWith('{') && !trimmed.includes('=>')
+  const isArrayLiteral = trimmed.startsWith('[')
+  const isJSONLike = /^["[{]/.test(trimmed) && !trimmed.includes('=>')
 
   return (
     (isFunction || isClass) &&
     !isObjectLiteral &&
     !isArrayLiteral &&
     !isJSONLike
-  );
-};
+  )
+}
 
 export const deepDestringify = (obj, destringified = {}) => {
   for (const prop in obj) {
-    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, prop);
-    if (!hasOwnProperty) continue;
+    const hasOwnProperty = Object.prototype.hasOwnProperty.call(obj, prop)
+    if (!hasOwnProperty) continue
 
-    const objProp = obj[prop];
+    const objProp = obj[prop]
 
     if (isString(objProp)) {
       if (hasFunction(objProp)) {
         try {
-          const evalProp = window.eval(`(${objProp})`);
-          destringified[prop] = evalProp;
+          const evalProp = window.eval(`(${objProp})`)
+          destringified[prop] = evalProp
         } catch (e) {
-          if (e) destringified[prop] = objProp;
+          if (e) destringified[prop] = objProp
         }
       } else {
-        destringified[prop] = objProp;
+        destringified[prop] = objProp
       }
     } else if (isArray(objProp)) {
-      destringified[prop] = [];
+      destringified[prop] = []
       objProp.forEach((arrProp) => {
         if (isString(arrProp)) {
           if (hasFunction(arrProp)) {
             try {
-              const evalProp = window.eval(`(${arrProp})`);
-              destringified[prop].push(evalProp);
+              const evalProp = window.eval(`(${arrProp})`)
+              destringified[prop].push(evalProp)
             } catch (e) {
-              if (e) destringified[prop].push(arrProp);
+              if (e) destringified[prop].push(arrProp)
             }
           } else {
-            destringified[prop].push(arrProp);
+            destringified[prop].push(arrProp)
           }
         } else if (isObject(arrProp)) {
-          destringified[prop].push(deepDestringify(arrProp));
+          destringified[prop].push(deepDestringify(arrProp))
         } else {
-          destringified[prop].push(arrProp);
+          destringified[prop].push(arrProp)
         }
-      });
+      })
     } else if (isObject(objProp)) {
-      destringified[prop] = deepDestringify(objProp, destringified[prop]);
+      destringified[prop] = deepDestringify(objProp, destringified[prop])
     } else {
-      destringified[prop] = objProp;
+      destringified[prop] = objProp
     }
   }
-  return destringified;
-};
+  return destringified
+}
 
 export const stringToObject = (str, opts = { verbose: true }) => {
   try {
-    return str ? window.eval("(" + str + ")") : {}; // eslint-disable-line
+    return str ? window.eval('(' + str + ')') : {} // eslint-disable-line
   } catch (e) {
-    if (opts.verbose) console.warn(e);
-    if (opts.errorCallback) opts.errorCallback(e);
+    if (opts.verbose) console.warn(e)
+    if (opts.errorCallback) opts.errorCallback(e)
   }
-};
+}
 
 export const diffObjects = (original, objToDiff, cache) => {
   for (const e in objToDiff) {
-    if (e === "ref") continue;
+    if (e === 'ref') continue
 
-    const originalProp = original[e];
-    const objToDiffProp = objToDiff[e];
+    const originalProp = original[e]
+    const objToDiffProp = objToDiff[e]
 
     if (isObject(originalProp) && isObject(objToDiffProp)) {
-      cache[e] = {};
-      diff(originalProp, objToDiffProp, cache[e]);
+      cache[e] = {}
+      diff(originalProp, objToDiffProp, cache[e])
     } else if (objToDiffProp !== undefined) {
-      cache[e] = objToDiffProp;
+      cache[e] = objToDiffProp
     }
   }
-  return cache;
-};
+  return cache
+}
 
 export const diffArrays = (original, objToDiff, cache) => {
   if (original.length !== objToDiff.length) {
-    cache = objToDiff;
+    cache = objToDiff
   } else {
-    const diffArr = [];
+    const diffArr = []
     for (let i = 0; i < original.length; i++) {
-      const diffObj = diff(original[i], objToDiff[i]);
+      const diffObj = diff(original[i], objToDiff[i])
       if (Object.keys(diffObj).length > 0) {
-        diffArr.push(diffObj);
+        diffArr.push(diffObj)
       }
     }
     if (diffArr.length > 0) {
-      cache = diffArr;
+      cache = diffArr
     }
   }
-  return cache;
-};
+  return cache
+}
 
 export const diff = (original, objToDiff, cache = {}) => {
   if (isArray(original) && isArray(objToDiff)) {
-    cache = [];
-    diffArrays(original, objToDiff, cache);
+    cache = []
+    diffArrays(original, objToDiff, cache)
   } else {
-    diffObjects(original, objToDiff, cache);
+    diffObjects(original, objToDiff, cache)
   }
 
-  return cache;
-};
+  return cache
+}
 
 export const hasOwnProperty = (o, ...args) =>
-  Object.prototype.hasOwnProperty.call(o, ...args);
+  Object.prototype.hasOwnProperty.call(o, ...args)
 
-export const isEmpty = (o) => Object.keys(o).length === 0;
+export const isEmpty = (o) => Object.keys(o).length === 0
 
-export const isEmptyObject = (o) => isObject(o) && isEmpty(o);
+export const isEmptyObject = (o) => isObject(o) && isEmpty(o)
 
-export const makeObjectWithoutPrototype = () => Object.create(null);
+export const makeObjectWithoutPrototype = () => Object.create(null)
 
 // by mattphillips
 // https://github.com/mattphillips/deep-object-diff/blob/main/src/diff.js
 export const deepDiff = (lhs, rhs) => {
-  if (lhs === rhs) return {};
+  if (lhs === rhs) return {}
 
-  if (!isObjectLike(lhs) || !isObjectLike(rhs)) return rhs;
+  if (!isObjectLike(lhs) || !isObjectLike(rhs)) return rhs
 
   const deletedValues = Object.keys(lhs).reduce((acc, key) => {
     if (!hasOwnProperty(rhs, key)) {
-      acc[key] = undefined;
+      acc[key] = undefined
     }
 
-    return acc;
-  }, makeObjectWithoutPrototype());
+    return acc
+  }, makeObjectWithoutPrototype())
 
   if (isDate(lhs) || isDate(rhs)) {
-    if (lhs.valueOf() === rhs.valueOf()) return {};
-    return rhs;
+    if (lhs.valueOf() === rhs.valueOf()) return {}
+    return rhs
   }
 
   return Object.keys(rhs).reduce((acc, key) => {
     if (!hasOwnProperty(lhs, key)) {
-      acc[key] = rhs[key];
-      return acc;
+      acc[key] = rhs[key]
+      return acc
     }
 
-    const difference = diff(lhs[key], rhs[key]);
+    const difference = diff(lhs[key], rhs[key])
 
     if (
       isEmptyObject(difference) &&
       !isDate(difference) &&
       (isEmptyObject(lhs[key]) || !isEmptyObject(rhs[key]))
     ) {
-      return acc;
+      return acc
     }
 
-    acc[key] = difference;
-    return acc;
-  }, deletedValues);
-};
+    acc[key] = difference
+    return acc
+  }, deletedValues)
+}
 
 /**
  * Overwrites object properties with another
  */
 export const overwrite = (element, params, opts = {}) => {
-  const { __ref: ref } = element;
-  const excl = opts.exclude || [];
-  const allowUnderscore = opts.preventUnderscore;
-  const preventCaching = opts.preventCaching;
+  const { __ref: ref } = element
+  const excl = opts.exclude || []
+  const allowUnderscore = opts.preventUnderscore
+  const preventCaching = opts.preventCaching
 
   for (const e in params) {
-    if (excl.includes(e) || (!allowUnderscore && e.startsWith("__"))) continue;
+    if (excl.includes(e) || (!allowUnderscore && e.startsWith('__'))) continue
 
-    const elementProp = element[e];
-    const paramsProp = params[e];
+    const elementProp = element[e]
+    const paramsProp = params[e]
 
     if (paramsProp !== undefined) {
-      element[e] = paramsProp;
+      element[e] = paramsProp
       if (ref && !preventCaching) {
-        ref.__cache[e] = elementProp;
+        ref.__cache[e] = elementProp
       }
       if (isObject(opts.diff)) {
-        diff[e] = elementProp;
+        diff[e] = elementProp
       }
     }
   }
 
-  return element;
-};
+  return element
+}
 
 export const overwriteShallow = (obj, params, excludeFrom = []) => {
   for (const e in params) {
-    if (excludeFrom.includes(e) || e.startsWith("__")) continue;
-    obj[e] = params[e];
+    if (excludeFrom.includes(e) || e.startsWith('__')) continue
+    obj[e] = params[e]
   }
-  return obj;
-};
+  return obj
+}
 
 /**
  * Overwrites DEEPLY object properties with another
@@ -617,8 +617,8 @@ export const overwriteDeep = (
   opts = {},
   visited = new WeakMap()
 ) => {
-  const excl = opts.exclude || [];
-  const forcedExclude = opts.preventForce ? [] : ["node", "window"];
+  const excl = opts.exclude || []
+  const forcedExclude = opts.preventForce ? [] : ['node', 'window']
 
   if (
     !isObjectLike(obj) ||
@@ -626,53 +626,53 @@ export const overwriteDeep = (
     isDOMNode(obj) ||
     isDOMNode(params)
   ) {
-    return params;
+    return params
   }
 
-  if (visited.has(obj)) return visited.get(obj);
-  visited.set(obj, obj);
+  if (visited.has(obj)) return visited.get(obj)
+  visited.set(obj, obj)
 
   for (const e in params) {
-    if (!Object.hasOwnProperty.call(params, e)) continue;
-    if (excl.includes(e) || (forcedExclude && e.startsWith("__"))) continue;
+    if (!Object.hasOwnProperty.call(params, e)) continue
+    if (excl.includes(e) || (forcedExclude && e.startsWith('__'))) continue
 
-    const objProp = obj[e];
-    const paramsProp = params[e];
+    const objProp = obj[e]
+    const paramsProp = params[e]
 
     if (isDOMNode(paramsProp)) {
-      obj[e] = paramsProp;
+      obj[e] = paramsProp
     } else if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
-      obj[e] = overwriteDeep(objProp, paramsProp, opts, visited);
+      obj[e] = overwriteDeep(objProp, paramsProp, opts, visited)
     } else if (paramsProp !== undefined) {
-      obj[e] = paramsProp;
+      obj[e] = paramsProp
     }
   }
 
-  return obj;
-};
+  return obj
+}
 
 /**
  * Overwrites object properties with another
  */
 export const mergeIfExisted = (a, b) => {
-  if (isObjectLike(a) && isObjectLike(b)) return deepMerge(a, b);
-  return a || b;
-};
+  if (isObjectLike(a) && isObjectLike(b)) return deepMerge(a, b)
+  return a || b
+}
 
 /**
  * Overwrites object properties with another
  */
 export const flattenRecursive = (param, prop, stack = []) => {
-  const objectized = mergeAndCloneIfArray(param);
-  stack.push(objectized);
+  const objectized = mergeAndCloneIfArray(param)
+  stack.push(objectized)
 
-  const extendOfExtend = objectized[prop];
-  if (extendOfExtend) flattenRecursive(extendOfExtend, prop, stack);
+  const extendOfExtend = objectized[prop]
+  if (extendOfExtend) flattenRecursive(extendOfExtend, prop, stack)
 
-  delete objectized[prop];
+  delete objectized[prop]
 
-  return stack;
-};
+  return stack
+}
 
 /**
  * Recursively compares two values to determine if they are deeply equal.
@@ -711,257 +711,257 @@ export const flattenRecursive = (param, prop, stack = []) => {
 export const isEqualDeep = (param, element, visited = new Set()) => {
   // Check if both values are non-null objects
   if (
-    typeof param !== "object" ||
-    typeof element !== "object" ||
+    typeof param !== 'object' ||
+    typeof element !== 'object' ||
     param === null ||
     element === null
   ) {
-    return param === element; // Compare non-object values directly
+    return param === element // Compare non-object values directly
   }
 
   // Check for circular references
   if (visited.has(param) || visited.has(element)) {
-    return true; // Assume equality to break the circular reference
+    return true // Assume equality to break the circular reference
   }
 
-  visited.add(param);
-  visited.add(element);
+  visited.add(param)
+  visited.add(element)
 
-  const keysParam = Object.keys(param);
-  const keysElement = Object.keys(element);
+  const keysParam = Object.keys(param)
+  const keysElement = Object.keys(element)
 
   // Check if both objects have the same number of properties
   if (keysParam.length !== keysElement.length) {
-    return false;
+    return false
   }
 
   // Check if all properties in param also exist in element
   for (const key of keysParam) {
     if (!keysElement.includes(key)) {
-      return false;
+      return false
     }
 
-    const paramProp = param[key];
-    const elementProp = element[key];
+    const paramProp = param[key]
+    const elementProp = element[key]
 
     // Recursively check property values
     if (!isEqualDeep(paramProp, elementProp, visited)) {
-      return false;
+      return false
     }
   }
 
-  return true;
-};
+  return true
+}
 
-export const deepContains = (obj1, obj2, ignoredKeys = ["node", "__ref"]) => {
-  if (obj1 === obj2) return true;
-  if (!isObjectLike(obj1) || !isObjectLike(obj2)) return false;
-  if (isDOMNode(obj1) || isDOMNode(obj2)) return obj1 === obj2;
+export const deepContains = (obj1, obj2, ignoredKeys = ['node', '__ref']) => {
+  if (obj1 === obj2) return true
+  if (!isObjectLike(obj1) || !isObjectLike(obj2)) return false
+  if (isDOMNode(obj1) || isDOMNode(obj2)) return obj1 === obj2
 
-  const stack = [[obj1, obj2]];
-  const visited = new WeakSet();
+  const stack = [[obj1, obj2]]
+  const visited = new WeakSet()
 
   while (stack.length > 0) {
-    const [current1, current2] = stack.pop();
+    const [current1, current2] = stack.pop()
 
-    if (visited.has(current1)) continue;
-    visited.add(current1);
+    if (visited.has(current1)) continue
+    visited.add(current1)
 
     const keys1 = Object.keys(current1).filter(
       (key) => !ignoredKeys.includes(key)
-    );
+    )
     const keys2 = Object.keys(current2).filter(
       (key) => !ignoredKeys.includes(key)
-    );
+    )
 
-    if (keys1.length !== keys2.length) return false;
+    if (keys1.length !== keys2.length) return false
 
     for (const key of keys1) {
-      if (!Object.prototype.hasOwnProperty.call(current2, key)) return false;
+      if (!Object.prototype.hasOwnProperty.call(current2, key)) return false
 
-      const value1 = current1[key];
-      const value2 = current2[key];
+      const value1 = current1[key]
+      const value2 = current2[key]
 
       if (isDOMNode(value1) || isDOMNode(value2)) {
-        if (value1 !== value2) return false;
+        if (value1 !== value2) return false
       } else if (isObjectLike(value1) && isObjectLike(value2)) {
         if (value1 !== value2) {
-          stack.push([value1, value2]);
+          stack.push([value1, value2])
         }
       } else if (value1 !== value2) {
-        return false;
+        return false
       }
     }
   }
 
-  return true;
-};
+  return true
+}
 
 export const removeFromObject = (obj, props) => {
-  if (props === undefined || props === null) return obj;
-  if (is(props)("string", "number")) {
-    delete obj[props];
+  if (props === undefined || props === null) return obj
+  if (is(props)('string', 'number')) {
+    delete obj[props]
   } else if (isArray(props)) {
-    props.forEach((prop) => delete obj[prop]);
+    props.forEach((prop) => delete obj[prop])
   } else {
     throw new Error(
-      "Invalid input: props must be a string or an array of strings"
-    );
+      'Invalid input: props must be a string or an array of strings'
+    )
   }
-  return obj;
-};
+  return obj
+}
 
 export const createObjectWithoutPrototype = (obj) => {
-  if (obj === null || typeof obj !== "object") {
-    return obj; // Return the value if obj is not an object
+  if (obj === null || typeof obj !== 'object') {
+    return obj // Return the value if obj is not an object
   }
 
-  const newObj = Object.create(null); // Create an object without prototype
+  const newObj = Object.create(null) // Create an object without prototype
 
   for (const key in obj) {
     if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      newObj[key] = createObjectWithoutPrototype(obj[key]); // Recursively copy each property
+      newObj[key] = createObjectWithoutPrototype(obj[key]) // Recursively copy each property
     }
   }
 
-  return newObj;
-};
+  return newObj
+}
 
 export const createNestedObject = (arr, lastValue) => {
-  const nestedObject = {};
+  const nestedObject = {}
 
   if (arr.length === 0) {
-    return lastValue;
+    return lastValue
   }
 
   arr.reduce((obj, value, index) => {
     if (!obj[value]) {
-      obj[value] = {};
+      obj[value] = {}
     }
     if (index === arr.length - 1 && lastValue !== undefined) {
-      obj[value] = lastValue;
+      obj[value] = lastValue
     }
-    return obj[value];
-  }, nestedObject);
+    return obj[value]
+  }, nestedObject)
 
-  return nestedObject;
-};
+  return nestedObject
+}
 
 export const removeNestedKeyByPath = (obj, path) => {
   if (!Array.isArray(path)) {
-    throw new Error("Path must be an array.");
+    throw new Error('Path must be an array.')
   }
 
-  let current = obj;
+  let current = obj
 
   for (let i = 0; i < path.length - 1; i++) {
     if (current[path[i]] === undefined) {
-      return; // Path does not exist, so nothing to remove.
+      return // Path does not exist, so nothing to remove.
     }
-    current = current[path[i]];
+    current = current[path[i]]
   }
 
-  const lastKey = path[path.length - 1];
+  const lastKey = path[path.length - 1]
   if (current && Object.hasOwnProperty.call(current, lastKey)) {
-    delete current[lastKey];
+    delete current[lastKey]
   }
-};
+}
 
 export const setInObjectByPath = (obj, path, value) => {
   if (!Array.isArray(path)) {
-    throw new Error("Path must be an array.");
+    throw new Error('Path must be an array.')
   }
 
-  let current = obj;
+  let current = obj
 
   for (let i = 0; i < path.length - 1; i++) {
     // If the current path segment doesn't exist or isn't an object, create it
-    if (!current[path[i]] || typeof current[path[i]] !== "object") {
-      current[path[i]] = {};
+    if (!current[path[i]] || typeof current[path[i]] !== 'object') {
+      current[path[i]] = {}
     }
-    current = current[path[i]];
+    current = current[path[i]]
   }
 
-  const lastKey = path[path.length - 1];
-  current[lastKey] = value;
+  const lastKey = path[path.length - 1]
+  current[lastKey] = value
 
-  return obj;
-};
+  return obj
+}
 
 export const getInObjectByPath = (obj, path) => {
   if (!Array.isArray(path)) {
-    throw new Error("Path must be an array.");
+    throw new Error('Path must be an array.')
   }
 
-  let current = obj;
+  let current = obj
 
   for (let i = 0; i < path.length; i++) {
     if (current === undefined || current === null) {
-      return undefined;
+      return undefined
     }
-    current = current[path[i]];
+    current = current[path[i]]
   }
 
-  return current;
-};
+  return current
+}
 
 export const detectInfiniteLoop = (arr) => {
-  const maxRepeats = 10; // Maximum allowed repetitions
-  let pattern = [];
-  let repeatCount = 0;
+  const maxRepeats = 3 // Maximum allowed repetitions
+  let pattern = []
+  let repeatCount = 0
 
   for (let i = 0; i < arr.length; i++) {
     if (pattern.length < 2) {
       // Build the initial pattern with two consecutive elements
-      pattern.push(arr[i]);
+      pattern.push(arr[i])
     } else {
       // Check if the current element follows the repeating pattern
       if (arr[i] === pattern[i % 2]) {
-        repeatCount++;
+        repeatCount++
       } else {
         // If there's a mismatch, reset the pattern and repeat counter
-        pattern = [arr[i - 1], arr[i]];
-        repeatCount = 1; // Reset to 1 because we start a new potential pattern
+        pattern = [arr[i - 1], arr[i]]
+        repeatCount = 1 // Reset to 1 because we start a new potential pattern
       }
 
       // If the pattern repeats more than `maxRepeats`, throw a warning
       if (repeatCount >= maxRepeats * 2) {
         if (isNotProduction()) {
           console.warn(
-            "Warning: Potential infinite loop detected due to repeated sequence:",
+            'Warning: Potential infinite loop detected due to repeated sequence:',
             pattern
-          );
+          )
         }
-        return true;
+        return true
       }
     }
   }
-};
+}
 
 export const isCyclic = (obj) => {
-  const seenObjects = [];
+  const seenObjects = []
 
   function detect(obj) {
-    if (obj && typeof obj === "object") {
+    if (obj && typeof obj === 'object') {
       if (seenObjects.indexOf(obj) !== -1) {
-        return true;
+        return true
       }
-      seenObjects.push(obj);
+      seenObjects.push(obj)
       for (const key in obj) {
         if (Object.hasOwnProperty.call(obj, key) && detect(obj[key])) {
-          console.log(obj, "cycle at " + key);
-          return true;
+          console.log(obj, 'cycle at ' + key)
+          return true
         }
       }
     }
-    return false;
+    return false
   }
 
-  return detect(obj);
-};
+  return detect(obj)
+}
 
 export const excludeKeysFromObject = (obj, excludedKeys) => {
-  const result = { ...obj };
-  excludedKeys.forEach((key) => delete result[key]);
-  return result;
-};
+  const result = { ...obj }
+  excludedKeys.forEach((key) => delete result[key])
+  return result
+}