domql 1.6.39 → 1.6.41

package/dist/cjs/element/utils/extendUtils.js

@@ -0,0 +1,142 @@
+"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 extendUtils_exports = {};
+__export(extendUtils_exports, {
+  cloneAndMergeArrayExtend: () => cloneAndMergeArrayExtend,
+  deepCloneExtend: () => deepCloneExtend,
+  deepExtend: () => deepExtend,
+  deepMergeExtend: () => deepMergeExtend,
+  extendCachedRegistry: () => extendCachedRegistry,
+  extendStackRegistry: () => extendStackRegistry,
+  extractArrayExtend: () => extractArrayExtend,
+  flattenExtend: () => flattenExtend,
+  generateHash: () => generateHash,
+  getExtendMerged: () => getExtendMerged,
+  getExtendStack: () => getExtendStack,
+  getExtendStackRegistry: () => getExtendStackRegistry,
+  getHashedExtend: () => getHashedExtend,
+  jointStacks: () => jointStacks,
+  replaceStringsWithComponents: () => replaceStringsWithComponents,
+  setHashedExtend: () => setHashedExtend
+});
+module.exports = __toCommonJS(extendUtils_exports);
+var import_utils = require("@domql/utils");
+const generateHash = () => Math.random().toString(36).substring(2);
+const extendStackRegistry = {};
+const extendCachedRegistry = {};
+const getHashedExtend = (extend) => {
+  return extendStackRegistry[extend.__hash];
+};
+const setHashedExtend = (extend, stack) => {
+  const hash = generateHash();
+  extend.__hash = hash;
+  extendStackRegistry[hash] = stack;
+  return stack;
+};
+const getExtendStackRegistry = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend(extend));
+  }
+  return setHashedExtend(extend, stack);
+};
+const extractArrayExtend = (extend, stack) => {
+  extend.forEach((each) => flattenExtend(each, stack));
+  return stack;
+};
+const deepExtend = (extend, stack) => {
+  const extendOflattenExtend = extend.extend;
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack);
+  }
+  return stack;
+};
+const flattenExtend = (extend, stack) => {
+  if (!extend)
+    return stack;
+  if ((0, import_utils.isArray)(extend))
+    return extractArrayExtend(extend, stack);
+  stack.push(extend);
+  if (extend.extend)
+    deepExtend(extend, stack);
+  return stack;
+};
+const deepCloneExtend = (obj) => {
+  const o = {};
+  for (const prop in obj) {
+    if (["parent", "node", "__element"].indexOf(prop) > -1)
+      continue;
+    const objProp = obj[prop];
+    if ((0, import_utils.isObject)(objProp)) {
+      o[prop] = deepCloneExtend(objProp);
+    } else if ((0, import_utils.isArray)(objProp)) {
+      o[prop] = objProp.map((x) => x);
+    } else
+      o[prop] = objProp;
+  }
+  return o;
+};
+const deepMergeExtend = (element, extend) => {
+  for (const e in extend) {
+    if (["parent", "node", "__element"].indexOf(e) > -1)
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if ((0, import_utils.isObject)(elementProp) && (0, import_utils.isObject)(extendProp)) {
+      deepMergeExtend(elementProp, extendProp);
+    } else if ((0, import_utils.isArray)(elementProp) && (0, import_utils.isArray)(extendProp)) {
+      element[e] = elementProp.concat(extendProp);
+    } else if ((0, import_utils.isArray)(elementProp) && (0, import_utils.isObject)(extendProp)) {
+      const obj = deepMergeExtend({}, elementProp);
+      element[e] = deepMergeExtend(obj, extendProp);
+    } else if (elementProp === void 0 && (0, import_utils.isFunction)(extendProp)) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+const cloneAndMergeArrayExtend = (stack) => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend(a, deepCloneExtend(c));
+  }, {});
+};
+const replaceStringsWithComponents = (stack, components) => {
+  return stack.map((v) => {
+    if ((0, import_utils.isString)(v))
+      return components[v];
+    else
+      return v;
+  });
+};
+const jointStacks = (extendStack, childExtendStack) => {
+  return [].concat(extendStack.slice(0, 1)).concat(childExtendStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendStack.slice(1));
+};
+const getExtendStack = (extend) => {
+  if (!extend)
+    return [];
+  if (extend.__hash)
+    return getHashedExtend(extend) || [];
+  const stack = flattenExtend(extend, []);
+  return getExtendStackRegistry(extend, stack);
+};
+const getExtendMerged = (extend) => {
+  const stack = getExtendStack(extend);
+  return cloneAndMergeArrayExtend(stack);
+};

package/dist/cjs/element/utils/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 utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./object"), module.exports);
+__reExport(utils_exports, require("./extendUtils"), module.exports);
+__reExport(utils_exports, require("./component"), module.exports);

