@domql/utils 2.5.200 → 3.0.0

package/dist/cjs/object.js

@@ -24,18 +24,12 @@ __export(object_exports, {
   deepClone: () => deepClone,
   deepContains: () => deepContains,
   deepDestringify: () => deepDestringify,
-  deepDiff: () => deepDiff,
   deepMerge: () => deepMerge,
   deepStringify: () => deepStringify,
-  deepStringifyWithMaxDepth: () => deepStringifyWithMaxDepth,
-  detachFunctionsFromObject: () => detachFunctionsFromObject,
   detectInfiniteLoop: () => detectInfiniteLoop,
-  diff: () => diff,
-  diffArrays: () => diffArrays,
-  diffObjects: () => diffObjects,
   excludeKeysFromObject: () => excludeKeysFromObject,
   exec: () => exec,
-  flattenRecursive: () => flattenRecursive,
+  execPromise: () => execPromise,
   getInObjectByPath: () => getInObjectByPath,
   hasFunction: () => hasFunction,
   hasOwnProperty: () => hasOwnProperty,
@@ -46,8 +40,6 @@ __export(object_exports, {
   makeObjectWithoutPrototype: () => makeObjectWithoutPrototype,
   map: () => map,
   merge: () => merge,
-  mergeArrayExclude: () => mergeArrayExclude,
-  mergeIfExisted: () => mergeIfExisted,
   objectToString: () => objectToString,
   overwrite: () => overwrite,
   overwriteDeep: () => overwriteDeep,
@@ -63,6 +55,7 @@ var import_types = require("./types.js");
 var import_array = require("./array.js");
 var import_string = require("./string.js");
 var import_node = require("./node.js");
+var import_keys = require("./keys.js");
 const ENV = "development";
 const exec = (param, element, state, context) => {
   if ((0, import_types.isFunction)(param)) {
@@ -75,6 +68,17 @@ const exec = (param, element, state, context) => {
   }
   return param;
 };
+const execPromise = async (param, element, state, context) => {
+  if ((0, import_types.isFunction)(param)) {
+    return await param.call(
+      element,
+      element,
+      state || element.state,
+      context || element.context
+    );
+  }
+  return param;
+};
 const map = (obj, extention, element) => {
   for (const e in extention) {
     obj[e] = exec(extention[e], element);
@@ -83,7 +87,9 @@ const map = (obj, extention, element) => {
 const merge = (element, obj, excludeFrom = []) => {
   for (const e in obj) {
     const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, e);
-    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__")) continue;
+    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__")) {
+      continue;
+    }
     const elementProp = element[e];
     const objProp = obj[e];
     if (elementProp === void 0) {
@@ -92,10 +98,12 @@ const merge = (element, obj, excludeFrom = []) => {
   }
   return element;
 };
-const deepMerge = (element, extend, excludeFrom = []) => {
+const deepMerge = (element, extend, excludeFrom = import_keys.METHODS_EXL) => {
   for (const e in extend) {
     const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(extend, e);
-    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__")) continue;
+    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__")) {
+      continue;
+    }
     const elementProp = element[e];
     const extendProp = extend[e];
     if ((0, import_types.isObjectLike)(elementProp) && (0, import_types.isObjectLike)(extendProp)) {
@@ -110,14 +118,13 @@ const clone = (obj, excludeFrom = []) => {
   const o = {};
   for (const prop in obj) {
     const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
-    if (!hasOwnProperty2 || excludeFrom.includes(prop) || prop.startsWith("__")) continue;
+    if (!hasOwnProperty2 || excludeFrom.includes(prop) || prop.startsWith("__")) {
+      continue;
+    }
     o[prop] = obj[prop];
   }
   return o;
 };
-const mergeArrayExclude = (arr, exclude = []) => {
-  return arr.reduce((acc, curr) => deepMerge(acc, deepClone(curr, { exclude })), {});
-};
 const deepClone = (obj, options = {}) => {
   const {
     exclude = [],
@@ -125,7 +132,7 @@ const deepClone = (obj, options = {}) => {
     cleanNull = false,
     window: targetWindow,
     visited = /* @__PURE__ */ new WeakMap(),
-    handleExtend = false
+    handleExtends = false
   } = options;
   if (!(0, import_types.isObjectLike)(obj) || (0, import_node.isDOMNode)(obj)) {
     return obj;
@@ -137,15 +144,19 @@ const deepClone = (obj, options = {}) => {
   visited.set(obj, clone2);
   for (const key in obj) {
     if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__") continue;
+    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__") {
+      continue;
+    }
     const value = obj[key];
-    if (cleanUndefined && (0, import_types.isUndefined)(value) || cleanNull && (0, import_types.isNull)(value)) continue;
+    if (cleanUndefined && (0, import_types.isUndefined)(value) || cleanNull && (0, import_types.isNull)(value)) {
+      continue;
+    }
     if ((0, import_node.isDOMNode)(value)) {
       clone2[key] = value;
       continue;
     }
-    if (handleExtend && key === "extend" && (0, import_types.isArray)(value)) {
-      clone2[key] = (0, import_array.mergeArray)(value, exclude);
+    if (handleExtends && key === "extends" && (0, import_types.isArray)(value)) {
+      clone2[key] = (0, import_array.unstackArrayOfObjects)(value, exclude);
       continue;
     }
     if ((0, import_types.isFunction)(value) && targetWindow) {
@@ -166,7 +177,11 @@ const deepClone = (obj, options = {}) => {
 const deepStringify = (obj, stringified = {}) => {
   var _a, _b;
   if (obj.node || obj.__ref || obj.parent || obj.__element || obj.parse) {
-    (obj.__element || ((_a = obj.parent) == null ? void 0 : _a.__element)).warn("Trying to clone element or state at", obj);
+    ;
+    (obj.__element || ((_a = obj.parent) == null ? void 0 : _a.__element)).warn(
+      "Trying to clone element or state at",
+      obj
+    );
     obj = (_b = obj.parse) == null ? void 0 : _b.call(obj);
   }
   for (const prop in obj) {
@@ -194,39 +209,6 @@ const deepStringify = (obj, stringified = {}) => {
   }
   return stringified;
 };
-const MAX_DEPTH = 100;
-const deepStringifyWithMaxDepth = (obj, stringified = {}, depth = 0, path = "") => {
-  if (depth > MAX_DEPTH) {
-    console.warn(`Maximum depth exceeded at path: ${path}. Possible circular reference.`);
-    return "[MAX_DEPTH_EXCEEDED]";
-  }
-  for (const prop in obj) {
-    const currentPath = path ? `${path}.${prop}` : prop;
-    const objProp = obj[prop];
-    if ((0, import_types.isFunction)(objProp)) {
-      stringified[prop] = objProp.toString();
-    } else if ((0, import_types.isObject)(objProp)) {
-      stringified[prop] = {};
-      deepStringifyWithMaxDepth(objProp, stringified[prop], depth + 1, currentPath);
-    } else if ((0, import_types.isArray)(objProp)) {
-      stringified[prop] = [];
-      objProp.forEach((v, i) => {
-        const itemPath = `${currentPath}[${i}]`;
-        if ((0, import_types.isObject)(v)) {
-          stringified[prop][i] = {};
-          deepStringifyWithMaxDepth(v, stringified[prop][i], depth + 1, itemPath);
-        } else if ((0, import_types.isFunction)(v)) {
-          stringified[prop][i] = v.toString();
-        } else {
-          stringified[prop][i] = v;
-        }
-      });
-    } else {
-      stringified[prop] = objProp;
-    }
-  }
-  return stringified;
-};
 const objectToString = (obj = {}, indent = 0) => {
   if (obj === null || typeof obj !== "object") {
     return String(obj);
@@ -237,7 +219,22 @@ const objectToString = (obj = {}, indent = 0) => {
   const spaces = "  ".repeat(indent);
   let str = "{\n";
   for (const [key, value] of Object.entries(obj)) {
-    const keyNotAllowdChars = (0, import_string.stringIncludesAny)(key, ["&", "*", "-", ":", "%", "{", "}", ">", "<", "@", ".", "/", "!", " "]);
+    const keyNotAllowdChars = (0, import_string.stringIncludesAny)(key, [
+      "&",
+      "*",
+      "-",
+      ":",
+      "%",
+      "{",
+      "}",
+      ">",
+      "<",
+      "@",
+      ".",
+      "/",
+      "!",
+      " "
+    ]);
     const stringedKey = keyNotAllowdChars ? `'${key}'` : key;
     str += `${spaces}  ${stringedKey}: `;
     if ((0, import_types.isArray)(value)) {
@@ -267,30 +264,6 @@ const objectToString = (obj = {}, indent = 0) => {
   str += `${spaces}}`;
   return str;
 };
-const detachFunctionsFromObject = (obj, detached = {}) => {
-  for (const prop in obj) {
-    const objProp = obj[prop];
-    if ((0, import_types.isFunction)(objProp)) continue;
-    else if ((0, import_types.isObject)(objProp)) {
-      detached[prop] = {};
-      deepStringify(objProp, detached[prop]);
-    } else if ((0, import_types.isArray)(objProp)) {
-      detached[prop] = [];
-      objProp.forEach((v, i) => {
-        if ((0, import_types.isFunction)(v)) return;
-        if ((0, import_types.isObject)(v)) {
-          detached[prop][i] = {};
-          detachFunctionsFromObject(v, detached[prop][i]);
-        } else {
-          detached[prop][i] = v;
-        }
-      });
-    } else {
-      detached[prop] = objProp;
-    }
-  }
-  return detached;
-};
 const hasFunction = (str) => {
   if (!str) return false;
   const trimmed = str.trim().replace(/\n\s*/g, " ").trim();
@@ -362,93 +335,18 @@ const stringToObject = (str, opts = { verbose: true }) => {
     if (opts.verbose) console.warn(e);
   }
 };
-const diffObjects = (original, objToDiff, cache) => {
-  for (const e in objToDiff) {
-    if (e === "ref") continue;
-    const originalProp = original[e];
-    const objToDiffProp = objToDiff[e];
-    if ((0, import_types.isObject)(originalProp) && (0, import_types.isObject)(objToDiffProp)) {
-      cache[e] = {};
-      diff(originalProp, objToDiffProp, cache[e]);
-    } else if (objToDiffProp !== void 0) {
-      cache[e] = objToDiffProp;
-    }
-  }
-  return cache;
-};
-const diffArrays = (original, objToDiff, cache) => {
-  if (original.length !== objToDiff.length) {
-    cache = objToDiff;
-  } else {
-    const diffArr = [];
-    for (let i = 0; i < original.length; i++) {
-      const diffObj = diff(original[i], objToDiff[i]);
-      if (Object.keys(diffObj).length > 0) {
-        diffArr.push(diffObj);
-      }
-    }
-    if (diffArr.length > 0) {
-      cache = diffArr;
-    }
-  }
-  return cache;
-};
-const diff = (original, objToDiff, cache = {}) => {
-  if ((0, import_types.isArray)(original) && (0, import_types.isArray)(objToDiff)) {
-    cache = [];
-    diffArrays(original, objToDiff, cache);
-  } else {
-    diffObjects(original, objToDiff, cache);
-  }
-  return cache;
-};
 const hasOwnProperty = (o, ...args) => Object.prototype.hasOwnProperty.call(o, ...args);
 const isEmpty = (o) => Object.keys(o).length === 0;
 const isEmptyObject = (o) => (0, import_types.isObject)(o) && isEmpty(o);
 const makeObjectWithoutPrototype = () => /* @__PURE__ */ Object.create(null);
-const deepDiff = (lhs, rhs) => {
-  if (lhs === rhs) return {};
-  if (!(0, import_types.isObjectLike)(lhs) || !(0, import_types.isObjectLike)(rhs)) return rhs;
-  const deletedValues = Object.keys(lhs).reduce((acc, key) => {
-    if (!hasOwnProperty(rhs, key)) {
-      acc[key] = void 0;
-    }
-    return acc;
-  }, makeObjectWithoutPrototype());
-  if ((0, import_types.isDate)(lhs) || (0, import_types.isDate)(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;
-    }
-    const difference = diff(lhs[key], rhs[key]);
-    if (isEmptyObject(difference) && !(0, import_types.isDate)(difference) && (isEmptyObject(lhs[key]) || !isEmptyObject(rhs[key]))) {
-      return acc;
-    }
-    acc[key] = difference;
-    return acc;
-  }, deletedValues);
-};
 const overwrite = (element, params, opts = {}) => {
-  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;
-    const elementProp = element[e];
     const paramsProp = params[e];
     if (paramsProp !== void 0) {
       element[e] = paramsProp;
-      if (ref && !preventCaching) {
-        ref.__cache[e] = elementProp;
-      }
-      if ((0, import_types.isObject)(opts.diff)) {
-        diff[e] = elementProp;
-      }
     }
   }
   return element;
@@ -483,18 +381,6 @@ const overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new Wea
   }
   return obj;
 };
-const mergeIfExisted = (a, b) => {
-  if ((0, import_types.isObjectLike)(a) && (0, import_types.isObjectLike)(b)) return deepMerge(a, b);
-  return a || b;
-};
-const flattenRecursive = (param, prop, stack = []) => {
-  const objectized = (0, import_array.mergeAndCloneIfArray)(param);
-  stack.push(objectized);
-  const extendOfExtend = objectized[prop];
-  if (extendOfExtend) flattenRecursive(extendOfExtend, prop, stack);
-  delete objectized[prop];
-  return stack;
-};
 const isEqualDeep = (param, element, visited = /* @__PURE__ */ new Set()) => {
   if (typeof param !== "object" || typeof element !== "object" || param === null || element === null) {
     return param === element;
@@ -523,33 +409,29 @@ const isEqualDeep = (param, element, visited = /* @__PURE__ */ new Set()) => {
 };
 const deepContains = (obj1, obj2, ignoredKeys = ["node", "__ref"]) => {
   if (obj1 === obj2) return true;
-  if (!(0, import_types.isObjectLike)(obj1) || !(0, import_types.isObjectLike)(obj2)) return false;
+  if (!(0, import_types.isObjectLike)(obj1) || !(0, import_types.isObjectLike)(obj2)) return obj1 === obj2;
   if ((0, import_node.isDOMNode)(obj1) || (0, import_node.isDOMNode)(obj2)) return obj1 === obj2;
-  const stack = [[obj1, obj2]];
   const visited = /* @__PURE__ */ new WeakSet();
-  while (stack.length > 0) {
-    const [current1, current2] = stack.pop();
-    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;
-    for (const key of keys1) {
-      if (!Object.prototype.hasOwnProperty.call(current2, key)) return false;
-      const value1 = current1[key];
-      const value2 = current2[key];
-      if ((0, import_node.isDOMNode)(value1) || (0, import_node.isDOMNode)(value2)) {
-        if (value1 !== value2) return false;
-      } else if ((0, import_types.isObjectLike)(value1) && (0, import_types.isObjectLike)(value2)) {
-        if (value1 !== value2) {
-          stack.push([value1, value2]);
-        }
-      } else if (value1 !== value2) {
+  function checkContains(target, source) {
+    if (visited.has(source)) return true;
+    visited.add(source);
+    for (const key in source) {
+      if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+      if (ignoredKeys.includes(key)) continue;
+      if (!Object.prototype.hasOwnProperty.call(target, key)) return false;
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if ((0, import_node.isDOMNode)(sourceValue) || (0, import_node.isDOMNode)(targetValue)) {
+        if (sourceValue !== targetValue) return false;
+      } else if ((0, import_types.isObjectLike)(sourceValue) && (0, import_types.isObjectLike)(targetValue)) {
+        if (!checkContains(targetValue, sourceValue)) return false;
+      } else if (sourceValue !== targetValue) {
         return false;
       }
     }
+    return true;
   }
-  return true;
+  return checkContains(obj1, obj2);
 };
 const removeFromObject = (obj, props) => {
   if (props === void 0 || props === null) return obj;
@@ -558,7 +440,9 @@ const removeFromObject = (obj, props) => {
   } else if ((0, import_types.isArray)(props)) {
     props.forEach((prop) => delete obj[prop]);
   } else {
-    throw new Error("Invalid input: props must be a string or an array of strings");
+    throw new Error(
+      "Invalid input: props must be a string or an array of strings"
+    );
   }
   return obj;
 };
@@ -583,7 +467,7 @@ const createNestedObject = (arr, lastValue) => {
     if (!obj[value]) {
       obj[value] = {};
     }
-    if (index === arr.length - 1 && lastValue !== void 0) {
+    if (index === arr.length - 1 && lastValue) {
       obj[value] = lastValue;
     }
     return obj[value];
@@ -650,7 +534,10 @@ const detectInfiniteLoop = (arr) => {
       }
       if (repeatCount >= maxRepeats * 2) {
         if (ENV === "test" || ENV === "development") {
-          console.warn("Warning: Potential infinite loop detected due to repeated sequence:", pattern);
+          console.warn(
+            "Warning: Potential infinite loop detected due to repeated sequence:",
+            pattern
+          );
         }
         return true;
       }

package/dist/cjs/props.js

@@ -0,0 +1,220 @@
+"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 props_exports = {};
+__export(props_exports, {
+  applyProps: () => applyProps,
+  createProps: () => createProps,
+  createPropsStack: () => createPropsStack,
+  inheritParentProps: () => inheritParentProps,
+  initProps: () => initProps,
+  objectizeStringProperty: () => objectizeStringProperty,
+  pickupElementFromProps: () => pickupElementFromProps,
+  pickupPropsFromElement: () => pickupPropsFromElement,
+  propExists: () => propExists,
+  propertizeElement: () => propertizeElement,
+  removeDuplicateProps: () => removeDuplicateProps,
+  setPropsPrototype: () => setPropsPrototype,
+  syncProps: () => syncProps,
+  update: () => update,
+  updateProps: () => updateProps
+});
+module.exports = __toCommonJS(props_exports);
+var import_keys = require("./keys.js");
+var import_events = require("./events.js");
+var import_object = require("./object.js");
+var import_types = require("./types.js");
+const createProps = (element, parent, key) => {
+  const { props, __ref: ref } = element;
+  ref.__propsStack = [];
+  if (props) ref.__initialProps = props;
+  else return {};
+  if (!(0, import_types.isObjectLike)(props)) {
+    ref.__propsStack.push(props);
+    return {};
+  }
+  return { ...props };
+};
+function pickupPropsFromElement(element, opts = {}) {
+  var _a, _b, _c;
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in element) {
+    const value = element[key];
+    const hasDefine = (0, import_types.isObject)((_a = element.define) == null ? void 0 : _a[key]);
+    const hasGlobalDefine = (0, import_types.isObject)((_c = (_b = element.context) == null ? void 0 : _b.define) == null ? void 0 : _c[key]);
+    const isElement = /^[A-Z]/.test(key) || /^\d+$/.test(key);
+    const isBuiltin = import_keys.DOMQ_PROPERTIES.includes(key);
+    if (!isElement && !isBuiltin && !hasDefine && !hasGlobalDefine) {
+      element.props[key] = value;
+      delete element[key];
+      cachedKeys.push(key);
+    }
+  }
+  return element;
+}
+function pickupElementFromProps(element, opts) {
+  var _a, _b, _c;
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in element.props) {
+    const value = element.props[key];
+    const isEvent = key.startsWith("on") && key.length > 2;
+    const isFn = (0, import_types.isFunction)(value);
+    if (isEvent && isFn) {
+      (0, import_events.addEventFromProps)(key, element);
+      delete element.props[key];
+      continue;
+    }
+    if (cachedKeys.includes(key)) continue;
+    const hasDefine = (0, import_types.isObject)((_a = element.define) == null ? void 0 : _a[key]);
+    const hasGlobalDefine = (0, import_types.isObject)((_c = (_b = element.context) == null ? void 0 : _b.define) == null ? void 0 : _c[key]);
+    const isElement = /^[A-Z]/.test(key) || /^\d+$/.test(key);
+    const isBuiltin = import_keys.DOMQ_PROPERTIES.includes(key);
+    if (isElement || isBuiltin || hasDefine || hasGlobalDefine) {
+      element[key] = value;
+      delete element.props[key];
+    }
+  }
+  return element;
+}
+function propertizeElement(element, opts = {}) {
+  const cachedKeys = [];
+  pickupPropsFromElement(element, { cachedKeys });
+  pickupElementFromProps(element, { cachedKeys });
+  return element;
+}
+const objectizeStringProperty = (propValue) => {
+  if ((0, import_types.is)(propValue)("string", "number")) {
+    return { inheritedString: propValue };
+  }
+  return propValue;
+};
+const propExists = (prop, stack) => {
+  if (!prop || !stack.length) return false;
+  const key = (0, import_types.isObject)(prop) ? JSON.stringify(prop) : prop;
+  return stack.some((existing) => {
+    const existingKey = (0, import_types.isObject)(existing) ? JSON.stringify(existing) : existing;
+    return existingKey === key;
+  });
+};
+const inheritParentProps = (element, parent) => {
+  var _a;
+  const { __ref: ref } = element;
+  const propsStack = ref.__propsStack || [];
+  const parentProps = parent.props;
+  if (!parentProps) return propsStack;
+  const matchParentKeyProps = parentProps[element.key];
+  const matchParentChildProps = parentProps.childProps;
+  const ignoreChildProps = (_a = element.props) == null ? void 0 : _a.ignoreChildProps;
+  if (matchParentChildProps && !ignoreChildProps) {
+    const childProps = objectizeStringProperty(matchParentChildProps);
+    propsStack.unshift(childProps);
+  }
+  if (matchParentKeyProps) {
+    const keyProps = objectizeStringProperty(matchParentKeyProps);
+    propsStack.unshift(keyProps);
+  }
+  return propsStack;
+};
+async function update(props, options) {
+  const element = this.__element;
+  await element.update({ props }, options);
+}
+function setPropsPrototype(element) {
+  const methods = { update: update.bind(element.props), __element: element };
+  Object.setPrototypeOf(element.props, methods);
+}
+const removeDuplicateProps = (propsStack) => {
+  const seen = /* @__PURE__ */ new Set();
+  return propsStack.filter((prop) => {
+    if (!prop || import_keys.PROPS_METHODS.includes(prop)) return false;
+    const key = (0, import_types.isObject)(prop) ? JSON.stringify(prop) : prop;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+const syncProps = (propsStack, element, opts) => {
+  element.props = propsStack.reduce((mergedProps, v) => {
+    if (import_keys.PROPS_METHODS.includes(v)) return mergedProps;
+    while ((0, import_types.isFunction)(v)) v = (0, import_object.exec)(v, element);
+    return (0, import_object.deepMerge)(mergedProps, (0, import_object.deepClone)(v, { exclude: import_keys.PROPS_METHODS }));
+  }, {});
+  setPropsPrototype(element);
+  return element.props;
+};
+const createPropsStack = (element, parent) => {
+  const { props, __ref: ref } = element;
+  let propsStack = ref.__propsStack || [];
+  if (parent && parent.props) {
+    const parentStack = inheritParentProps(element, parent);
+    propsStack = [...parentStack];
+  }
+  if ((0, import_types.isObject)(props)) propsStack.push(props);
+  else if (props === "inherit" && (parent == null ? void 0 : parent.props)) propsStack.push(parent.props);
+  else if (props) propsStack.push(props);
+  if ((0, import_types.isArray)(ref.__extendsStack)) {
+    ref.__extendsStack.forEach((_extends) => {
+      if (_extends.props && _extends.props !== props) {
+        propsStack.push(_extends.props);
+      }
+    });
+  }
+  ref.__propsStack = removeDuplicateProps(propsStack);
+  return ref.__propsStack;
+};
+const applyProps = (element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = createPropsStack(element, parent);
+  if (propsStack.length) {
+    syncProps(propsStack, element);
+  } else {
+    ref.__propsStack = [];
+    element.props = {};
+  }
+};
+const initProps = function(element, parent, options) {
+  const { __ref: ref } = element;
+  if (ref.__if) applyProps(element, parent);
+  else {
+    try {
+      applyProps(element, parent);
+    } catch {
+      element.props = {};
+      ref.__propsStack = [];
+    }
+  }
+  setPropsPrototype(element);
+  return element;
+};
+const updateProps = (newProps, element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = ref.__propsStack || [];
+  let newStack = [...propsStack];
+  const parentProps = inheritParentProps(element, parent);
+  if (parentProps.length) {
+    newStack = [...parentProps, ...newStack];
+  }
+  if (newProps) {
+    newStack = [newProps, ...newStack];
+  }
+  ref.__propsStack = removeDuplicateProps(newStack);
+  if (ref.__propsStack.length) {
+    syncProps(ref.__propsStack, element);
+  }
+  return element;
+};

package/dist/cjs/scope.js

@@ -0,0 +1,28 @@
+"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 scope_exports = {};
+__export(scope_exports, {
+  createScope: () => createScope
+});
+module.exports = __toCommonJS(scope_exports);
+const createScope = (element, parent) => {
+  var _a;
+  const { __ref: ref } = element;
+  if (!element.scope) element.scope = parent.scope || ((_a = ref.root) == null ? void 0 : _a.scope) || {};
+};