@domql/utils 2.3.53 → 2.3.57

package/dist/cjs/array.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/function.js

@@ -0,0 +1,46 @@
+"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);
+var function_exports = {};
+__export(function_exports, {
+  debounce: () => debounce,
+  memoize: () => memoize
+});
+module.exports = __toCommonJS(function_exports);
+const debounce = (element, func, timeout = 300) => {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      func.apply(element, args);
+    }, timeout);
+  };
+};
+const memoize = (fn) => {
+  const cache = {};
+  return (...args) => {
+    const n = args[0];
+    if (n in cache) {
+      return cache[n];
+    } else {
+      const result = fn(n);
+      cache[n] = result;
+      return result;
+    }
+  };
+};

package/dist/cjs/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./types.js"), module.exports);
+__reExport(utils_exports, require("./object.js"), module.exports);
+__reExport(utils_exports, require("./function.js"), module.exports);
+__reExport(utils_exports, require("./array.js"), module.exports);
+__reExport(utils_exports, require("./node.js"), module.exports);
+__reExport(utils_exports, require("./log.js"), module.exports);

package/dist/cjs/log.js

@@ -0,0 +1,35 @@
+"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);
+var log_exports = {};
+__export(log_exports, {
+  logGroupIf: () => logGroupIf,
+  logIf: () => logIf
+});
+module.exports = __toCommonJS(log_exports);
+const logIf = (bool, ...arg) => {
+  if (bool)
+    arg.map((v) => console.log(v));
+};
+const logGroupIf = (bool, key, ...arg) => {
+  if (bool) {
+    console.group(key);
+    arg.map((v) => console.log(v));
+    console.groupEnd(key);
+  }
+};

package/dist/cjs/node.js

@@ -0,0 +1,35 @@
+"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);
+var node_exports = {};
+__export(node_exports, {
+  cleanWithNode: () => cleanWithNode,
+  createID: () => createID,
+  createSnapshotId: () => createSnapshotId
+});
+module.exports = __toCommonJS(node_exports);
+const cleanWithNode = (extend) => delete extend.node && extend;
+const createID = function() {
+  let index = 0;
+  function newId() {
+    index++;
+    return index;
+  }
+  return newId;
+}();
+const createSnapshotId = createID;

package/dist/cjs/object.js