package/dist/cjs/element/utils/object.js

@@ -0,0 +1,142 @@
+"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 object_exports = {};
+__export(object_exports, {
+  METHODS_EXL: () => METHODS_EXL,
+  clone: () => clone,
+  deepClone: () => deepClone,
+  deepMerge: () => deepMerge,
+  flattenRecursive: () => flattenRecursive,
+  mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+  mergeArray: () => mergeArray,
+  mergeIfExisted: () => mergeIfExisted,
+  overwrite: () => overwrite,
+  overwriteDeep: () => overwriteDeep,
+  overwriteShallow: () => overwriteShallow
+});
+module.exports = __toCommonJS(object_exports);
+var import_utils = require("@domql/utils");
+var import_state = require("@domql/state");
+var import_props = require("@domql/props");
+var import_methods = require("@domql/methods");
+const METHODS_EXL = (0, import_utils.joinArrays)(
+  ["node", "state", "context", "extend"],
+  import_methods.METHODS,
+  import_state.IGNORE_STATE_PARAMS,
+  import_props.IGNORE_PROPS_PARAMS
+);
+const deepMerge = (element, extend, exclude = METHODS_EXL) => {
+  for (const e in extend) {
+    if (exclude.includes(e))
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if ((0, import_utils.isObjectLike)(elementProp) && (0, import_utils.isObject)(extendProp)) {
+      deepMerge(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+const clone = (obj, exclude = METHODS_EXL) => {
+  const o = {};
+  for (const e in obj) {
+    if (exclude.includes(e))
+      continue;
+    o[e] = obj[e];
+  }
+  return o;
+};
+const deepClone = (obj, exclude = METHODS_EXL) => {
+  const o = (0, import_utils.isArray)(obj) ? [] : {};
+  for (const e in obj) {
+    if (exclude.includes(e))
+      continue;
+    let objProp = obj[e];
+    if (e === "extend" && (0, import_utils.isArray)(objProp)) {
+      objProp = mergeArray(objProp, exclude);
+    }
+    if ((0, import_utils.isObjectLike)(objProp)) {
+      o[e] = deepClone(objProp, exclude);
+    } else
+      o[e] = objProp;
+  }
+  return o;
+};
+const overwrite = (element, params, options) => {
+  const changes = {};
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  for (const e in params) {
+    if (e === "props" || e === "state" || e === "__ref")
+      continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp !== void 0) {
+      __cached[e] = changes[e] = elementProp;
+      element[e] = paramsProp;
+    }
+    if (options.cleanExec)
+      delete __exec[e];
+  }
+  return changes;
+};
+const overwriteShallow = (obj, params, exclude = METHODS_EXL) => {
+  for (const e in params) {
+    if (exclude.includes(e))
+      continue;
+    obj[e] = params[e];
+  }
+  return obj;
+};
+const overwriteDeep = (obj, params, exclude = METHODS_EXL) => {
+  for (const e in params) {
+    if (exclude.includes(e))
+      continue;
+    const objProp = obj[e];
+    const paramsProp = params[e];
+    if ((0, import_utils.isObjectLike)(objProp) && (0, import_utils.isObjectLike)(paramsProp)) {
+      overwriteDeep(objProp, paramsProp);
+    } else if (paramsProp !== void 0) {
+      obj[e] = paramsProp;
+    }
+  }
+  return obj;
+};
+const mergeIfExisted = (a, b) => {
+  if ((0, import_utils.isObjectLike)(a) && (0, import_utils.isObjectLike)(b))
+    return deepMerge(a, b);
+  return a || b;
+};
+const mergeArray = (arr, exclude = ["parent", "node", "__element", "state", "context", "__ref"]) => {
+  return arr.reduce((a, c) => deepMerge(a, deepClone(c, exclude)), {});
+};
+const mergeAndCloneIfArray = (obj) => {
+  return (0, import_utils.isArray)(obj) ? mergeArray(obj) : deepClone(obj);
+};
+const flattenRecursive = (param, prop, stack = []) => {
+  const objectized = mergeAndCloneIfArray(param);
+  stack.push(objectized);
+  const extendOfExtend = objectized[prop];
+  if (extendOfExtend)
+    flattenRecursive(extendOfExtend, prop, stack);
+  delete objectized[prop];
+  return stack;
+};

package/dist/esm/element/applyParam.js

@@ -4095,7 +4095,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4112,9 +4112,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils9.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4616,7 +4616,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props3.createProps)(element, parent);
-  (0, import_state3.createState)(element, parent, { skip: true });
+  (0, import_state3.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/element/create.js

@@ -4035,7 +4035,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4052,9 +4052,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils7.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4811,7 +4811,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props4.createProps)(element, parent);
-  (0, import_state5.createState)(element, parent, { skip: true });
+  (0, import_state5.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/element/define.js

@@ -4095,7 +4095,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4112,9 +4112,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils9.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4635,7 +4635,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props3.createProps)(element, parent);
-  (0, import_state3.createState)(element, parent, { skip: true });
+  (0, import_state3.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/element/index.js

@@ -4038,7 +4038,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4055,9 +4055,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils7.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4800,7 +4800,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props4.createProps)(element, parent);
-  (0, import_state5.createState)(element, parent, { skip: true });
+  (0, import_state5.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/element/iterate.js

@@ -2647,7 +2647,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -2664,9 +2664,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils6.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }

package/dist/esm/element/methods.js

@@ -4095,7 +4095,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4112,9 +4112,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils9.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4555,7 +4555,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props3.createProps)(element, parent);
-  (0, import_state3.createState)(element, parent, { skip: true });
+  (0, import_state3.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/element/node.js

@@ -4159,7 +4159,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4176,9 +4176,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils12.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4765,7 +4765,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props4.createProps)(element, parent);
-  (0, import_state5.createState)(element, parent, { skip: true });
+  (0, import_state5.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/element/parse.js

@@ -4038,7 +4038,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4055,9 +4055,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils7.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4811,7 +4811,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props4.createProps)(element, parent);
-  (0, import_state5.createState)(element, parent, { skip: true });
+  (0, import_state5.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/element/set.js

@@ -4068,7 +4068,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4085,9 +4085,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils8.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4788,7 +4788,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props4.createProps)(element, parent);
-  (0, import_state5.createState)(element, parent, { skip: true });
+  (0, import_state5.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/element/update.js

@@ -4042,7 +4042,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4059,9 +4059,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils7.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4628,7 +4628,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props3.createProps)(element, parent);
-  (0, import_state4.createState)(element, parent, { skip: true });
+  (0, import_state4.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/esm/index.js

@@ -4042,7 +4042,7 @@ var throughInitialDefine = (element) => {
         ref.__defineCache[param] = elementProp;
       }
     }
-    const execParam = defineObj[param](elementProp, element, element.state);
+    const execParam = defineObj[param](elementProp, element, element.state, element.context);
     if (execParam)
       element[param] = execParam;
   }
