@domql/element 3.1.1 → 3.2.3

package/dist/cjs/iterate.js

@@ -27,14 +27,21 @@ __export(iterate_exports, {
 });
 module.exports = __toCommonJS(iterate_exports);
 var import_utils = require("@domql/utils");
-const throughInitialExec = async (element, exclude = {}) => {
+const throughInitialExec = (element, exclude = {}) => {
   const { __ref: ref } = element;
   for (const param in element) {
     if (exclude[param]) continue;
     const prop = element[param];
     if ((0, import_utils.isFunction)(prop) && !(0, import_utils.isMethod)(param, element)) {
       ref.__exec[param] = prop;
-      element[param] = await prop(element, element.state, element.context);
+      const result = prop(element, element.state, element.context);
+      if (result && typeof result.then === "function") {
+        result.then((resolved) => {
+          element[param] = resolved;
+        });
+      } else {
+        element[param] = result;
+      }
     }
   }
 };
@@ -46,6 +53,12 @@ const throughUpdatedExec = (element, options = {}) => {
     const isDefinedParam = ref.__defineCache[param];
     if (isDefinedParam) continue;
     const newExec = ref.__exec[param](element, element.state, element.context);
+    if (newExec && typeof newExec.then === "function") {
+      newExec.then((resolved) => {
+        element[param] = resolved;
+      });
+      continue;
+    }
     const execReturnsString = (0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec);
     if (prop && prop.node && execReturnsString) {
       (0, import_utils.overwrite)(prop, { text: newExec });
@@ -65,23 +78,37 @@ const throughUpdatedExec = (element, options = {}) => {
   }
   return changes;
 };
-const throughExecProps = async (element) => {
+const throughExecProps = (element) => {
   const { __ref: ref } = element;
   const { props } = element;
   for (const k in props) {
     const isDefine = k.startsWith("is") || k.startsWith("has") || k.startsWith("use");
     const cachedExecProp = ref.__execProps[k];
     if ((0, import_utils.isFunction)(cachedExecProp)) {
-      props[k] = await (0, import_utils.execPromise)(cachedExecProp, element);
+      const result = (0, import_utils.exec)(cachedExecProp, element);
+      if (result && typeof result.then === "function") {
+        result.then((resolved) => {
+          props[k] = resolved;
+        });
+      } else {
+        props[k] = result;
+      }
     } else if (isDefine && (0, import_utils.isFunction)(props[k])) {
       ref.__execProps[k] = props[k];
-      props[k] = await (0, import_utils.execPromise)(props[k], element);
+      const result = (0, import_utils.exec)(props[k], element);
+      if (result && typeof result.then === "function") {
+        result.then((resolved) => {
+          props[k] = resolved;
+        });
+      } else {
+        props[k] = result;
+      }
     }
   }
 };
 const isPropertyInDefines = (key, element) => {
 };
-const throughInitialDefine = async (element) => {
+const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
   const hasGlobalDefine = context && (0, import_utils.isObject)(context.define);
@@ -91,23 +118,38 @@ const throughInitialDefine = async (element) => {
     let elementProp = element[param];
     if ((0, import_utils.isFunction)(elementProp) && !(0, import_utils.isMethod)(param, element)) {
       ref.__exec[param] = elementProp;
-      const execParam2 = elementProp = await (0, import_utils.execPromise)(elementProp, element);
-      if (execParam2) {
-        elementProp = element[param] = execParam2.parse ? execParam2.parse() : execParam2;
-        ref.__defineCache[param] = elementProp;
+      let execParam2 = (0, import_utils.exec)(elementProp, element);
+      if (execParam2 && typeof execParam2.then === "function") {
+        execParam2.then((resolved) => {
+          elementProp = element[param] = resolved && resolved.parse ? resolved.parse() : resolved;
+          if (resolved) {
+            ref.__defineCache[param] = elementProp;
+          }
+        });
+      } else {
+        elementProp = element[param] = execParam2 && execParam2.parse ? execParam2.parse() : execParam2;
+        if (execParam2) {
+          ref.__defineCache[param] = elementProp;
+        }
       }
     }
-    const execParam = await defineObj[param](
+    const execParam = defineObj[param](
       elementProp,
       element,
       element.state,
       element.context
     );
-    if (execParam) element[param] = execParam;
+    if (execParam && typeof execParam.then === "function") {
+      execParam.then((resolved) => {
+        if (resolved) element[param] = resolved;
+      });
+    } else if (execParam) {
+      element[param] = execParam;
+    }
   }
   return element;
 };
-const throughUpdatedDefine = async (element) => {
+const throughUpdatedDefine = (element) => {
   const { context, define, __ref: ref } = element;
   const changes = {};
   let obj = {};
@@ -116,15 +158,29 @@ const throughUpdatedDefine = async (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam) {
-      ref.__defineCache[param] = await execParam(
-        element,
-        element.state,
-        element.context
-      );
+      const result = execParam(element, element.state, element.context);
+      if (result && typeof result.then === "function") {
+        result.then((resolved) => {
+          ref.__defineCache[param] = resolved;
+        });
+      } else {
+        ref.__defineCache[param] = result;
+      }
+    }
+    const cached = (0, import_utils.exec)(ref.__defineCache[param], element);
+    if (cached && typeof cached.then === "function") {
+      cached.then((resolved) => {
+      });
+      continue;
     }
-    const cached = await (0, import_utils.execPromise)(ref.__defineCache[param], element);
     const newExecParam = typeof obj[param] === "function" ? obj[param](cached, element, element.state, element.context) : void 0;
-    if (newExecParam) element[param] = newExecParam;
+    if (newExecParam && typeof newExecParam.then === "function") {
+      newExecParam.then((resolved) => {
+        element[param] = resolved;
+      });
+    } else if (newExecParam) {
+      element[param] = newExecParam;
+    }
   }
   return changes;
 };

package/dist/cjs/mixins/content.js

@@ -0,0 +1,73 @@
+"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 content_exports = {};
+__export(content_exports, {
+  default: () => content_default,
+  removeContent: () => removeContent,
+  setContent: () => setContent,
+  updateContent: () => updateContent
+});
+module.exports = __toCommonJS(content_exports);
+var import_utils = require("@domql/utils");
+var import_set = require("../set.js");
+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);
+};
+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 (element[contentElementKey]) {
+    if (element[contentElementKey].node && element.node) {
+      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);
+      }
+    }
+    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();
+    }
+    ref.__children.splice(ref.__children.indexOf(element[contentElementKey]), 1);
+    delete element[contentElementKey];
+  }
+};
+function setContent(param, element, node, opts) {
+  var _a;
+  const contentElementKey = (0, import_utils.setContentKey)(element, opts);
+  if (param && element) {
+    if ((_a = element[contentElementKey]) == null ? void 0 : _a.update) {
+      element[contentElementKey].update({}, opts);
+    } else {
+      import_set.set.call(element, param, opts);
+    }
+  }
+}
+var content_default = setContent;

