@domql/element 3.1.2 → 3.2.7

package/README.md

@@ -9,12 +9,10 @@ import DOM from 'domql'
 
 const Poster = {
   extends: [Link, Img],
-  props: {
-    boxSize: [100, 200],
-    borderRadius: 12,
-    padding: 16,
-    background: '#fff'
-  }
+  boxSize: [100, 200],
+  borderRadius: 12,
+  padding: 16,
+  background: '#fff'
 }
 
 DOM.create(Poster, document.body)

package/children.js

@@ -3,7 +3,7 @@
 import {
   concatAddExtends,
   deepClone,
-  execPromise,
+  exec,
   getChildStateInKey,
   isArray,
   isDefined,
@@ -16,21 +16,43 @@ import {
   matchesComponentNaming
 } from '@domql/utils'
 
+const shallowChildrenEqual = (a, b) => {
+  if (a === b) return true
+  if (!a || !b) return false
+  if (isArray(a) && isArray(b)) {
+    if (a.length !== b.length) return false
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false
+    }
+    return true
+  }
+  if (isObject(a) && isObject(b)) {
+    const keysA = Object.keys(a)
+    const keysB = Object.keys(b)
+    if (keysA.length !== keysB.length) return false
+    for (let i = 0; i < keysA.length; i++) {
+      const key = keysA[i]
+      if (a[key] !== b[key]) return false
+    }
+    return true
+  }
+  return a === b
+}
+
 /**
  * Apply data parameters on the DOM nodes
  * this should only work if `showOnNode: true` is passed
  */