@@ -0,0 +1,258 @@
+"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);
+var object_exports = {};
+__export(object_exports, {
+  clone: () => clone,
+  deepClone: () => deepClone,
+  deepCloneExclude: () => deepCloneExclude,
+  deepDestringify: () => deepDestringify,
+  deepMerge: () => deepMerge,
+  deepStringify: () => deepStringify,
+  diff: () => diff,
+  exec: () => exec,
+  flattenRecursive: () => flattenRecursive,
+  isEqualDeep: () => isEqualDeep,
+  map: () => map,
+  merge: () => merge,
+  mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+  mergeArray: () => mergeArray,
+  mergeArrayExclude: () => mergeArrayExclude,
+  mergeIfExisted: () => mergeIfExisted,
+  overwrite: () => overwrite,
+  overwriteDeep: () => overwriteDeep,
+  overwriteObj: () => overwriteObj
+});
+module.exports = __toCommonJS(object_exports);
+var import_types = require("./types.js");
+const exec = (param, element, state) => {
+  if ((0, import_types.isFunction)(param))
+    return param(element, state || element.state);
+  return param;
+};
+const map = (obj2, extention, element) => {
+  for (const e in extention) {
+    obj2[e] = exec(extention[e], element);
+  }
+};
+const merge = (element, obj2) => {
+  for (const e in obj2) {
+    const elementProp = element[e];
+    const objProp2 = obj2[e];
+    if (elementProp === void 0) {
+      element[e] = objProp2;
+    }
+  }
+  return element;
+};
+const deepMerge = (element, extend) => {
+  for (const e in extend) {
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (e === "parent" || e === "props")
+      continue;
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if ((0, import_types.isObjectLike)(elementProp) && (0, import_types.isObject)(extendProp)) {
+      deepMerge(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+const clone = (obj2) => {
+  const o = {};
+  for (const prop2 in obj2) {
+    if (prop2 === "node")
+      continue;
+    o[prop2] = obj2[prop2];
+  }
+  return o;
+};
+const deepCloneExclude = (obj2, exclude = []) => {
+  if ((0, import_types.isArray)(obj2)) {
+    return obj2.map((x) => deepCloneExclude(x, exclude));
+  }
+  const o = {};
+  for (const k in obj2) {
+    if (exclude.indexOf(k) > -1)
+      continue;
+    let v = obj2[k];
+    if (k === "extend" && (0, import_types.isArray)(v)) {
+      v = mergeArrayExclude(v, exclude);
+    }
+    if ((0, import_types.isArray)(v)) {
+      o[k] = v.map((x) => deepCloneExclude(x, exclude));
+    } else if ((0, import_types.isObject)(v)) {
+      o[k] = deepCloneExclude(v, exclude);
+    } else
+      o[k] = v;
+  }
+  return o;
+};
+const mergeArrayExclude = (arr, excl = []) => {
+  return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {});
+};
+const deepClone = (obj2) => {
+  if ((0, import_types.isArray)(obj2)) {
+    return obj2.map(deepClone);
+  }
+  const o = {};
+  for (const prop2 in obj2) {
+    let objProp2 = obj2[prop2];
+    if (prop2 === "extend" && (0, import_types.isArray)(objProp2)) {
+      objProp2 = mergeArray(objProp2);
+    }
+    if ((0, import_types.isArray)(objProp2)) {
+      o[prop2] = objProp2.map((v) => (0, import_types.isObject)(v) ? deepClone(v) : v);
+    } else if ((0, import_types.isObject)(objProp2)) {
+      o[prop2] = deepClone(objProp2);
+    } else
+      o[prop2] = objProp2;
+  }
+  return o;
+};
+const deepStringify = (obj2, stringified2 = {}) => {
+  for (const prop2 in obj2) {
+    const objProp2 = obj2[prop2];
+    if ((0, import_types.isFunction)(objProp2)) {
+      stringified2[prop2] = objProp2.toString();
+    } else if ((0, import_types.isObject)(objProp2)) {
+      stringified2[prop2] = {};
+      deepStringify(objProp2[prop2], stringified2[prop2]);
+    } else if ((0, import_types.isArray)(objProp2)) {
+      stringified2[prop2] = [];
+      objProp2.map((v, i) => deepStringify(v, stringified2[prop2][i]));
+    } else
+      stringified2[prop2] = objProp2;
+  }
+  return stringified2;
+};
+const deepDestringify = (obj, stringified = {}) => {
+  for (const prop in obj) {
+    const objProp = obj[prop];
+    if ((0, import_types.isString)(objProp)) {
+      if (objProp.includes("=>") || objProp.includes("function") || objProp[0] === "(") {
+        try {
+          const evalProp = eval(objProp);
+          stringified[prop] = evalProp;
+        } catch (e) {
+          if (e)
+            stringified[prop] = objProp;
+        }
+      }
+    } else
+      stringified[prop] = objProp;
+    if ((0, import_types.isObject)(objProp))
+      deepDestringify(stringified[prop], stringified[prop]);
+  }
+  return stringified;
+};
+const overwrite = (element, params, options) => {
+  const { ref } = element;
+  const changes = {};
+  for (const e in params) {
+    if (e === "props")
+      continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp) {
+      ref.__cache[e] = changes[e] = elementProp;
+      ref[e] = paramsProp;
+    }
+  }
+  return changes;
+};
+const diff = (obj2, original, cache) => {
+  const changes = cache || {};
+  for (const e in obj2) {
+    if (e === "ref")
+      continue;
+    const originalProp = original[e];
+    const objProp2 = obj2[e];
+    if ((0, import_types.isObjectLike)(originalProp) && (0, import_types.isObjectLike)(objProp2)) {
+      changes[e] = {};
+      diff(originalProp, objProp2, changes[e]);
+    } else if (objProp2 !== void 0) {
+      changes[e] = objProp2;
+    }
+  }
+  return changes;
+};
+const overwriteObj = (params, obj2) => {
+  const changes = {};
+  for (const e in params) {
+    const objProp2 = obj2[e];
+    const paramsProp = params[e];
+    if (paramsProp) {
+      obj2[e] = changes[e] = objProp2;
+    }
+  }
+  return changes;
+};
+const overwriteDeep = (params, obj2) => {
+  for (const e in params) {
+    const objProp2 = obj2[e];
+    const paramsProp = params[e];
+    if ((0, import_types.isObjectLike)(objProp2) && (0, import_types.isObjectLike)(paramsProp)) {
+      overwriteDeep(objProp2, paramsProp);
+    } else if (paramsProp !== void 0) {
+      obj2[e] = paramsProp;
+    }
+  }
+  return obj2;
+};
+const mergeIfExisted = (a, b) => {
+  if ((0, import_types.isObjectLike)(a) && (0, import_types.isObjectLike)(b))
+    return deepMerge(a, b);
+  return a || b;
+};
+const mergeArray = (arr) => {
+  return arr.reduce((a, c) => deepMerge(a, deepClone(c)), {});
+};
+const mergeAndCloneIfArray = (obj2) => {
+  return (0, import_types.isArray)(obj2) ? mergeArray(obj2) : deepClone(obj2);
+};
+const flattenRecursive = (param, prop2, stack = []) => {
+  const objectized = mergeAndCloneIfArray(param);
+  stack.push(objectized);
+  const extendOfExtend = objectized[prop2];
+  if (extendOfExtend)
+    flattenRecursive(extendOfExtend, prop2, stack);
+  delete objectized[prop2];
+  return stack;
+};
+const isEqualDeep = (param, element) => {
+  if (param === element)
+    return true;
+  if (!param || !element)
+    return false;
+  for (const prop2 in param) {
+    const paramProp = param[prop2];
+    const elementProp = element[prop2];
+    if ((0, import_types.isObjectLike)(paramProp)) {
+      const isEqual = isEqualDeep(paramProp, elementProp);
+      if (!isEqual)
+        return false;
+    } else {
+      const isEqual = paramProp === elementProp;
+      if (!isEqual)
+        return false;
+    }
+  }
+  return true;
+};

package/dist/cjs/package-cjs.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "main": "index.js"
+}

package/dist/cjs/types.js

@@ -0,0 +1,92 @@
+"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);
+var types_exports = {};
+__export(types_exports, {
+  TYPES: () => TYPES,
+  is: () => is,
+  isArray: () => isArray,
+  isBoolean: () => isBoolean,
+  isDefined: () => isDefined,
+  isFunction: () => isFunction,
+  isHtmlElement: () => isHtmlElement,
+  isNode: () => isNode,
+  isNot: () => isNot,
+  isNull: () => isNull,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isObjectLike: () => isObjectLike,
+  isString: () => isString,
+  isUndefined: () => isUndefined,
+  isValidHtmlTag: () => isValidHtmlTag
+});
+module.exports = __toCommonJS(types_exports);
+var import_globals = require("@domql/globals");
+var import_tags = require("@domql/tags");
+const isValidHtmlTag = (arg) => import_tags.HTML_TAGS.body.indexOf(arg);
+const isObject = (arg) => {
+  if (arg === null)
+    return false;
+  return typeof arg === "object" && arg.constructor === Object;
+};
+const isString = (arg) => typeof arg === "string";
+const isNumber = (arg) => typeof arg === "number";
+const isFunction = (arg) => typeof arg === "function";
+const isBoolean = (arg) => arg === true || arg === false;
+const isNull = (arg) => arg === null;
+const isArray = (arg) => Array.isArray(arg);
+const isObjectLike = (arg) => {
+  if (arg === null)
+    return false;
+  return typeof arg === "object";
+};
+const isNode = (obj) => {
+  return typeof import_globals.window.Node === "object" ? obj instanceof import_globals.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+};
+const isHtmlElement = (obj) => {
+  return typeof import_globals.window.HTMLElement === "object" ? obj instanceof import_globals.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
+};
+const isDefined = (arg) => {
+  return isObject(arg) || isObjectLike(arg) || isString(arg) || isNumber(arg) || isFunction(arg) || isArray(arg) || isObjectLike(arg) || isBoolean(arg) || isNull(arg);
+};
+const isUndefined = (arg) => {
+  return arg === void 0;
+};
+const TYPES = {
+  boolean: isBoolean,
+  array: isArray,
+  object: isObject,
+  string: isString,
+  number: isNumber,
+  null: isNull,
+  function: isFunction,
+  objectLike: isObjectLike,
+  node: isNode,
+  htmlElement: isHtmlElement,
+  defined: isDefined
+};
+const is = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+  };
+};
+const isNot = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+  };
+};

