@domql/element 2.5.203 → 2.5.206

package/dist/cjs/mixins/attr.js

@@ -28,17 +28,13 @@ var import_utils2 = require("../utils/index.js");
 function attr(params, element, node) {
   const { __ref: ref, props } = element;
   const { __attr } = ref;
-  if ((0, import_utils.isNot)("object"))
-    (0, import_report.report)("HTMLInvalidAttr", params);
+  if ((0, import_utils.isNot)("object")) (0, import_report.report)("HTMLInvalidAttr", params);
   if (params) {
-    if (props.attr)
-      (0, import_utils2.deepMerge)(params, props.attr);
+    if (props.attr) (0, import_utils2.deepMerge)(params, props.attr);
     for (const attr2 in params) {
       const val = (0, import_utils.exec)(params[attr2], element);
-      if (val !== false && !(0, import_utils.isUndefined)(val) && !(0, import_utils.isNull)(val) && node.setAttribute)
-        node.setAttribute(attr2, val);
-      else if (node.removeAttribute)
-        node.removeAttribute(attr2);
+      if (val !== false && !(0, import_utils.isUndefined)(val) && !(0, import_utils.isNull)(val) && node.setAttribute) node.setAttribute(attr2, val);
+      else if (node.removeAttribute) node.removeAttribute(attr2);
       __attr[attr2] = val;
     }
   }

package/dist/cjs/mixins/classList.js

@@ -29,8 +29,7 @@ module.exports = __toCommonJS(classList_exports);
 var import_utils = require("@domql/utils");
 const assignKeyAsClassname = (element) => {
   const { key } = element;
-  if (element.class === true)
-    element.class = key;
+  if (element.class === true) element.class = key;
   else if (!element.class && typeof key === "string" && key.charAt(0) === "_" && key.charAt(1) !== "_") {
     element.class = key.slice(1);
   }
@@ -39,10 +38,8 @@ const classify = (obj, element) => {
   let className = "";
   for (const item in obj) {
     const param = obj[item];
-    if (typeof param === "boolean" && param)
-      className += ` ${item}`;
-    else if (typeof param === "string")
-      className += ` ${param}`;
+    if (typeof param === "boolean" && param) className += ` ${item}`;
+    else if (typeof param === "string") className += ` ${param}`;
     else if (typeof param === "function") {
       className += ` ${(0, import_utils.exec)(param, element)}`;
     }
@@ -50,18 +47,13 @@ const classify = (obj, element) => {
   return className;
 };
 const classList = (params, element) => {
-  if (!params)
-    return;
+  if (!params) return;
   const { key } = element;
-  if (params === true)
-    params = element.class = { key };
-  if ((0, import_utils.isString)(params))
-    params = element.class = { default: params };
-  if ((0, import_utils.isObject)(params))
-    params = classify(params, element);
+  if (params === true) params = element.class = { key };
+  if ((0, import_utils.isString)(params)) params = element.class = { default: params };
+  if ((0, import_utils.isObject)(params)) params = classify(params, element);
   const className = params.replace(/\s+/g, " ").trim();
-  if (element.ref)
-    element.ref.class = className;
+  if (element.ref) element.ref.class = className;
   return className;
 };
 const applyClassListOnNode = (params, element, node) => {

package/dist/cjs/mixins/content.js

@@ -30,44 +30,37 @@ const updateContent = function(params, options) {
   const element = this;
   const ref = element.__ref;
   const contentKey = ref.contentElementKey;
-  if (!element[contentKey])
-    return;
-  if (element[contentKey].update)
-    element[contentKey].update(params, options);
+  if (!element[contentKey]) return;
+  if (element[contentKey].update) element[contentKey].update(params, options);
 };
 const removeContent = function(el, opts = {}) {
   const element = el || this;
   const { __ref: ref } = element;
   const contentElementKey = (0, import_utils.setContentKey)(element, opts);
-  if (opts.contentElementKey !== "content")
-    opts.contentElementKey = "content";
+  if (opts.contentElementKey !== "content") opts.contentElementKey = "content";
   if (element[contentElementKey]) {
     if (element[contentElementKey].node && element.node) {
-      if (element[contentElementKey].tag === "fragment")
-        element.node.innerHTML = "";
+      if (element[contentElementKey].tag === "fragment") element.node.innerHTML = "";
       else {
         const contentNode = element[contentElementKey].node;
-        if (contentNode.parentNode === element.node)
-          element.node.removeChild(element[contentElementKey].node);
+        if (contentNode.parentNode === element.node) element.node.removeChild(element[contentElementKey].node);
       }
     }
     const { __cached } = ref;
     if (__cached && __cached[contentElementKey]) {
-      if (__cached[contentElementKey].tag === "fragment")
-        __cached[contentElementKey].parent.node.innerHTML = "";
-      else if (__cached[contentElementKey] && (0, import_utils.isFunction)(__cached[contentElementKey].remove))
-        __cached[contentElementKey].remove();
+      if (__cached[contentElementKey].tag === "fragment") __cached[contentElementKey].parent.node.innerHTML = "";
+      else if (__cached[contentElementKey] && (0, import_utils.isFunction)(__cached[contentElementKey].remove)) __cached[contentElementKey].remove();
     }
     delete element[contentElementKey];
   }
 };
-function setContent(param, element, node, opts) {
+async function setContent(param, element, node, opts) {
   const contentElementKey = (0, import_utils.setContentKey)(element, opts);
   if (param && element) {
     if (element[contentElementKey].update) {
       element[contentElementKey].update({}, opts);
     } else {
-      import_set.set.call(element, param, opts);
+      await import_set.set.call(element, param, opts);
     }
   }
 }

package/dist/cjs/mixins/data.js

@@ -26,11 +26,9 @@ var import_utils = require("@domql/utils");
 var import_report = require("@domql/report");
 function data(params, element, node) {
   if (params) {
-    if (element.props.data)
-      (0, import_utils.deepMerge)(params, element.props.data);
+    if (element.props.data) (0, import_utils.deepMerge)(params, element.props.data);
     if (params.showOnNode) {
-      if (!(0, import_utils.isObject)(params))
-        (0, import_report.report)("HTMLInvalidData", params);
+      if (!(0, import_utils.isObject)(params)) (0, import_report.report)("HTMLInvalidData", params);
       for (const dataset in params) {
         if (dataset !== "showOnNode") {
           node.dataset[dataset] = (0, import_utils.exec)(params[dataset], element);

package/dist/cjs/mixins/html.js

@@ -28,10 +28,8 @@ function html(param, element, node) {
   const prop = (0, import_utils.exec)(param, element) || (0, import_utils.exec)((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.html, element);
   const { __ref } = element;
   if (prop !== __ref.__html) {
-    if (node.nodeName === "SVG")
-      node.textContent = prop;
-    else
-      node.innerHTML = prop;
+    if (node.nodeName === "SVG") node.textContent = prop;
+    else node.innerHTML = prop;
     __ref.__html = prop;
   }
 }

package/dist/cjs/mixins/scope.js

@@ -24,8 +24,7 @@ __export(scope_exports, {
 module.exports = __toCommonJS(scope_exports);
 var import_utils = require("@domql/utils");
 function scope(params, element, node) {
-  if (!(0, import_utils.isObject)(params))
-    return;
+  if (!(0, import_utils.isObject)(params)) return;
   for (const scopeItem in params) {
     const value = params[scopeItem];
     if ((0, import_utils.isFunction)(value)) {

package/dist/cjs/mixins/state.js

@@ -28,10 +28,8 @@ function state(params, element, node) {
   const state2 = (0, import_utils.exec)(params, element);
   if ((0, import_utils.isObject)(state2)) {
     for (const param in state2) {
-      if (import_state.IGNORE_STATE_PARAMS.includes(param))
-        continue;
-      if (!Object.hasOwnProperty.call(state2, param))
-        continue;
+      if (import_state.IGNORE_STATE_PARAMS.includes(param)) continue;
+      if (!Object.hasOwnProperty.call(state2, param)) continue;
     }
   }
   return element;

package/dist/cjs/mixins/style.js

@@ -26,10 +26,8 @@ var import_utils = require("@domql/utils");
 var import_report = require("@domql/report");
 function style(params, element, node) {
   if (params) {
-    if ((0, import_utils.isObject)(params))
-      (0, import_utils.map)(node.style, params, element);
-    else
-      (0, import_report.report)("HTMLInvalidStyles", params);
+    if ((0, import_utils.isObject)(params)) (0, import_utils.map)(node.style, params, element);
+    else (0, import_report.report)("HTMLInvalidStyles", params);
   }
 }
 var style_default = style;

package/dist/cjs/mixins/text.js

@@ -33,13 +33,10 @@ function text(param, element, node) {
     node.nodeValue = prop;
   } else if (param !== void 0 || param !== null) {
     if (element.__text) {
-      if (element.__text.text === prop)
-        return;
+      if (element.__text.text === prop) return;
       element.__text.text = prop;
-      if (element.__text.node)
-        element.__text.node.nodeValue = prop;
-    } else
-      (0, import_create.create)({ tag: "string", text: prop }, element, "__text");
+      if (element.__text.node) element.__text.node.nodeValue = prop;
+    } else (0, import_create.create)({ tag: "string", text: prop }, element, "__text");
   }
 }
 var text_default = text;

package/dist/cjs/node.js

@@ -37,18 +37,15 @@ const createNode = async (element, options) => {
   let isNewNode;
   if (!node) {
     isNewNode = true;
-    if (!ref.__if)
-      return element;
+    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, options);
   }
   if (ENV === "testing" || ENV === "development" || options.alowRefReference) {
     node.ref = element;
-    if ((0, import_utils.isFunction)(node.setAttribute))
-      node.setAttribute("key", element.key);
+    if ((0, import_utils.isFunction)(node.setAttribute)) node.setAttribute("key", element.key);
   }
   (0, import_iterate.throughExecProps)(element);
   (0, import_iterate.throughInitialDefine)(element);
@@ -61,11 +58,9 @@ const createNode = async (element, options) => {
   }
   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]))
-      continue;
-    const isElement = (0, import_applyParam.applyParam)(param, element, options);
+    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])) continue;
+    const isElement = await (0, import_applyParam.applyParam)(param, element, options);
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement;
       if (element[param] && !hasDefine && !hasContextDefine) {
@@ -79,8 +74,7 @@ const createNode = async (element, options) => {
               (0, import_event.triggerEventOn)("lazyLoad", element, options);
             }
           });
-        } else
-          await createAsync();
+        } else await createAsync();
       }
     }
   }

package/dist/cjs/props/create.js

@@ -28,16 +28,12 @@ var import_inherit = require("./inherit.js");
 const createPropsStack = (element, parent) => {
   const { props, __ref: ref } = element;
   const propsStack = ref.__props = (0, import_inherit.inheritParentProps)(element, parent);
-  if ((0, import_utils.isObject)(props))
-    propsStack.push(props);
-  else if (props === "inherit" && parent.props)
-    propsStack.push(parent.props);
-  else if (props)
-    propsStack.push(props);
+  if ((0, import_utils.isObject)(props)) propsStack.push(props);
+  else if (props === "inherit" && parent.props) propsStack.push(parent.props);
+  else if (props) propsStack.push(props);
   if ((0, import_utils.isArray)(ref.__extend)) {
     ref.__extend.forEach((extend) => {
-      if (extend.props && extend.props !== props)
-        propsStack.push(extend.props);
+      if (extend.props && extend.props !== props) propsStack.push(extend.props);
     });
   }
   ref.__props = propsStack;
@@ -47,8 +43,7 @@ const syncProps = (props, element, opts) => {
   element.props = {};
   const mergedProps = {};
   props.forEach((v) => {
-    if (import_ignore.IGNORE_PROPS_PARAMS.includes(v))
-      return;
+    if (import_ignore.IGNORE_PROPS_PARAMS.includes(v)) return;
     let execProps;
     try {
       execProps = (0, import_utils.exec)(v, element);
@@ -78,8 +73,7 @@ const createProps = function(element, parent, options) {
       element.props = {};
     }
   };
-  if (ref.__if)
-    applyProps();
+  if (ref.__if) applyProps();
   else {
     try {
       applyProps();

package/dist/cjs/props/inherit.js

@@ -38,8 +38,7 @@ const inheritParentProps = (element, parent) => {
   if (matchParent) {
     if (matchParentIsString) {
       const inheritedStringExists = propsStack.filter((v) => v.inheritedString)[0];
-      if (inheritedStringExists)
-        inheritedStringExists.inheritedString = matchParent;
+      if (inheritedStringExists) inheritedStringExists.inheritedString = matchParent;
       else {
         propsStack = [].concat(objectizeStringProperty(matchParent), propsStack);
       }
@@ -47,7 +46,6 @@ const inheritParentProps = (element, parent) => {
       propsStack.push(objectizeStringProperty(matchParent));
     }
   }
-  if (matchParentChildProps && !((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.ignoreChildProps))
-    propsStack.push(matchParentChildProps);
+  if (matchParentChildProps && !((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.ignoreChildProps)) propsStack.push(matchParentChildProps);
   return propsStack;
 };

package/dist/cjs/props/update.js

@@ -27,11 +27,8 @@ const updateProps = (newProps, element, parent) => {
   const { __ref } = element;
   let propsStack = __ref.__props;
   const parentProps = (0, import_inherit.inheritParentProps)(element, parent);
-  if (parentProps.length)
-    propsStack = __ref.__props = [].concat(parentProps, propsStack);
-  if (newProps)
-    propsStack = __ref.__props = [].concat(newProps, propsStack);
-  if (propsStack)
-    (0, import_create.syncProps)(propsStack, element);
+  if (parentProps.length) propsStack = __ref.__props = [].concat(parentProps, propsStack);
+  if (newProps) propsStack = __ref.__props = [].concat(newProps, propsStack);
+  if (propsStack) (0, import_create.syncProps)(propsStack, element);
   return element;
 };

package/dist/cjs/set.js

@@ -31,8 +31,7 @@ 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);
+  if (!options.preventRemove) (0, import_content.removeContent)(element, options);
   const { __ref: ref } = element;
   await (0, import_create.create)(params, element, ref.contentElementKey || "content", {
     ignoreChildExtend: true,
@@ -41,9 +40,9 @@ const resetElement = async (params, element, options) => {
     ...options
   });
 };
-const reset = (options) => {
+const reset = async (options) => {
   const element = void 0;
-  (0, import_create.create)(element, element.parent, void 0, {
+  await (0, import_create.create)(element, element.parent, void 0, {
     ignoreChildExtend: true,
     ...import_mixins.registry.defaultOptions,
     ...import_options.OPTIONS.create,
@@ -58,24 +57,19 @@ const set = async function(params, options = {}, el) {
   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 (options.preventContentUpdate === true && !hasCollection) return;
   if (ref.__noCollectionDifference || __contentRef && __contentRef.__cached && (0, import_utils.deepContains)(params, content)) {
     if (!options.preventBeforeUpdateListener && !options.preventListeners) {
       const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)("beforeUpdate", params, element, options);
-      if (beforeUpdateReturns === false)
-        return element;
+      if (beforeUpdateReturns === false) return element;
     }
-    if (content == null ? void 0 : content.update)
-      content.update();
-    if (!options.preventUpdateListener)
-      await (0, import_event.triggerEventOn)("update", element, options);
+    if (content == null ? void 0 : content.update) await content.update();
+    if (!options.preventUpdateListener) await (0, import_event.triggerEventOn)("update", element, options);
     return;
   }
   if (params) {
     let { childExtend, props } = params;
-    if (!props)
-      props = params.props = {};
+    if (!props) props = params.props = {};
     if (!childExtend && element.childExtend) {
       params.childExtend = element.childExtend;
       props.ignoreChildExtend = true;
@@ -91,8 +85,7 @@ const set = async function(params, options = {}, el) {
           (0, import_event.triggerEventOn)("lazyLoad", element, options);
         }
       });
-    } else
-      await resetElement(params, element, options);
+    } else await resetElement(params, element, options);
   }
   return element;
 };

package/dist/cjs/update.js

@@ -52,37 +52,28 @@ const update = async function(params = {}, opts) {
   const { parent, node, key } = element;
   const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
-  if (!ref)
-    ref = element.__ref = {};
+  if (!ref) ref = element.__ref = {};
   const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options);
-  if (snapshotHasUpdated)
-    return;
-  if (!options.preventListeners)
-    await (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
-  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
-    return;
-  if (!excludes)
-    (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
+  if (snapshotHasUpdated) return;
+  if (!options.preventListeners) await (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) return;
+  if (!excludes) (0, import_utils.merge)(options, UPDATE_DEFAULT_OPTIONS);
   if ((0, import_utils.isString)(params) || (0, import_utils.isNumber)(params)) {
     params = { text: params };
   }
   const inheritState = await inheritStateUpdates(element, options);
-  if (inheritState === false)
-    return;
+  if (inheritState === false) return;
   const ifFails = checkIfOnUpdate(element, parent, options);
-  if (ifFails)
-    return;
+  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 props = params.props || hasParentProps || hasFunctionInProps.length;
-    if (props)
-      (0, import_props.updateProps)(props, element, parent);
+    if (props) (0, import_props.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;
+    if (beforeUpdateReturns === false) return element;
   }
   (0, import_utils.overwriteDeep)(element, params, { exclude: import_utils2.METHODS_EXL });
   (0, import_iterate.throughExecProps)(element);
@@ -91,8 +82,7 @@ const update = async function(params = {}, opts) {
   if (!options.isForced && !options.preventListeners) {
     (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   }
-  if (!ref.__if)
-    return false;
+  if (!ref.__if) return false;
   if (!node) {
     return;
   }
@@ -107,49 +97,41 @@ const update = async function(params = {}, opts) {
     preventUpdateAfterCount
   } = options;
   if (preventUpdateAfter) {
-    if ((0, import_utils.isNumber)(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount)
-      return;
-    else if (options.preventUpdateAfterCount === void 0)
-      options.preventUpdateAfterCount = 1;
-    else
-      options.preventUpdateAfterCount++;
+    if ((0, import_utils.isNumber)(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) return;
+    else if (options.preventUpdateAfterCount === void 0) options.preventUpdateAfterCount = 1;
+    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))
-      continue;
-    if (preventStateUpdate === "once")
-      options.preventStateUpdate = false;
-    const isElement = (0, import_applyParam.applyParam)(param, element, options);
+    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)) continue;
+    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();
+      lazyLoad ? import_utils.window.requestAnimationFrame(async () => {
+        await childUpdateCall();
         if (!options.preventUpdateListener) {
           (0, import_event.triggerEventOn)("lazyLoad", element, options);
         }
-      }) : childUpdateCall();
+      }) : await childUpdateCall();
     }
   }
-  if (!preventUpdateListener)
-    (0, import_event.triggerEventOn)("update", element, options);
+  if (!preventUpdateListener) await (0, import_event.triggerEventOn)("update", element, options);
 };
 const captureSnapshot = (element, options) => {
   const ref = element.__ref;
@@ -168,8 +150,7 @@ const captureSnapshot = (element, options) => {
 };
 const checkIfOnUpdate = (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)
-    return;
+  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 itWasFalse = ref.__if !== true;
@@ -194,8 +175,7 @@ const checkIfOnUpdate = (element, parent, options) => {
       const contentKey = ref.contentElementKey;
       if (element.$collection || element.$stateCollection || element.$propsCollection) {
         element.removeContent();
-      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep)
-        element[contentKey] = element[contentKey].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;
@@ -224,8 +204,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;
@@ -237,25 +216,22 @@ const inheritStateUpdates = async (element, options) => {
     return;
   }
   const keyInParentState = (0, import_state.findInheritedState)(element, element.parent);
-  if (!keyInParentState || options.preventInheritedStateUpdate)
-    return;
+  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;
+    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);
   }
 };
-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;

package/dist/cjs/utils/applyParam.js

@@ -23,7 +23,7 @@ __export(applyParam_exports, {
 module.exports = __toCommonJS(applyParam_exports);
 var import_utils = require("@domql/utils");
 var import_mixins = require("../mixins/index.js");
-const applyParam = (param, element, options) => {
+const applyParam = async (param, element, options) => {
   const { node, context, __ref: ref } = element;
   const prop = element[param];
   const { onlyUpdate } = options;
@@ -32,12 +32,11 @@ const applyParam = (param, element, options) => {
   const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
   const hasDefine = element.define && element.define[param];
   const hasContextDefine = context && context.define && context.define[param];
-  if (!ref.__if)
-    return;
+  if (!ref.__if) return;
   const hasOnlyUpdate = onlyUpdate ? onlyUpdate === param || element.lookup(onlyUpdate) : true;
   if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
     if ((0, import_utils.isFunction)(isGlobalTransformer)) {
-      isGlobalTransformer(prop, element, node, options);
+      await isGlobalTransformer(prop, element, node, options);
       return;
     }
   }

package/dist/cjs/utils/component.js

@@ -46,8 +46,7 @@ const createValidDomqlObjectFromSugar = (el, parent, key, options) => {
 };
 const overwriteVariant = (element, variant, variantProps) => {
   let variantElement = element[variant];
-  if (!variantElement)
-    return;
+  if (!variantElement) return;
   const props = (0, import_utils.isObject)(variantProps) ? variantProps : {};
   if ((0, import_utils.isString)(variantElement)) {
     variantElement = {
@@ -62,16 +61,14 @@ const overwriteVariant = (element, variant, variantProps) => {
 };
 const applyVariant = (element) => {
   const { props } = element;
-  if (!(0, import_utils.hasVariantProp)(element))
-    return element;
+  if (!(0, import_utils.hasVariantProp)(element)) return element;
   const { variant } = props;
   overwriteVariant(element, `.${variant}`);
   const elKeys = Object.keys(element).filter((key) => (0, import_utils.isVariant)(key));
   elKeys.forEach((variant2) => {
     const slicedVariantElementKey = variant2.slice(1);
     const variantElementProps = props[slicedVariantElementKey];
-    if (variantElementProps)
-      overwriteVariant(element, variant2, variantElementProps);
+    if (variantElementProps) overwriteVariant(element, variant2, variantElementProps);
   });
   return element;
 };