@@ -4059,9 +4059,9 @@ var throughUpdatedDefine = (element) => {
   for (const param in obj) {
     const execParam = ref.__exec[param];
     if (execParam)
-      ref.__defineCache[param] = execParam(element, element.state);
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = (0, import_utils7.exec)(ref.__defineCache[param], element);
-    const newExecParam = obj[param](cached, element, element.state);
+    const newExecParam = obj[param](cached, element, element.state, element.context);
     if (newExecParam)
       element[param] = newExecParam;
   }
@@ -4804,7 +4804,7 @@ var resolveExtends = (element, parent, options) => {
   if (!element.state)
     element.state = {};
   element = (0, import_props4.createProps)(element, parent);
-  (0, import_state5.createState)(element, parent, { skip: true });
+  (0, import_state5.createState)(element, parent, { skipApplyMethods: true });
   applyVariant(element, parent);
   throughInitialExec(element, options.propsExcludedFromExec);
   for (const param in element) {

package/dist/iife/index.js

@@ -4044,7 +4044,7 @@ ${element}` : ""
           ref.__defineCache[param] = elementProp;
         }
       }
-      const execParam = defineObj[param](elementProp, element, element.state);
+      const execParam = defineObj[param](elementProp, element, element.state, element.context);
       if (execParam)
         element[param] = execParam;
     }
@@ -4061,9 +4061,9 @@ ${element}` : ""
     for (const param in obj) {
       const execParam = ref.__exec[param];
       if (execParam)
-        ref.__defineCache[param] = execParam(element, element.state);
+        ref.__defineCache[param] = execParam(element, element.state, element.context);
       const cached = (0, import_utils7.exec)(ref.__defineCache[param], element);
-      const newExecParam = obj[param](cached, element, element.state);
+      const newExecParam = obj[param](cached, element, element.state, element.context);
       if (newExecParam)
         element[param] = newExecParam;
     }
@@ -4806,7 +4806,7 @@ ${element}` : ""
     if (!element.state)
       element.state = {};
     element = (0, import_props4.createProps)(element, parent);
-    (0, import_state5.createState)(element, parent, { skip: true });
+    (0, import_state5.createState)(element, parent, { skipApplyMethods: true });
     applyVariant(element, parent);
     throughInitialExec(element, options.propsExcludedFromExec);
     for (const param in element) {