package/dist/esm/function.js

@@ -0,0 +1,26 @@
+const debounce = (element, func, timeout = 300) => {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      func.apply(element, args);
+    }, timeout);
+  };
+};
+const memoize = (fn) => {
+  const cache = {};
+  return (...args) => {
+    const n = args[0];
+    if (n in cache) {
+      return cache[n];
+    } else {
+      const result = fn(n);
+      cache[n] = result;
+      return result;
+    }
+  };
+};
+export {
+  debounce,
+  memoize
+};

package/dist/esm/log.js

@@ -0,0 +1,15 @@
+const logIf = (bool, ...arg) => {
+  if (bool)
+    arg.map((v) => console.log(v));
+};
+const logGroupIf = (bool, key, ...arg) => {
+  if (bool) {
+    console.group(key);
+    arg.map((v) => console.log(v));
+    console.groupEnd(key);
+  }
+};
+export {
+  logGroupIf,
+  logIf
+};

package/dist/esm/node.js

@@ -0,0 +1,15 @@
+const cleanWithNode = (extend) => delete extend.node && extend;
+const createID = function() {
+  let index = 0;
+  function newId() {
+    index++;
+    return index;
+  }
+  return newId;
+}();
+const createSnapshotId = createID;
+export {
+  cleanWithNode,
+  createID,
+  createSnapshotId
+};