package/dist/cjs/mixins/html.js

@@ -25,7 +25,7 @@ module.exports = __toCommonJS(html_exports);
 var import_utils = require("@domql/utils");
 function html(param, element, node) {
   var _a;
-  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 prop = (0, import_utils.exec)(((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.html) || param, element);
   const { __ref } = element;
   if (prop !== __ref.__html) {
     if (node.nodeName === "SVG") node.textContent = prop;

package/dist/cjs/mixins/registry.js

@@ -32,7 +32,7 @@ __export(registry_exports, {
   default: () => registry_default
 });
 module.exports = __toCommonJS(registry_exports);
-var import_attr = __toESM(require("./attr.js"), 1);
+var import_attr = require("./attr.js");
 var import_classList = require("./classList.js");
 var import_data = __toESM(require("./data.js"), 1);
 var import_html = __toESM(require("./html.js"), 1);
@@ -41,7 +41,7 @@ var import_state = __toESM(require("./state.js"), 1);
 var import_style = __toESM(require("./style.js"), 1);
 var import_text = __toESM(require("./text.js"), 1);
 const REGISTRY = {
-  attr: import_attr.default,
+  attr: import_attr.attr,
   style: import_style.default,
   text: import_text.default,
   html: import_html.default,

package/dist/cjs/mixins/scope.js

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

package/dist/cjs/mixins/state.js

@@ -23,8 +23,8 @@ __export(state_exports, {
 });
 module.exports = __toCommonJS(state_exports);
 var import_utils = require("@domql/utils");
-async function state(params, element, node) {
-  const state2 = await (0, import_utils.execPromise)(params, element);
+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_utils.STATE_METHODS.includes(param)) continue;

package/dist/cjs/mixins/text.js

@@ -24,10 +24,10 @@ __export(text_exports, {
 module.exports = __toCommonJS(text_exports);
 var import_create = require("../create.js");
 var import_utils = require("@domql/utils");
-async function text(param, element, node) {
-  let prop = (0, import_utils.exec)(param || element.props.text, element);
+function text(param, element, node) {
+  let prop = (0, import_utils.exec)(element.props.text || param, element);
   if ((0, import_utils.isString)(prop) && prop.includes("{{")) {
-    prop = element.call("replaceLiteralsWithObjectFields", prop);
+    prop = element.call("replaceLiteralsWithObjectFields", prop, element.state);
   }
   if (element.tag === "string") {
     node.nodeValue = prop;
@@ -36,7 +36,7 @@ async function text(param, element, node) {
       if (element.__text.text === prop) return;
       element.__text.text = prop;
       if (element.__text.node) element.__text.node.nodeValue = prop;
-    } else await (0, import_create.create)({ tag: "string", text: prop }, element, "__text");
+    } else (0, import_create.create)({ tag: "string", text: prop }, element, "__text");
   }
 }
 var text_default = text;

package/dist/cjs/node.js

@@ -42,7 +42,7 @@ var import_applyParam = require("./utils/applyParam.js");
 var import_children = __toESM(require("./children.js"), 1);
 var import_set = require("./set.js");
 const ENV = "development";
-const createNode = async (element, opts) => {
+const createNode = (element, opts) => {
   let { node, tag, __ref: ref } = element;
   if (!ref.__if) return element;
   let isNewNode;
@@ -51,42 +51,42 @@ const createNode = async (element, opts) => {
     if (tag === "shadow") {
       node = element.node = element.parent.node.attachShadow({ mode: "open" });
     } else node = element.node = (0, import_render.cacheNode)(element);
-    await (0, import_event.triggerEventOn)("attachNode", element, opts);
+    (0, import_event.triggerEventOn)("attachNode", element, opts);
   }
   if (ENV === "test" || ENV === "development" || opts.alowRefReference) {
     node.ref = element;
     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 });
+  (0, import_iterate.throughExecProps)(element);
+  (0, import_iterate.throughInitialDefine)(element);
+  (0, import_iterate.throughInitialExec)(element);
+  (0, import_event.applyEventsOnNode)(element, { isNewNode, ...opts });
   for (const param in element) {
     const value = element[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 = await (0, import_applyParam.applyParam)(param, element, opts);
+    const isElement = (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)(value, element, param, opts);
+        const createAsync = () => {
+          (0, import_create.create)(value, element, param, opts);
         };
         if (element.props && element.props.lazyLoad || opts.lazyLoad) {
-          window.requestAnimationFrame(async () => {
-            await createAsync();
+          window.requestAnimationFrame(() => {
+            createAsync();
             if (!opts.preventUpdateListener) {
-              await (0, import_event.triggerEventOn)("lazyLoad", element, opts);
+              (0, import_event.triggerEventOn)("lazyLoad", element, opts);
             }
           });
-        } else await createAsync();
+        } else createAsync();
       }
     }
   }
-  const content = element.children ? await (0, import_children.default)(element.children, element, opts) : element.content || element.content;
+  const content = element.children ? (0, import_children.default)(element.children, element, opts) : element.content || element.content;
   if (content) {
-    await (0, import_set.setContent)(content, element, opts);
+    (0, import_set.setContent)(content, element, opts);
   }
   return element;
 };

package/dist/cjs/set.js

@@ -39,45 +39,40 @@ const setContentKey = (element, opts = {}) => {
   }
   return ref.contentElementKey;
 };
-const reset = async (options) => {
+const reset = (options) => {
   const element = void 0;
-  await (0, import_create.create)(element, element.parent, void 0, {
+  (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) => {
+const resetContent = (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
-    }
-  );
+  const contentElem = (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 updateContent = 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);
+    element[contentElementKey].update(params, opts);
   }
 };
-async function setContent(param, element, opts) {
-  const content = await (0, import_utils.execPromise)(param, element);
+function setContent(param, element, opts) {
+  const content = (0, import_utils.exec)(param, element);
   if (content && element) {
-    await set.call(element, content, opts);
+    set.call(element, content, opts);
   }
 }
 const removeContent = function(el, opts = {}) {
@@ -109,7 +104,7 @@ const removeContent = function(el, opts = {}) {
   }
   delete element[contentElementKey];
 };
-const set = async function(params, options = {}, el) {
+const set = function(params, options = {}, el) {
   var _a;
   const element = el || this;
   const { __ref: ref } = element;
@@ -123,7 +118,7 @@ const set = async function(params, options = {}, el) {
   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)(
+      const beforeUpdateReturns = (0, import_event.triggerEventOnUpdate)(
         "beforeUpdate",
         params,
         element,
@@ -131,9 +126,9 @@ const set = async function(params, options = {}, el) {
       );
       if (beforeUpdateReturns === false) return element;
     }
-    await content.update(params);
+    content.update(params);
     if (!options.preventUpdateListener && !options.preventListeners) {
-      await (0, import_event.triggerEventOn)("update", element, options);
+      (0, import_event.triggerEventOn)("update", element, options);
     }
     return;
   }
@@ -151,14 +146,14 @@ const set = async function(params, options = {}, el) {
     }
   }
   if (lazyLoad) {
-    window.requestAnimationFrame(async () => {
-      await resetContent(params, element, options);
+    window.requestAnimationFrame(() => {
+      resetContent(params, element, options);
       if (!options.preventUpdateListener) {
-        await (0, import_event.triggerEventOn)("lazyLoad", element, options);
+        (0, import_event.triggerEventOn)("lazyLoad", element, options);
       }
     });
   } else {
-    await resetContent(params, element, options);
+    resetContent(params, element, options);
   }
 };
 var set_default = set;

package/dist/cjs/update.js

@@ -50,7 +50,7 @@ const UPDATE_DEFAULT_OPTIONS = {
   calleeElement: false,
   exclude: import_utils2.METHODS_EXL
 };
-const update = async function(params = {}, opts) {
+const update = function(params = {}, opts) {
   const calleeElementCache = opts == null ? void 0 : opts.calleeElement;
   const options = (0, import_utils.deepClone)(
     (0, import_utils.isObject)(opts) ? (0, import_utils.deepMerge)(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
@@ -66,7 +66,7 @@ const update = async function(params = {}, opts) {
   );
   if (snapshotHasUpdated) return;
   if (!options.preventListeners) {
-    await (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
+    (0, import_event.triggerEventOnUpdate)("startUpdate", params, element, options);
   }
   const { parent, node, key } = element;
   const { exclude, preventInheritAtCurrentState } = options;
@@ -78,9 +78,9 @@ const update = async function(params = {}, opts) {
     params = { text: params };
   }
   params = import_utils.propertizeUpdate.call(element, params);
-  const inheritState = await inheritStateUpdates(element, options);
+  const inheritState = inheritStateUpdates(element, options);
   if (inheritState === false) return;
-  const ifFails = await checkIfOnUpdate(element, parent, options);
+  const ifFails = checkIfOnUpdate(element, parent, options);
   if (ifFails) return;
   if (ref.__if && !options.preventPropsUpdate) {
     const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
@@ -90,7 +90,7 @@ const update = async function(params = {}, opts) {
   }
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
     const simulate = { ...params, ...element };
-    const beforeUpdateReturns = await (0, import_event.triggerEventOnUpdate)(
+    const beforeUpdateReturns = (0, import_event.triggerEventOnUpdate)(
       "beforeUpdate",
       params,
       simulate,
@@ -103,7 +103,7 @@ const update = async function(params = {}, opts) {
   (0, import_iterate.throughUpdatedExec)(element, { ignore: UPDATE_DEFAULT_OPTIONS });
   (0, import_iterate.throughUpdatedDefine)(element);
   if (!options.isForced && !options.preventListeners) {
-    await (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
+    (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   }
   if (!ref.__if) return false;
   if (!node) {
@@ -135,7 +135,7 @@ const update = async function(params = {}, opts) {
       continue;
     }
     if (preventStateUpdate === "once") options.preventStateUpdate = false;
-    const isElement = await (0, import_applyParam.applyParam)(param, element, options);
+    const isElement = (0, import_applyParam.applyParam)(param, element, options);
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement;
       const canUpdate = (0, import_utils.isObject)(prop) && !hasDefine && !hasContextDefine && !preventRecursive;
@@ -144,33 +144,33 @@ const update = async function(params = {}, opts) {
       if (options.onEachUpdate) {
         options.onEachUpdate(param, element, element.state, element.context);
       }
-      const childUpdateCall = async () => await update.call(prop, params[prop], {
+      const childUpdateCall = () => update.call(prop, params[prop], {
         ...options,
         currentSnapshot: snapshotOnCallee,
         calleeElement
       });
       if (lazyLoad) {
-        import_utils.window.requestAnimationFrame(async () => {
-          await childUpdateCall();
+        import_utils.window.requestAnimationFrame(() => {
+          childUpdateCall();
           if (!options.preventUpdateListener) {
-            await (0, import_event.triggerEventOn)("lazyLoad", element, options);
+            (0, import_event.triggerEventOn)("lazyLoad", element, options);
           }
         });
-      } else await childUpdateCall();
+      } else childUpdateCall();
     }
   }
   if (!preventContentUpdate) {
     const children = params.children || element.children;
-    const content = children ? await (0, import_children.default)(children, element, opts) : element.children || params.content;
+    const content = children ? (0, import_children.default)(children, element, opts) : element.children || params.content;
     if (content) {
-      await (0, import_set.setContent)(content, element, options);
+      (0, import_set.setContent)(content, element, options);
     }
   }
   if (!preventUpdateListener) {
-    await (0, import_event.triggerEventOn)("update", element, options);
+    (0, import_event.triggerEventOn)("update", element, options);
   }
 };
-const checkIfOnUpdate = async (element, parent, 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;
@@ -219,7 +219,7 @@ const checkIfOnUpdate = async (element, parent, options) => {
       };
       delete element.__ref;
       delete element.parent;
-      const createdElement = await (0, import_create.create)(
+      const createdElement = (0, import_create.create)(
         element,
         parent,
         element.key,
@@ -227,11 +227,7 @@ const checkIfOnUpdate = async (element, parent, options) => {
         attachOptions
       );
       if (options.preventUpdate !== true && element.on && (0, import_utils.isFunction)(element.on.update)) {
-        await (0, import_event.applyEvent)(
-          element.on.update,
-          createdElement,
-          createdElement.state
-        );
+        (0, import_event.applyEvent)(element.on.update, createdElement, createdElement.state);
       }
       return createdElement;
     }
@@ -240,7 +236,7 @@ const checkIfOnUpdate = async (element, parent, options) => {
     delete ref.__if;
   }
 };
-const inheritStateUpdates = async (element, options) => {
+const inheritStateUpdates = (element, options) => {
   const { __ref: ref } = element;
   const stateKey = ref.__state;
   const { parent, state } = element;
@@ -264,7 +260,7 @@ const inheritStateUpdates = async (element, options) => {
   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)(
+    const initStateReturns = (0, import_event.triggerEventOnUpdate)(
       "beforeStateUpdate",
       keyInParentState,
       element,
@@ -272,19 +268,14 @@ const inheritStateUpdates = async (element, options) => {
     );
     if (initStateReturns === false) return element;
   }
-  const newState = await createStateUpdate(element, parent, options);
+  const newState = createStateUpdate(element, parent, options);
   if (!options.preventStateUpdateListener && !options.preventListeners) {
-    await (0, import_event.triggerEventOnUpdate)(
-      "stateUpdate",
-      newState.parse(),
-      element,
-      options
-    );
+    (0, import_event.triggerEventOnUpdate)("stateUpdate", newState.parse(), element, options);
   }
 };
-const createStateUpdate = async (element, parent, options) => {
+const createStateUpdate = (element, parent, options) => {
   const __stateChildren = element.state.__children;
-  const newState = await (0, import_state.createState)(element, parent);
+  const newState = (0, import_state.createState)(element, parent);
   element.state = newState;
   for (const child in __stateChildren) {
     if (newState[child]) newState.__children[child] = __stateChildren[child];

package/dist/cjs/utils/applyParam.js

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