@domql/element 2.5.200 → 3.0.1

package/dist/esm/update.js

@@ -8,69 +8,90 @@ import {
   isString,
   isUndefined,
   merge,
-  isVariant,
   overwriteDeep,
-  createSnapshotId,
-  deepClone
+  deepClone,
+  propertizeElement,
+  isMethod,
+  findInheritedState,
+  deepMerge,
+  OPTIONS,
+  updateProps,
+  captureSnapshot
 } from "@domql/utils";
 import { applyEvent, triggerEventOn, triggerEventOnUpdate } from "@domql/event";
-import { isMethod } from "./methods/index.js";
-import { updateProps } from "./props/index.js";
-import { createState, findInheritedState } from "@domql/state";
+import { createState } from "@domql/state";
 import { create } from "./create.js";
-import { throughExecProps, throughUpdatedDefine, throughUpdatedExec } from "./iterate.js";
+import {
+  throughExecProps,
+  throughUpdatedDefine,
+  throughUpdatedExec
+} from "./iterate.js";
 import { REGISTRY } from "./mixins/index.js";
 import { applyParam } from "./utils/applyParam.js";
-import { OPTIONS } from "./cache/options.js";
-import { METHODS_EXL, deepMerge } from "./utils/index.js";
-const snapshot = {
-  snapshotId: createSnapshotId
-};
+import { METHODS_EXL } from "./utils/index.js";
+import { setContent } from "./set.js";
+import setChildren from "./children.js";
 const UPDATE_DEFAULT_OPTIONS = {
   stackChanges: false,
   cleanExec: true,
   preventRecursive: false,
   currentSnapshot: false,
   calleeElement: false,
-  excludes: METHODS_EXL
+  exclude: METHODS_EXL
 };
 const update = async function(params = {}, opts) {
   const calleeElementCache = opts == null ? void 0 : opts.calleeElement;
-  const options = deepClone(isObject(opts) ? deepMerge(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS, { exclude: ["calleeElement"] });
+  const options = deepClone(
+    isObject(opts) ? deepMerge(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
+    { exclude: ["calleeElement"] }
+  );
   options.calleeElement = calleeElementCache;
   const element = this;
-  const { parent, node, key } = element;
-  const { excludes, preventInheritAtCurrentState } = options;
   let ref = element.__ref;
   if (!ref) ref = element.__ref = {};
-  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options);
+  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(
+    element,
+    options
+  );
   if (snapshotHasUpdated) return;
-  if (!options.preventListeners) await triggerEventOnUpdate("startUpdate", params, element, options);
-  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) return;
-  if (!excludes) merge(options, UPDATE_DEFAULT_OPTIONS);
+  if (!options.preventListeners) {
+    await triggerEventOnUpdate("startUpdate", params, element, options);
+  }
+  const { parent, node, key } = element;
+  const { exclude, preventInheritAtCurrentState } = options;
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) {
+    return;
+  }
+  if (!exclude) merge(options, UPDATE_DEFAULT_OPTIONS);
   if (isString(params) || isNumber(params)) {
     params = { text: params };
   }
+  params = propertizeElement(params);
   const inheritState = await inheritStateUpdates(element, options);
   if (inheritState === false) return;
-  const ifFails = checkIfOnUpdate(element, parent, options);
+  const ifFails = await checkIfOnUpdate(element, parent, options);
   if (ifFails) return;
   if (ref.__if && !options.preventPropsUpdate) {
     const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
-    const hasFunctionInProps = ref.__props.filter((v) => isFunction(v));
+    const hasFunctionInProps = ref.__propsStack.filter((v) => isFunction(v));
     const props = params.props || hasParentProps || hasFunctionInProps.length;
     if (props) updateProps(props, element, parent);
   }
   if (!options.preventBeforeUpdateListener && !options.preventListeners) {
-    const beforeUpdateReturns = await triggerEventOnUpdate("beforeUpdate", params, element, options);
+    const beforeUpdateReturns = await triggerEventOnUpdate(
+      "beforeUpdate",
+      params,
+      element,
+      options
+    );
     if (beforeUpdateReturns === false) return element;
   }