-export async function setChildren (param, element, opts) {
+export function setChildren (param, element, opts) {
   let { children, __ref: ref, state } = element
 
   let { childrenAs } = element.props || {}
-  children =
-    (await execPromise(param, element, state)) ||
-    (await execPromise(children, element, state))
+  let execParam = exec(param, element, state)
+  let execChildren = exec(children, element, state)
+  children = execParam || execChildren
 
   if (children) {
     if (isState(children)) children = children.parse()
-
     if (isString(children) || isNumber(children)) {
       if (children === 'state') children = state.parse()
       else {
@@ -58,36 +80,41 @@ export async function setChildren (param, element, opts) {
 
   if (!children || isNot(children)('array', 'object')) return
 
-  if (isArray(children) && children.find(v => v?.$$typeof)) {
-    const filterReact = children.filter(v => !v?.$$typeof)
-    if (filterReact.length !== children.length) {
-      const extractedReactComponents = children.filter(v => v?.$$typeof)
-      element.call('renderReact', extractedReactComponents, element)
+  if (isArray(children) && children.some(v => v?.$$typeof)) {
+    const filterReact = []
+    const reactComponents = []
+    for (let i = 0; i < children.length; i++) {
+      if (children[i]?.$$typeof) reactComponents.push(children[i])
+      else filterReact.push(children[i])
+    }
+    if (reactComponents.length) {
+      element.call('renderReact', reactComponents, element)
     }
     children = filterReact
   }
 
+  let cloned
   if (ref.__childrenCache) {
-    const equals =
-      JSON.stringify(children) === JSON.stringify(ref.__childrenCache) // make smarter diff
-    if (equals) {
+    if (shallowChildrenEqual(children, ref.__childrenCache)) {
       ref.__noChildrenDifference = true
     } else {
-      ref.__childrenCache = deepClone(children)
+      cloned = deepClone(children)
+      ref.__childrenCache = cloned
       delete ref.__noChildrenDifference
     }
   } else {
-    ref.__childrenCache = deepClone(children)
+    cloned = deepClone(children)
+    ref.__childrenCache = cloned
   }
 
   if (isObject(children) || isArray(children)) {
-    children = deepClone(children)
+    children = cloned || deepClone(children)
   }
 
   const content = { tag: 'fragment' }
 
   for (const key in children) {
-    const value = Object.hasOwnProperty.call(children, key) && children[key]
+    const value = Object.prototype.hasOwnProperty.call(children, key) && children[key]
     if (isDefined(value) && value !== null && value !== false) {
       content[key] = isObjectLike(value)
         ? childrenAs

package/create.js

@@ -9,6 +9,7 @@ import {
   isUndefined,
   detectInfiniteLoop,
   propertizeElement,
+  pickupElementFromProps,
   createElement,
   applyExtends,
   createScope,
@@ -19,21 +20,44 @@ import {
   createRoot
 } from '@domql/utils'
 
-import { applyAnimationFrame, triggerEventOn } from '@domql/event'
-import { assignNode } from '@domql/render'
+import { applyAnimationFrame, triggerEventOn } from './event/index.js'
+import { assignNode } from './render/index.js'
 import { createState } from '@domql/state'
 
 import { REGISTRY } from './mixins/index.js'
 import { addMethods } from './methods/set.js'
 import { assignKeyAsClassname } from './mixins/classList.js'
 import { throughInitialExec, throughInitialDefine } from './iterate.js'
+import { filterAttributesByTagName } from 'attrs-in-props'
+
+const EXCLUDED_ATTRS = new Set(['class', 'style'])
+
+const applyPropsAsAttrs = (element) => {
+  const { tag, props, context } = element
+  if (!tag || !props) return
+
+  const autoAttrs = filterAttributesByTagName(tag, props, context?.cssPropsRegistry)
+  const filtered = {}
+  for (const key in autoAttrs) {
+    if (!EXCLUDED_ATTRS.has(key)) filtered[key] = autoAttrs[key]
+  }
+  let hasFiltered = false
+  for (const _k in filtered) { hasFiltered = true; break } // eslint-disable-line
+  if (!hasFiltered) return
+
+  if (!element.attr) {
+    element.attr = filtered
+  } else if (typeof element.attr === 'object') {
+    element.attr = { ...filtered, ...element.attr }
+  }
+}
 
 const ENV = process.env.NODE_ENV
 
 /**
  * Creating a DOMQL element using passed parameters
  */
-export const create = async (
+export const create = (
   props,
   parentEl,
   passedKey,
@@ -51,27 +75,31 @@ export const create = async (
 
   applyExtends(element, parent, options)
 
-  propertizeElement.call(element, element)
-
-  await triggerEventOn('start', element, options)
-
   if (options.onlyResolveExtends) {
     return onlyResolveExtends(element, parent, key, options)
   }
 
+  propertizeElement.call(element, element)
+
+  triggerEventOn('start', element, options)
+
   resetOptions(element, parent, options)
 
   addMethods(element, parent, options)
 
   createScope(element, parent)
 
-  await createState(element, parent)
+  createState(element, parent)
   if (element.scope === 'state') element.scope = element.state
 
   createIfConditionFlag(element, parent)
 
   // apply props settings
   initProps(element, parent, options)
+  // Re-pickup component-named properties that entered props via childProps/inheritParentProps
+  pickupElementFromProps.call(element, element, { cachedKeys: [] })
+  // Populate element.attr from props matching the tag's HTML spec
+  applyPropsAsAttrs(element)
   if (element.scope === 'props' || element.scope === true) {
     element.scope = element.props
   }
@@ -87,7 +115,7 @@ export const create = async (
   // apply variants
   // applyVariant(element, parent)
 
-  const onInit = await triggerEventOn('init', element, options)
+  const onInit = triggerEventOn('init', element, options)
   if (onInit === false) return element
 
   triggerEventOn('beforeClassAssign', element, options)
@@ -95,11 +123,11 @@ export const create = async (
   // generate a CLASS name
   assignKeyAsClassname(element)
 
-  await renderElement(element, parent, options, attachOptions)
+  renderElement(element, parent, options, attachOptions)
 
   addElementIntoParentChildren(element, parent)
 
-  await triggerEventOn('complete', element, options)
+  triggerEventOn('complete', element, options)
 
   return element
 }
@@ -112,7 +140,9 @@ const cacheOptions = options => {
 }
 
 const resetOptions = (element, parent, options) => {
-  if (Object.keys(options).length) {
+  let hasKeys = false
+  for (const _k in options) { hasKeys = true; break } // eslint-disable-line
+  if (hasKeys) {
     OPTIONS.defaultOptions = options
     if (options.ignoreChildExtends) delete options.ignoreChildExtends
   }
@@ -124,8 +154,9 @@ const addElementIntoParentChildren = (element, parent) => {
   }
 }
 
+let _uniqIdCounter = 1
 const visitedElements = new WeakMap()
-const renderElement = async (element, parent, options, attachOptions) => {
+const renderElement = (element, parent, options, attachOptions) => {
   if (visitedElements.has(element)) {
     if (ENV === 'test' || ENV === 'development') {
       console.warn('Cyclic rendering detected:', element.__ref.path)
@@ -136,19 +167,19 @@ const renderElement = async (element, parent, options, attachOptions) => {
 
   const { __ref: ref, key } = element
 
-  const createNestedChild = async () => {
+  const createNestedChild = () => {
     const isInfiniteLoopDetected = detectInfiniteLoop(ref.path)
     if (ref.__uniqId || isInfiniteLoopDetected) return
-    await createNode(element, options)
-    ref.__uniqId = Math.random()
+    createNode(element, options)
+    ref.__uniqId = _uniqIdCounter++
   }
 
   // CREATE a real NODE
   if (ENV === 'test' || ENV === 'development') {
-    await createNestedChild()
+    createNestedChild()
   } else {
     try {
-      await createNestedChild()
+      createNestedChild()
     } catch (e) {
       const path = ref.path
       if (path.includes('ComponentsGrid')) {
@@ -182,17 +213,17 @@ const renderElement = async (element, parent, options, attachOptions) => {
   applyAnimationFrame(element, options)
 
   // run `on.render`
-  await triggerEventOn('render', element, options)
+  triggerEventOn('render', element, options)
   // triggerEventOn('render', element, options).then(() => {})
 
   // run `on.renderRouter`
-  await triggerEventOn('renderRouter', element, options)
+  triggerEventOn('renderRouter', element, options)
 
   // run `on.done`
-  await triggerEventOn('done', element, options)
+  triggerEventOn('done', element, options)
 
   // run `on.done`
-  await triggerEventOn('create', element, options)
+  triggerEventOn('create', element, options)
 }
 
 const onlyResolveExtends = (element, parent, key, options) => {
@@ -209,6 +240,8 @@ const onlyResolveExtends = (element, parent, key, options) => {
 
   // apply props settings
   initProps(element, parent, options)
+  // Re-pickup component-named properties that entered props via childProps/inheritParentProps
+  pickupElementFromProps.call(element, element, { cachedKeys: [] })
   if (element.scope === 'props' || element.scope === true) {
     element.scope = element.props
   }
@@ -235,10 +268,9 @@ const onlyResolveExtends = (element, parent, key, options) => {
         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]
+      const hasDefine = element.define?.[k]
+      const contextHasDefine = element.context?.define?.[k]
+      const optionsHasDefine = options.define?.[k]
 
       if (!ref.__skipCreate && REGISTRY[k] && !optionsHasDefine) {
         continue
@@ -267,24 +299,4 @@ const onlyResolveExtends = (element, parent, key, options) => {
   return element
 }
 
-// const checkIfMedia = (key) => key.slice(0, 1) === '@'
-
-// 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' }
-//     return element
-//   } else {
-//     return {
-//       ...element,
-//       props: {
-//         display: 'none',
-//         [key]: { display: 'block' }
-//       }
-//     }
-//   }
-// }
-
 export default create

package/define.js

@@ -1,7 +1,7 @@
 'use strict'
 
 import { report } from '@domql/report'
-import { REGISTRY } from './mixins'
+import { REGISTRY } from './mixins/index.js'
 
 export default (params, options = {}) => {
   const { overwrite } = options

package/dist/cjs/children.js

@@ -23,10 +23,34 @@ __export(children_exports, {
 });
 module.exports = __toCommonJS(children_exports);
 var import_utils = require("@domql/utils");
-async function setChildren(param, element, opts) {
+const shallowChildrenEqual = (a, b) => {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if ((0, import_utils.isArray)(a) && (0, import_utils.isArray)(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) return false;
+    }
+    return true;
+  }
+  if ((0, import_utils.isObject)(a) && (0, import_utils.isObject)(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    for (let i = 0; i < keysA.length; i++) {
+      const key = keysA[i];
+      if (a[key] !== b[key]) return false;
+    }
+    return true;
+  }
+  return a === b;
+};
+function setChildren(param, element, opts) {
   let { children, __ref: ref, state } = element;
   let { childrenAs } = element.props || {};
-  children = await (0, import_utils.execPromise)(param, element, state) || await (0, import_utils.execPromise)(children, element, state);
+  let execParam = (0, import_utils.exec)(param, element, state);
+  let execChildren = (0, import_utils.exec)(children, element, state);
+  children = execParam || execChildren;
   if (children) {
     if ((0, import_utils.isState)(children)) children = children.parse();
     if ((0, import_utils.isString)(children) || (0, import_utils.isNumber)(children)) {
@@ -53,31 +77,37 @@ async function setChildren(param, element, opts) {
     }
   }
   if (!children || (0, import_utils.isNot)(children)("array", "object")) return;
-  if ((0, import_utils.isArray)(children) && children.find((v) => v == null ? void 0 : v.$$typeof)) {
-    const filterReact = children.filter((v) => !(v == null ? void 0 : v.$$typeof));
-    if (filterReact.length !== children.length) {
-      const extractedReactComponents = children.filter((v) => v == null ? void 0 : v.$$typeof);
-      element.call("renderReact", extractedReactComponents, element);
+  if ((0, import_utils.isArray)(children) && children.some((v) => v?.$$typeof)) {
+    const filterReact = [];
+    const reactComponents = [];
+    for (let i = 0; i < children.length; i++) {
+      if (children[i]?.$$typeof) reactComponents.push(children[i]);
+      else filterReact.push(children[i]);
+    }
+    if (reactComponents.length) {
+      element.call("renderReact", reactComponents, element);
     }
     children = filterReact;
   }
+  let cloned;
   if (ref.__childrenCache) {
-    const equals = JSON.stringify(children) === JSON.stringify(ref.__childrenCache);
-    if (equals) {
+    if (shallowChildrenEqual(children, ref.__childrenCache)) {
       ref.__noChildrenDifference = true;
     } else {
-      ref.__childrenCache = (0, import_utils.deepClone)(children);
+      cloned = (0, import_utils.deepClone)(children);
+      ref.__childrenCache = cloned;
       delete ref.__noChildrenDifference;
     }
   } else {
-    ref.__childrenCache = (0, import_utils.deepClone)(children);
+    cloned = (0, import_utils.deepClone)(children);
+    ref.__childrenCache = cloned;
   }
   if ((0, import_utils.isObject)(children) || (0, import_utils.isArray)(children)) {
-    children = (0, import_utils.deepClone)(children);
+    children = cloned || (0, import_utils.deepClone)(children);
   }
   const content = { tag: "fragment" };
   for (const key in children) {
-    const value = Object.hasOwnProperty.call(children, key) && children[key];
+    const value = Object.prototype.hasOwnProperty.call(children, key) && children[key];
     if ((0, import_utils.isDefined)(value) && value !== null && value !== false) {
       content[key] = (0, import_utils.isObjectLike)(value) ? childrenAs ? { [childrenAs]: value } : value : childrenAs ? { [childrenAs]: childrenAs === "state" ? { value } : { text: value } } : { text: value };
     }

package/dist/cjs/create.js

@@ -25,33 +25,57 @@ module.exports = __toCommonJS(create_exports);
 var import_node = require("./node.js");
 var import_tree = require("./tree.js");
 var import_utils = require("@domql/utils");
-var import_event = require("@domql/event");
-var import_render = require("@domql/render");
+var import_event = require("./event/index.js");
+var import_render = require("./render/index.js");
 var import_state = require("@domql/state");
 var import_mixins = require("./mixins/index.js");
 var import_set = require("./methods/set.js");
 var import_classList = require("./mixins/classList.js");
 var import_iterate = require("./iterate.js");
-const ENV = "development";
-const create = async (props, parentEl, passedKey, options = import_utils.OPTIONS.create || {}, attachOptions) => {
+var import_attrs_in_props = require("attrs-in-props");
+const EXCLUDED_ATTRS = /* @__PURE__ */ new Set(["class", "style"]);
+const applyPropsAsAttrs = (element) => {
+  const { tag, props, context } = element;
+  if (!tag || !props) return;
+  const autoAttrs = (0, import_attrs_in_props.filterAttributesByTagName)(tag, props, context?.cssPropsRegistry);
+  const filtered = {};
+  for (const key in autoAttrs) {
+    if (!EXCLUDED_ATTRS.has(key)) filtered[key] = autoAttrs[key];
+  }
+  let hasFiltered = false;
+  for (const _k in filtered) {
+    hasFiltered = true;
+    break;
+  }
+  if (!hasFiltered) return;
+  if (!element.attr) {
+    element.attr = filtered;
+  } else if (typeof element.attr === "object") {
+    element.attr = { ...filtered, ...element.attr };
+  }
+};
+const ENV = process.env.NODE_ENV;
+const create = (props, parentEl, passedKey, options = import_utils.OPTIONS.create || {}, attachOptions) => {
   cacheOptions(options);
   const element = (0, import_utils.createElement)(props, parentEl, passedKey, options, import_tree.ROOT);
   if (!element) return;
   const { key, parent, __ref: ref } = element;
   (0, import_utils.createRoot)(element, parent);
   (0, import_utils.applyExtends)(element, parent, options);
-  import_utils.propertizeElement.call(element, element);
-  await (0, import_event.triggerEventOn)("start", element, options);
   if (options.onlyResolveExtends) {
     return onlyResolveExtends(element, parent, key, options);
   }
+  import_utils.propertizeElement.call(element, element);
+  (0, import_event.triggerEventOn)("start", element, options);
   resetOptions(element, parent, options);
   (0, import_set.addMethods)(element, parent, options);
   (0, import_utils.createScope)(element, parent);
-  await (0, import_state.createState)(element, parent);
+  (0, import_state.createState)(element, parent);
   if (element.scope === "state") element.scope = element.state;
   (0, import_utils.createIfConditionFlag)(element, parent);
   (0, import_utils.initProps)(element, parent, options);
+  import_utils.pickupElementFromProps.call(element, element, { cachedKeys: [] });
+  applyPropsAsAttrs(element);
   if (element.scope === "props" || element.scope === true) {
     element.scope = element.props;
   }
@@ -59,13 +83,13 @@ const create = async (props, parentEl, passedKey, options = import_utils.OPTIONS
   if (element.node) {
     if (ref.__if) return (0, import_render.assignNode)(element, parent, key, attachOptions);
   }
-  const onInit = await (0, import_event.triggerEventOn)("init", element, options);
+  const onInit = (0, import_event.triggerEventOn)("init", element, options);
   if (onInit === false) return element;
   (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
   (0, import_classList.assignKeyAsClassname)(element);
-  await renderElement(element, parent, options, attachOptions);
+  renderElement(element, parent, options, attachOptions);
   addElementIntoParentChildren(element, parent);
-  await (0, import_event.triggerEventOn)("complete", element, options);
+  (0, import_event.triggerEventOn)("complete", element, options);
   return element;
 };
 const cacheOptions = (options) => {
@@ -75,7 +99,12 @@ const cacheOptions = (options) => {
   }
 };
 const resetOptions = (element, parent, options) => {
-  if (Object.keys(options).length) {
+  let hasKeys = false;
+  for (const _k in options) {
+    hasKeys = true;
+    break;
+  }
+  if (hasKeys) {
     import_utils.OPTIONS.defaultOptions = options;
     if (options.ignoreChildExtends) delete options.ignoreChildExtends;
   }
@@ -85,9 +114,9 @@ const addElementIntoParentChildren = (element, parent) => {
     parent.__ref.__children.push(element.key);
   }
 };
+let _uniqIdCounter = 1;
 const visitedElements = /* @__PURE__ */ new WeakMap();
-const renderElement = async (element, parent, options, attachOptions) => {
-  var _a, _b, _c;
+const renderElement = (element, parent, options, attachOptions) => {
   if (visitedElements.has(element)) {
     if (ENV === "test" || ENV === "development") {
       console.warn("Cyclic rendering detected:", element.__ref.path);
@@ -95,17 +124,17 @@ const renderElement = async (element, parent, options, attachOptions) => {
   }
   visitedElements.set(element, true);
   const { __ref: ref, key } = element;
-  const createNestedChild = async () => {
+  const createNestedChild = () => {
     const isInfiniteLoopDetected = (0, import_utils.detectInfiniteLoop)(ref.path);
     if (ref.__uniqId || isInfiniteLoopDetected) return;
-    await (0, import_node.createNode)(element, options);
-    ref.__uniqId = Math.random();
+    (0, import_node.createNode)(element, options);
+    ref.__uniqId = _uniqIdCounter++;
   };
   if (ENV === "test" || ENV === "development") {
-    await createNestedChild();
+    createNestedChild();
   } else {
     try {
-      await createNestedChild();
+      createNestedChild();
     } catch (e) {
       const path = ref.path;
       if (path.includes("ComponentsGrid")) {
@@ -114,14 +143,14 @@ const renderElement = async (element, parent, options, attachOptions) => {
       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;
+      const isDemoComponent = element.lookup((el) => el.state.key)?.state?.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) {
+      if (element.on?.error) {
         element.on.error(e, element, element.state, element.context, options);
       }
     }
@@ -132,10 +161,10 @@ const renderElement = async (element, parent, options, attachOptions) => {
   }
   (0, import_render.assignNode)(element, parent, key, attachOptions);
   (0, import_event.applyAnimationFrame)(element, options);
-  await (0, import_event.triggerEventOn)("render", element, options);
-  await (0, import_event.triggerEventOn)("renderRouter", element, options);
-  await (0, import_event.triggerEventOn)("done", element, options);
-  await (0, import_event.triggerEventOn)("create", element, options);
+  (0, import_event.triggerEventOn)("render", element, options);
+  (0, import_event.triggerEventOn)("renderRouter", element, options);
+  (0, import_event.triggerEventOn)("done", element, options);
+  (0, import_event.triggerEventOn)("create", element, options);
 };
 const onlyResolveExtends = (element, parent, key, options) => {
   const { __ref: ref } = element;
@@ -145,6 +174,7 @@ const onlyResolveExtends = (element, parent, key, options) => {
   if (element.scope === "state") element.scope = element.state;
   (0, import_utils.createIfConditionFlag)(element, parent);
   (0, import_utils.initProps)(element, parent, options);
+  import_utils.pickupElementFromProps.call(element, element, { cachedKeys: [] });
   if (element.scope === "props" || element.scope === true) {
     element.scope = element.props;
   }
@@ -160,9 +190,9 @@ const onlyResolveExtends = (element, parent, key, options) => {
       if ((0, import_utils.isUndefined)(element[k]) || (0, import_utils.isMethod)(k, element) || (0, import_utils.isObject)(import_mixins.REGISTRY[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];
+      const hasDefine = element.define?.[k];
+      const contextHasDefine = element.context?.define?.[k];
+      const optionsHasDefine = options.define?.[k];
       if (!ref.__skipCreate && import_mixins.REGISTRY[k] && !optionsHasDefine) {
         continue;
       } else if (element[k] && !hasDefine && !optionsHasDefine && !contextHasDefine) {

package/dist/cjs/define.js

@@ -22,7 +22,7 @@ __export(define_exports, {
 });
 module.exports = __toCommonJS(define_exports);
 var import_report = require("@domql/report");
-var import_mixins = require("./mixins");
+var import_mixins = require("./mixins/index.js");
 var define_default = (params, options = {}) => {
   const { overwrite } = options;
   for (const param in params) {