package/dist/esm/object.js

@@ -0,0 +1,238 @@
+import { isFunction, isObjectLike, isObject, isArray, isString } from "./types.js";
+const exec = (param, element, state) => {
+  if (isFunction(param))
+    return param(element, state || element.state);
+  return param;
+};
+const map = (obj2, extention, element) => {
+  for (const e in extention) {
+    obj2[e] = exec(extention[e], element);
+  }
+};
+const merge = (element, obj2) => {
+  for (const e in obj2) {
+    const elementProp = element[e];
+    const objProp2 = obj2[e];
+    if (elementProp === void 0) {
+      element[e] = objProp2;
+    }
+  }
+  return element;
+};
+const deepMerge = (element, extend) => {
+  for (const e in extend) {
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (e === "parent" || e === "props")
+      continue;
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if (isObjectLike(elementProp) && isObject(extendProp)) {
+      deepMerge(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+const clone = (obj2) => {
+  const o = {};
+  for (const prop2 in obj2) {
+    if (prop2 === "node")
+      continue;
+    o[prop2] = obj2[prop2];
+  }
+  return o;
+};
+const deepCloneExclude = (obj2, exclude = []) => {
+  if (isArray(obj2)) {
+    return obj2.map((x) => deepCloneExclude(x, exclude));
+  }
+  const o = {};
+  for (const k in obj2) {
+    if (exclude.indexOf(k) > -1)
+      continue;
+    let v = obj2[k];
+    if (k === "extend" && isArray(v)) {
+      v = mergeArrayExclude(v, exclude);
+    }
+    if (isArray(v)) {
+      o[k] = v.map((x) => deepCloneExclude(x, exclude));
+    } else if (isObject(v)) {
+      o[k] = deepCloneExclude(v, exclude);
+    } else
+      o[k] = v;
+  }
+  return o;
+};
+const mergeArrayExclude = (arr, excl = []) => {
+  return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {});
+};
+const deepClone = (obj2) => {
+  if (isArray(obj2)) {
+    return obj2.map(deepClone);
+  }
+  const o = {};
+  for (const prop2 in obj2) {
+    let objProp2 = obj2[prop2];
+    if (prop2 === "extend" && isArray(objProp2)) {
+      objProp2 = mergeArray(objProp2);
+    }
+    if (isArray(objProp2)) {
+      o[prop2] = objProp2.map((v) => isObject(v) ? deepClone(v) : v);
+    } else if (isObject(objProp2)) {
+      o[prop2] = deepClone(objProp2);
+    } else
+      o[prop2] = objProp2;
+  }
+  return o;
+};
+const deepStringify = (obj2, stringified2 = {}) => {
+  for (const prop2 in obj2) {
+    const objProp2 = obj2[prop2];
+    if (isFunction(objProp2)) {
+      stringified2[prop2] = objProp2.toString();
+    } else if (isObject(objProp2)) {
+      stringified2[prop2] = {};
+      deepStringify(objProp2[prop2], stringified2[prop2]);
+    } else if (isArray(objProp2)) {
+      stringified2[prop2] = [];
+      objProp2.map((v, i) => deepStringify(v, stringified2[prop2][i]));
+    } else
+      stringified2[prop2] = objProp2;
+  }
+  return stringified2;
+};
+const deepDestringify = (obj, stringified = {}) => {
+  for (const prop in obj) {
+    const objProp = obj[prop];
+    if (isString(objProp)) {
+      if (objProp.includes("=>") || objProp.includes("function") || objProp[0] === "(") {
+        try {
+          const evalProp = eval(objProp);
+          stringified[prop] = evalProp;
+        } catch (e) {
+          if (e)
+            stringified[prop] = objProp;
+        }
+      }
+    } else
+      stringified[prop] = objProp;
+    if (isObject(objProp))
+      deepDestringify(stringified[prop], stringified[prop]);
+  }
+  return stringified;
+};
+const overwrite = (element, params, options) => {
+  const { ref } = element;
+  const changes = {};
+  for (const e in params) {
+    if (e === "props")
+      continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp) {
+      ref.__cache[e] = changes[e] = elementProp;
+      ref[e] = paramsProp;
+    }
+  }
+  return changes;
+};
+const diff = (obj2, original, cache) => {
+  const changes = cache || {};
+  for (const e in obj2) {
+    if (e === "ref")
+      continue;
+    const originalProp = original[e];
+    const objProp2 = obj2[e];
+    if (isObjectLike(originalProp) && isObjectLike(objProp2)) {
+      changes[e] = {};
+      diff(originalProp, objProp2, changes[e]);
+    } else if (objProp2 !== void 0) {
+      changes[e] = objProp2;
+    }
+  }
+  return changes;
+};
+const overwriteObj = (params, obj2) => {
+  const changes = {};
+  for (const e in params) {
+    const objProp2 = obj2[e];
+    const paramsProp = params[e];
+    if (paramsProp) {
+      obj2[e] = changes[e] = objProp2;
+    }
+  }
+  return changes;
+};
+const overwriteDeep = (params, obj2) => {
+  for (const e in params) {
+    const objProp2 = obj2[e];
+    const paramsProp = params[e];
+    if (isObjectLike(objProp2) && isObjectLike(paramsProp)) {
+      overwriteDeep(objProp2, paramsProp);
+    } else if (paramsProp !== void 0) {
+      obj2[e] = paramsProp;
+    }
+  }
+  return obj2;
+};
+const mergeIfExisted = (a, b) => {
+  if (isObjectLike(a) && isObjectLike(b))
+    return deepMerge(a, b);
+  return a || b;
+};
+const mergeArray = (arr) => {
+  return arr.reduce((a, c) => deepMerge(a, deepClone(c)), {});
+};
+const mergeAndCloneIfArray = (obj2) => {
+  return isArray(obj2) ? mergeArray(obj2) : deepClone(obj2);
+};
+const flattenRecursive = (param, prop2, stack = []) => {
+  const objectized = mergeAndCloneIfArray(param);
+  stack.push(objectized);
+  const extendOfExtend = objectized[prop2];
+  if (extendOfExtend)
+    flattenRecursive(extendOfExtend, prop2, stack);
+  delete objectized[prop2];
+  return stack;
+};
+const isEqualDeep = (param, element) => {
+  if (param === element)
+    return true;
+  if (!param || !element)
+    return false;
+  for (const prop2 in param) {
+    const paramProp = param[prop2];
+    const elementProp = element[prop2];
+    if (isObjectLike(paramProp)) {
+      const isEqual = isEqualDeep(paramProp, elementProp);
+      if (!isEqual)
+        return false;
+    } else {
+      const isEqual = paramProp === elementProp;
+      if (!isEqual)
+        return false;
+    }
+  }
+  return true;
+};
+export {
+  clone,
+  deepClone,
+  deepCloneExclude,
+  deepDestringify,
+  deepMerge,
+  deepStringify,
+  diff,
+  exec,
+  flattenRecursive,
+  isEqualDeep,
+  map,
+  merge,
+  mergeAndCloneIfArray,
+  mergeArray,
+  mergeArrayExclude,
+  mergeIfExisted,
+  overwrite,
+  overwriteDeep,
+  overwriteObj
+};

package/dist/esm/types.js

@@ -0,0 +1,72 @@
+import { window } from "@domql/globals";
+import { HTML_TAGS } from "@domql/tags";
+const isValidHtmlTag = (arg) => HTML_TAGS.body.indexOf(arg);
+const isObject = (arg) => {
+  if (arg === null)
+    return false;
+  return typeof arg === "object" && arg.constructor === Object;
+};
+const isString = (arg) => typeof arg === "string";
+const isNumber = (arg) => typeof arg === "number";
+const isFunction = (arg) => typeof arg === "function";
+const isBoolean = (arg) => arg === true || arg === false;
+const isNull = (arg) => arg === null;
+const isArray = (arg) => Array.isArray(arg);
+const isObjectLike = (arg) => {
+  if (arg === null)
+    return false;
+  return typeof arg === "object";
+};
+const isNode = (obj) => {
+  return typeof window.Node === "object" ? obj instanceof window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+};
+const isHtmlElement = (obj) => {
+  return typeof window.HTMLElement === "object" ? obj instanceof window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
+};
+const isDefined = (arg) => {
+  return isObject(arg) || isObjectLike(arg) || isString(arg) || isNumber(arg) || isFunction(arg) || isArray(arg) || isObjectLike(arg) || isBoolean(arg) || isNull(arg);
+};
+const isUndefined = (arg) => {
+  return arg === void 0;
+};
+const TYPES = {
+  boolean: isBoolean,
+  array: isArray,
+  object: isObject,
+  string: isString,
+  number: isNumber,
+  null: isNull,
+  function: isFunction,
+  objectLike: isObjectLike,
+  node: isNode,
+  htmlElement: isHtmlElement,
+  defined: isDefined
+};
+const is = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+  };
+};
+const isNot = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+  };
+};
+export {
+  TYPES,
+  is,
+  isArray,
+  isBoolean,
+  isDefined,
+  isFunction,
+  isHtmlElement,
+  isNode,
+  isNot,
+  isNull,
+  isNumber,
+  isObject,
+  isObjectLike,
+  isString,
+  isUndefined,
+  isValidHtmlTag
+};