-  overwriteDeep(element, params, { exclude: METHODS_EXL });
+  overwriteDeep(element, params);
   throughExecProps(element);
   throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS });
   throughUpdatedDefine(element);
   if (!options.isForced && !options.preventListeners) {
-    triggerEventOn("beforeClassAssign", element, options);
+    await triggerEventOn("beforeClassAssign", element, options);
   }
   if (!ref.__if) return false;
   if (!node) {
@@ -87,19 +108,22 @@ const update = async function(params = {}, opts) {
     preventUpdateAfterCount
   } = options;
   if (preventUpdateAfter) {
-    if (isNumber(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) return;
-    else if (options.preventUpdateAfterCount === void 0) options.preventUpdateAfterCount = 1;
-    else options.preventUpdateAfterCount++;
+    if (isNumber(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) {
+      return;
+    } else if (options.preventUpdateAfterCount === void 0) {
+      options.preventUpdateAfterCount = 1;
+    } else options.preventUpdateAfterCount++;
   }
   for (const param in element) {
     const prop = element[param];
     if (!Object.hasOwnProperty.call(element, param)) continue;
     const isInPreventUpdate = isArray(preventUpdate) && preventUpdate.includes(param);
     const isInPreventDefineUpdate = isArray(preventDefineUpdate) && preventDefineUpdate.includes(param);
-    const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection;
-    if (isUndefined(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventContentUpdate && param === "content" && !hasCollection || (preventStateUpdate && param) === "state" || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param)) continue;
+    if (isUndefined(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || (preventStateUpdate && param) === "state" || isMethod(param, element) || isObject(REGISTRY[param])) {
+      continue;
+    }
     if (preventStateUpdate === "once") options.preventStateUpdate = false;
-    const isElement = applyParam(param, element, options);
+    const isElement = await applyParam(param, element, options);
     if (isElement) {
       const { hasDefine, hasContextDefine } = isElement;
       const canUpdate = isObject(prop) && !hasDefine && !hasContextDefine && !preventRecursive;
@@ -108,48 +132,51 @@ const update = async function(params = {}, opts) {
       if (options.onEachUpdate) {
         options.onEachUpdate(param, element, element.state, element.context);
       }
-      const childUpdateCall = () => update.call(prop, params[prop], {
+      const childUpdateCall = async () => await update.call(prop, params[prop], {
         ...options,
         currentSnapshot: snapshotOnCallee,
         calleeElement
       });
-      lazyLoad ? window.requestAnimationFrame(() => {
-        childUpdateCall();
-        if (!options.preventUpdateListener) {
-          triggerEventOn("lazyLoad", element, options);
-        }
-      }) : childUpdateCall();
+      if (lazyLoad) {
+        window.requestAnimationFrame(async () => {
+          await childUpdateCall();
+          if (!options.preventUpdateListener) {
+            await triggerEventOn("lazyLoad", element, options);
+          }
+        });
+      } else await childUpdateCall();
     }
   }
-  if (!preventUpdateListener) triggerEventOn("update", element, options);
-};
-const captureSnapshot = (element, options) => {
-  const ref = element.__ref;
-  const { currentSnapshot, calleeElement } = options;
-  const isCallee = calleeElement === element;
-  if (!calleeElement || isCallee) {
-    const createdStanpshot = snapshot.snapshotId();
-    ref.__currentSnapshot = createdStanpshot;
-    return [createdStanpshot, element];
-  }
-  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
-  if (currentSnapshot < snapshotOnCallee) {
-    return [snapshotOnCallee, calleeElement, true];
-  }
-  return [snapshotOnCallee, calleeElement];
+  if (!preventContentUpdate) {
+    const children = params.children || element.children;
+    const content = children ? await setChildren(children, element, opts) : element.children || params.content;
+    if (content) {
+      await setContent(content, element, options);
+    }
+  }
+  if (!preventUpdateListener) {
+    await triggerEventOn("update", element, options);
+  }
 };
-const checkIfOnUpdate = (element, parent, options) => {
+const checkIfOnUpdate = async (element, parent, options) => {
   var _a, _b, _c;
-  if (!isFunction(element.if) && !isFunction((_a = element.props) == null ? void 0 : _a.if) || !parent) return;
+  if (!isFunction(element.if) && !isFunction((_a = element.props) == null ? void 0 : _a.if) || !parent) {
+    return;
+  }
   const ref = element.__ref;
-  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(element, element.state, element.context, options);
+  const ifPassed = (element.if || ((_b = element.props) == null ? void 0 : _b.if))(
+    element,
+    element.state,
+    element.context,
+    options
+  );
   const itWasFalse = ref.__if !== true;
   if (ifPassed) {
     ref.__if = true;
     if (itWasFalse) {
       delete element.__hash;
       delete element.__text;
-      delete element.extend;
+      delete element.extends;
       if (!ref.__hasRootState) {
         delete element.state;
       }
@@ -163,9 +190,11 @@ const checkIfOnUpdate = (element, parent, options) => {
         delete element.node;
       }
       const contentKey = ref.contentElementKey;
-      if (element.$collection || element.$stateCollection || element.$propsCollection) {
+      if (element.children) {
         element.removeContent();
-      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep) element[contentKey] = element[contentKey].parseDeep();
+      } else if ((_c = element[contentKey]) == null ? void 0 : _c.parseDeep) {
+        element[contentKey] = element[contentKey].parseDeep();
+      }
       const previousElement = element.previousElement();
       const previousNode = previousElement == null ? void 0 : previousElement.node;
       const hasPrevious = previousNode == null ? void 0 : previousNode.parentNode;
@@ -178,9 +207,19 @@ const checkIfOnUpdate = (element, parent, options) => {
       };
       delete element.__ref;
       delete element.parent;
-      const createdElement = create(element, parent, element.key, OPTIONS.create, attachOptions);
+      const createdElement = await create(
+        element,
+        parent,
+        element.key,
+        OPTIONS.create,
+        attachOptions
+      );
       if (options.preventUpdate !== true && element.on && isFunction(element.on.update)) {
-        applyEvent(element.on.update, createdElement, createdElement.state);
+        await applyEvent(
+          element.on.update,
+          createdElement,
+          createdElement.state
+        );
       }
       return createdElement;
     }
@@ -202,23 +241,38 @@ const inheritStateUpdates = async (element, options) => {
   const shouldForceFunctionState = isFunction(stateKey) && !isHoisted && execStateFunction;
   if (shouldForceFunctionState) {
     const execState = exec(stateKey, element);
-    state.set(execState, { ...options, preventUpdate: true, preventStateUpdateListener: false, updatedByStateFunction: true });
+    state.set(execState, {
+      ...options,
+      preventUpdate: true,
+      preventStateUpdateListener: false,
+      updatedByStateFunction: true
+    });
     return;
   }
   const keyInParentState = findInheritedState(element, element.parent);
   if (!keyInParentState || options.preventInheritedStateUpdate) return;
   if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {
-    const initStateReturns = await triggerEventOnUpdate("beforeStateUpdate", keyInParentState, element, options);
+    const initStateReturns = await triggerEventOnUpdate(
+      "beforeStateUpdate",
+      keyInParentState,
+      element,
+      options
+    );
     if (initStateReturns === false) return element;
   }
-  const newState = createStateUpdate(element, parent, options);
+  const newState = await createStateUpdate(element, parent, options);
   if (!options.preventStateUpdateListener && !options.preventListeners) {
-    await triggerEventOnUpdate("stateUpdate", newState.parse(), element, options);
+    await triggerEventOnUpdate(
+      "stateUpdate",
+      newState.parse(),
+      element,
+      options
+    );
   }
 };
-const createStateUpdate = (element, parent, options) => {
+const createStateUpdate = async (element, parent, options) => {
   const __stateChildren = element.state.__children;
-  const newState = createState(element, parent);
+  const newState = await createState(element, parent);
   element.state = newState;
   for (const child in __stateChildren) {
     if (newState[child]) newState.__children[child] = __stateChildren[child];

package/dist/esm/utils/applyParam.js

@@ -1,6 +1,6 @@
 import { isFunction } from "@domql/utils";
 import { REGISTRY } from "../mixins/index.js";
-const applyParam = (param, element, options) => {
+const applyParam = async (param, element, options) => {
   const { node, context, __ref: ref } = element;
   const prop = element[param];
   const { onlyUpdate } = options;
@@ -13,7 +13,7 @@ const applyParam = (param, element, options) => {
   const hasOnlyUpdate = onlyUpdate ? onlyUpdate === param || element.lookup(onlyUpdate) : true;
   if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
     if (isFunction(isGlobalTransformer)) {
-      isGlobalTransformer(prop, element, node, options);
+      await isGlobalTransformer(prop, element, node, options);
       return;
     }
   }

package/dist/esm/utils/index.js

@@ -1,3 +1,4 @@
-export * from "./object.js";
-export * from "./extendUtils.js";
-export * from "./component.js";
+const METHODS_EXL = [];
+export {
+  METHODS_EXL
+};

package/dist/esm/utils/onlyResolveExtends.js

@@ -1,19 +1,22 @@
-import { exec, isFunction, isObject, isUndefined } from "@domql/utils";
+import {
+  exec,
+  initProps,
+  isFunction,
+  isMethod,
+  isObject,
+  isUndefined
+} from "@domql/utils";
 import { create } from "..";
 import { REGISTRY } from "../mixins/index.js";
-import { applyVariant, isVariant } from ".";
-import { isMethod } from "../methods";
 import { addMethods } from "../methods/set";
 import { createState } from "@domql/state";
 import { detectTag } from "@domql/render";
-import { createProps } from "../props";
 import { throughInitialDefine, throughInitialExec } from "../iterate";
 const onlyResolveExtends = (element, parent, key, options) => {
   const { __ref } = element;
   element.tag = detectTag(element);
   {
     const { __ref: ref2 } = element;
-    if (!ref2.__cached) ref2.__cached = {};
     if (!ref2.__defineCache) ref2.__defineCache = {};
     if (!ref2.__exec) ref2.__exec = {};
     if (!ref2.__execProps) ref2.__execProps = {};
@@ -35,14 +38,15 @@ const onlyResolveExtends = (element, parent, key, options) => {
   if (element.node && ref.__if) {
     parent[key || element.key] = element;
   }
-  createProps(element, parent, options);
-  applyVariant(element, parent);
+  initProps(element, parent, options);
   if (element.tag !== "string" && element.tag !== "fragment") {
     throughInitialDefine(element);
     throughInitialExec(element);
     for (const param in element) {
       const prop = element[param];
-      if (isUndefined(prop) || isMethod(param, element) || isObject(REGISTRY[param]) || isVariant(param)) continue;
+      if (isUndefined(prop) || isMethod(param, element) || isObject(REGISTRY[param])) {
+        continue;
+      }
       const hasDefine = element.define && element.define[param];
       const contextHasDefine = element.context && element.context.define && element.context.define[param];
       const optionsHasDefine = options.define && options.define[param];

package/iterate.js

@@ -6,28 +6,25 @@ import {
   isFunction,
   isNumber,
   isString,
-  checkIfKeyIsComponent,
-  extendizeByKey,
-  isVariant
+  matchesComponentNaming,
+  isContextComponent,
+  isMethod,
+  overwrite
 } from '@domql/utils'
 
-import { METHODS_EXL, overwrite } from './utils/index.js'
-import { isMethod } from './methods/index.js'
-
 export const throughInitialExec = (element, exclude = {}) => {
   const { __ref: ref } = element
   for (const param in element) {
     if (exclude[param]) continue
     const prop = element[param]
-    if (isFunction(prop) && !isMethod(param, element) && !isVariant(param)) {
+    if (isFunction(prop) && !isMethod(param, element)) {
       ref.__exec[param] = prop
       element[param] = prop(element, element.state, element.context)
-      // if (isComponent)
     }
   }
 }
 
-export const throughUpdatedExec = (element, options = { excludes: METHODS_EXL }) => {
+export const throughUpdatedExec = (element, options = {}) => {
   const { __ref: ref } = element
   const changes = {}
 
@@ -41,15 +38,17 @@ export const throughUpdatedExec = (element, options = { excludes: METHODS_EXL })
     const execReturnsString = isString(newExec) || isNumber(newExec)
     // if (prop && prop.node && execReturnsString) {
     if (prop && prop.node && execReturnsString) {
-      overwrite(prop, { text: newExec }, options)
+      overwrite(prop, { text: newExec })
     } else if (newExec !== prop) {
-      if (checkIfKeyIsComponent(param)) {
-        const { extend, ...newElem } = extendizeByKey(newExec, element, param)
-        overwrite(prop, newElem, options)
-        // } else {
-        //   overwrite(prop, newExec, options)
+      if (matchesComponentNaming(param)) {
+        const { extends: extend, ...newElem } = isContextComponent(
+          newExec,
+          element,
+          param
+        )
+        overwrite(prop, newElem)
       } else {
-        ref.__cached[param] = changes[param] = prop
+        changes[param] = prop
         element[param] = newExec
       }
     }
@@ -58,11 +57,12 @@ export const throughUpdatedExec = (element, options = { excludes: METHODS_EXL })
   return changes
 }
 
-export const throughExecProps = (element) => {
+export const throughExecProps = element => {
   const { __ref: ref } = element
   const { props } = element
   for (const k in props) {
-    const isDefine = k.startsWith('is') || k.startsWith('has') || k.startsWith('use')
+    const isDefine =
+      k.startsWith('is') || k.startsWith('has') || k.startsWith('use')
     const cachedExecProp = ref.__execProps[k]
     if (isFunction(cachedExecProp)) {
       props[k] = exec(cachedExecProp, element)
@@ -73,7 +73,9 @@ export const throughExecProps = (element) => {
   }
 }
 
-export const throughInitialDefine = (element) => {
+export const isPropertyInDefines = (key, element) => {}
+
+export const throughInitialDefine = element => {
   const { define, context, __ref: ref } = element
 
   let defineObj = {}
@@ -84,23 +86,30 @@ export const throughInitialDefine = (element) => {
   for (const param in defineObj) {
     let elementProp = element[param]
 
-    if (isFunction(elementProp) && !isMethod(param, element) && !isVariant(param)) {
+    if (isFunction(elementProp) && !isMethod(param, element)) {
       ref.__exec[param] = elementProp
-      const execParam = elementProp = exec(elementProp, element)
+      const execParam = (elementProp = exec(elementProp, element))
 
       if (execParam) {
-        elementProp = element[param] = execParam.parse ? execParam.parse() : execParam
+        elementProp = element[param] = execParam.parse
+          ? execParam.parse()
+          : execParam
         ref.__defineCache[param] = elementProp
       }
     }
 
-    const execParam = defineObj[param](elementProp, element, element.state, element.context)
+    const execParam = defineObj[param](
+      elementProp,
+      element,
+      element.state,
+      element.context
+    )
     if (execParam) element[param] = execParam
   }
   return element
 }
 
-export const throughUpdatedDefine = (element) => {
+export const throughUpdatedDefine = element => {
   const { context, define, __ref: ref } = element
   const changes = {}
 
@@ -110,9 +119,18 @@ export const throughUpdatedDefine = (element) => {
 
   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)
+    const newExecParam =
+      typeof obj[param] === 'function'
+        ? obj[param](cached, element, element.state, element.context)
+        : undefined
     if (newExecParam) element[param] = newExecParam
   }
   return changes

package/methods/set.js

@@ -2,10 +2,9 @@
 
 import { merge, overwrite } from '@domql/utils'
 
-import { set, reset } from '../set.js'
+import { set, reset, updateContent, removeContent } from '../set.js'
 import { update } from '../update.js'
 
-import { removeContent, updateContent } from '../mixins/content.js'
 import {
   call,
   error,
@@ -27,7 +26,7 @@ import {
   variables,
   verbose,
   warn
-} from './index.js'
+} from '@domql/utils/methods'
 
 export const addMethods = (element, parent, options = {}) => {
   const proto = {
@@ -57,6 +56,8 @@ export 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)
 }

package/methods/v2.js

@@ -1,7 +1,6 @@
 'use strict'
 
 import { isDefined, isFunction, isObjectLike } from '@domql/utils'
-import { parseFilters, REGISTRY } from '../mixins/index.js'
 
 export const defineSetter = (element, key, get, set) =>
   Object.defineProperty(element, key, { get, set })
@@ -10,7 +9,7 @@ export const keys = function () {
   const element = this
   const keys = []
   for (const param in element) {
-    if (REGISTRY[param] && !parseFilters.elementKeys.includes(param)) { continue }
+    // if (REGISTRY[param] && !parseFilters.elementKeys.includes(param)) { continue }
     keys.push(param)
   }
   return keys
@@ -39,7 +38,9 @@ export const parseDeep = function (excl = []) {
   const obj = parse.call(element, excl)
   for (const v in obj) {
     if (excl.includes(v)) return
-    if (isObjectLike(obj[v])) { obj[v] = parseDeep.call(obj[v], excl) }
+    if (isObjectLike(obj[v])) {
+      obj[v] = parseDeep.call(obj[v], excl)
+    }
   }
   return obj
 }
@@ -51,7 +52,7 @@ export const log = function (...args) {
   if (args.length) {
     args.forEach(v => console.log(`%c${v}:\n`, 'font-weight: bold', element[v]))
   } else {
-    console.log(__ref.path)
+    console.log(__ref?.path)
     const keys = element.keys()
     keys.forEach(v => console.log(`%c${v}:\n`, 'font-weight: bold', element[v]))
   }

package/mixins/attr.js

@@ -1,8 +1,7 @@
 'use strict'
 
-import { exec, isNot, isNull, isUndefined } from '@domql/utils'
+import { deepMerge, exec, isNot, isNull, isUndefined } from '@domql/utils'
 import { report } from '@domql/report'
-import { deepMerge } from '../utils/index.js'
 
 /**
  * Recursively add attributes to a DOM node
@@ -12,12 +11,19 @@ export function attr (params, element, node) {
   const { __attr } = ref
   if (isNot('object')) report('HTMLInvalidAttr', params)
   if (params) {
-    if (props.attr) deepMerge(params, props.attr)
-    for (const attr in params) {
-      const val = exec(params[attr], element)
+    const attrs = exec(params, element)
+    if (props.attr) deepMerge(attrs, props.attr)
+    for (const attr in attrs) {
+      const val = exec(attrs[attr], element)
       // if (__attr[attr] === val) return
-      if (val !== false && !isUndefined(val) && !isNull(val) && node.setAttribute) node.setAttribute(attr, val)
-      else if (node.removeAttribute) node.removeAttribute(attr)
+      if (
+        val !== false &&
+        !isUndefined(val) &&
+        !isNull(val) &&
+        node.setAttribute
+      ) {
+        node.setAttribute(attr, val)
+      } else if (node.removeAttribute) node.removeAttribute(attr)
       __attr[attr] = val
     }
   }

package/mixins/classList.js

@@ -2,10 +2,15 @@
 
 import { exec, isObject, isString } from '@domql/utils'
 
-export const assignKeyAsClassname = (element) => {
+export const assignKeyAsClassname = element => {
   const { key } = element
   if (element.class === true) element.class = key
-  else if (!element.class && typeof key === 'string' && key.charAt(0) === '_' && key.charAt(1) !== '_') {
+  else if (
+    !element.class &&
+    typeof key === 'string' &&
+    key.charAt(0) === '_' &&
+    key.charAt(1) !== '_'
+  ) {
     element.class = key.slice(1)
   }
 }

package/mixins/data.js

@@ -1,6 +1,6 @@
 'use strict'
 
-import { exec, isObject, deepMerge } from '@domql/utils'
+import { isObject, deepMerge, exec } from '@domql/utils'
 import { report } from '@domql/report'
 
 /**