@domql/element 2.5.198 → 3.0.0

package/dist/cjs/node.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var node_exports = {};
 __export(node_exports, {
@@ -25,65 +35,59 @@ module.exports = __toCommonJS(node_exports);
 var import_utils = require("@domql/utils");
 var import_event = require("@domql/event");
 var import_render = require("@domql/render");
-var import_methods = require("./methods/index.js");
 var import_create = require("./create.js");
 var import_iterate = require("./iterate.js");
 var import_mixins = require("./mixins/index.js");
 var import_applyParam = require("./utils/applyParam.js");
-var import_propEvents = require("./utils/propEvents.js");
+var import_children = __toESM(require("./children.js"), 1);
+var import_set = require("./set.js");
 const ENV = "development";
-const createNode = async (element, options) => {
+const createNode = async (element, opts) => {
   let { node, tag, __ref: ref } = element;
+  if (!ref.__if) return element;
   let isNewNode;
   if (!node) {
     isNewNode = true;
-    if (!ref.__if)
-      return element;
     if (tag === "shadow") {
       node = element.node = element.parent.node.attachShadow({ mode: "open" });
-    } else
-      node = element.node = (0, import_render.cacheNode)(element);
-    (0, import_event.triggerEventOn)("attachNode", element, options);
+    } else node = element.node = (0, import_render.cacheNode)(element);
+    await (0, import_event.triggerEventOn)("attachNode", element, opts);
   }
-  if (ENV === "test" || ENV === "development" || options.alowRefReference) {
+  if (ENV === "test" || ENV === "development" || opts.alowRefReference) {
     node.ref = element;
-    if ((0, import_utils.isFunction)(node.setAttribute))
-      node.setAttribute("key", element.key);
-  }
-  (0, import_iterate.throughExecProps)(element);
-  (0, import_iterate.throughInitialDefine)(element);
-  (0, import_iterate.throughInitialExec)(element);
-  if (element.tag !== "string" && element.tag !== "fragment") {
-    (0, import_propEvents.propagateEventsFromProps)(element);
-    if (isNewNode && (0, import_utils.isObject)(element.on)) {
-      (0, import_event.applyEventsOnNode)(element, options);
-    }
+    if ((0, import_utils.isFunction)(node.setAttribute)) node.setAttribute("key", element.key);
   }
+  await (0, import_iterate.throughExecProps)(element);
+  await (0, import_iterate.throughInitialDefine)(element);
+  await (0, import_iterate.throughInitialExec)(element);
+  await (0, import_event.applyEventsOnNode)(element, { isNewNode, ...opts });
   for (const param in element) {
     const value = element[param];
-    if (!Object.hasOwnProperty.call(element, param))
-      continue;
-    if ((0, import_utils.isUndefined)(value) || (0, import_methods.isMethod)(param, element) || (0, import_utils.isVariant)(param) || (0, import_utils.isObject)(import_mixins.REGISTRY[param]))
+    if (!Object.hasOwnProperty.call(element, param) || (0, import_utils.isUndefined)(value) || (0, import_utils.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param])) {
       continue;
-    const isElement = (0, import_applyParam.applyParam)(param, element, options);
+    }
+    const isElement = await (0, import_applyParam.applyParam)(param, element, opts);
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement;
       if (element[param] && !hasDefine && !hasContextDefine) {
         const createAsync = async () => {
-          await (0, import_create.create)((0, import_utils.exec)(value, element), element, param, options);
+          await (0, import_create.create)(value, element, param, opts);
         };
-        if (element.props && element.props.lazyLoad || options.lazyLoad) {
+        if (element.props && element.props.lazyLoad || opts.lazyLoad) {
           window.requestAnimationFrame(async () => {
             await createAsync();
-            if (!options.preventUpdateListener) {
-              (0, import_event.triggerEventOn)("lazyLoad", element, options);
+            if (!opts.preventUpdateListener) {
+              await (0, import_event.triggerEventOn)("lazyLoad", element, opts);
             }
           });
-        } else
-          await createAsync();
+        } else await createAsync();
       }
     }
   }
+  const content = element.children ? await (0, import_children.default)(element.children, element, opts) : element.content || element.content;
+  if (content) {
+    await (0, import_set.setContent)(content, element, opts);
+  }
   return element;
 };
 var node_default = createNode;

package/dist/cjs/set.js

@@ -19,81 +19,146 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var set_exports = {};
 __export(set_exports, {
   default: () => set_default,
+  removeContent: () => removeContent,
   reset: () => reset,
-  resetElement: () => resetElement,
-  set: () => set
+  resetContent: () => resetContent,
+  set: () => set,
+  setContent: () => setContent,
+  setContentKey: () => setContentKey,
+  updateContent: () => updateContent
 });
 module.exports = __toCommonJS(set_exports);
 var import_utils = require("@domql/utils");
-var import_options = require("./cache/options.js");
 var import_create = require("./create.js");
-var import_mixins = require("./mixins/index.js");
-var import_content = require("./mixins/content.js");
 var import_event = require("@domql/event");
-const resetElement = async (params, element, options) => {
-  if (!options.preventRemove)
-    (0, import_content.removeContent)(element, options);
+const setContentKey = (element, opts = {}) => {
   const { __ref: ref } = element;
-  await (0, import_create.create)(params, element, ref.contentElementKey || "content", {
-    ignoreChildExtend: true,
-    ...import_mixins.registry.defaultOptions,
-    ...import_options.OPTIONS.create,
-    ...options
-  });
+  const contentElementKey = opts.contentElementKey;
+  if (!ref.contentElementKey || contentElementKey !== ref.contentElementKey) {
+    ref.contentElementKey = contentElementKey || "content";
+  }
+  return ref.contentElementKey;
 };
-const reset = (options) => {
+const reset = async (options) => {
   const element = void 0;
-  (0, import_create.create)(element, element.parent, void 0, {
-    ignoreChildExtend: true,
-    ...import_mixins.registry.defaultOptions,
-    ...import_options.OPTIONS.create,
+  await (0, import_create.create)(element, element.parent, void 0, {
+    ignoreChildExtends: true,
+    ...import_utils.OPTIONS.defaultOptions,
+    ...import_utils.OPTIONS.create,
     ...options
   });
 };
+const resetContent = async (params, element, opts) => {
+  var _a;
+  const contentElementKey = setContentKey(element, opts);
+  if ((_a = element[contentElementKey]) == null ? void 0 : _a.node) removeContent(element, opts);
+  const contentElem = await (0, import_create.create)(
+    params,
+    element,
+    contentElementKey || "content",
+    {
+      ignoreChildExtends: true,
+      ...import_utils.OPTIONS.defaultOptions,
+      ...import_utils.OPTIONS.create,
+      ...opts
+    }
+  );
+  if (contentElementKey !== "content") opts.contentElementKey = "content";
+  return contentElem;
+};
+const updateContent = async function(params, opts) {
+  const element = this;
+  const contentElementKey = setContentKey(element, opts);
+  if (!element[contentElementKey]) return;
+  if (element[contentElementKey].update) {
+    await element[contentElementKey].update(params, opts);
+  }
+};
+async function setContent(param, element, opts) {
+  const content = await (0, import_utils.execPromise)(param, element);
+  if (content && element) {
+    set.call(element, content, opts);
+  }
+}
+const removeContent = function(el, opts = {}) {
+  var _a;
+  const element = el || this;
+  const contentElementKey = setContentKey(element, opts);
+  if (opts.contentElementKey !== "content") {
+    opts.contentElementKey = "content";
+  }
+  const content = element[contentElementKey];
+  if (!content) return;
+  if (content.tag === "fragment" && ((_a = content.__ref) == null ? void 0 : _a.__children)) {
+    content.__ref.__children.forEach((key) => {
+      const child = content[key];
+      if (child.node && child.node.parentNode) {
+        child.node.parentNode.removeChild(child.node);
+      }
+      if ((0, import_utils.isFunction)(child.remove)) {
+        child.remove();
+      }
+    });
+  } else {
+    if (content.node && content.node.parentNode) {
+      content.node.parentNode.removeChild(content.node);
+    }
+    if ((0, import_utils.isFunction)(content.remove)) {
+      content.remove();
+    }
+  }
+  delete element[contentElementKey];
+};
 const set = async function(params, options = {}, el) {
   var _a;
   const element = el || this;
   const { __ref: ref } = element;
-  const content = (0, import_utils.setContentKey)(element, options);
+  const contentElementKey = setContentKey(element, options);
+  const content = element[contentElementKey];
   const __contentRef = content && content.__ref;
   const lazyLoad = element.props && element.props.lazyLoad;
-  const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
-  if (options.preventContentUpdate === true && !hasCollection)
-    return;
-  if (ref.__noCollectionDifference || __contentRef && __contentRef.__cached && (0, import_utils.deepContains)(params, content)) {
+  const hasChildren = element.children;
+  if (options.preventContentUpdate === true && !hasChildren) return;
+  const childHasChanged = !ref.__noChildrenDifference;
+  const childrenIsDifferentFromCache = childHasChanged && __contentRef && Object.keys(params).length === Object.keys(content).length && (0, import_utils.deepContains)(params, content);
+  if ((content == null ? void 0 : content.update) && !childHasChanged && !childrenIsDifferentFromCache) {
     if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-      const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)("beforeUpdate", params, element, options);
-      if (beforeUpdateReturns === false)
-        return element;
+      const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
+        "beforeUpdate",
+        params,
+        element,
+        options
+      );
+      if (beforeUpdateReturns === false) return element;
     }
-    if (content == null ? void 0 : content.update)
-      content.update();
-    if (!options.preventUpdateListener)
+    await content.update(params);
+    if (!options.preventUpdateListener && !options.preventListeners) {
       await (0, import_event.triggerEventOn)("update", element, options);
+    }
     return;
   }
-  if (params) {
-    let { childExtend, props } = params;
-    if (!props)
-      props = params.props = {};
-    if (!childExtend && element.childExtend) {
-      params.childExtend = element.childExtend;
-      props.ignoreChildExtend = true;
+  if (!params) return element;
+  let { childExtends, props, tag } = params;
+  if (!props) props = params.props = {};
+  if (tag === "fragment") {
+    if (!childExtends && element.childExtends) {
+      params.childExtends = element.childExtends;
+      props.ignoreChildExtends = true;
     }
     if (!(props == null ? void 0 : props.childProps) && ((_a = element.props) == null ? void 0 : _a.childProps)) {
       props.childProps = element.props.childProps;
       props.ignoreChildProps = true;
     }
-    if (lazyLoad) {
-      window.requestAnimationFrame(async () => {
-        await resetElement(params, element, options);
-        if (!options.preventUpdateListener) {
-          (0, import_event.triggerEventOn)("lazyLoad", element, options);
-        }
-      });
-    } else
-      await resetElement(params, element, options);
   }
-  return element;
+  if (lazyLoad) {
+    window.requestAnimationFrame(async () => {
+      await resetContent(params, element, options);
+      if (!options.preventUpdateListener) {
+        await (0, import_event.triggerEventOn)("lazyLoad", element, options);
+      }
+    });
+  } else {
+    await resetContent(params, element, options);
+  }
 };
 var set_default = set;

package/dist/cjs/update.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var update_exports = {};
 __export(update_exports, {
@@ -24,75 +34,77 @@ __export(update_exports, {
 module.exports = __toCommonJS(update_exports);
 var import_utils = require("@domql/utils");
 var import_event = require("@domql/event");
-var import_methods = require("./methods/index.js");
-var import_props = require("./props/index.js");
 var import_state = require("@domql/state");
 var import_create = require("./create.js");
 var import_iterate = require("./iterate.js");
 var import_mixins = require("./mixins/index.js");
 var import_applyParam = require("./utils/applyParam.js");
-var import_options = require("./cache/options.js");
 var import_utils2 = require("./utils/index.js");
-const snapshot = {
-  snapshotId: import_utils.createSnapshotId
-};
+var import_set = require("./set.js");
+var import_children = __toESM(require("./children.js"), 1);
 const UPDATE_DEFAULT_OPTIONS = {
   stackChanges: false,
   cleanExec: true,
   preventRecursive: false,
   currentSnapshot: false,
   calleeElement: false,
-  excludes: import_utils2.METHODS_EXL
+  exclude: import_utils2.METHODS_EXL
 };
 const update = async function(params = {}, opts) {
   const calleeElementCache = opts == null ? void 0 : opts.calleeElement;
-  const options = (0, import_utils.deepClone)((0, import_utils.isObject)(opts) ? (0, import_utils2.deepMerge)(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS, { exclude: ["calleeElement"] });
+  const options = (0, import_utils.deepClone)(
+    (0, import_utils.isObject)(opts) ? (0, import_utils.deepMerge)(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
+    { exclude: ["calleeElement"] }
+  );
   options.calleeElement = calleeElementCache;
   const element = this;
-  const { parent, node, key } = element;
-  const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
-  if (!ref)
-    ref = element.__ref = {};
-  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options);
-  if (snapshotHasUpdated)
-    return;
-  if (!options.preventListeners)
+  if (!ref) ref = element.__ref = {};
+  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = (0, import_utils.captureSnapshot)(
+    element,
+    options
+  );
+  if (snapshotHasUpdated) return;
+  if (!options.preventListeners) {
     await (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
-  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
+  }
+  const { parent, node, key } = element;
+  const { exclude, preventInheritAtCurrentState } = options;
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) {
     return;
-  if (!excludes)
-    (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
+  }
+  if (!exclude) (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
   if ((0, import_utils.isString)(params) || (0, import_utils.isNumber)(params)) {
     params = { text: params };
   }
+  params = (0, import_utils.propertizeElement)(params);
   const inheritState = await inheritStateUpdates(element, options);
-  if (inheritState === false)
-    return;
-  const ifFails = checkIfOnUpdate(element, parent, options);
-  if (ifFails)
-    return;
+  if (inheritState === false) return;
+  const ifFails = await checkIfOnUpdate(element, parent, options);
+  if (ifFails) return;
   if (ref.__if && !options.preventPropsUpdate) {
     const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
-    const hasFunctionInProps = ref.__props.filter((v) => (0, import_utils.isFunction)(v));
+    const hasFunctionInProps = ref.__propsStack.filter((v) => (0, import_utils.isFunction)(v));
     const props = params.props || hasParentProps || hasFunctionInProps.length;
-    if (props)
-      (0, import_props.updateProps)(props, element, parent);
+    if (props) (0, import_utils.updateProps)(props, element, parent);
   }
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-    const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)("beforeUpdate", params, element, options);
-    if (beforeUpdateReturns === false)
-      return element;
+    const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
+      "beforeUpdate",
+      params,
+      element,
+      options
+    );
+    if (beforeUpdateReturns === false) return element;
   }
-  (0, import_utils.overwriteDeep)(element, params, { exclude: import_utils2.METHODS_EXL });
+  (0, import_utils.overwriteDeep)(element, params);
   (0, import_iterate.throughExecProps)(element);
   (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
   (0, import_iterate.throughUpdatedDefine)(element);
   if (!options.isForced && !options.preventListeners) {
-    (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
+    await (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   }
-  if (!ref.__if)
-    return false;
+  if (!ref.__if) return false;
   if (!node) {
     return;
   }
@@ -107,78 +119,75 @@ const update = async function(params = {}, opts) {
     preventUpdateAfterCount
   } = options;
   if (preventUpdateAfter) {
-    if ((0, import_utils.isNumber)(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount)
+    if ((0, import_utils.isNumber)(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) {
       return;
-    else if (options.preventUpdateAfterCount === void 0)
+    } else if (options.preventUpdateAfterCount === void 0) {
       options.preventUpdateAfterCount = 1;
-    else
-      options.preventUpdateAfterCount++;
+    } else options.preventUpdateAfterCount++;
   }
   for (const param in element) {
     const prop = element[param];
-    if (!Object.hasOwnProperty.call(element, param))
-      continue;
+    if (!Object.hasOwnProperty.call(element, param)) continue;
     const isInPreventUpdate = (0, import_utils.isArray)(preventUpdate) && preventUpdate.includes(param);
     const isInPreventDefineUpdate = (0, import_utils.isArray)(preventDefineUpdate) && preventDefineUpdate.includes(param);
-    const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
-    if ((0, import_utils.isUndefined)(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param]) || (0, import_utils.isVariant)(param))
+    if ((0, import_utils.isUndefined)(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || (preventStateUpdate && param) === "state" || (0, import_utils.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param])) {
       continue;
-    if (preventStateUpdate === "once")
-      options.preventStateUpdate = false;
-    const isElement = (0, import_applyParam.applyParam)(param, element, options);
+    }
+    if (preventStateUpdate === "once") options.preventStateUpdate = false;
+    const isElement = await (0, import_applyParam.applyParam)(param, element, options);
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement;
       const canUpdate = (0, import_utils.isObject)(prop) && !hasDefine && !hasContextDefine && !preventRecursive;
-      if (!canUpdate)
-        continue;
+      if (!canUpdate) continue;
       const lazyLoad = element.props.lazyLoad || options.lazyLoad;
       if (options.onEachUpdate) {
         options.onEachUpdate(param, element, element.state, element.context);
       }
-      const childUpdateCall = () => update.call(prop, params[prop], {
+      const childUpdateCall = async () => await update.call(prop, params[prop], {
         ...options,
         currentSnapshot: snapshotOnCallee,
         calleeElement
       });
-      lazyLoad ? import_utils.window.requestAnimationFrame(() => {
-        childUpdateCall();
-        if (!options.preventUpdateListener) {
-          (0, import_event.triggerEventOn)("lazyLoad", element, options);
-        }
-      }) : childUpdateCall();
+      if (lazyLoad) {
+        import_utils.window.requestAnimationFrame(async () => {
+          await childUpdateCall();
+          if (!options.preventUpdateListener) {
+            await (0, import_event.triggerEventOn)("lazyLoad", element, options);
+          }
+        });
+      } else await childUpdateCall();
     }
   }
-  if (!preventUpdateListener)
-    (0, import_event.triggerEventOn)("update", element, options);
-};
-const captureSnapshot = (element, options) => {
-  const ref = element.__ref;
-  const { currentSnapshot, calleeElement } = options;
-  const isCallee = calleeElement === element;
-  if (!calleeElement || isCallee) {
-    const createdStanpshot = snapshot.snapshotId();
-    ref.__currentSnapshot = createdStanpshot;
-    return [createdStanpshot, element];
+  if (!preventContentUpdate) {
+    const children = params.children || element.children;
+    const content = children ? await (0, import_children.default)(children, element, opts) : element.children || params.content;
+    if (content) {
+      await (0, import_set.setContent)(content, element, options);
+    }
   }
-  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
-  if (currentSnapshot < snapshotOnCallee) {
-    return [snapshotOnCallee, calleeElement, true];
+  if (!preventUpdateListener) {
+    await (0, import_event.triggerEventOn)("update", element, options);
   }
-  return [snapshotOnCallee, calleeElement];
 };
-const checkIfOnUpdate = (element, parent, options) => {
+const checkIfOnUpdate = async (element, parent, options) => {
   var _a, _b, _c;
-  if (!(0, import_utils.isFunction)(element.if) && !(0, import_utils.isFunction)((_a = element.props) == null ? void 0 : _a.if) || !parent)
+  if (!(0, import_utils.isFunction)(element.if) && !(0, import_utils.isFunction)((_a = element.props) == null ? void 0 : _a.if) || !parent) {
     return;
+  }
   const ref = element.__ref;
-  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(element, element.state, element.context, options);
+  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(
+    element,
+    element.state,
+    element.context,
+    options
+  );
   const itWasFalse = ref.__if !== true;
   if (ifPassed) {
     ref.__if = true;
     if (itWasFalse) {
       delete element.__hash;
       delete element.__text;
-      delete element.extend;
+      delete element.extends;
       if (!ref.__hasRootState) {
         delete element.state;
       }
@@ -192,10 +201,11 @@ const checkIfOnUpdate = (element, parent, options) => {
         delete element.node;
       }
       const contentKey = ref.contentElementKey;
-      if (element.$collection || element.$stateCollection || element.$propsCollection) {
+      if (element.children) {
         element.removeContent();
-      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep)
+      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep) {
         element[contentKey] = element[contentKey].parseDeep();
+      }
       const previousElement = element.previousElement();
       const previousNode = previousElement == null ? void 0 : previousElement.node;
       const hasPrevious = previousNode == null ? void 0 : previousNode.parentNode;
@@ -208,9 +218,19 @@ const checkIfOnUpdate = (element, parent, options) => {
       };
       delete element.__ref;
       delete element.parent;
-      const createdElement = (0, import_create.create)(element, parent, element.key, import_options.OPTIONS.create, attachOptions);
+      const createdElement = await (0, import_create.create)(
+        element,
+        parent,
+        element.key,
+        import_utils.OPTIONS.create,
+        attachOptions
+      );
       if (options.preventUpdate !== true && element.on && (0, import_utils.isFunction)(element.on.update)) {
-        (0, import_event.applyEvent)(element.on.update, createdElement, createdElement.state);
+        await (0, import_event.applyEvent)(
+          element.on.update,
+          createdElement,
+          createdElement.state
+        );
       }
       return createdElement;
     }
@@ -224,8 +244,7 @@ const inheritStateUpdates = async (element, options) => {
   const stateKey = ref.__state;
   const { parent, state } = element;
   const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } = options;
-  if (preventUpdateTriggerStateUpdate)
-    return;
+  if (preventUpdateTriggerStateUpdate) return;
   if (!stateKey && !ref.__hasRootState) {
     element.state = parent && parent.state || {};
     return;
@@ -233,29 +252,41 @@ const inheritStateUpdates = async (element, options) => {
   const shouldForceFunctionState = (0, import_utils.isFunction)(stateKey) && !isHoisted && execStateFunction;
   if (shouldForceFunctionState) {
     const execState = (0, import_utils.exec)(stateKey, element);
-    state.set(execState, { ...options, preventUpdate: true, preventStateUpdateListener: false, updatedByStateFunction: true });
+    state.set(execState, {
+      ...options,
+      preventUpdate: true,
+      preventStateUpdateListener: false,
+      updatedByStateFunction: true
+    });
     return;
   }
-  const keyInParentState = (0, import_state.findInheritedState)(element, element.parent);
-  if (!keyInParentState || options.preventInheritedStateUpdate)
-    return;
+  const keyInParentState = (0, import_utils.findInheritedState)(element, element.parent);
+  if (!keyInParentState || options.preventInheritedStateUpdate) return;
   if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {
-    const initStateReturns = await (0, import_event.triggerEventOnUpdate)("beforeStateUpdate", keyInParentState, element, options);
-    if (initStateReturns === false)
-      return element;
+    const initStateReturns = await (0, import_event.triggerEventOnUpdate)(
+      "beforeStateUpdate",
+      keyInParentState,
+      element,
+      options
+    );
+    if (initStateReturns === false) return element;
   }
-  const newState = createStateUpdate(element, parent, options);
+  const newState = await createStateUpdate(element, parent, options);
   if (!options.preventStateUpdateListener && !options.preventListeners) {
-    await (0, import_event.triggerEventOnUpdate)("stateUpdate", newState.parse(), element, options);
+    await (0, import_event.triggerEventOnUpdate)(
+      "stateUpdate",
+      newState.parse(),
+      element,
+      options
+    );
   }
 };
-const createStateUpdate = (element, parent, options) => {
+const createStateUpdate = async (element, parent, options) => {
   const __stateChildren = element.state.__children;
-  const newState = (0, import_state.createState)(element, parent);
+  const newState = await (0, import_state.createState)(element, parent);
   element.state = newState;
   for (const child in __stateChildren) {
-    if (newState[child])
-      newState.__children[child] = __stateChildren[child];
+    if (newState[child]) newState.__children[child] = __stateChildren[child];
     Object.getPrototypeOf(__stateChildren[child]).parent = newState;
   }
   return newState;