package/dist/iife/array.js

@@ -0,0 +1,3 @@
+"use strict";
+(() => {
+})();

package/dist/iife/function.js

@@ -0,0 +1,25 @@
+"use strict";
+(() => {
+  const debounce = (element, func, timeout = 300) => {
+    let timer;
+    return (...args) => {
+      clearTimeout(timer);
+      timer = setTimeout(() => {
+        func.apply(element, args);
+      }, timeout);
+    };
+  };
+  const memoize = (fn) => {
+    const cache = {};
+    return (...args) => {
+      const n = args[0];
+      if (n in cache) {
+        return cache[n];
+      } else {
+        const result = fn(n);
+        cache[n] = result;
+        return result;
+      }
+    };
+  };
+})();

package/dist/iife/index.js

@@ -0,0 +1,23 @@
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var utils_exports = {};
+  __reExport(utils_exports, require("./types.js"));
+  __reExport(utils_exports, require("./object.js"));
+  __reExport(utils_exports, require("./function.js"));
+  __reExport(utils_exports, require("./array.js"));
+  __reExport(utils_exports, require("./node.js"));
+  __reExport(utils_exports, require("./log.js"));
+})();

package/dist/iife/log.js

@@ -0,0 +1,14 @@
+"use strict";
+(() => {
+  const logIf = (bool, ...arg) => {
+    if (bool)
+      arg.map((v) => console.log(v));
+  };
+  const logGroupIf = (bool, key, ...arg) => {
+    if (bool) {
+      console.group(key);
+      arg.map((v) => console.log(v));
+      console.groupEnd(key);
+    }
+  };
+})();

