@domql/element 3.2.3 → 3.2.8

package/dist/cjs/event/store.js

@@ -0,0 +1,27 @@
+"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 store_exports = {};
+__export(store_exports, {
+  default: () => store_default
+});
+module.exports = __toCommonJS(store_exports);
+var store_default = {
+  click: [],
+  render: []
+};

package/dist/cjs/extend.js

@@ -27,8 +27,8 @@ let mainExtend;
 const applyExtend = (element, parent, options = {}) => {
   if ((0, import_utils.isFunction)(element)) element = (0, import_utils.exec)(element, parent);
   const { props, __ref } = element;
-  let extend = (props == null ? void 0 : props.extends) || element.extends || element.extend;
-  const variant = props == null ? void 0 : props.variant;
+  let extend = props?.extends || element.extends || element.extend;
+  const variant = props?.variant;
   const context = element.context || parent.context;
   extend = (0, import_utils2.fallbackStringExtend)(extend, context, options, variant);
   const extendStack = (0, import_utils2.getExtendStack)(extend, context);
@@ -36,9 +36,9 @@ const applyExtend = (element, parent, options = {}) => {
   let childExtendStack = [];
   if (parent) {
     element.parent = parent;
-    if (!options.ignoreChildExtend && !(props && props.ignoreChildExtend)) {
+    if (!options.ignoreChildExtend && !props?.ignoreChildExtend) {
       childExtendStack = (0, import_utils2.getExtendStack)(parent.childExtend, context);
-      const ignoreChildExtendRecursive = props && props.ignoreChildExtendRecursive;
+      const ignoreChildExtendRecursive = props?.ignoreChildExtendRecursive;
       if (parent.childExtendRecursive && !ignoreChildExtendRecursive) {
         const canExtendRecursive = element.key !== "__text";
         if (canExtendRecursive) {
@@ -75,9 +75,9 @@ const applyExtend = (element, parent, options = {}) => {
   }
   if (__ref) __ref.__extend = stack;
   let mergedExtend = (0, import_utils2.cloneAndMergeArrayExtend)(stack);
-  const COMPONENTS = context && context.components || options.components;
+  const COMPONENTS = context?.components || options.components;
   const component = (0, import_utils.exec)(element.component || mergedExtend.component, element);
-  if (component && COMPONENTS && COMPONENTS[component]) {
+  if (component && COMPONENTS?.[component]) {
     const componentExtend = (0, import_utils2.cloneAndMergeArrayExtend)(
       (0, import_utils2.getExtendStack)(COMPONENTS[component])
     );

package/dist/cjs/index.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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-
@@ -36,9 +37,11 @@ __export(index_exports, {
   update: () => import_update.default
 });
 module.exports = __toCommonJS(index_exports);
-var import_tree = require("./tree");
-var import_create = __toESM(require("./create"), 1);
-var import_node = __toESM(require("./node"), 1);
-var import_define = __toESM(require("./define"), 1);
-var import_update = __toESM(require("./update"), 1);
-var import_set = __toESM(require("./set"), 1);
+var import_tree = require("./tree.js");
+var import_create = __toESM(require("./create.js"), 1);
+var import_node = __toESM(require("./node.js"), 1);
+var import_define = __toESM(require("./define.js"), 1);
+var import_update = __toESM(require("./update.js"), 1);
+var import_set = __toESM(require("./set.js"), 1);
+__reExport(index_exports, require("./event/index.js"), module.exports);
+__reExport(index_exports, require("./render/index.js"), module.exports);

package/dist/cjs/iterate.js

@@ -18,7 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var iterate_exports = {};
 __export(iterate_exports, {
-  isPropertyInDefines: () => isPropertyInDefines,
   throughExecProps: () => throughExecProps,
   throughInitialDefine: () => throughInitialDefine,
   throughInitialExec: () => throughInitialExec,
@@ -60,7 +59,7 @@ const throughUpdatedExec = (element, options = {}) => {
       continue;
     }
     const execReturnsString = (0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec);
-    if (prop && prop.node && execReturnsString) {
+    if (prop?.node && execReturnsString) {
       (0, import_utils.overwrite)(prop, { text: newExec });
     } else if (newExec !== prop) {
       if ((0, import_utils.matchesComponentNaming)(param)) {
@@ -82,7 +81,11 @@ 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 c0 = k.charCodeAt(0);
+    const c1 = k.charCodeAt(1);
+    const isDefine = c0 === 105 && c1 === 115 || // 'is'
+    c0 === 104 && c1 === 97 && k.charCodeAt(2) === 115 || // 'has'
+    c0 === 117 && c1 === 115 && k.charCodeAt(2) === 101;
     const cachedExecProp = ref.__execProps[k];
     if ((0, import_utils.isFunction)(cachedExecProp)) {
       const result = (0, import_utils.exec)(cachedExecProp, element);
@@ -106,14 +109,12 @@ const throughExecProps = (element) => {
     }
   }
 };
-const isPropertyInDefines = (key, element) => {
-};
 const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element;
-  let defineObj = {};
+  const hasLocalDefine = (0, import_utils.isObject)(define);
   const hasGlobalDefine = context && (0, import_utils.isObject)(context.define);
-  if ((0, import_utils.isObject)(define)) defineObj = { ...define };
-  if (hasGlobalDefine) defineObj = { ...defineObj, ...context.define };
+  if (!hasLocalDefine && !hasGlobalDefine) return element;
+  const defineObj = hasLocalDefine && hasGlobalDefine ? { ...define, ...context.define } : hasLocalDefine ? define : context.define;
   for (const param in defineObj) {
     let elementProp = element[param];
     if ((0, import_utils.isFunction)(elementProp) && !(0, import_utils.isMethod)(param, element)) {
@@ -151,10 +152,10 @@ const throughInitialDefine = (element) => {
 };
 const throughUpdatedDefine = (element) => {
   const { context, define, __ref: ref } = element;
-  const changes = {};
-  let obj = {};
-  if ((0, import_utils.isObject)(define)) obj = { ...define };
-  if ((0, import_utils.isObject)(context && context.define)) obj = { ...obj, ...context.define };
+  const hasLocalDefine = (0, import_utils.isObject)(define);
+  const hasGlobalDefine = (0, import_utils.isObject)(context?.define);
+  if (!hasLocalDefine && !hasGlobalDefine) return;
+  const obj = hasLocalDefine && hasGlobalDefine ? { ...define, ...context.define } : hasLocalDefine ? define : context.define;
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam) {
@@ -182,5 +183,4 @@ const throughUpdatedDefine = (element) => {
       element[param] = newExecParam;
     }
   }
-  return changes;
 };

package/dist/cjs/methods/set.js

@@ -40,6 +40,11 @@ const addMethods = (element, parent, options = {}) => {
     lookdownAll: import_methods.lookdownAll,
     getRef: import_methods.getRef,
     getPath: import_methods.getPath,
+    getRootState: import_methods.getRootState,
+    getRoot: import_methods.getRoot,
+    getRootData: import_methods.getRootData,
+    getRootContext: import_methods.getRootContext,
+    getContext: import_methods.getContext,
     setNodeStyles: import_methods.setNodeStyles,
     spotByPath: import_methods.spotByPath,
     parse: import_methods.parse,

package/dist/cjs/methods/v2.js

@@ -73,7 +73,7 @@ const log = function(...args) {
     args.forEach((v) => console.log(`%c${v}:
 `, "font-weight: bold", element[v]));
   } else {
-    console.log(__ref == null ? void 0 : __ref.path);
+    console.log(__ref?.path);
     const keys2 = element.keys();
     keys2.forEach((v) => console.log(`%c${v}:
 `, "font-weight: bold", element[v]));

package/dist/cjs/mixins/attr.js

@@ -27,13 +27,14 @@ var import_report = require("@domql/report");
 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)(params)("object")) (0, import_report.report)("HTMLInvalidAttr", params);
   if (params) {
     const attrs = (0, import_utils.exec)(params, element);
     if (props.attr) (0, import_utils.deepMerge)(attrs, props.attr);
     for (const attr2 in attrs) {
       const val = (0, import_utils.exec)(attrs[attr2], element);
-      if (val !== false && !(0, import_utils.isUndefined)(val) && !(0, import_utils.isNull)(val) && node.setAttribute) {
+      if (val === __attr[attr2]) continue;
+      if (val !== false && val !== void 0 && val !== null && node.setAttribute) {
         node.setAttribute(attr2, val);
       } else if (node.removeAttribute) node.removeAttribute(attr2);
       __attr[attr2] = val;

package/dist/cjs/mixins/classList.js

@@ -57,7 +57,17 @@ const classList = (params, element) => {
 };
 const applyClassListOnNode = (params, element, node) => {
   const className = classList(params, element);
-  node.classList = className;
+  const { __ref } = element;
+  if (className === __ref.__className) return className;
+  __ref.__className = className;
+  if (node && typeof node.setAttribute === "function") {
+    node.setAttribute("class", className);
+  } else if (node) {
+    try {
+      node.className = className;
+    } catch (e) {
+    }
+  }
   return className;
 };
 function applyClasslist(params, element, node) {

package/dist/cjs/mixins/content.js

@@ -60,10 +60,9 @@ const removeContent = function(el, opts = {}) {
   }
 };
 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) {
+    if (element[contentElementKey]?.update) {
       element[contentElementKey].update({}, opts);
     } else {
       import_set.set.call(element, param, opts);

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)(((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.html) || param, 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/state.js

@@ -27,8 +27,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_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

@@ -31,7 +31,11 @@ function text(param, element, node) {
   }
   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;

package/dist/cjs/node.js

@@ -33,15 +33,16 @@ __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 ENV = process.env.NODE_ENV;
 const createNode = (element, opts) => {
   let { node, tag, __ref: ref } = element;
   if (!ref.__if) return element;
@@ -60,10 +61,12 @@ const createNode = (element, 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 = (0, import_applyParam.applyParam)(param, element, opts);
@@ -84,7 +87,7 @@ const createNode = (element, opts) => {
       }
     }
   }
-  const content = element.children ? (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) {
     (0, import_set.setContent)(content, element, opts);
   }

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,19 +39,18 @@ const setContentKey = (element, opts = {}) => {
   }
   return ref.contentElementKey;
 };
-const reset = (options) => {
-  const element = 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 = (params, element, opts) => {
-  var _a;
   const contentElementKey = setContentKey(element, opts);
-  if ((_a = element[contentElementKey]) == null ? void 0 : _a.node) removeContent(element, opts);
+  if (element[contentElementKey]?.node) removeContent(element, opts);
   const contentElem = (0, import_create.create)(params, element, contentElementKey || "content", {
     ignoreChildExtends: true,
     ...import_utils.OPTIONS.defaultOptions,
@@ -76,7 +75,6 @@ function setContent(param, element, opts) {
   }
 }
 const removeContent = function(el, opts = {}) {
-  var _a;
   const element = el || this;
   const contentElementKey = setContentKey(element, opts);
   if (opts.contentElementKey !== "content") {
@@ -84,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);
@@ -105,7 +104,6 @@ const removeContent = function(el, opts = {}) {
   delete element[contentElementKey];
 };
 const set = function(params, options = {}, el) {
-  var _a;
   const element = el || this;
   const { __ref: ref } = element;
   const contentElementKey = setContentKey(element, options);
@@ -116,7 +114,7 @@ const set = 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 = (0, import_event.triggerEventOnUpdate)(
         "beforeUpdate",
@@ -140,7 +138,7 @@ const set = 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;
     }