@domql/element 3.1.2 → 3.2.7

package/dist/cjs/mixins/content.js

@@ -0,0 +1,72 @@
+"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) {
+  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);
+    }
+  }
+}
+var content_default = setContent;

package/dist/cjs/mixins/html.js

@@ -24,8 +24,7 @@ __export(html_exports, {
 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)(element?.props?.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,12 +23,12 @@ __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;
-      if (!Object.hasOwnProperty.call(state2, param)) continue;
+      if (import_utils.STATE_METHODS.has(param)) continue;
+      if (!Object.prototype.hasOwnProperty.call(state2, param)) continue;
     }
   }
   return element;

package/dist/cjs/mixins/style.js

@@ -26,8 +26,17 @@ 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)) {
+      const { __ref } = element;
+      if (!__ref.__style) __ref.__style = {};
+      const cache = __ref.__style;
+      for (const prop in params) {
+        const val = (0, import_utils.exec)(params[prop], element);
+        if (val === cache[prop]) continue;
+        cache[prop] = val;
+        node.style[prop] = val;
+      }
+    } else (0, import_report.report)("HTMLInvalidStyles", params);
   }
 }
 var style_default = style;

package/dist/cjs/mixins/text.js

@@ -24,19 +24,23 @@ __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;
-  } else if (param !== void 0 || param !== null) {
+  } else if (param !== void 0 && param !== null) {
+    if (import_utils.SVG_TAGS.has(element.tag)) {
+      if (node) node.textContent = prop;
+      return;
+    }
     if (element.__text) {
       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

@@ -33,16 +33,17 @@ __export(node_exports, {
 });
 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_event = require("./event/index.js");
+var import_propEvents = require("./utils/propEvents.js");
+var import_render = require("./render/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_children = __toESM(require("./children.js"), 1);
 var import_set = require("./set.js");
-const ENV = "development";
-const createNode = async (element, opts) => {
+const ENV = process.env.NODE_ENV;
+const createNode = (element, opts) => {
   let { node, tag, __ref: ref } = element;
   if (!ref.__if) return element;
   let isNewNode;
@@ -51,42 +52,44 @@ 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_propEvents.propagateEventsFromProps)(element);
+  (0, import_propEvents.propagateEventsFromElement)(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])) {
+    if (!Object.prototype.hasOwnProperty.call(element, param) || value === void 0 || (0, import_utils.isMethod)(param, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[param]) || param.length > 2 && param.charCodeAt(0) === 111 && param.charCodeAt(1) === 110 && param.charCodeAt(2) >= 65 && param.charCodeAt(2) <= 90) {
       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.children || element.content;
   if (content) {
-    await (0, import_set.setContent)(content, element, opts);
+    (0, import_set.setContent)(content, element, opts);
   }
   return element;
 };

package/dist/cjs/render/append.js

@@ -0,0 +1,72 @@
+"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 append_exports = {};
+__export(append_exports, {
+  appendNode: () => appendNode,
+  assignNode: () => assignNode,
+  insertNodeAfter: () => insertNodeAfter,
+  insertNodeBefore: () => insertNodeBefore
+});
+module.exports = __toCommonJS(append_exports);
+const appendNode = (node, parentNode) => {
+  try {
+    parentNode.appendChild(node);
+    return node;
+  } catch (e) {
+    console.error("Does not support to append", parentNode, node);
+  }
+};
+const insertNodeAfter = (node, siblingNode, parentNode) => {
+  if (!node) {
+    throw new Error("Node is required");
+  }
+  const parent = parentNode || siblingNode?.parentNode;
+  if (siblingNode?.nextSibling) {
+    parent?.insertBefore(node, siblingNode.nextSibling);
+  } else if (siblingNode?.insertAdjacentElement) {
+    siblingNode.insertAdjacentElement("afterend", node);
+  } else {
+    parent?.insertBefore(node, siblingNode);
+  }
+};
+const insertNodeBefore = (node, siblingNode, parentNode) => {
+  if (!node) {
+    throw new Error("Node is required");
+  }
+  const parent = parentNode || siblingNode.parentNode;
+  parent?.insertBefore(node, siblingNode);
+};
+const assignNode = (element, parent, key, attachOptions) => {
+  if (!element) {
+    throw new Error("Element is required");
+  }
+  if (!parent) {
+    throw new Error("Parent is required");
+  }
+  parent[key || element.key] = element;
+  if (element.tag !== "shadow") {
+    if (attachOptions && attachOptions.position) {
+      ;
+      (attachOptions.position === "before" ? insertNodeBefore : insertNodeAfter)(element.node, attachOptions.node || parent.node);
+    } else {
+      appendNode(element.node, parent.node, element);
+    }
+  }
+  return element;
+};

package/dist/cjs/render/cache.js

@@ -0,0 +1,80 @@
+"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 cache_exports = {};
+__export(cache_exports, {
+  cacheNode: () => cacheNode,
+  createHTMLNode: () => createHTMLNode,
+  detectTag: () => detectTag
+});
+module.exports = __toCommonJS(cache_exports);
+var import_report = require("@domql/report");
+var import_event = require("../event/index.js");
+var import_utils = require("@domql/utils");
+const SVG_NS = "http://www.w3.org/2000/svg";
+const createHTMLNode = (element) => {
+  const { tag, context } = element;
+  const doc = context.document || import_utils.document;
+  if (tag) {
+    if (tag === "string") return doc.createTextNode(element.text);
+    else if (tag === "fragment") {
+      return doc.createDocumentFragment();
+    } else if (import_utils.SVG_TAGS.has(tag)) {
+      if (tag === "svg" || element.parent?.node?.namespaceURI === SVG_NS) {
+        return doc.createElementNS(SVG_NS, tag);
+      }
+      return doc.createElement(tag);
+    } else return doc.createElement(tag);
+  } else {
+    return doc.createElement("div");
+  }
+};
+const detectTag = (element) => {
+  let { tag, key, props } = element;
+  tag = (0, import_utils.exec)(tag, element);
+  if (tag === true) tag = key;
+  if ((0, import_utils.isObject)(props) && (0, import_utils.isString)(props.tag)) {
+    const tagExists = (0, import_utils.isValidHtmlTag)(props.tag);
+    if (tagExists) return props.tag;
+  }
+  if ((0, import_utils.isString)(tag)) {
+    if ((0, import_utils.isValidHtmlTag)(tag)) return tag;
+  } else {
+    let keyAsTag = key.toLowerCase();
+    if (keyAsTag.includes(".")) keyAsTag = keyAsTag.split(".")[0];
+    if (keyAsTag.includes("_")) keyAsTag = keyAsTag.split("_")[0];
+    if ((0, import_utils.isValidHtmlTag)(keyAsTag)) return keyAsTag;
+  }
+  return "div";
+};
+const cacheNode = (element) => {
+  const { context } = element;
+  const win = context.window || window;
+  const tag = element.tag = detectTag(element);
+  if (!(0, import_event.canRenderTag)(tag)) {
+    return (0, import_report.report)("HTMLInvalidTag", element.tag, element);
+  }
+  if (!win.nodeCaches) win.nodeCaches = {};
+  const isSvgContext = import_utils.SVG_TAGS.has(tag) && (tag === "svg" || element.parent?.node?.namespaceURI === SVG_NS);
+  const cacheKey = isSvgContext ? "svg:" + tag : tag;
+  let cachedTag = win.nodeCaches[cacheKey];
+  if (!cachedTag) cachedTag = win.nodeCaches[cacheKey] = createHTMLNode(element);
+  const clonedNode = cachedTag.cloneNode(true);
+  if (tag === "string") clonedNode.nodeValue = element.text;
+  return clonedNode;
+};

package/dist/cjs/render/create.js

@@ -0,0 +1,25 @@
+"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 create_exports = {};
+__export(create_exports, {
+  createNode: () => createNode
+});
+module.exports = __toCommonJS(create_exports);
+const createNode = (element) => {
+};

package/dist/cjs/render/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var render_exports = {};
+module.exports = __toCommonJS(render_exports);
+__reExport(render_exports, require("./create.js"), module.exports);
+__reExport(render_exports, require("./cache.js"), module.exports);
+__reExport(render_exports, require("./append.js"), module.exports);

package/dist/cjs/set.js

@@ -30,7 +30,7 @@ __export(set_exports, {
 module.exports = __toCommonJS(set_exports);
 var import_utils = require("@domql/utils");
 var import_create = require("./create.js");
-var import_event = require("@domql/event");
+var import_event = require("./event/index.js");
 const setContentKey = (element, opts = {}) => {
   const { __ref: ref } = element;
   const contentElementKey = opts.contentElementKey;
@@ -39,49 +39,42 @@ const setContentKey = (element, opts = {}) => {
   }
   return ref.contentElementKey;
 };
-const reset = async (options) => {
-  const element = void 0;
-  await (0, import_create.create)(element, element.parent, void 0, {
+function reset(options) {
+  const element = this;
+  (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 resetContent = (params, element, opts) => {
   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 (element[contentElementKey]?.node) removeContent(element, 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 = {}) {
-  var _a;
   const element = el || this;
   const contentElementKey = setContentKey(element, opts);
   if (opts.contentElementKey !== "content") {
@@ -89,16 +82,17 @@ const removeContent = function(el, opts = {}) {
   }
   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 (content.tag === "fragment" && content.__ref?.__children) {
+    const __children = content.__ref.__children;
+    for (let i = 0; i < __children.length; i++) {
+      const child = content[__children[i]];
       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);
@@ -109,8 +103,7 @@ const removeContent = function(el, opts = {}) {
   }
   delete element[contentElementKey];
 };
-const set = async function(params, options = {}, el) {
-  var _a;
+const set = function(params, options = {}, el) {
   const element = el || this;
   const { __ref: ref } = element;
   const contentElementKey = setContentKey(element, options);
@@ -121,9 +114,9 @@ const set = async function(params, options = {}, el) {
   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 (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 +124,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;
   }
@@ -145,20 +138,20 @@ const set = async function(params, options = {}, el) {
       params.childExtends = element.childExtends;
       props.ignoreChildExtends = true;
     }
-    if (!(props == null ? void 0 : props.childProps) && ((_a = element.props) == null ? void 0 : _a.childProps)) {
+    if (!props?.childProps && element.props?.childProps) {
       props.childProps = element.props.childProps;
       props.ignoreChildProps = true;
     }
   }
   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;