domql 1.5.136 → 1.6.0

package/dist/cjs/element/set.js

@@ -0,0 +1,55 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+__export(set_exports, {
+  default: () => set_default
+});
+module.exports = __toCommonJS(set_exports);
+var import_utils = require("@domql/utils");
+var import_remove = require("./remove");
+var import_create = __toESM(require("./create"));
+var import_mixins = require("./mixins");
+var import_options = __toESM(require("./options"));
+const set = function(params, options = {}, el) {
+  const element = el || this;
+  const __contentRef = element.content && element.content.__ref;
+  const isEqual = (0, import_utils.isEqualDeep)(params, element.content);
+  if (isEqual && __contentRef && __contentRef.__cached)
+    return element;
+  (0, import_remove.removeContentElement)(element);
+  if (params) {
+    const { childExtend } = params;
+    if (!childExtend && element.childExtend)
+      params.childExtend = element.childExtend;
+    (0, import_create.default)(params, element, "content", {
+      ignoreChildExtend: true,
+      ...import_mixins.registry.defaultOptions,
+      ...import_options.default.create,
+      ...options
+    });
+  }
+  return element;
+};
+var set_default = set;

package/dist/cjs/element/state.js

@@ -0,0 +1,208 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var state_exports = {};
+__export(state_exports, {
+  IGNORE_STATE_PARAMS: () => IGNORE_STATE_PARAMS,
+  cleanState: () => cleanState,
+  createState: () => createState,
+  default: () => state_default,
+  isState: () => isState,
+  parseState: () => parseState,
+  rootUpdate: () => rootUpdate,
+  updateState: () => updateState
+});
+module.exports = __toCommonJS(state_exports);
+var import_event = require("../event");
+var import_event2 = require("@domql/event");
+var import_utils = require("@domql/utils");
+var import_utils2 = require("../utils");
+const IGNORE_STATE_PARAMS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__root",
+  "rootUpdate"
+];
+const parseState = function() {
+  const state = this;
+  const parseState2 = {};
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param)) {
+      parseState2[param] = state[param];
+    }
+  }
+  return parseState2;
+};
+const cleanState = function() {
+  const state = this;
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param)) {
+      delete state[param];
+    }
+  }
+  state.update();
+  return state;
+};
+const rootUpdate = function(obj, options = {}) {
+  const state = this;
+  if (!state)
+    return;
+  const rootState = state.__element.__ref.__root.state;
+  return rootState.update(obj, options);
+};
+const updateState = function(obj, options = {}) {
+  const state = this;
+  const element = state.__element;
+  const __elementRef = element.__ref;
+  state.parent = element.parent.state;
+  for (const param in state)
+    if ((0, import_utils.isUndefined)(state[param]))
+      delete state[param];
+  if (!state.__element)
+    createState(element, element.parent);
+  if (element.on && (0, import_utils.isFunction)(element.on.initStateUpdated)) {
+    const initReturns = import_event.on.initStateUpdated(element.on.initStateUpdated, element, state, obj);
+    if (initReturns === false)
+      return;
+  }
+  const stateKey = __elementRef.__state;
+  if (stateKey) {
+    console.log(stateKey);
+    if (state.parent && state.parent[stateKey]) {
+      const keyInParentState = state.parent[stateKey];
+      console.log(keyInParentState);
+      if (keyInParentState && !options.stopStatePropogation) {
+        if (__elementRef.__stateType === "string") {
+          return state.parent.update({ [stateKey]: obj.value }, options);
+        }
+        return state.parent.update({ [stateKey]: obj }, options);
+      }
+      console.warn(state.parent);
+    }
+  } else {
+    if (options && options.shallow) {
+      (0, import_utils2.overwriteShallow)(state, obj, IGNORE_STATE_PARAMS);
+    } else {
+      (0, import_utils2.overwriteDeep)(state, obj, IGNORE_STATE_PARAMS);
+    }
+  }
+  if (!options.preventUpdate) {
+    element.update({}, options);
+  } else if (options.preventUpdate === "recursive") {
+    element.update({}, { ...options, preventUpdate: true });
+  }
+  if (state.__depends) {
+    for (const el in state.__depends) {
+      const findElement = state.__depends[el];
+      findElement.clean().update(state.parse(), options);
+    }
+  }
+  if (!options.preventUpdateListener && element.on && (0, import_utils.isFunction)(element.on.stateUpdated)) {
+    import_event.on.stateUpdated(element.on.stateUpdated, element, state, obj);
+  }
+  return state;
+};
+const createState = function(element, parent, opts) {
+  const skip = opts && opts.skip ? opts.skip : false;
+  let { state, __ref: __elementRef } = element;
+  if ((0, import_utils.isFunction)(state))
+    state = (0, import_utils.exec)(state, element);
+  if ((0, import_utils.is)(state)("string", "number")) {
+    __elementRef.__state = state;
+    state = {};
+  }
+  if (state === true) {
+    __elementRef.__state = element.key;
+    state = {};
+  }
+  if (!state) {
+    if (parent && parent.state)
+      return parent.state;
+    return {};
+  } else {
+    __elementRef.__hasRootState = true;
+  }
+  (0, import_event2.triggerEventOn)("stateInit", element);
+  let stateKey = __elementRef.__state;
+  if (stateKey) {
+    let parentState = parent.state;
+    const parentKeysArr = stateKey.split("../");
+    for (let i = 1; i < parentKeysArr.length; i++) {
+      stateKey = parentKeysArr[i];
+      parentState = parentState.parent;
+    }
+    const childrenKeysArr = stateKey.split(".");
+    for (let i = 0; i < childrenKeysArr.length; i++) {
+      const childKey = childrenKeysArr[i];
+      const grandChildKey = childrenKeysArr[i + 1];
+      const childInParent = parentState[childKey];
+      if (childInParent && childInParent[grandChildKey]) {
+        stateKey = grandChildKey;
+        parentState = childInParent;
+      }
+    }
+    if (parentState && parentState[stateKey]) {
+      const keyInParentState = parentState[stateKey];
+      if ((0, import_utils.is)(keyInParentState)("object", "array")) {
+        state = (0, import_utils2.deepClone)(keyInParentState);
+      } else if ((0, import_utils.is)(keyInParentState)("string", "number")) {
+        state = { value: keyInParentState };
+        __elementRef.__stateType = "string";
+      } else if ((0, import_utils.isUndefined)(keyInParentState)) {
+        console.warn(stateKey, "is not in present", "replacing with ", {});
+        state = {};
+      }
+    }
+  }
+  const { __ref } = state;
+  if (__ref) {
+    state = (0, import_utils2.deepClone)(__ref, IGNORE_STATE_PARAMS);
+    if ((0, import_utils.isObject)(__ref.__depends)) {
+      __ref.__depends[element.key] = state;
+    } else
+      __ref.__depends = { [element.key]: state };
+  } else {
+    state = (0, import_utils2.deepClone)(state, IGNORE_STATE_PARAMS);
+  }
+  element.state = state;
+  if (skip)
+    return state;
+  state.clean = cleanState;
+  state.parse = parseState;
+  state.update = updateState;
+  state.rootUpdate = rootUpdate;
+  state.create = createState;
+  state.parent = element.parent.state;
+  state.__element = element;
+  state.__root = __elementRef.__root ? __elementRef.__root.state : state;
+  (0, import_event2.triggerEventOn)("stateCreated", element);
+  return state;
+};
+const isState = function(state) {
+  if ((0, import_utils.is)(state)("object", "array"))
+    return false;
+  if (!state)
+    return false;
+};
+var state_default = createState;

