@domql/utils 2.5.200 → 3.0.1

package/dist/esm/object.js

@@ -26,12 +26,12 @@ import {
   isString,
   is,
   isUndefined,
-  isDate,
   isNull
 } from "./types.js";
-import { mergeAndCloneIfArray, mergeArray } from "./array.js";
+import { unstackArrayOfObjects } from "./array.js";
 import { stringIncludesAny } from "./string.js";
 import { isDOMNode } from "./node.js";
+import { METHODS_EXL } from "./keys.js";
 const ENV = "development";
 const exec = (param, element, state, context) => {
   if (isFunction(param)) {
@@ -44,6 +44,17 @@ const exec = (param, element, state, context) => {
   }
   return param;
 };
+const execPromise = async (param, element, state, context) => {
+  if (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);
@@ -52,7 +63,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) {
@@ -61,10 +74,12 @@ const merge = (element, obj, excludeFrom = []) => {
   }
   return element;
 };
-const deepMerge = (element, extend, excludeFrom = []) => {
+const deepMerge = (element, extend, excludeFrom = 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 (isObjectLike(elementProp) && isObjectLike(extendProp)) {
@@ -79,14 +94,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 = [],
@@ -94,7 +108,7 @@ const deepClone = (obj, options = {}) => {
     cleanNull = false,
     window: targetWindow,
     visited = /* @__PURE__ */ new WeakMap(),
-    handleExtend = false
+    handleExtends = false
   } = options;
   if (!isObjectLike(obj) || isDOMNode(obj)) {
     return obj;
@@ -106,15 +120,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 && isUndefined(value) || cleanNull && isNull(value)) continue;
+    if (cleanUndefined && isUndefined(value) || cleanNull && isNull(value)) {
+      continue;
+    }
     if (isDOMNode(value)) {
       clone2[key] = value;
       continue;
     }
-    if (handleExtend && key === "extend" && isArray(value)) {
-      clone2[key] = mergeArray(value, exclude);
+    if (handleExtends && key === "extends" && isArray(value)) {
+      clone2[key] = unstackArrayOfObjects(value, exclude);
       continue;
     }
     if (isFunction(value) && targetWindow) {
@@ -134,7 +152,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) {
@@ -162,39 +184,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 (isFunction(objProp)) {
-      stringified[prop] = objProp.toString();
-    } else if (isObject(objProp)) {
-      stringified[prop] = {};
-      deepStringifyWithMaxDepth(objProp, stringified[prop], depth + 1, currentPath);
-    } else if (isArray(objProp)) {
-      stringified[prop] = [];
-      objProp.forEach((v, i) => {
-        const itemPath = `${currentPath}[${i}]`;
-        if (isObject(v)) {
-          stringified[prop][i] = {};
-          deepStringifyWithMaxDepth(v, stringified[prop][i], depth + 1, itemPath);
-        } else if (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);
@@ -205,7 +194,22 @@ const objectToString = (obj = {}, indent = 0) => {
   const spaces = "  ".repeat(indent);
   let str = "{\n";
   for (const [key, value] of Object.entries(obj)) {
-    const keyNotAllowdChars = stringIncludesAny(key, ["&", "*", "-", ":", "%", "{", "}", ">", "<", "@", ".", "/", "!", " "]);
+    const keyNotAllowdChars = stringIncludesAny(key, [
+      "&",
+      "*",
+      "-",
+      ":",
+      "%",
+      "{",
+      "}",
+      ">",
+      "<",
+      "@",
+      ".",
+      "/",
+      "!",
+      " "
+    ]);
     const stringedKey = keyNotAllowdChars ? `'${key}'` : key;
     str += `${spaces}  ${stringedKey}: `;
     if (isArray(value)) {
@@ -235,30 +239,6 @@ const objectToString = (obj = {}, indent = 0) => {
   str += `${spaces}}`;
   return str;
 };
-const detachFunctionsFromObject = (obj, detached = {}) => {
-  for (const prop in obj) {
-    const objProp = obj[prop];
-    if (isFunction(objProp)) continue;
-    else if (isObject(objProp)) {
-      detached[prop] = {};
-      deepStringify(objProp, detached[prop]);
-    } else if (isArray(objProp)) {
-      detached[prop] = [];
-      objProp.forEach((v, i) => {
-        if (isFunction(v)) return;
-        if (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();
@@ -330,93 +310,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 (isObject(originalProp) && 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 (isArray(original) && 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) => isObject(o) && isEmpty(o);
 const makeObjectWithoutPrototype = () => /* @__PURE__ */ Object.create(null);
-const deepDiff = (lhs, rhs) => {
-  if (lhs === rhs) return {};
-  if (!isObjectLike(lhs) || !isObjectLike(rhs)) return rhs;
-  const deletedValues = Object.keys(lhs).reduce((acc, key) => {
-    if (!hasOwnProperty(rhs, key)) {
-      acc[key] = void 0;
-    }
-    return acc;
-  }, makeObjectWithoutPrototype());
-  if (isDate(lhs) || 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) && !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 (isObject(opts.diff)) {
-        diff[e] = elementProp;
-      }
     }
   }
   return element;
@@ -451,18 +356,6 @@ const overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new Wea
   }
   return obj;
 };
-const mergeIfExisted = (a, b) => {
-  if (isObjectLike(a) && isObjectLike(b)) return deepMerge(a, b);
-  return a || b;
-};
-const flattenRecursive = (param, prop, stack = []) => {
-  const objectized = 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;
@@ -491,33 +384,29 @@ const isEqualDeep = (param, element, visited = /* @__PURE__ */ new Set()) => {
 };
 const deepContains = (obj1, obj2, ignoredKeys = ["node", "__ref"]) => {
   if (obj1 === obj2) return true;
-  if (!isObjectLike(obj1) || !isObjectLike(obj2)) return false;
+  if (!isObjectLike(obj1) || !isObjectLike(obj2)) return obj1 === obj2;
   if (isDOMNode(obj1) || 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 (isDOMNode(value1) || isDOMNode(value2)) {
-        if (value1 !== value2) return false;
-      } else if (isObjectLike(value1) && 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 (isDOMNode(sourceValue) || isDOMNode(targetValue)) {
+        if (sourceValue !== targetValue) return false;
+      } else if (isObjectLike(sourceValue) && 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;
@@ -526,7 +415,9 @@ const removeFromObject = (obj, props) => {
   } else if (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;
 };
@@ -551,7 +442,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];
@@ -618,7 +509,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;
       }
@@ -656,18 +550,12 @@ export {
   deepClone,
   deepContains,
   deepDestringify,
-  deepDiff,
   deepMerge,
   deepStringify,
-  deepStringifyWithMaxDepth,
-  detachFunctionsFromObject,
   detectInfiniteLoop,
-  diff,
-  diffArrays,
-  diffObjects,
   excludeKeysFromObject,
   exec,
-  flattenRecursive,
+  execPromise,
   getInObjectByPath,
   hasFunction,
   hasOwnProperty,
@@ -678,8 +566,6 @@ export {
   makeObjectWithoutPrototype,
   map,
   merge,
-  mergeArrayExclude,
-  mergeIfExisted,
   objectToString,
   overwrite,
   overwriteDeep,

package/dist/esm/props.js

@@ -0,0 +1,216 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { DOMQ_PROPERTIES, PROPS_METHODS } from "./keys.js";
+import { addEventFromProps } from "./events.js";
+import { deepClone, deepMerge, exec } from "./object.js";
+import { is, isArray, isFunction, isObject, isObjectLike } from "./types.js";
+const createProps = (element, parent, key) => {
+  const { props, __ref: ref } = element;
+  ref.__propsStack = [];
+  if (props) ref.__initialProps = props;
+  else return {};
+  if (!isObjectLike(props)) {
+    ref.__propsStack.push(props);
+    return {};
+  }
+  return __spreadValues({}, props);
+};
+function pickupPropsFromElement(element, opts = {}) {
+  var _a, _b, _c;
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in element) {
+    const value = element[key];
+    const hasDefine = isObject((_a = element.define) == null ? void 0 : _a[key]);
+    const hasGlobalDefine = 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 = 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 = isFunction(value);
+    if (isEvent && isFn) {
+      addEventFromProps(key, element);
+      delete element.props[key];
+      continue;
+    }
+    if (cachedKeys.includes(key)) continue;
+    const hasDefine = isObject((_a = element.define) == null ? void 0 : _a[key]);
+    const hasGlobalDefine = 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 = 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 (is(propValue)("string", "number")) {
+    return { inheritedString: propValue };
+  }
+  return propValue;
+};
+const propExists = (prop, stack) => {
+  if (!prop || !stack.length) return false;
+  const key = isObject(prop) ? JSON.stringify(prop) : prop;
+  return stack.some((existing) => {
+    const existingKey = 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 || PROPS_METHODS.includes(prop)) return false;
+    const key = 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 (PROPS_METHODS.includes(v)) return mergedProps;
+    while (isFunction(v)) v = exec(v, element);
+    return deepMerge(mergedProps, deepClone(v, { exclude: 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 (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 (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 (e) {
+      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;
+};
+export {
+  applyProps,
+  createProps,
+  createPropsStack,
+  inheritParentProps,
+  initProps,
+  objectizeStringProperty,
+  pickupElementFromProps,
+  pickupPropsFromElement,
+  propExists,
+  propertizeElement,
+  removeDuplicateProps,
+  setPropsPrototype,
+  syncProps,
+  update,
+  updateProps
+};

package/dist/esm/scope.js

@@ -0,0 +1,8 @@
+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) || {};
+};
+export {
+  createScope
+};