@domql/element 2.5.203 → 2.5.206

package/dist/cjs/create.js

@@ -63,20 +63,17 @@ const create = async (element, parent, key, options = import_options.OPTIONS.cre
   (0, import_set.addMethods)(element, parent, options);
   createScope(element, parent);
   await (0, import_state.createState)(element, parent);
-  if (element.scope === "state")
-    element.scope = element.state;
+  if (element.scope === "state") element.scope = element.state;
   createIfConditionFlag(element, parent);
   (0, import_props.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 (0, import_render.assignNode)(element, parent, key, attachOptions);
   }
   (0, import_component.applyVariant)(element, parent);
   const onInit = await (0, import_event.triggerEventOn)("init", element, options);
-  if (onInit === false)
-    return element;
+  if (onInit === false) return element;
   (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   (0, import_classList.assignKeyAsClassname)(element);
   (0, import_utils.addChildrenIfNotInOriginal)(element, parent, key);
@@ -92,15 +89,13 @@ const createBasedOnType = (element, parent, key, options) => {
     }
     return {};
   }
-  if ((0, import_utils.isString)(key) && key.slice(0, 2 === "__")) {
+  if ((0, import_utils.isString)(key) && key.slice(0, false)) {
     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 };
   }
@@ -109,10 +104,8 @@ 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 (0, import_component.createValidDomqlObjectFromSugar)(element, parent, key, options);
   } else if ((0, import_utils.checkIfKeyIsComponent)(key)) {
     return (0, import_utils.applyKeyComponentAsExtend)(elementWrapper, parent, key);
@@ -123,8 +116,7 @@ const redefineElement = (element, parent, key, options) => {
   return elementWrapper;
 };
 const redefineParent = (element, parent, key, options) => {
-  if (!parent)
-    return import_tree.ROOT;
+  if (!parent) return import_tree.ROOT;
   if ((0, import_utils.isNode)(parent)) {
     const parentNodeWrapper = { key: ":root", node: parent };
     import_tree.ROOT[`${key}_parent`] = parentNodeWrapper;
@@ -142,36 +134,30 @@ const createKey = (element, parent, key) => {
   return ((0, import_utils.exec)(key, element) || key || element.key || (0, import_utils.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) {
     import_mixins.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 === "testing" || 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 = (0, import_utils.detectInfiniteLoop)(ref.path);
-    if (ref.__uniqId || isInfiniteLoopDetected)
-      return;
+    if (ref.__uniqId || isInfiniteLoopDetected) return;
     await (0, import_node.createNode)(element, options);
     ref.__uniqId = Math.random();
   };
@@ -182,18 +168,14 @@ const renderElement = async (element, parent, options, attachOptions) => {
       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) {
@@ -220,55 +202,37 @@ const applyValueAsText = (element, parent, key) => {
 };
 const applyContext = (element, parent, 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;
+  if (forcedOptionsContext) import_tree.ROOT.context = options.context;
+  if (!element.context) element.context = parent.context || options.context || import_tree.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 ((0, import_utils.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 ((0, import_utils.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 ((0, import_utils.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) => {
@@ -278,17 +242,14 @@ const onlyResolveExtends = (element, parent, key, options) => {
     (0, import_set.addMethods)(element, parent, options);
     createScope(element, parent);
     (0, import_state.createState)(element, parent);
-    if (element.scope === "state")
-      element.scope = element.state;
+    if (element.scope === "state") element.scope = element.state;
     createIfConditionFlag(element, parent);
     (0, import_props.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 = {};
     (0, import_component.applyVariant)(element, parent);
     addElementIntoParentChildren(element, parent);
   }
@@ -296,8 +257,7 @@ const onlyResolveExtends = (element, parent, key, options) => {
     (0, import_iterate.throughInitialDefine)(element);
     (0, import_iterate.throughInitialExec)(element);
     for (const k in element) {
-      if ((0, import_utils.isUndefined)(element[k]) || (0, import_methods.isMethod)(k, element) || (0, import_utils.isObject)((import_mixins.registry.default || import_mixins.registry)[k]) || (0, import_utils.isVariant)(k))
-        continue;
+      if ((0, import_utils.isUndefined)(element[k]) || (0, import_methods.isMethod)(k, element) || (0, import_utils.isObject)((import_mixins.registry.default || import_mixins.registry)[k]) || (0, import_utils.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];
@@ -322,10 +282,8 @@ 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/cjs/define.js

@@ -28,7 +28,6 @@ var define_default = (params, options = {}) => {
   for (const param in params) {
     if (import_mixins.REGISTRY[param] && !overwrite) {
       (0, import_report.report)("OverwriteToBuiltin", param);
-    } else
-      import_mixins.REGISTRY[param] = params[param];
+    } else import_mixins.REGISTRY[param] = params[param];
   }
 };

package/dist/cjs/extend.js

@@ -26,16 +26,14 @@ var import_utils2 = require("./utils/index.js");
 const ENV = "development";
 let mainExtend;
 const applyExtend = (element, parent, options = {}) => {
-  if ((0, import_utils.isFunction)(element))
-    element = (0, import_utils.exec)(element, parent);
+  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;
   const context = element.context || parent.context;
   extend = (0, import_utils2.fallbackStringExtend)(extend, context, options, variant);
   const extendStack = (0, import_utils2.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;
@@ -61,8 +59,7 @@ 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 = (0, import_utils2.getExtendStack)(context.defaultExtends, context);
@@ -71,8 +68,7 @@ const applyExtend = (element, parent, options = {}) => {
     }
     stack = [].concat(stack, mainExtend);
   }
-  if (__ref)
-    __ref.__extend = stack;
+  if (__ref) __ref.__extend = stack;
   let mergedExtend = (0, import_utils2.cloneAndMergeArrayExtend)(stack);
   const COMPONENTS = context && context.components || options.components;
   const component = (0, import_utils.exec)(element.component || mergedExtend.component, element);

package/dist/cjs/index.js

@@ -26,8 +26,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var element_exports = {};
-__export(element_exports, {
+var index_exports = {};
+__export(index_exports, {
   TREE: () => import_tree.TREE,
   create: () => import_create.default,
   createNode: () => import_node.default,
@@ -35,7 +35,7 @@ __export(element_exports, {
   set: () => import_set.default,
   update: () => import_update.default
 });
-module.exports = __toCommonJS(element_exports);
+module.exports = __toCommonJS(index_exports);
 var import_tree = require("./tree");
 var import_create = __toESM(require("./create"), 1);
 var import_node = __toESM(require("./node"), 1);

package/dist/cjs/iterate.js

@@ -31,8 +31,7 @@ var import_methods = require("./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 ((0, import_utils.isFunction)(prop) && !(0, import_methods.isMethod)(param, element) && !(0, import_utils.isVariant)(param)) {
       ref.__exec[param] = prop;
@@ -46,8 +45,7 @@ const throughUpdatedExec = (element, options = { excludes: import_utils2.METHODS
   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 = (0, import_utils.isString)(newExec) || (0, import_utils.isNumber)(newExec);
     if (prop && prop.node && execReturnsString) {
@@ -82,10 +80,8 @@ const throughInitialDefine = (element) => {
   const { define, context, __ref: ref } = element;
   let defineObj = {};
   const hasGlobalDefine = context && (0, import_utils.isObject)(context.define);
-  if ((0, import_utils.isObject)(define))
-    defineObj = { ...define };
-  if (hasGlobalDefine)
-    defineObj = { ...defineObj, ...context.define };
+  if ((0, import_utils.isObject)(define)) defineObj = { ...define };
+  if (hasGlobalDefine) defineObj = { ...defineObj, ...context.define };
   for (const param in defineObj) {
     let elementProp = element[param];
     if ((0, import_utils.isFunction)(elementProp) && !(0, import_methods.isMethod)(param, element) && !(0, import_utils.isVariant)(param)) {
@@ -97,8 +93,7 @@ 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;
 };
@@ -106,18 +101,14 @@ 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 };
+  if ((0, import_utils.isObject)(define)) obj = { ...define };
+  if ((0, import_utils.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 = (0, import_utils.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/cjs/methods/index.js

@@ -53,15 +53,12 @@ function spotByPath(path) {
   const element = this;
   const arr = [].concat(path);
   let active = import_tree.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;
 }
@@ -69,21 +66,15 @@ function lookup(param) {
   const el = this;
   let { parent } = el;
   if ((0, import_utils.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;
 }
@@ -95,8 +86,7 @@ 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 ((0, import_utils.isFunction)(param)) {
       const exec = param(childElem, childElem.state, childElem.context);
       if (childElem.state && exec) {
@@ -104,8 +94,7 @@ 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 = []) {
@@ -116,12 +105,10 @@ 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 ((0, import_utils.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);
   }
@@ -130,32 +117,26 @@ 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 ((0, import_utils.isObject)(value) && childElem)
-      setNodeStyles.call(childElem, value);
-    else
-      el.node.style[param] = value;
+    if ((0, import_utils.isObject)(value) && childElem) setNodeStyles.call(childElem, value);
+    else el.node.style[param] = value;
   }
   return el;
 }
 function remove(opts) {
   const element = this;
   const beforeRemoveReturns = (0, import_event.triggerEventOn)("beforeRemove", element, opts);
-  if (beforeRemoveReturns === false)
-    return element;
-  if ((0, import_utils.isFunction)(element.node.remove))
-    element.node.remove();
+  if (beforeRemoveReturns === false) return element;
+  if ((0, import_utils.isFunction)(element.node.remove)) element.node.remove();
   else if (!(0, import_utils.isProduction)()) {
     console.warn("This item cant be removed");
     element.log();
   }
   delete element.parent[element.key];
-  if (element.parent.__ref)
-    element.parent.__ref.__children = (0, import_utils.removeValueFromArray)(element.parent.__ref.__children, element.key);
+  if (element.parent.__ref) element.parent.__ref.__children = (0, import_utils.removeValueFromArray)(element.parent.__ref.__children, element.key);
   (0, import_event.triggerEventOn)("remove", element, opts);
 }
 function get(param) {
@@ -164,8 +145,7 @@ 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;
 }
@@ -192,23 +172,19 @@ 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 = (0, import_utils.isFunction)(val && val.parse) ? val.parse() : val;
       obj[v] = (0, import_utils.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 ((0, import_utils.isDefined)(val) && Object.hasOwnProperty.call(element, v))
-      obj[v] = val;
+    } else if ((0, import_utils.isDefined)(val) && Object.hasOwnProperty.call(element, v)) obj[v] = val;
   });
   return obj;
 }
@@ -216,8 +192,7 @@ 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 ((0, import_utils.isObjectLike)(obj[v])) {
       obj[v] = parseDeep.call(obj[v], excl);
     }
@@ -225,8 +200,7 @@ 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);
@@ -255,10 +229,8 @@ function warn(...params) {
 function error(...params) {
   var _a, _b;
   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);
+    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);
   }
 }
@@ -274,17 +246,14 @@ 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;
@@ -296,8 +265,7 @@ function variables(obj = {}) {
   }
   return {
     changed: (cb) => {
-      if (!changed)
-        return;
+      if (!changed) return;
       const returns = cb(changes, (0, import_utils.deepClone)(varCaches));
       for (const key in changes) {
         varCaches[key] = changes[key];
@@ -305,8 +273,7 @@ function variables(obj = {}) {
       return returns;
     },
     timeout: (cb, timeout) => {
-      if (!changed)
-        return;
+      if (!changed) return;
       const t = setTimeout(() => {
         cb(changes);
         clearTimeout(t);

package/dist/cjs/methods/set.js

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

package/dist/cjs/methods/v2.js

@@ -46,19 +46,15 @@ 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 ((0, import_utils.isFunction)(val && val.parse))
-        val = val.parse();
+      if (element.__ref && element.__ref.__hasRootState) return;
+      if ((0, import_utils.isFunction)(val && val.parse)) val = val.parse();
     } else if (v === "props") {
       const { __element, update, ...props } = element[v];
       obj[v] = props;
-    } else if ((0, import_utils.isDefined)(val))
-      obj[v] = val;
+    } else if ((0, import_utils.isDefined)(val)) obj[v] = val;
   });
   return obj;
 };
@@ -66,8 +62,7 @@ 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 ((0, import_utils.isObjectLike)(obj[v])) {
       obj[v] = parseDeep.call(obj[v], excl);
     }
@@ -102,8 +97,7 @@ 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]];
 };