@domql/element 2.5.200 → 2.5.205

package/dist/esm/create.js

@@ -59,17 +59,20 @@ const create = async (element, parent, key, options = OPTIONS.create || {}, atta
   addMethods(element, parent, options);
   createScope(element, parent);
   await createState(element, parent);
-  if (element.scope === "state") element.scope = element.state;
+  if (element.scope === "state")
+    element.scope = element.state;
   createIfConditionFlag(element, parent);
   createProps(element, parent, options);
-  if (element.scope === "props" || element.scope === true) element.scope = element.props;
+  if (element.scope === "props" || element.scope === true)
+    element.scope = element.props;
   createIfConditionFlag(element, parent);
   if (element.node && ref.__if) {
     return assignNode(element, parent, key, attachOptions);
   }
   applyVariant(element, parent);
   const onInit = await triggerEventOn("init", element, options);
-  if (onInit === false) return element;
+  if (onInit === false)
+    return element;
   triggerEventOn("beforeClassAssign", element, options);
   assignKeyAsClassname(element);
   addChildrenIfNotInOriginal(element, parent, key);
@@ -80,18 +83,20 @@ const create = async (element, parent, key, options = OPTIONS.create || {}, atta
 };
 const createBasedOnType = (element, parent, key, options) => {
   if (element === void 0) {
-    if (ENV === "test" || ENV === "development") {
+    if (ENV === "testing" || ENV === "development") {
       console.warn(key, "element is undefined in", parent && parent.__ref && parent.__ref.path);
     }
     return {};
   }
-  if (isString(key) && key.slice(0, false)) {
-    if (ENV === "test" || ENV === "development") {
+  if (isString(key) && key.slice(0, 2 === "__")) {
+    if (ENV === "testing" || ENV === "development") {
       console.warn(key, "seems like to be in __ref");
     }
   }
-  if (element === null) return;
-  if (element === true) return { text: true };
+  if (element === null)
+    return;
+  if (element === true)
+    return { text: true };
   if (element.__hash) {
     return { extend: element };
   }
@@ -100,8 +105,10 @@ const createBasedOnType = (element, parent, key, options) => {
 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) {
-    if (element.props) element.props.syntaxv3 = true;
-    else element.syntaxv3 = true;
+    if (element.props)
+      element.props.syntaxv3 = true;
+    else
+      element.syntaxv3 = true;
     return createValidDomqlObjectFromSugar(element, parent, key, options);
   } else if (checkIfKeyIsComponent(key)) {
     return applyKeyComponentAsExtend(elementWrapper, parent, key);
@@ -112,7 +119,8 @@ const redefineElement = (element, parent, key, options) => {
   return elementWrapper;
 };
 const redefineParent = (element, parent, key, options) => {
-  if (!parent) return ROOT;
+  if (!parent)
+    return ROOT;
   if (isNode(parent)) {
     const parentNodeWrapper = { key: ":root", node: parent };
     ROOT[`${key}_parent`] = parentNodeWrapper;
@@ -130,48 +138,58 @@ const createKey = (element, parent, key) => {
   return (exec(key, element) || key || element.key || generateKey()).toString();
 };
 const addRef = (element, parent) => {
-  if (element.__ref) element.__ref.origin = element;
-  else element.__ref = { origin: element };
+  if (element.__ref)
+    element.__ref.origin = element;
+  else
+    element.__ref = { origin: element };
   return element.__ref;
 };
 const switchDefaultOptions = (element, parent, options) => {
   if (Object.keys(options).length) {
     registry.defaultOptions = options;
-    if (options.ignoreChildExtend) delete options.ignoreChildExtend;
+    if (options.ignoreChildExtend)
+      delete options.ignoreChildExtend;
   }
 };
 const addElementIntoParentChildren = (element, parent) => {
-  if (parent.__ref && parent.__ref.__children) parent.__ref.__children.push(element.key);
+  if (parent.__ref && parent.__ref.__children)
+    parent.__ref.__children.push(element.key);
 };
 const visitedElements = /* @__PURE__ */ new WeakMap();
 const renderElement = async (element, parent, options, attachOptions) => {
   var _a, _b, _c, _d;
   if (visitedElements.has(element)) {
-    if (ENV === "test" || ENV === "development") console.warn("Cyclic rendering detected:", element.__ref.path);
+    if (ENV === "testing" || ENV === "development")
+      console.warn("Cyclic rendering detected:", element.__ref.path);
   }
   visitedElements.set(element, true);
   const { __ref: ref, key } = element;
   const createNestedChild = async () => {
     const isInfiniteLoopDetected = detectInfiniteLoop(ref.path);
-    if (ref.__uniqId || isInfiniteLoopDetected) return;
+    if (ref.__uniqId || isInfiniteLoopDetected)
+      return;
     await createNode(element, options);
     ref.__uniqId = Math.random();
   };
-  if (ENV === "test" || ENV === "development") {
+  if (ENV === "testing" || ENV === "development") {
     await createNestedChild();
   } else {
     try {
       await createNestedChild();
     } catch (e) {
       const path = ref.path;
-      if (path.includes("ComponentsGrid")) path.splice(0, path.indexOf("ComponentsGrid") + 2);
-      if (path.includes("demoComponent")) path.splice(0, path.indexOf("demoComponent") + 1);
+      if (path.includes("ComponentsGrid"))
+        path.splice(0, path.indexOf("ComponentsGrid") + 2);
+      if (path.includes("demoComponent"))
+        path.splice(0, path.indexOf("demoComponent") + 1);
       const isDemoComponent = (_b = (_a = element.lookup((el) => el.state.key)) == null ? void 0 : _a.state) == null ? void 0 : _b.key;
       element.warn("Error happened in:", isDemoComponent ? isDemoComponent + " " : "" + path.join("."));
       element.verbose();
       element.error(e, options);
-      if ((_c = element.on) == null ? void 0 : _c.error) element.on.error(e, element, element.state, element.context, options);
-      if ((_d = element.props) == null ? void 0 : _d.onError) element.props.onError(e, element, element.state, element.context, options);
+      if ((_c = element.on) == null ? void 0 : _c.error)
+        element.on.error(e, element, element.state, element.context, options);
+      if ((_d = element.props) == null ? void 0 : _d.onError)
+        element.props.onError(e, element, element.state, element.context, options);
     }
   }
   if (!ref.__if) {
@@ -198,37 +216,55 @@ const applyValueAsText = (element, parent, key) => {
 };
 const applyContext = (element, parent, options) => {
   const forcedOptionsContext = options.context && !ROOT.context && !element.context;
-  if (forcedOptionsContext) ROOT.context = options.context;
-  if (!element.context) element.context = parent.context || options.context || ROOT.context;
+  if (forcedOptionsContext)
+    ROOT.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || ROOT.context;
 };
 const createScope = (element, parent) => {
   const { __ref: ref } = element;
-  if (!element.scope) element.scope = parent.scope || ref.root.scope || {};
+  if (!element.scope)
+    element.scope = parent.scope || ref.root.scope || {};
 };
 const createIfConditionFlag = (element, parent) => {
   const { __ref: ref } = element;
   if (isFunction(element.if) && !element.if(element, element.state, element.context)) {
     delete ref.__if;
-  } else ref.__if = true;
+  } else
+    ref.__if = true;
 };
 const addCaching = (element, parent) => {
   const { __ref: ref, key } = element;
   let { __ref: parentRef } = parent;
-  if (!element.transform) element.transform = {};
-  if (!ref.__cached) ref.__cached = {};
-  if (!ref.__defineCache) ref.__defineCache = {};
-  if (!ref.__exec) ref.__exec = {};
-  if (!ref.__execProps) ref.__execProps = {};
-  if (!ref.__class) ref.__class = {};
-  if (!ref.__classNames) ref.__classNames = {};
-  if (!ref.__attr) ref.__attr = {};
-  if (!ref.__changes) ref.__changes = [];
-  if (!ref.__children) ref.__children = [];
-  if (checkIfKeyIsComponent(key)) ref.__componentKey = key.split("_")[0].split(".")[0].split("+")[0];
+  if (!element.transform)
+    element.transform = {};
+  if (!ref.__cached)
+    ref.__cached = {};
+  if (!ref.__defineCache)
+    ref.__defineCache = {};
+  if (!ref.__exec)
+    ref.__exec = {};
+  if (!ref.__execProps)
+    ref.__execProps = {};
+  if (!ref.__class)
+    ref.__class = {};
+  if (!ref.__classNames)
+    ref.__classNames = {};
+  if (!ref.__attr)
+    ref.__attr = {};
+  if (!ref.__changes)
+    ref.__changes = [];
+  if (!ref.__children)
+    ref.__children = [];
+  if (checkIfKeyIsComponent(key))
+    ref.__componentKey = key.split("_")[0].split(".")[0].split("+")[0];
   const hasRoot = parent && parent.key === ":root";
-  if (!ref.root) ref.root = hasRoot ? element : parentRef.root;
-  if (!parentRef) parentRef = parent.ref = {};
-  if (!parentRef.path) parentRef.path = [];
+  if (!ref.root)
+    ref.root = hasRoot ? element : parentRef.root;
+  if (!parentRef)
+    parentRef = parent.ref = {};
+  if (!parentRef.path)
+    parentRef.path = [];
   ref.path = parentRef.path.concat(element.key);
 };
 const onlyResolveExtends = (element, parent, key, options) => {
@@ -238,14 +274,17 @@ const onlyResolveExtends = (element, parent, key, options) => {
     addMethods(element, parent, options);
     createScope(element, parent);
     createState(element, parent);
-    if (element.scope === "state") element.scope = element.state;
+    if (element.scope === "state")
+      element.scope = element.state;
     createIfConditionFlag(element, parent);
     createProps(element, parent, options);
-    if (element.scope === "props" || element.scope === true) element.scope = element.props;
+    if (element.scope === "props" || element.scope === true)
+      element.scope = element.props;
     if (element.node && ref.__if) {
       parent[key || element.key] = element;
     }
-    if (!element.props) element.props = {};
+    if (!element.props)
+      element.props = {};
     applyVariant(element, parent);
     addElementIntoParentChildren(element, parent);
   }
@@ -253,7 +292,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
     throughInitialDefine(element);
     throughInitialExec(element);
     for (const k in element) {
-      if (isUndefined(element[k]) || isMethod(k, element) || isObject((registry.default || registry)[k]) || isVariant(k)) continue;
+      if (isUndefined(element[k]) || isMethod(k, element) || isObject((registry.default || registry)[k]) || isVariant(k))
+        continue;
       const hasDefine = element.define && element.define[k];
       const contextHasDefine = element.context && element.context.define && element.context.define[k];
       const optionsHasDefine = options.define && options.define[k];
@@ -278,8 +318,10 @@ const applyMediaProps = (element, parent, key) => {
   const { props } = element;
   if (props) {
     props.display = "none";
-    if (props[key]) props[key].display = props.display;
-    else props[key] = { display: props.display || "block" };
+    if (props[key])
+      props[key].display = props.display;
+    else
+      props[key] = { display: props.display || "block" };
     return element;
   } else {
     return {

package/dist/esm/define.js

@@ -5,7 +5,8 @@ var define_default = (params, options = {}) => {
   for (const param in params) {
     if (REGISTRY[param] && !overwrite) {
       report("OverwriteToBuiltin", param);
-    } else REGISTRY[param] = params[param];
+    } else
+      REGISTRY[param] = params[param];
   }
 };
 export {

package/dist/esm/extend.js

@@ -9,14 +9,16 @@ import {
 const ENV = "development";
 let mainExtend;
 const applyExtend = (element, parent, options = {}) => {
-  if (isFunction(element)) element = exec(element, parent);
+  if (isFunction(element))
+    element = 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;
   const context = element.context || parent.context;
   extend = fallbackStringExtend(extend, context, options, variant);
   const extendStack = getExtendStack(extend, context);
-  if (ENV !== "test" || ENV !== "development") delete element.extend;
+  if (ENV !== "test" || ENV !== "development")
+    delete element.extend;
   let childExtendStack = [];
   if (parent) {
     element.parent = parent;
@@ -42,7 +44,8 @@ const applyExtend = (element, parent, options = {}) => {
     stack = extendStack;
   } else if (childExtendLength) {
     stack = childExtendStack;
-  } else if (!context.defaultExtends) return element;
+  } else if (!context.defaultExtends)
+    return element;
   if (context.defaultExtends) {
     if (!mainExtend) {
       const defaultOptionsExtend = getExtendStack(context.defaultExtends, context);
@@ -51,7 +54,8 @@ const applyExtend = (element, parent, options = {}) => {
     }
     stack = [].concat(stack, mainExtend);
   }
-  if (__ref) __ref.__extend = stack;
+  if (__ref)
+    __ref.__extend = stack;
   let mergedExtend = cloneAndMergeArrayExtend(stack);
   const COMPONENTS = context && context.components || options.components;
   const component = exec(element.component || mergedExtend.component, element);

package/dist/esm/iterate.js

@@ -13,7 +13,8 @@ import { isMethod } from "./methods/index.js";
 const throughInitialExec = (element, exclude = {}) => {
   const { __ref: ref } = element;
   for (const param in element) {
-    if (exclude[param]) continue;
+    if (exclude[param])
+      continue;
     const prop = element[param];
     if (isFunction(prop) && !isMethod(param, element) && !isVariant(param)) {
       ref.__exec[param] = prop;
@@ -27,7 +28,8 @@ const throughUpdatedExec = (element, options = { excludes: METHODS_EXL }) => {
   for (const param in ref.__exec) {
     const prop = element[param];
     const isDefinedParam = ref.__defineCache[param];
-    if (isDefinedParam) continue;
+    if (isDefinedParam)
+      continue;
     const newExec = ref.__exec[param](element, element.state, element.context);
     const execReturnsString = isString(newExec) || isNumber(newExec);
     if (prop && prop.node && execReturnsString) {
@@ -62,8 +64,10 @@ const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
   const hasGlobalDefine = context && isObject(context.define);
-  if (isObject(define)) defineObj = { ...define };
-  if (hasGlobalDefine) defineObj = { ...defineObj, ...context.define };
+  if (isObject(define))
+    defineObj = { ...define };
+  if (hasGlobalDefine)
+    defineObj = { ...defineObj, ...context.define };
   for (const param in defineObj) {
     let elementProp = element[param];
     if (isFunction(elementProp) && !isMethod(param, element) && !isVariant(param)) {
@@ -75,7 +79,8 @@ const throughInitialDefine = (element) => {
       }
     }
     const execParam = defineObj[param](elementProp, element, element.state, element.context);
-    if (execParam) element[param] = execParam;
+    if (execParam)
+      element[param] = execParam;
   }
   return element;
 };
@@ -83,14 +88,18 @@ const throughUpdatedDefine = (element) => {
   const { context, define, __ref: ref } = element;
   const changes = {};
   let obj = {};
-  if (isObject(define)) obj = { ...define };
-  if (isObject(context && context.define)) obj = { ...obj, ...context.define };
+  if (isObject(define))
+    obj = { ...define };
+  if (isObject(context && context.define))
+    obj = { ...obj, ...context.define };
   for (const param in obj) {
     const execParam = ref.__exec[param];
-    if (execParam) ref.__defineCache[param] = execParam(element, element.state, element.context);
+    if (execParam)
+      ref.__defineCache[param] = execParam(element, element.state, element.context);
     const cached = exec(ref.__defineCache[param], element);
     const newExecParam = obj[param](cached, element, element.state, element.context);
-    if (newExecParam) element[param] = newExecParam;
+    if (newExecParam)
+      element[param] = newExecParam;
   }
   return changes;
 };

package/dist/esm/methods/index.js

@@ -7,12 +7,15 @@ function spotByPath(path) {
   const element = this;
   const arr = [].concat(path);
   let active = TREE[arr[0]];
-  if (!arr || !arr.length) return console.log(arr, "on", element.key, "is undefined");
+  if (!arr || !arr.length)
+    return console.log(arr, "on", element.key, "is undefined");
   while (active.key === arr[0]) {
     arr.shift();
-    if (!arr.length) break;
+    if (!arr.length)
+      break;
     active = active[arr[0]];
-    if (!active) return;
+    if (!active)
+      return;
   }
   return active;
 }
@@ -20,15 +23,21 @@ function lookup(param) {
   const el = this;
   let { parent } = el;
   if (isFunction(param)) {
-    if (parent.state && param(parent, parent.state, parent.context)) return parent;
-    else if (parent.parent) return parent.lookup(param);
-    else return;
+    if (parent.state && param(parent, parent.state, parent.context))
+      return parent;
+    else if (parent.parent)
+      return parent.lookup(param);
+    else
+      return;
   }
-  if (el[param]) return el[param];
+  if (el[param])
+    return el[param];
   while (parent.param !== param) {
-    if (parent[param]) return parent[param];
+    if (parent[param])
+      return parent[param];
     parent = parent.parent;
-    if (!parent) return;
+    if (!parent)
+      return;
   }
   return parent;
 }
@@ -40,7 +49,8 @@ function lookdown(param) {
   for (let i = 0; i < children.length; i++) {
     const v = children[i];
     const childElem = el[v];
-    if (v === param) return childElem;
+    if (v === param)
+      return childElem;
     else if (isFunction(param)) {
       const exec = param(childElem, childElem.state, childElem.context);
       if (childElem.state && exec) {
@@ -48,7 +58,8 @@ function lookdown(param) {
       }
     }
     const lookdown2 = (_a = childElem == null ? void 0 : childElem.lookdown) == null ? void 0 : _a.call(childElem, param);
-    if (lookdown2) return lookdown2;
+    if (lookdown2)
+      return lookdown2;
   }
 }
 function lookdownAll(param, results = []) {
@@ -59,10 +70,12 @@ function lookdownAll(param, results = []) {
   for (let i = 0; i < children.length; i++) {
     const v = children[i];
     const childElem = el[v];
-    if (v === param) results.push(childElem);
+    if (v === param)
+      results.push(childElem);
     else if (isFunction(param)) {
       const exec = param(childElem, childElem.state, childElem.context);
-      if (childElem.state && exec) results.push(childElem);
+      if (childElem.state && exec)
+        results.push(childElem);
     }
     (_a = childElem == null ? void 0 : childElem.lookdownAll) == null ? void 0 : _a.call(childElem, param, results);
   }
@@ -71,26 +84,32 @@ function lookdownAll(param, results = []) {
 function setNodeStyles(params = {}) {
   var _a;
   const el = this;
-  if (!((_a = el.node) == null ? void 0 : _a.style)) return;
+  if (!((_a = el.node) == null ? void 0 : _a.style))
+    return;
   for (const param in params) {
     const value = params[param];
     const childElem = el[param];
-    if (isObject(value) && childElem) setNodeStyles.call(childElem, value);
-    else el.node.style[param] = value;
+    if (isObject(value) && childElem)
+      setNodeStyles.call(childElem, value);
+    else
+      el.node.style[param] = value;
   }
   return el;
 }
 function remove(opts) {
   const element = this;
   const beforeRemoveReturns = triggerEventOn("beforeRemove", element, opts);
-  if (beforeRemoveReturns === false) return element;
-  if (isFunction(element.node.remove)) element.node.remove();
+  if (beforeRemoveReturns === false)
+    return element;
+  if (isFunction(element.node.remove))
+    element.node.remove();
   else if (!isProduction()) {
     console.warn("This item cant be removed");
     element.log();
   }
   delete element.parent[element.key];
-  if (element.parent.__ref) element.parent.__ref.__children = removeValueFromArray(element.parent.__ref.__children, element.key);
+  if (element.parent.__ref)
+    element.parent.__ref.__children = removeValueFromArray(element.parent.__ref.__children, element.key);
   triggerEventOn("remove", element, opts);
 }
 function get(param) {
@@ -99,7 +118,8 @@ function get(param) {
 }
 function setProps(param, options) {
   const element = this;
-  if (!param || !element.props) return;
+  if (!param || !element.props)
+    return;
   element.update({ props: param }, options);
   return element;
 }
@@ -126,19 +146,23 @@ function parse(excl = []) {
   const obj = {};
   const keyList = keys.call(element);
   keyList.forEach((v) => {
-    if (excl.includes(v)) return;
+    if (excl.includes(v))
+      return;
     const val = element[v];
     if (v === "state") {
-      if (element.__ref && !element.__ref.__hasRootState) return;
+      if (element.__ref && !element.__ref.__hasRootState)
+        return;
       const parsedVal = isFunction(val && val.parse) ? val.parse() : val;
       obj[v] = isFunction(parsedVal) ? parsedVal : JSON.parse(JSON.stringify(parsedVal || {}));
     } else if (v === "scope") {
-      if (element.__ref && !element.__ref.__hasRootScope) return;
+      if (element.__ref && !element.__ref.__hasRootScope)
+        return;
       obj[v] = JSON.parse(JSON.stringify(val || {}));
     } else if (v === "props") {
       const { __element, update, ...props } = element[v];
       obj[v] = props;
-    } else if (isDefined(val) && Object.hasOwnProperty.call(element, v)) obj[v] = val;
+    } else if (isDefined(val) && Object.hasOwnProperty.call(element, v))
+      obj[v] = val;
   });
   return obj;
 }
@@ -146,7 +170,8 @@ function parseDeep(excl = []) {
   const element = this;
   const obj = parse.call(element, excl);
   for (const v in obj) {
-    if (excl.includes(v)) return;
+    if (excl.includes(v))
+      return;
     if (isObjectLike(obj[v])) {
       obj[v] = parseDeep.call(obj[v], excl);
     }
@@ -154,7 +179,8 @@ function parseDeep(excl = []) {
   return obj;
 }
 function verbose(...args) {
-  if (ENV !== "test" && ENV !== "development") return;
+  if (ENV !== "test" && ENV !== "development")
+    return;
   const element = this;
   const { __ref: ref } = element;
   console.groupCollapsed(element.key);
@@ -171,20 +197,22 @@ function verbose(...args) {
   return element;
 }
 function log(...params) {
-  if (ENV === "test" || ENV === "development") {
+  if (ENV === "testing" || ENV === "development") {
     console.log(...params);
   }
 }
 function warn(...params) {
-  if (ENV === "test" || ENV === "development") {
+  if (ENV === "testing" || ENV === "development") {
     console.warn(...params);
   }
 }
 function error(...params) {
   var _a, _b;
-  if (ENV === "test" || ENV === "development") {
-    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);
+  if (ENV === "testing" || ENV === "development") {
+    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);
     throw new Error(...params);
   }
 }
@@ -200,14 +228,17 @@ function previousElement(el) {
   const element = el || this;
   const { key, parent } = element;
   const { __children } = parent.__ref;
-  if (!__children) return;
+  if (!__children)
+    return;
   const currentIndex = __children.indexOf(key);
   return parent[__children[currentIndex - 1]];
 }
 function variables(obj = {}) {
   const element = this;
-  if (!element.data) element.data = {};
-  if (!element.data.varCaches) element.data.varCaches = {};
+  if (!element.data)
+    element.data = {};
+  if (!element.data.varCaches)
+    element.data.varCaches = {};
   const varCaches = element.data.varCaches;
   const changes = {};
   let changed;
@@ -219,7 +250,8 @@ function variables(obj = {}) {
   }
   return {
     changed: (cb) => {
-      if (!changed) return;
+      if (!changed)
+        return;
       const returns = cb(changes, deepClone(varCaches));
       for (const key in changes) {
         varCaches[key] = changes[key];
@@ -227,7 +259,8 @@ function variables(obj = {}) {
       return returns;
     },
     timeout: (cb, timeout) => {
-      if (!changed) return;
+      if (!changed)
+        return;
       const t = setTimeout(() => {
         cb(changes);
         clearTimeout(t);

package/dist/esm/methods/set.js

@@ -52,7 +52,8 @@ const addMethods = (element, parent, options = {}) => {
     error,
     call
   };
-  if (element.context.methods) (options.strict ? merge : overwrite)(proto, element.context.methods);
+  if (element.context.methods)
+    (options.strict ? merge : overwrite)(proto, element.context.methods);
   Object.setPrototypeOf(element, proto);
 };
 export {

package/dist/esm/methods/v2.js

@@ -17,15 +17,19 @@ const parse = function(excl = []) {
   const obj = {};
   const keyList = keys.call(element);
   keyList.forEach((v) => {
-    if (excl.includes(v)) return;
+    if (excl.includes(v))
+      return;
     let val = element[v];
     if (v === "state") {
-      if (element.__ref && element.__ref.__hasRootState) return;
-      if (isFunction(val && val.parse)) val = val.parse();
+      if (element.__ref && element.__ref.__hasRootState)
+        return;
+      if (isFunction(val && val.parse))
+        val = val.parse();
     } else if (v === "props") {
       const { __element, update, ...props } = element[v];
       obj[v] = props;
-    } else if (isDefined(val)) obj[v] = val;
+    } else if (isDefined(val))
+      obj[v] = val;
   });
   return obj;
 };
@@ -33,7 +37,8 @@ const parseDeep = function(excl = []) {
   const element = this;
   const obj = parse.call(element, excl);
   for (const v in obj) {
-    if (excl.includes(v)) return;
+    if (excl.includes(v))
+      return;
     if (isObjectLike(obj[v])) {
       obj[v] = parseDeep.call(obj[v], excl);
     }
@@ -68,7 +73,8 @@ const previousElement = function(el) {
   const element = el || this;
   const { key, parent } = element;
   const { __children } = parent.__ref;
-  if (!__children) return;
+  if (!__children)
+    return;
   const currentIndex = __children.indexOf(key);
   return parent[__children[currentIndex - 1]];
 };