package/dist/cjs/element/tree.js

@@ -0,0 +1,31 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tree_exports = {};
+__export(tree_exports, {
+  default: () => tree_default
+});
+module.exports = __toCommonJS(tree_exports);
+var import_root = __toESM(require("./root"));
+var tree_default = import_root.default;

package/dist/cjs/element/update.js

@@ -0,0 +1,158 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var update_exports = {};
+__export(update_exports, {
+  default: () => update_default
+});
+module.exports = __toCommonJS(update_exports);
+var import_globals = require("@domql/globals");
+var import_utils = require("@domql/utils");
+var import_event = require("@domql/event");
+var import_utils2 = require("../utils");
+var import_event2 = require("../event");
+var import_create = __toESM(require("./create"));
+var import_iterate = require("./iterate");
+var import_methods = require("./methods");
+var import_mixins = require("./mixins");
+var import_props = require("./props");
+var import_state = __toESM(require("./state"));
+var import_applyParam = require("./applyParam");
+const snapshot = {
+  snapshotId: import_utils.createSnapshotId
+};
+const UPDATE_DEFAULT_OPTIONS = {
+  stackChanges: false,
+  cleanExec: true,
+  preventRecursive: false,
+  currentSnapshot: false,
+  calleeElement: false
+};
+const update = function(params = {}, options = UPDATE_DEFAULT_OPTIONS) {
+  const element = this;
+  const { parent, node, key } = element;
+  let __ref = element.__ref;
+  if (!__ref)
+    __ref = element.__ref = {};
+  const { currentSnapshot, calleeElement } = options;
+  if (!calleeElement) {
+    __ref.__currentSnapshot = snapshot.snapshotId();
+  }
+  const snapshotOnCallee = __ref.__currentSnapshot || calleeElement && calleeElement.__ref && calleeElement.__currentSnapshot;
+  if (snapshotOnCallee && currentSnapshot < snapshotOnCallee) {
+  }
+  if ((0, import_utils.isString)(params) || (0, import_utils.isNumber)(params)) {
+    params = { text: params };
+  }
+  if ((0, import_utils.isFunction)(element.if)) {
+    const ifPassed = element.if(element, element.state);
+    const itWasFalse = __ref.__if !== true;
+    if (ifPassed)
+      __ref.__if = true;
+    if (itWasFalse && ifPassed) {
+      delete element.__hash;
+      delete element.extend;
+      if (!__ref.__hasRootState)
+        delete element.state;
+      if (__ref.__state)
+        element.state = __ref.__state;
+      const created = (0, import_create.default)(element, element.parent, element.key);
+      if (!options.preventUpdate) {
+        if (element.on && (0, import_utils.isFunction)(element.on.update)) {
+          (0, import_event.applyEvent)(element.on.update, created, created.state);
+        }
+      }
+      return created;
+    } else if (element.node && !ifPassed) {
+      element.node.remove();
+      delete __ref.__if;
+    }
+  }
+  if (__ref.__state) {
+    const keyInParentState = parent.state[__ref.__state];
+    if (keyInParentState) {
+      const newState = __ref.__stateType === "string" ? (0, import_state.default)(element, parent) : (0, import_state.default)(element, parent);
+      const changes = (0, import_utils.diff)(newState.parse(), element.state.parse());
+      if (element.on && (0, import_utils.isFunction)(element.on.initStateUpdated)) {
+        const initReturns = import_event2.on.initStateUpdated(element.on.initStateUpdated, element, element.state, changes);
+        if (initReturns === false)
+          return;
+      }
+      element.state = newState;
+      if (!options.preventUpdateListener && element.on && (0, import_utils.isFunction)(element.on.stateUpdated)) {
+        import_event2.on.stateUpdated(element.on.stateUpdated, element, element.state, changes);
+      }
+    }
+  } else if (!__ref.__hasRootState)
+    element.state = parent && parent.state || {};
+  if (__ref.__if && !options.preventPropsUpdate) {
+    const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
+    (0, import_props.updateProps)(params.props || hasParentProps && {}, element, parent);
+  }
+  if (element.on && (0, import_utils.isFunction)(element.on.initUpdate) && !options.ignoreInitUpdate) {
+    const whatinitreturns = import_event2.on.initUpdate(element.on.initUpdate, element, element.state);
+    if (whatinitreturns === false)
+      return;
+  }
+  const overwriteChanges = (0, import_utils2.overwrite)(element, params, UPDATE_DEFAULT_OPTIONS);
+  const execChanges = (0, import_iterate.throughUpdatedExec)(element, UPDATE_DEFAULT_OPTIONS);
+  const definedChanges = (0, import_iterate.throughUpdatedDefine)(element);
+  if (options.stackChanges && element.__stackChanges) {
+    const stackChanges = (0, import_utils2.merge)(definedChanges, (0, import_utils2.merge)(execChanges, overwriteChanges));
+    element.__stackChanges.push(stackChanges);
+  }
+  if (!__ref.__if)
+    return false;
+  if (!node) {
+    return;
+  }
+  for (const param in element) {
+    const prop = element[param];
+    if (options.preventDefineUpdate === true || options.preventDefineUpdate === param || options.preventContentUpdate && param === "content" || (options.preventStateUpdate && param) === "state" || (0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || prop === void 0)
+      continue;
+    if (options.preventStateUpdate === "once")
+      options.preventStateUpdate = false;
+    const isElement = (0, import_applyParam.applyParam)(param, element, options);
+    if (isElement) {
+      const { hasDefine, hasContextDefine } = isElement;
+      if (prop && (0, import_utils.isObject)(prop) && !hasDefine && !hasContextDefine) {
+        if (!options.preventRecursive) {
+          const childUpdateCall = () => update.call(prop, params[prop], {
+            ...options,
+            currentSnapshot: snapshotOnCallee,
+            calleeElement: element
+          });
+          if (element.props.lazyLoad || options.lazyLoad) {
+            import_globals.window.requestAnimationFrame(() => childUpdateCall());
+          } else
+            childUpdateCall();
+        }
+      }
+    }
+  }
+  if (!options.preventUpdate) {
+    (0, import_event.triggerEventOn)("update", element);
+  }
+};
+var update_default = update;

package/dist/cjs/event/can.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var can_exports = {};
+__export(can_exports, {
+  render: () => render
+});
+module.exports = __toCommonJS(can_exports);
+var import_registry = require("@domql/registry");
+var import_report = require("@domql/report");
+const render = (element) => {
+  const tag = element.tag || "div";
+  const isValid = import_registry.TAGS.body.indexOf(tag) > -1;
+  return isValid || (0, import_report.report)("HTMLInvalidTag");
+};

package/dist/cjs/event/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var event_exports = {};
+__export(event_exports, {
+  can: () => can,
+  is: () => is,
+  on: () => on
+});
+module.exports = __toCommonJS(event_exports);
+var on = __toESM(require("./on"));
+var can = __toESM(require("./can"));
+var is = __toESM(require("./is"));

package/dist/cjs/event/is.js

@@ -0,0 +1,28 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var is_exports = {};
+__export(is_exports, {
+  node: () => node
+});
+module.exports = __toCommonJS(is_exports);
+var import_globals = require("@domql/globals");
+const node = (node2) => {
+  const { Node } = import_globals.window;
+  return typeof Node === "function" ? node2 instanceof Node : node2 && typeof node2 === "object" && typeof node2.nodeType === "number" && typeof node2.tag === "string";
+};

package/dist/cjs/event/on.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var on_exports = {};
+__export(on_exports, {
+  initStateUpdated: () => initStateUpdated,
+  initUpdate: () => initUpdate,
+  stateUpdated: () => stateUpdated
+});
+module.exports = __toCommonJS(on_exports);
+const initUpdate = (param, element, state, changes) => {
+  return param(element, state, changes);
+};
+const initStateUpdated = (param, element, state, changes) => {
+  return param(element, state, changes);
+};
+const stateUpdated = (param, element, state, changes) => {
+  return param(element, state, changes);
+};

package/dist/cjs/event/store.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var store_exports = {};
+__export(store_exports, {
+  default: () => store_default
+});
+module.exports = __toCommonJS(store_exports);
+var store_default = {
+  click: [],
+  render: []
+};

package/dist/cjs/event/wrappers.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var wrappers_exports = {};
+__export(wrappers_exports, {
+  getScrollPositions: () => getScrollPositions
+});
+module.exports = __toCommonJS(wrappers_exports);
+var import_globals = require("@domql/globals");
+const getScrollPositions = () => {
+  if (global.pageYOffset !== void 0) {
+    return [global.pageXOffset, import_globals.window.pageYOffset];
+  } else {
+    const d = import_globals.document;
+    const r = d.documentElement;
+    const b = d.body;
+    const sx = r.scrollLeft || b.scrollLeft || 0;
+    const sy = r.scrollTop || b.scrollTop || 0;
+    return [sx, sy];
+  }
+};

package/dist/cjs/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_globals = require("@domql/globals");
+var import_element = require("./element");
+const ENV = "development";
+if (ENV === "test" || ENV === "development")
+  import_globals.window.tree = import_element.tree;
+var src_default = {
+  create: import_element.create,
+  parse: import_element.parse,
+  set: import_element.set,
+  define: import_element.define,
+  tree: import_element.tree
+};