package/dist/iife/node.js

@@ -0,0 +1,13 @@
+"use strict";
+(() => {
+  const cleanWithNode = (extend) => delete extend.node && extend;
+  const createID = function() {
+    let index = 0;
+    function newId() {
+      index++;
+      return index;
+    }
+    return newId;
+  }();
+  const createSnapshotId = createID;
+})();

package/dist/iife/object.js

@@ -0,0 +1,220 @@
+"use strict";
+(() => {
+  var import_types = require("./types.js");
+  const exec = (param, element, state) => {
+    if ((0, import_types.isFunction)(param))
+      return param(element, state || element.state);
+    return param;
+  };
+  const map = (obj2, extention, element) => {
+    for (const e in extention) {
+      obj2[e] = exec(extention[e], element);
+    }
+  };
+  const merge = (element, obj2) => {
+    for (const e in obj2) {
+      const elementProp = element[e];
+      const objProp2 = obj2[e];
+      if (elementProp === void 0) {
+        element[e] = objProp2;
+      }
+    }
+    return element;
+  };
+  const deepMerge = (element, extend) => {
+    for (const e in extend) {
+      const elementProp = element[e];
+      const extendProp = extend[e];
+      if (e === "parent" || e === "props")
+        continue;
+      if (elementProp === void 0) {
+        element[e] = extendProp;
+      } else if ((0, import_types.isObjectLike)(elementProp) && (0, import_types.isObject)(extendProp)) {
+        deepMerge(elementProp, extendProp);
+      }
+    }
+    return element;
+  };
+  const clone = (obj2) => {
+    const o = {};
+    for (const prop2 in obj2) {
+      if (prop2 === "node")
+        continue;
+      o[prop2] = obj2[prop2];
+    }
+    return o;
+  };
+  const deepCloneExclude = (obj2, exclude = []) => {
+    if ((0, import_types.isArray)(obj2)) {
+      return obj2.map((x) => deepCloneExclude(x, exclude));
+    }
+    const o = {};
+    for (const k in obj2) {
+      if (exclude.indexOf(k) > -1)
+        continue;
+      let v = obj2[k];
+      if (k === "extend" && (0, import_types.isArray)(v)) {
+        v = mergeArrayExclude(v, exclude);
+      }
+      if ((0, import_types.isArray)(v)) {
+        o[k] = v.map((x) => deepCloneExclude(x, exclude));
+      } else if ((0, import_types.isObject)(v)) {
+        o[k] = deepCloneExclude(v, exclude);
+      } else
+        o[k] = v;
+    }
+    return o;
+  };
+  const mergeArrayExclude = (arr, excl = []) => {
+    return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {});
+  };
+  const deepClone = (obj2) => {
+    if ((0, import_types.isArray)(obj2)) {
+      return obj2.map(deepClone);
+    }
+    const o = {};
+    for (const prop2 in obj2) {
+      let objProp2 = obj2[prop2];
+      if (prop2 === "extend" && (0, import_types.isArray)(objProp2)) {
+        objProp2 = mergeArray(objProp2);
+      }
+      if ((0, import_types.isArray)(objProp2)) {
+        o[prop2] = objProp2.map((v) => (0, import_types.isObject)(v) ? deepClone(v) : v);
+      } else if ((0, import_types.isObject)(objProp2)) {
+        o[prop2] = deepClone(objProp2);
+      } else
+        o[prop2] = objProp2;
+    }
+    return o;
+  };
+  const deepStringify = (obj2, stringified2 = {}) => {
+    for (const prop2 in obj2) {
+      const objProp2 = obj2[prop2];
+      if ((0, import_types.isFunction)(objProp2)) {
+        stringified2[prop2] = objProp2.toString();
+      } else if ((0, import_types.isObject)(objProp2)) {
+        stringified2[prop2] = {};
+        deepStringify(objProp2[prop2], stringified2[prop2]);
+      } else if ((0, import_types.isArray)(objProp2)) {
+        stringified2[prop2] = [];
+        objProp2.map((v, i) => deepStringify(v, stringified2[prop2][i]));
+      } else
+        stringified2[prop2] = objProp2;
+    }
+    return stringified2;
+  };
+  const deepDestringify = (obj, stringified = {}) => {
+    for (const prop in obj) {
+      const objProp = obj[prop];
+      if ((0, import_types.isString)(objProp)) {
+        if (objProp.includes("=>") || objProp.includes("function") || objProp[0] === "(") {
+          try {
+            const evalProp = eval(objProp);
+            stringified[prop] = evalProp;
+          } catch (e) {
+            if (e)
+              stringified[prop] = objProp;
+          }
+        }
+      } else
+        stringified[prop] = objProp;
+      if ((0, import_types.isObject)(objProp))
+        deepDestringify(stringified[prop], stringified[prop]);
+    }
+    return stringified;
+  };
+  const overwrite = (element, params, options) => {
+    const { ref } = element;
+    const changes = {};
+    for (const e in params) {
+      if (e === "props")
+        continue;
+      const elementProp = element[e];
+      const paramsProp = params[e];
+      if (paramsProp) {
+        ref.__cache[e] = changes[e] = elementProp;
+        ref[e] = paramsProp;
+      }
+    }
+    return changes;
+  };
+  const diff = (obj2, original, cache) => {
+    const changes = cache || {};
+    for (const e in obj2) {
+      if (e === "ref")
+        continue;
+      const originalProp = original[e];
+      const objProp2 = obj2[e];
+      if ((0, import_types.isObjectLike)(originalProp) && (0, import_types.isObjectLike)(objProp2)) {
+        changes[e] = {};
+        diff(originalProp, objProp2, changes[e]);
+      } else if (objProp2 !== void 0) {
+        changes[e] = objProp2;
+      }
+    }
+    return changes;
+  };
+  const overwriteObj = (params, obj2) => {
+    const changes = {};
+    for (const e in params) {
+      const objProp2 = obj2[e];
+      const paramsProp = params[e];
+      if (paramsProp) {
+        obj2[e] = changes[e] = objProp2;
+      }
+    }
+    return changes;
+  };
+  const overwriteDeep = (params, obj2) => {
+    for (const e in params) {
+      const objProp2 = obj2[e];
+      const paramsProp = params[e];
+      if ((0, import_types.isObjectLike)(objProp2) && (0, import_types.isObjectLike)(paramsProp)) {
+        overwriteDeep(objProp2, paramsProp);
+      } else if (paramsProp !== void 0) {
+        obj2[e] = paramsProp;
+      }
+    }
+    return obj2;
+  };
+  const mergeIfExisted = (a, b) => {
+    if ((0, import_types.isObjectLike)(a) && (0, import_types.isObjectLike)(b))
+      return deepMerge(a, b);
+    return a || b;
+  };
+  const mergeArray = (arr) => {
+    return arr.reduce((a, c) => deepMerge(a, deepClone(c)), {});
+  };
+  const mergeAndCloneIfArray = (obj2) => {
+    return (0, import_types.isArray)(obj2) ? mergeArray(obj2) : deepClone(obj2);
+  };
+  const flattenRecursive = (param, prop2, stack = []) => {
+    const objectized = mergeAndCloneIfArray(param);
+    stack.push(objectized);
+    const extendOfExtend = objectized[prop2];
+    if (extendOfExtend)
+      flattenRecursive(extendOfExtend, prop2, stack);
+    delete objectized[prop2];
+    return stack;
+  };
+  const isEqualDeep = (param, element) => {
+    if (param === element)
+      return true;
+    if (!param || !element)
+      return false;
+    for (const prop2 in param) {
+      const paramProp = param[prop2];
+      const elementProp = element[prop2];
+      if ((0, import_types.isObjectLike)(paramProp)) {
+        const isEqual = isEqualDeep(paramProp, elementProp);
+        if (!isEqual)
+          return false;
+      } else {
+        const isEqual = paramProp === elementProp;
+        if (!isEqual)
+          return false;
+      }
+    }
+    return true;
+  };
+})();

