@domql/element 2.31.25 → 2.31.27

package/create.js

@@ -26,7 +26,7 @@ import { applyAnimationFrame, triggerEventOn } from '@domql/event'
 import { assignNode } from '@domql/render'
 import { createState } from '@domql/state'
 
-import { isMethod } from './methods/index.js'
+import { error, isMethod } from './methods/index.js'
 import { createProps } from './props/index.js'
 import { applyExtend } from './extend.js'
 import { REGISTRY, registry } from './mixins/index.js'
@@ -52,6 +52,16 @@ export const create = async (
   options = OPTIONS.create || {},
   attachOptions
 ) => {
+  const isValid = validateElement(element, options)
+  if (!isValid) {
+    error.call(
+      element,
+      'Error while creating element: Not valid type',
+      element,
+      options
+    )
+    return
+  }
   cacheOptions(element, options)
 
   // if element is STRING
@@ -85,13 +95,13 @@ export const create = async (
 
   switchDefaultOptions(element, parent, options)
 
-  addCaching(element, parent)
+  addCaching(element, parent, options)
 
   addMethods(element, parent, options)
 
-  createScope(element, parent)
+  createScope(element, parent, options)
 
-  await createState(element, parent)
+  await createState(element, parent, options)
   if (element.scope === 'state') element.scope = element.state
 
   createIfConditionFlag(element, parent)
@@ -156,6 +166,14 @@ const createBasedOnType = (element, parent, key, options) => {
     return { extend: element }
   }
 
+  // Check if element was passed as node, reassign it to element.node
+  if (
+    (typeof Node !== 'undefined' && element instanceof Node) ||
+    (typeof DocumentFragment !== 'undefined' &&
+      element instanceof DocumentFragment)
+  )
+    return { node: element }
+
   return element
 }
 
@@ -193,6 +211,87 @@ const redefineParent = (element, parent, key, options) => {
   return parent
 }
 
+const validateElement = (value, options) => {
+  if (value == null) return false // null or undefined are not valid elements
+
+  // --- 1. Invalid primitive types
+  const t = typeof value
+  if (t === 'function' || t === 'symbol' || t === 'bigint') return false
+  if (Number.isNaN(value) || value === Infinity || value === -Infinity)
+    return false
+
+  // --- 2. Global / host objects
+  const unsafeGlobals = [
+    typeof window !== 'undefined' && window,
+    typeof document !== 'undefined' && document,
+    typeof globalThis !== 'undefined' && globalThis,
+    typeof navigator !== 'undefined' && navigator,
+    typeof location !== 'undefined' && location,
+    typeof history !== 'undefined' && history,
+    typeof screen !== 'undefined' && screen,
+    typeof frames !== 'undefined' && frames,
+    typeof parent !== 'undefined' && parent,
+    typeof self !== 'undefined' && self,
+    typeof top !== 'undefined' && top,
+    typeof performance !== 'undefined' && performance,
+    typeof console !== 'undefined' && console,
+    typeof indexedDB !== 'undefined' && indexedDB,
+    typeof caches !== 'undefined' && caches,
+    typeof localStorage !== 'undefined' && localStorage,
+    typeof sessionStorage !== 'undefined' && sessionStorage,
+    typeof crypto !== 'undefined' && crypto,
+    typeof visualViewport !== 'undefined' && visualViewport,
+    typeof customElements !== 'undefined' && customElements
+  ].filter(Boolean)
+
+  if (unsafeGlobals.includes(value)) return false
+
+  // --- 3. DOM node instances
+  // allow nodes in order to assign it in element.node
+  // if (typeof Node !== 'undefined' && value instanceof Node) return false
+  // if (typeof DocumentFragment !== 'undefined' && value instanceof DocumentFragment) return false
+  if (typeof EventTarget !== 'undefined' && value instanceof EventTarget)
+    return false
+  if (typeof Event !== 'undefined' && value instanceof Event) return false
+
+  // --- 4. Prototype / built-in objects
+  if (
+    value === Object.prototype ||
+    value === Array.prototype ||
+    value === Function.prototype ||
+    value === Map.prototype ||
+    value === Set.prototype ||
+    value === WeakMap.prototype ||
+    value === WeakSet.prototype ||
+    value === Promise.prototype ||
+    value === Symbol.prototype
+  )
+    return false
+
+  // --- 5. Platform API instances
+  const unsafeConstructors = [
+    typeof Worker !== 'undefined' && Worker,
+    typeof SharedWorker !== 'undefined' && SharedWorker,
+    typeof MessagePort !== 'undefined' && MessagePort,
+    typeof BroadcastChannel !== 'undefined' && BroadcastChannel,
+    typeof ReadableStream !== 'undefined' && ReadableStream,
+    typeof WritableStream !== 'undefined' && WritableStream,
+    typeof TransformStream !== 'undefined' && TransformStream,
+    typeof File !== 'undefined' && File,
+    typeof Blob !== 'undefined' && Blob,
+    typeof FormData !== 'undefined' && FormData,
+    typeof XMLHttpRequest !== 'undefined' && XMLHttpRequest,
+    typeof AbortController !== 'undefined' && AbortController,
+    typeof AbortSignal !== 'undefined' && AbortSignal
+  ].filter(Boolean)
+
+  for (const Ctor of unsafeConstructors) {
+    if (value instanceof Ctor) return false
+  }
+
+  return true
+}
+
 const cacheOptions = (element, options) => {
   if (options && !OPTIONS.create) {
     OPTIONS.create = options
@@ -252,7 +351,7 @@ const renderElement = async (element, parent, options, attachOptions) => {
         path.splice(0, path.indexOf('ComponentsGrid') + 2)
       if (path.includes('demoComponent'))
         path.splice(0, path.indexOf('demoComponent') + 1)
-      const isDemoComponent = element.lookup(el => el.state.key)?.state?.key
+      const isDemoComponent = element.lookup((el) => el.state.key)?.state?.key
       element.warn(
         'Error happened in:',
         isDemoComponent ? isDemoComponent + ' ' : '' + path.join('.')
@@ -297,7 +396,7 @@ const renderElement = async (element, parent, options, attachOptions) => {
   await triggerEventOn('create', element, options)
 }
 
-const checkIfPrimitive = element => is(element)('string', 'number')
+const checkIfPrimitive = (element) => is(element)('string', 'number')
 
 const applyValueAsText = (element, parent, key) => {
   const extendTag = element.extend && element.extend.tag
@@ -395,7 +494,7 @@ const onlyResolveExtends = async (element, parent, key, options) => {
 
     createScope(element, parent)
 
-    createState(element, parent)
+    createState(element, parent, options)
     if (element.scope === 'state') element.scope = element.state
 
     createIfConditionFlag(element, parent)
@@ -460,7 +559,7 @@ const onlyResolveExtends = async (element, parent, key, options) => {
   return element
 }
 
-const checkIfMedia = key => key.slice(0, 1) === '@'
+const checkIfMedia = (key) => key.slice(0, 1) === '@'
 
 const applyMediaProps = (element, parent, key) => {
   const { props } = element

package/dist/cjs/create.js

@@ -38,58 +38,68 @@ var import_iterate = require("./iterate.js");
 var import_options = require("./cache/options.js");
 var import_component = require("./utils/component.js");
 var import_env = require("@domql/utils/env.js");
-const create = async (element, parent, key, options = import_options.OPTIONS.create || {}, attachOptions) => {
+const create = async (element, parent2, key, options = import_options.OPTIONS.create || {}, attachOptions) => {
+  const isValid = validateElement(element, options);
+  if (!isValid) {
+    import_methods.error.call(
+      element,
+      "Error while creating element: Not valid type",
+      element,
+      options
+    );
+    return;
+  }
   cacheOptions(element, options);
   if (checkIfPrimitive(element)) {
-    element = applyValueAsText(element, parent, key);
+    element = applyValueAsText(element, parent2, key);
   }
-  element = redefineElement(element, parent, key, options);
-  parent = redefineParent(element, parent, key);
-  key = createKey(element, parent, key);
-  const ref = addRef(element, parent, key);
+  element = redefineElement(element, parent2, key, options);
+  parent2 = redefineParent(element, parent2, key);
+  key = createKey(element, parent2, key);
+  const ref = addRef(element, parent2, key);
   ref.__initialProps = (0, import_utils.deepClone)(element.props);
-  applyContext(element, parent, options);
-  (0, import_utils.applyComponentFromContext)(element, parent, options);
+  applyContext(element, parent2, options);
+  (0, import_utils.applyComponentFromContext)(element, parent2, options);
   if (!ref.__skipCreate) {
-    (0, import_extend.applyExtend)(element, parent, options);
+    (0, import_extend.applyExtend)(element, parent2, options);
   }
   element.key = key;
   if (options.onlyResolveExtends) {
-    return await onlyResolveExtends(element, parent, key, options);
+    return await onlyResolveExtends(element, parent2, key, options);
   }
   await (0, import_event.triggerEventOn)("start", element, options);
-  switchDefaultOptions(element, parent, options);
-  addCaching(element, parent);
-  (0, import_set.addMethods)(element, parent, options);
-  createScope(element, parent);
-  await (0, import_state.createState)(element, parent);
+  switchDefaultOptions(element, parent2, options);
+  addCaching(element, parent2, options);
+  (0, import_set.addMethods)(element, parent2, options);
+  createScope(element, parent2, options);
+  await (0, import_state.createState)(element, parent2, options);
   if (element.scope === "state") element.scope = element.state;
-  createIfConditionFlag(element, parent);
-  (0, import_props.createProps)(element, parent, options);
+  createIfConditionFlag(element, parent2);
+  (0, import_props.createProps)(element, parent2, options);
   if (element.scope === "props" || element.scope === true)
     element.scope = element.props;
-  createIfConditionFlag(element, parent);
+  createIfConditionFlag(element, parent2);
   if (element.node && ref.__if) {
-    return (0, import_render.assignNode)(element, parent, key, attachOptions);
+    return (0, import_render.assignNode)(element, parent2, key, attachOptions);
   }
-  (0, import_component.applyVariant)(element, parent);
-  (0, import_utils.addChildrenIfNotInOriginal)(element, parent, key);
+  (0, import_component.applyVariant)(element, parent2);
+  (0, import_utils.addChildrenIfNotInOriginal)(element, parent2, key);
   const onInit = await (0, import_event.triggerEventOn)("init", element, options);
   if (onInit === false) return element;
   await (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   (0, import_classList.assignKeyAsClassname)(element);
-  await renderElement(element, parent, options, attachOptions);
-  addElementIntoParentChildren(element, parent);
+  await renderElement(element, parent2, options, attachOptions);
+  addElementIntoParentChildren(element, parent2);
   await (0, import_event.triggerEventOn)("complete", element, options);
   return element;
 };
-const createBasedOnType = (element, parent, key, options) => {
+const createBasedOnType = (element, parent2, key, options) => {
   if (element === void 0) {
     if ((0, import_env.isNotProduction)()) {
       console.warn(
         key,
         "element is undefined in",
-        parent && parent.__ref && parent.__ref.path
+        parent2 && parent2.__ref && parent2.__ref.path
       );
     }
     return {};
@@ -104,30 +114,86 @@ const createBasedOnType = (element, parent, key, options) => {
   if (element.__hash) {
     return { extend: element };
   }
+  if (typeof Node !== "undefined" && element instanceof Node || typeof DocumentFragment !== "undefined" && element instanceof DocumentFragment)
+    return { node: element };
   return element;
 };
-const redefineElement = (element, parent, key, options) => {
-  const elementWrapper = createBasedOnType(element, parent, key, options);
-  if (options.syntaxv3 || element.props && element.props.syntaxv3 || parent && parent.props && parent.props.syntaxv3) {
+const redefineElement = (element, parent2, key, options) => {
+  const elementWrapper = createBasedOnType(element, parent2, key, options);
+  if (options.syntaxv3 || element.props && element.props.syntaxv3 || parent2 && parent2.props && parent2.props.syntaxv3) {
     if (element.props) element.props.syntaxv3 = true;
     else element.syntaxv3 = true;
-    return (0, import_component.createValidDomqlObjectFromSugar)(element, parent, key, options);
+    return (0, import_component.createValidDomqlObjectFromSugar)(element, parent2, key, options);
   } else if ((0, import_utils.checkIfKeyIsComponent)(key)) {
-    return (0, import_utils.applyKeyComponentAsExtend)(elementWrapper, parent, key);
+    return (0, import_utils.applyKeyComponentAsExtend)(elementWrapper, parent2, key);
   }
   if (checkIfMedia(key)) {
-    return applyMediaProps(elementWrapper, parent, key);
+    return applyMediaProps(elementWrapper, parent2, key);
   }
   return elementWrapper;
 };
-const redefineParent = (element, parent, key, options) => {
-  if (!parent) return import_tree.ROOT;
-  if ((0, import_utils.isNode)(parent)) {
-    const parentNodeWrapper = { key: ":root", node: parent };
+const redefineParent = (element, parent2, key, options) => {
+  if (!parent2) return import_tree.ROOT;
+  if ((0, import_utils.isNode)(parent2)) {
+    const parentNodeWrapper = { key: ":root", node: parent2 };
     import_tree.ROOT[`${key}_parent`] = parentNodeWrapper;
     return parentNodeWrapper;
   }
-  return parent;
+  return parent2;
+};
+const validateElement = (value, options) => {
+  if (value == null) return false;
+  const t = typeof value;
+  if (t === "function" || t === "symbol" || t === "bigint") return false;
+  if (Number.isNaN(value) || value === Infinity || value === -Infinity)
+    return false;
+  const unsafeGlobals = [
+    typeof window !== "undefined" && window,
+    typeof document !== "undefined" && document,
+    typeof globalThis !== "undefined" && globalThis,
+    typeof navigator !== "undefined" && navigator,
+    typeof location !== "undefined" && location,
+    typeof history !== "undefined" && history,
+    typeof screen !== "undefined" && screen,
+    typeof frames !== "undefined" && frames,
+    typeof parent !== "undefined" && parent,
+    typeof self !== "undefined" && self,
+    typeof top !== "undefined" && top,
+    typeof performance !== "undefined" && performance,
+    typeof console !== "undefined" && console,
+    typeof indexedDB !== "undefined" && indexedDB,
+    typeof caches !== "undefined" && caches,
+    typeof localStorage !== "undefined" && localStorage,
+    typeof sessionStorage !== "undefined" && sessionStorage,
+    typeof crypto !== "undefined" && crypto,
+    typeof visualViewport !== "undefined" && visualViewport,
+    typeof customElements !== "undefined" && customElements
+  ].filter(Boolean);
+  if (unsafeGlobals.includes(value)) return false;
+  if (typeof EventTarget !== "undefined" && value instanceof EventTarget)
+    return false;
+  if (typeof Event !== "undefined" && value instanceof Event) return false;
+  if (value === Object.prototype || value === Array.prototype || value === Function.prototype || value === Map.prototype || value === Set.prototype || value === WeakMap.prototype || value === WeakSet.prototype || value === Promise.prototype || value === Symbol.prototype)
+    return false;
+  const unsafeConstructors = [
+    typeof Worker !== "undefined" && Worker,
+    typeof SharedWorker !== "undefined" && SharedWorker,
+    typeof MessagePort !== "undefined" && MessagePort,
+    typeof BroadcastChannel !== "undefined" && BroadcastChannel,
+    typeof ReadableStream !== "undefined" && ReadableStream,
+    typeof WritableStream !== "undefined" && WritableStream,
+    typeof TransformStream !== "undefined" && TransformStream,
+    typeof File !== "undefined" && File,
+    typeof Blob !== "undefined" && Blob,
+    typeof FormData !== "undefined" && FormData,
+    typeof XMLHttpRequest !== "undefined" && XMLHttpRequest,
+    typeof AbortController !== "undefined" && AbortController,
+    typeof AbortSignal !== "undefined" && AbortSignal
+  ].filter(Boolean);
+  for (const Ctor of unsafeConstructors) {
+    if (value instanceof Ctor) return false;
+  }
+  return true;
 };
 const cacheOptions = (element, options) => {
   if (options && !import_options.OPTIONS.create) {
@@ -135,26 +201,26 @@ const cacheOptions = (element, options) => {
     import_options.OPTIONS.create.context = element.context || options.context;
   }
 };
-const createKey = (element, parent, key) => {
+const createKey = (element, parent2, key) => {
   return ((0, import_utils.exec)(key, element) || key || element.key || (0, import_utils.generateKey)()).toString();
 };
-const addRef = (element, parent) => {
+const addRef = (element, parent2) => {
   if (element.__ref) element.__ref.origin = element;
   else element.__ref = { origin: element };
   return element.__ref;
 };
-const switchDefaultOptions = (element, parent, options) => {
+const switchDefaultOptions = (element, parent2, options) => {
   if (Object.keys(options).length) {
     import_mixins.registry.defaultOptions = options;
     if (options.ignoreChildExtend) delete options.ignoreChildExtend;
   }
 };
-const addElementIntoParentChildren = (element, parent) => {
-  if (parent.__ref && parent.__ref.__children)
-    parent.__ref.__children.push(element.key);
+const addElementIntoParentChildren = (element, parent2) => {
+  if (parent2.__ref && parent2.__ref.__children)
+    parent2.__ref.__children.push(element.key);
 };
 const visitedElements = /* @__PURE__ */ new WeakMap();
-const renderElement = async (element, parent, options, attachOptions) => {
+const renderElement = async (element, parent2, options, attachOptions) => {
   var _a, _b, _c, _d;
   if (visitedElements.has(element)) {
     if ((0, import_env.isNotProduction)())
@@ -199,10 +265,10 @@ const renderElement = async (element, parent, options, attachOptions) => {
     }
   }
   if (!ref.__if) {
-    parent[key || element.key] = element;
+    parent2[key || element.key] = element;
     return element;
   }
-  (0, import_render.assignNode)(element, parent, key, attachOptions);
+  (0, import_render.assignNode)(element, parent2, key, attachOptions);
   (0, import_event.applyAnimationFrame)(element, options);
   await (0, import_event.triggerEventOn)("render", element, options);
   await (0, import_event.triggerEventOn)("renderRouter", element, options);
@@ -210,35 +276,35 @@ const renderElement = async (element, parent, options, attachOptions) => {
   await (0, import_event.triggerEventOn)("create", element, options);
 };
 const checkIfPrimitive = (element) => (0, import_utils.is)(element)("string", "number");
-const applyValueAsText = (element, parent, key) => {
+const applyValueAsText = (element, parent2, key) => {
   const extendTag = element.extend && element.extend.tag;
-  const childExtendTag = parent.childExtend && parent.childExtend.tag;
-  const childPropsTag = parent.props.childProps && parent.props.childProps.tag;
+  const childExtendTag = parent2.childExtend && parent2.childExtend.tag;
+  const childPropsTag = parent2.props.childProps && parent2.props.childProps.tag;
   const isKeyValidHTMLTag = import_utils.HTML_TAGS.body.indexOf(key) > -1 && key;
   return {
     text: element,
     tag: extendTag || childExtendTag || childPropsTag || isKeyValidHTMLTag || "string"
   };
 };
-const applyContext = (element, parent, options) => {
+const applyContext = (element, parent2, options) => {
   const forcedOptionsContext = options.context && !import_tree.ROOT.context && !element.context;
   if (forcedOptionsContext) import_tree.ROOT.context = options.context;
   if (!element.context)
-    element.context = parent.context || options.context || import_tree.ROOT.context;
+    element.context = parent2.context || options.context || import_tree.ROOT.context;
 };
-const createScope = (element, parent) => {
+const createScope = (element, parent2) => {
   const { __ref: ref } = element;
-  if (!element.scope) element.scope = parent.scope || ref.root.scope || {};
+  if (!element.scope) element.scope = parent2.scope || ref.root.scope || {};
 };
-const createIfConditionFlag = (element, parent) => {
+const createIfConditionFlag = (element, parent2) => {
   const { __ref: ref } = element;
   if ((0, import_utils.isFunction)(element.if) && !element.if(element, element.state, element.context)) {
     delete ref.__if;
   } else ref.__if = true;
 };
-const addCaching = (element, parent) => {
+const addCaching = (element, parent2) => {
   const { __ref: ref, key } = element;
-  let { __ref: parentRef } = parent;
+  let { __ref: parentRef } = parent2;
   if (!element.transform) element.transform = {};
   if (!ref.__cached) ref.__cached = {};
   if (!ref.__defineCache) ref.__defineCache = {};
@@ -251,30 +317,30 @@ const addCaching = (element, parent) => {
   if (!ref.__children) ref.__children = [];
   if ((0, import_utils.checkIfKeyIsComponent)(key))
     ref.__componentKey = key.split("_")[0].split(".")[0].split("+")[0];
-  const hasRoot = parent && parent.key === ":root";
+  const hasRoot = parent2 && parent2.key === ":root";
   if (!ref.root) ref.root = hasRoot ? element : parentRef.root;
-  if (!parentRef) parentRef = parent.ref = {};
+  if (!parentRef) parentRef = parent2.ref = {};
   if (!parentRef.path) parentRef.path = [];
   ref.path = parentRef.path.concat(element.key);
 };
-const onlyResolveExtends = async (element, parent, key, options) => {
+const onlyResolveExtends = async (element, parent2, key, options) => {
   const { __ref: ref } = element;
   if (!ref.__skipCreate) {
-    addCaching(element, parent);
-    (0, import_set.addMethods)(element, parent, options);
-    createScope(element, parent);
-    (0, import_state.createState)(element, parent);
+    addCaching(element, parent2);
+    (0, import_set.addMethods)(element, parent2, options);
+    createScope(element, parent2);
+    (0, import_state.createState)(element, parent2, options);
     if (element.scope === "state") element.scope = element.state;
-    createIfConditionFlag(element, parent);
-    (0, import_props.createProps)(element, parent, options);
+    createIfConditionFlag(element, parent2);
+    (0, import_props.createProps)(element, parent2, options);
     if (element.scope === "props" || element.scope === true)
       element.scope = element.props;
     if (element.node && ref.__if) {
-      parent[key || element.key] = element;
+      parent2[key || element.key] = element;
     }
     if (!element.props) element.props = {};
-    (0, import_component.applyVariant)(element, parent);
-    addElementIntoParentChildren(element, parent);
+    (0, import_component.applyVariant)(element, parent2);
+    addElementIntoParentChildren(element, parent2);
   }
   if (element.tag !== "string" && element.tag !== "fragment") {
     await (0, import_iterate.throughInitialDefine)(element);
@@ -292,7 +358,7 @@ const onlyResolveExtends = async (element, parent, key, options) => {
       }
     }
   }
-  parent[key || element.key] = element;
+  parent2[key || element.key] = element;
   delete element.update;
   delete element.__element;
   if (element.props) {
@@ -302,7 +368,7 @@ const onlyResolveExtends = async (element, parent, key, options) => {
   return element;
 };
 const checkIfMedia = (key) => key.slice(0, 1) === "@";
-const applyMediaProps = (element, parent, key) => {
+const applyMediaProps = (element, parent2, key) => {
   const { props } = element;
   if (props) {
     props.display = "none";

package/dist/cjs/iterate.js

@@ -71,6 +71,8 @@ const throughExecProps = (element) => {
   const { props } = element;
   for (const k in props) {
     const isDefine = k.startsWith("is") || k.startsWith("has") || k.startsWith("use");
+    if (!ref.__execProps)
+      return import_methods.warn.call(element, "Element was not initiated to execute props");
     const cachedExecProp = ref.__execProps[k];
     if ((0, import_utils.isFunction)(cachedExecProp)) {
       props[k] = (0, import_utils.exec)(cachedExecProp, element);

package/dist/cjs/methods/index.js

@@ -99,6 +99,12 @@ function lookdown(param) {
       );
     if (v === param) return childElem;
     else if ((0, import_utils.isFunction)(param)) {
+      if (!childElem) {
+        this.error(
+          `"${v}" found in element __children, but content is not defined`
+        );
+        continue;
+      }
       const exec = param(childElem, childElem.state, childElem.context);
       if (childElem.state && exec) {
         return childElem;
@@ -119,6 +125,12 @@ function lookdownAll(param, results = []) {
     const childElem = el[v];
     if (v === param) results.push(childElem);
     else if ((0, import_utils.isFunction)(param)) {
+      if (!childElem) {
+        this.error(
+          `"${v}" found in element __children, but content is not defined`
+        );
+        continue;
+      }
       const exec = param(childElem, childElem.state, childElem.context);
       if (childElem.state && exec) results.push(childElem);
     }
@@ -138,7 +150,7 @@ function setNodeStyles(params = {}) {
   }
   return el;
 }
-async function remove(opts) {
+async function remove(opts = {}) {
   const element = this;
   const beforeRemoveReturns = (0, import_event.triggerEventOn)("beforeRemove", element, opts);
   if (beforeRemoveReturns === false) return element;
@@ -159,10 +171,10 @@ function get(param) {
   const element = this;
   return element[param];
 }
-function setProps(param, options) {
+function setProps(param, opts = {}) {
   const element = this;
   if (!param || !element.props) return;
-  element.update({ props: param }, options);
+  element.update({ props: param }, opts);
   return element;
 }
 function getRef(key) {
@@ -253,9 +265,11 @@ function warn(...params) {
   console.warn(...params, this);
 }
 function error(...params) {
-  var _a, _b;
+  var _a, _b, _c, _d;
   if ((_a = params[params.length - 1]) == null ? void 0 : _a.debugger) debugger;
   if ((_b = params[params.length - 1]) == null ? void 0 : _b.verbose) verbose.call(this, ...params);
+  if ((0, import_utils.isFunction)((_c = params[params.length - 1]) == null ? void 0 : _c.onError))
+    (_d = params[params.length - 1]) == null ? void 0 : _d.onError.call(this, ...params);
   console.error(...params, this);
 }
 function nextElement() {
@@ -266,8 +280,8 @@ function nextElement() {
   const nextChild = __children[currentIndex + 1];
   return parent[nextChild];
 }
-async function append(el, key) {
-  return await (0, import_create.create)(el, this, key);
+async function append(el, key, opts) {
+  return await (0, import_create.create)(el, this, key, opts);
 }
 function previousElement(el) {
   const element = el || this;
@@ -318,8 +332,8 @@ function call(fnKey, ...args) {
     }
     return result;
   } catch (error2) {
-    console.error(`Error calling '${fnKey}':`, error2);
-    throw error2;
+    console.error(`Error calling '${fnKey}'`);
+    throw new Error(error2);
   }
 }
 const METHODS = [

package/dist/cjs/mixins/content.js

@@ -56,7 +56,7 @@ const removeContent = function(el, opts = {}) {
       else if (__cached[contentElementKey] && (0, import_utils.isFunction)(__cached[contentElementKey].remove))
         __cached[contentElementKey].remove();
     }
-    ref.__children.splice(ref.__children.indexOf(element[contentElementKey]), 1);
+    ref.__children.splice(ref.__children.indexOf(contentElementKey), 1);
     delete element[contentElementKey];
   }
 };

package/dist/cjs/node.js

@@ -57,11 +57,15 @@ const createNode = async (element, options) => {
       (0, import_event.applyEventsOnNode)(element, options);
     }
   }
-  for (const param in element) {
+  const keys = Object.keys(element);
+  for (const param of keys) {
     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;
+    if (param === "onClick") {
+      debugger;
+    }
     const isElement = await (0, import_applyParam.applyParam)(param, element, options);
     if (!isElement) continue;
     const { hasDefine, hasContextDefine } = isElement;