package/dist/iife/types.js

@@ -0,0 +1,57 @@
+"use strict";
+(() => {
+  var import_globals = require("@domql/globals");
+  var import_tags = require("@domql/tags");
+  const isValidHtmlTag = (arg) => import_tags.HTML_TAGS.body.indexOf(arg);
+  const isObject = (arg) => {
+    if (arg === null)
+      return false;
+    return typeof arg === "object" && arg.constructor === Object;
+  };
+  const isString = (arg) => typeof arg === "string";
+  const isNumber = (arg) => typeof arg === "number";
+  const isFunction = (arg) => typeof arg === "function";
+  const isBoolean = (arg) => arg === true || arg === false;
+  const isNull = (arg) => arg === null;
+  const isArray = (arg) => Array.isArray(arg);
+  const isObjectLike = (arg) => {
+    if (arg === null)
+      return false;
+    return typeof arg === "object";
+  };
+  const isNode = (obj) => {
+    return typeof import_globals.window.Node === "object" ? obj instanceof import_globals.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+  };
+  const isHtmlElement = (obj) => {
+    return typeof import_globals.window.HTMLElement === "object" ? obj instanceof import_globals.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
+  };
+  const isDefined = (arg) => {
+    return isObject(arg) || isObjectLike(arg) || isString(arg) || isNumber(arg) || isFunction(arg) || isArray(arg) || isObjectLike(arg) || isBoolean(arg) || isNull(arg);
+  };
+  const isUndefined = (arg) => {
+    return arg === void 0;
+  };
+  const TYPES = {
+    boolean: isBoolean,
+    array: isArray,
+    object: isObject,
+    string: isString,
+    number: isNumber,
+    null: isNull,
+    function: isFunction,
+    objectLike: isObjectLike,
+    node: isNode,
+    htmlElement: isHtmlElement,
+    defined: isDefined
+  };
+  const is = (arg) => {
+    return (...args) => {
+      return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+    };
+  };
+  const isNot = (arg) => {
+    return (...args) => {
+      return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+    };
+  };
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domql/utils",
-  "version": "2.3.53",
+  "version": "2.3.57",
   "license": "MIT",
   "type": "module",
   "module": "dist/esm/index.js",
@@ -11,17 +11,18 @@
   "source": "index.js",
   "files": [
     "*.js",
-    "dist/*.js"
+    "dist"
   ],
   "scripts": {
+    "copy:package:cjs": "cp ../../package-cjs.json dist/cjs",
     "build:esm": "npx esbuild *.js --target=es2020 --format=esm --outdir=dist/esm",
-    "build:cjs": "npx esbuild *.js --target=node16 --format=cjs --outdir=dist/cjs",
+    "build:cjs": "npx esbuild *.js --target=node16 --format=cjs --outdir=dist/cjs && yarn copy:package:cjs",
     "build:iife": "npx esbuild *.js --target=node16 --format=iife --outdir=dist/iife",
-    "prepublish": "rm -rf dist && yarn build:esm && yarn build:cjs && yarn build:iife"
+    "prepublish": "rimraf -I dist && yarn build:esm && yarn build:cjs && yarn build:iife"
   },
   "dependencies": {
     "@domql/globals": "latest",
     "@domql/tags": "latest"
   },
-  "gitHead": "07a6de35403188c15c3824fae6fbc80a2ac44d79"
+  "gitHead": "d557c80ac22bfe7a747badf29553c297e2b05cda"
 }