@symbo.ls/utils 2.33.41 → 2.34.1

package/dist/cjs/domqlv3hacks.js

@@ -0,0 +1,3838 @@
+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);
+
+// src/domqlv3hacks.js
+var domqlv3hacks_exports = {};
+__export(domqlv3hacks_exports, {
+  temporaryDomqlHack: () => temporaryDomqlHack,
+  temporaryDomqlHackReverse: () => temporaryDomqlHackReverse
+});
+module.exports = __toCommonJS(domqlv3hacks_exports);
+
+// ../../../domql/packages/utils/dist/esm/key.js
+var generateKey = /* @__PURE__ */ (function() {
+  let index = 0;
+  function newId() {
+    index++;
+    return index;
+  }
+  return newId;
+})();
+var createSnapshotId = generateKey;
+
+// ../../../domql/packages/utils/dist/esm/env.js
+var NODE_ENV = "development";
+var isProduction = (env = NODE_ENV) => env === "production";
+var isNotProduction = (env = NODE_ENV) => !isProduction(env);
+
+// ../../../domql/packages/utils/dist/esm/globals.js
+var window2 = globalThis;
+var document2 = window2.document;
+
+// ../../../domql/packages/utils/dist/esm/node.js
+var isNode = (obj) => {
+  return (typeof Node === "object" ? obj instanceof window2.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+};
+var isHtmlElement = (obj) => {
+  return (typeof HTMLElement === "object" ? obj instanceof window2.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+};
+var isDOMNode = (obj) => {
+  return typeof window2 !== "undefined" && (obj instanceof window2.Node || obj instanceof window2.Window || obj === window2 || obj === document);
+};
+
+// ../../../domql/packages/utils/dist/esm/types.js
+var isObject = (arg) => {
+  if (arg === null) return false;
+  return typeof arg === "object" && arg.constructor === Object;
+};
+var isString = (arg) => typeof arg === "string";
+var isNumber = (arg) => typeof arg === "number";
+var isFunction = (arg) => typeof arg === "function";
+var isBoolean = (arg) => arg === true || arg === false;
+var isNull = (arg) => arg === null;
+var isArray = (arg) => Array.isArray(arg);
+var isDate = (d) => d instanceof Date;
+var isObjectLike = (arg) => {
+  if (arg === null) return false;
+  return typeof arg === "object";
+};
+var isDefined = (arg) => {
+  return isObject(arg) || isObjectLike(arg) || isString(arg) || isNumber(arg) || isFunction(arg) || isArray(arg) || isObjectLike(arg) || isBoolean(arg) || isDate(arg) || isNull(arg);
+};
+var isUndefined = (arg) => {
+  return arg === void 0;
+};
+var TYPES = {
+  boolean: isBoolean,
+  array: isArray,
+  object: isObject,
+  string: isString,
+  date: isDate,
+  number: isNumber,
+  null: isNull,
+  function: isFunction,
+  objectLike: isObjectLike,
+  node: isNode,
+  htmlElement: isHtmlElement,
+  defined: isDefined
+};
+var is = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+  };
+};
+var isNot = (arg) => {
+  return (...args) => {
+    return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+  };
+};
+
+// ../../../domql/packages/utils/dist/esm/array.js
+var removeFromArray = (arr, index) => {
+  if (isString(index)) index = parseInt(index);
+  if (isNumber(index)) {
+    if (index < 0 || index >= arr.length || isNaN(index)) {
+      throw new Error("Invalid index");
+    }
+    arr.splice(index, 1);
+  } else if (isArray(index)) {
+    index.forEach((idx) => removeFromArray(arr, idx));
+  } else {
+    throw new Error("Invalid index");
+  }
+  return arr;
+};
+var joinArrays = (...arrays) => {
+  return [].concat(...arrays);
+};
+var mergeArray = (arr, exclude = []) => {
+  return arr.reduce(
+    (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+    {}
+  );
+};
+var removeValueFromArray = (arr, value) => {
+  const index = arr.indexOf(value);
+  if (index > -1) {
+    const newArray = [...arr];
+    newArray.splice(index, 1);
+    return newArray;
+  }
+  return arr;
+};
+
+// ../../../domql/packages/utils/dist/esm/string.js
+var lowercaseFirstLetter = (inputString) => {
+  return `${inputString.charAt(0).toLowerCase()}${inputString.slice(1)}`;
+};
+
+// ../../../domql/packages/utils/dist/esm/object.js
+var __defProp2 = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+function exec(param, element, state2, context, opts = {}) {
+  if (!element) element = this;
+  if (isFunction(param)) {
+    try {
+      const result = param.call(
+        element,
+        element,
+        state2 || element.state,
+        context || element.context
+      );
+      if (result && typeof result.then === "function") {
+        return result;
+      }
+      return result;
+    } catch (e) {
+      element.log(param);
+      element.warn("Error executing function", e, opts);
+    }
+  }
+  return param;
+}
+var map = (obj, extention, element) => {
+  for (const e in extention) {
+    obj[e] = exec(extention[e], element);
+  }
+};
+var merge = (element, obj, excludeFrom = []) => {
+  for (const e in obj) {
+    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, e);
+    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__"))
+      continue;
+    const elementProp = element[e];
+    const objProp = obj[e];
+    if (elementProp === void 0) {
+      element[e] = objProp;
+    }
+  }
+  return element;
+};
+var deepMerge = (element, extend, excludeFrom = [], level = Infinity) => {
+  for (const e in extend) {
+    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(extend, e);
+    if (!hasOwnProperty2 || excludeFrom.includes(e) || e.startsWith("__"))
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
+      if (level > 0) {
+        deepMerge(elementProp, extendProp, excludeFrom, level - 1);
+      } else {
+        for (const k in extendProp) {
+          if (excludeFrom.includes(k) || elementProp[k] === void 0) continue;
+          elementProp[k] = extendProp[k];
+        }
+      }
+    } else if (elementProp === void 0) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+var clone = (obj, excludeFrom = []) => {
+  const o = {};
+  for (const prop in obj) {
+    const hasOwnProperty2 = Object.prototype.hasOwnProperty.call(obj, prop);
+    if (!hasOwnProperty2 || excludeFrom.includes(prop) || prop.startsWith("__"))
+      continue;
+    o[prop] = obj[prop];
+  }
+  return o;
+};
+var deepClone = (obj, options = {}) => {
+  const {
+    exclude = [],
+    cleanUndefined = false,
+    cleanNull = false,
+    window: targetWindow,
+    visited = /* @__PURE__ */ new WeakMap(),
+    handleExtend = false
+  } = options;
+  const contentWindow = targetWindow || window2 || globalThis;
+  if (!isObjectLike(obj) || isDOMNode(obj)) {
+    return obj;
+  }
+  if (visited.has(obj)) {
+    return visited.get(obj);
+  }
+  const clone2 = contentWindow ? isArray(obj) ? new contentWindow.Array() : new contentWindow.Object() : isArray(obj) ? [] : {};
+  visited.set(obj, clone2);
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+    if (exclude.includes(key) || key.startsWith("__") || key === "__proto__")
+      continue;
+    let value = obj[key];
+    if (cleanUndefined && isUndefined(value) || cleanNull && isNull(value))
+      continue;
+    if (isDOMNode(value)) {
+      clone2[key] = value;
+      continue;
+    }
+    if (handleExtend && key === "extend" && isArray(value)) {
+      clone2[key] = mergeArray(value, exclude);
+      continue;
+    }
+    if (isFunction(value) && options.window) {
+      clone2[key] = contentWindow.eval("(" + value.toString() + ")");
+      continue;
+    }
+    if ((value == null ? void 0 : value.__ref) && (value == null ? void 0 : value.node)) {
+      value = value.parseDeep();
+    }
+    if (value == null ? void 0 : value.__element) {
+      value = value.parse();
+    }
+    if (isObjectLike(value)) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      clone2[key] = deepClone(value, __spreadProps(__spreadValues({}, options), {
+        visited
+      }));
+    } else {
+      clone2[key] = value;
+    }
+  }
+  return clone2;
+};
+var deepStringifyFunctions = (obj, stringified = {}) => {
+  var _a, _b;
+  if (!obj) return;
+  if (obj.node || obj.__ref || obj.parent || obj.__element || obj.parse) {
+    ;
+    (obj.__element || ((_a = obj.parent) == null ? void 0 : _a.__element)).warn(
+      "Trying to clone element or state at",
+      obj
+    );
+    obj = (_b = obj.parse) == null ? void 0 : _b.call(obj);
+  }
+  for (const prop in obj) {
+    const objProp = obj[prop];
+    if (isFunction(objProp)) {
+      stringified[prop] = objProp.toString();
+    } else if (isObject(objProp)) {
+      stringified[prop] = {};
+      deepStringifyFunctions(objProp, stringified[prop]);
+    } else if (isArray(objProp)) {
+      stringified[prop] = [];
+      objProp.forEach((v, i) => {
+        if (isObject(v)) {
+          stringified[prop][i] = {};
+          deepStringifyFunctions(v, stringified[prop][i]);
+        } else if (isFunction(v)) {
+          stringified[prop][i] = v.toString();
+        } else {
+          stringified[prop][i] = v;
+        }
+      });
+    } else {
+      stringified[prop] = objProp;
+    }
+  }
+  return stringified;
+};
+var diffObjects = (original, objToDiff, cache, opts) => {
+  let hasDiff = false;
+  const originalKeys = Object.keys(original);
+  const diffKeys = Object.keys(objToDiff);
+  const allKeys = [.../* @__PURE__ */ new Set([...originalKeys, ...diffKeys])];
+  const originalKeyOrder = originalKeys.join(",");
+  const diffKeyOrder = diffKeys.filter((k) => originalKeys.includes(k)).join(",");
+  if (originalKeyOrder !== diffKeyOrder) {
+    hasDiff = true;
+  }
+  for (const key of allKeys) {
+    if (key === "ref") continue;
+    const originalProp = original[key];
+    const objToDiffProp = objToDiff[key];
+    if (!(key in objToDiff)) {
+      cache[key] = void 0;
+      hasDiff = true;
+      continue;
+    }
+    if (isObject(originalProp) && isObject(objToDiffProp)) {
+      const nestedDiff = diff(originalProp, objToDiffProp, {}, opts);
+      if (nestedDiff && Object.keys(nestedDiff).length > 0) {
+        cache[key] = nestedDiff;
+        hasDiff = true;
+      }
+    } else if (isArray(originalProp) && isArray(objToDiffProp)) {
+      const nestedDiff = diffArrays(originalProp, objToDiffProp, [], opts);
+      if (nestedDiff && nestedDiff.length > 0) {
+        cache[key] = nestedDiff;
+        hasDiff = true;
+      }
+    } else if (objToDiffProp !== originalProp) {
+      cache[key] = objToDiffProp;
+      hasDiff = true;
+    }
+  }
+  return hasDiff ? cache : void 0;
+};
+var diffArrays = (original, objToDiff, cache, opts) => {
+  if (original.length !== objToDiff.length) {
+    return objToDiff;
+  }
+  let hasDiff = false;
+  const originalStringified = original.map((item) => JSON.stringify(item));
+  const diffStringified = objToDiff.map((item) => JSON.stringify(item));
+  if (originalStringified.join(",") !== diffStringified.join(",")) {
+    hasDiff = true;
+  }
+  for (let i = 0; i < original.length; i++) {
+    const diffObj = diff(original[i], objToDiff[i], {}, opts);
+    if (diffObj && (isObject(diffObj) ? Object.keys(diffObj).length > 0 : true)) {
+      cache[i] = diffObj;
+      hasDiff = true;
+    }
+  }
+  return hasDiff ? objToDiff : void 0;
+};
+var diff = (original, objToDiff, cache = {}, opts = {}) => {
+  if (opts.cloneInstances) {
+    original = deepClone(original);
+    objToDiff = deepClone(objToDiff);
+  }
+  original = deepStringifyFunctions(original);
+  objToDiff = deepStringifyFunctions(objToDiff);
+  if (isArray(original) && isArray(objToDiff)) {
+    const result = diffArrays(original, objToDiff, [], opts);
+    return result === void 0 ? {} : result;
+  }
+  if (isObject(original) && isObject(objToDiff)) {
+    const result = diffObjects(original, objToDiff, {}, opts);
+    return result === void 0 ? {} : result;
+  }
+  if (original !== objToDiff) {
+    return objToDiff;
+  }
+  return {};
+};
+var overwrite = (element, params, opts = {}) => {
+  const { __ref: ref } = element;
+  const excl = opts.exclude || [];
+  const allowUnderscore = opts.preventUnderscore;
+  const preventCaching = opts.preventCaching;
+  for (const e in params) {
+    if (excl.includes(e) || !allowUnderscore && e.startsWith("__")) continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp !== void 0) {
+      element[e] = paramsProp;
+      if (ref && !preventCaching) {
+        ref.__cache[e] = elementProp;
+      }
+      if (isObject(opts.diff)) {
+        diff[e] = elementProp;
+      }
+    }
+  }
+  return element;
+};
+var overwriteShallow = (obj, params, excludeFrom = []) => {
+  for (const e in params) {
+    if (excludeFrom.includes(e) || e.startsWith("__")) continue;
+    obj[e] = params[e];
+  }
+  return obj;
+};
+var overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new WeakMap()) => {
+  const excl = opts.exclude || [];
+  const forcedExclude = opts.preventForce ? [] : ["node", "window"];
+  if (!isObjectLike(obj) || !isObjectLike(params) || isDOMNode(obj) || isDOMNode(params)) {
+    return params;
+  }
+  if (visited.has(obj)) return visited.get(obj);
+  visited.set(obj, obj);
+  for (const e in params) {
+    if (!Object.hasOwnProperty.call(params, e)) continue;
+    if (excl.includes(e) || forcedExclude && e.startsWith("__")) continue;
+    const objProp = obj[e];
+    const paramsProp = params[e];
+    if (isDOMNode(paramsProp)) {
+      obj[e] = paramsProp;
+    } else if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
+      obj[e] = overwriteDeep(objProp, paramsProp, opts, visited);
+    } else if (paramsProp !== void 0) {
+      obj[e] = paramsProp;
+    }
+  }
+  return obj;
+};
+var deepContains = (obj1, obj2, ignoredKeys = ["node", "__ref"]) => {
+  if (obj1 === obj2) return true;
+  if (!isObjectLike(obj1) || !isObjectLike(obj2)) return false;
+  if (isDOMNode(obj1) || isDOMNode(obj2)) return obj1 === obj2;
+  const stack = [[obj1, obj2]];
+  const visited = /* @__PURE__ */ new WeakSet();
+  while (stack.length > 0) {
+    const [current1, current2] = stack.pop();
+    if (visited.has(current1)) continue;
+    visited.add(current1);
+    const keys1 = Object.keys(current1).filter(
+      (key) => !ignoredKeys.includes(key)
+    );
+    const keys22 = Object.keys(current2).filter(
+      (key) => !ignoredKeys.includes(key)
+    );
+    if (keys1.length !== keys22.length) return false;
+    for (const key of keys1) {
+      if (!Object.prototype.hasOwnProperty.call(current2, key)) return false;
+      const value1 = current1[key];
+      const value2 = current2[key];
+      if (isDOMNode(value1) || isDOMNode(value2)) {
+        if (value1 !== value2) return false;
+      } else if (isObjectLike(value1) && isObjectLike(value2)) {
+        if (value1 !== value2) {
+          stack.push([value1, value2]);
+        }
+      } else if (value1 !== value2) {
+        return false;
+      }
+    }
+  }
+  return true;
+};
+var removeFromObject = (obj, props) => {
+  if (props === void 0 || props === null) return obj;
+  if (is(props)("string", "number")) {
+    delete obj[props];
+  } else if (isArray(props)) {
+    props.forEach((prop) => delete obj[prop]);
+  } else {
+    throw new Error(
+      "Invalid input: props must be a string or an array of strings"
+    );
+  }
+  return obj;
+};
+var createNestedObject = (arr, lastValue) => {
+  const nestedObject = {};
+  if (arr.length === 0) {
+    return lastValue;
+  }
+  arr.reduce((obj, value, index) => {
+    if (!obj[value]) {
+      obj[value] = {};
+    }
+    if (index === arr.length - 1 && lastValue !== void 0) {
+      obj[value] = lastValue;
+    }
+    return obj[value];
+  }, nestedObject);
+  return nestedObject;
+};
+var removeNestedKeyByPath = (obj, path) => {
+  if (!Array.isArray(path)) {
+    throw new Error("Path must be an array.");
+  }
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    if (current[path[i]] === void 0) {
+      return;
+    }
+    current = current[path[i]];
+  }
+  const lastKey = path[path.length - 1];
+  if (current && Object.hasOwnProperty.call(current, lastKey)) {
+    delete current[lastKey];
+  }
+};
+var setInObjectByPath = (obj, path, value) => {
+  if (!Array.isArray(path)) {
+    throw new Error("Path must be an array.");
+  }
+  let current = obj;
+  for (let i = 0; i < path.length - 1; i++) {
+    if (!current[path[i]] || typeof current[path[i]] !== "object") {
+      current[path[i]] = {};
+    }
+    current = current[path[i]];
+  }
+  const lastKey = path[path.length - 1];
+  current[lastKey] = value;
+  return obj;
+};
+var getInObjectByPath = (obj, path) => {
+  if (!Array.isArray(path)) {
+    throw new Error("Path must be an array.");
+  }
+  let current = obj;
+  for (let i = 0; i < path.length; i++) {
+    if (current === void 0 || current === null) {
+      return void 0;
+    }
+    current = current[path[i]];
+  }
+  return current;
+};
+var detectInfiniteLoop = (arr) => {
+  const maxRepeats = 3;
+  let pattern = [];
+  let repeatCount = 0;
+  for (let i = 0; i < arr.length; i++) {
+    if (pattern.length < 2) {
+      pattern.push(arr[i]);
+    } else {
+      if (arr[i] === pattern[i % 2]) {
+        repeatCount++;
+      } else {
+        pattern = [arr[i - 1], arr[i]];
+        repeatCount = 1;
+      }
+      if (repeatCount >= maxRepeats * 2) {
+        if (isNotProduction()) {
+          console.warn(
+            "Warning: Potential infinite loop detected due to repeated sequence:",
+            pattern
+          );
+        }
+        return true;
+      }
+    }
+  }
+};
+
+// ../../../domql/packages/utils/dist/esm/function.js
+function getContextFunction(fnKey) {
+  var _a, _b, _c, _d;
+  return ((_a = this.context.utils) == null ? void 0 : _a[fnKey]) || ((_b = this.context.functions) == null ? void 0 : _b[fnKey]) || ((_c = this.context.methods) == null ? void 0 : _c[fnKey]) || ((_d = this.context.snippets) == null ? void 0 : _d[fnKey]);
+}
+
+// ../../../domql/packages/utils/dist/esm/cookie.js
+var isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
+
+// ../../../domql/packages/utils/dist/esm/tags.js
+var HTML_TAGS = {
+  root: ["body", "html"],
+  head: ["title", "base", "meta", "style", "noscript", "script"],
+  body: [
+    "string",
+    "style",
+    "fragment",
+    "a",
+    "abbr",
+    "acronym",
+    "address",
+    "applet",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "basefont",
+    "bdi",
+    "bdo",
+    "big",
+    "blockquote",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "center",
+    "cite",
+    "code",
+    "search",
+    "col",
+    "colgroup",
+    "data",
+    "datalist",
+    "dd",
+    "del",
+    "details",
+    "dfn",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "font",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "i",
+    "iframe",
+    "img",
+    "input",
+    "ins",
+    "kbd",
+    "label",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "map",
+    "mark",
+    "meter",
+    "nav",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "picture",
+    "pre",
+    "progress",
+    "hgroup",
+    "q",
+    "rp",
+    "rt",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "section",
+    "select",
+    "small",
+    "source",
+    "span",
+    "strike",
+    "strong",
+    "sub",
+    "summary",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "hgroup",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "tr",
+    "track",
+    "tt",
+    "u",
+    "ul",
+    "var",
+    "video",
+    "wbr",
+    // SVG
+    "svg",
+    "path"
+  ]
+};
+var isValidHtmlTag = (arg) => HTML_TAGS.body.includes(arg);
+
+// ../../../domql/packages/utils/dist/esm/component.js
+var __defProp3 = Object.defineProperty;
+var __defProps2 = Object.defineProperties;
+var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp3.call(b, prop))
+      __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b)) {
+      if (__propIsEnum2.call(b, prop))
+        __defNormalProp2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
+var checkIfKeyIsComponent = (key) => {
+  const isFirstKeyString = isString(key);
+  if (!isFirstKeyString) return;
+  const firstCharKey = key.slice(0, 1);
+  return /^[A-Z]*$/.test(firstCharKey);
+};
+var addAdditionalExtend = (newExtend, element) => {
+  if (!newExtend) return element;
+  const { extend: elementExtend } = element;
+  const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend];
+  const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
+  const extend = joinArrays(receivedArray, originalArray);
+  return __spreadProps2(__spreadValues2({}, element), { extend });
+};
+var checkIfSugar = (element, parent2, key) => {
+  var _a;
+  const {
+    extend,
+    props,
+    childExtend,
+    extends: extendProps,
+    childExtends,
+    childProps,
+    children,
+    on,
+    $collection,
+    $stateCollection,
+    $propsCollection
+  } = element;
+  const hasComponentAttrs = extend || childExtend || props || on || $collection || $stateCollection || $propsCollection;
+  if (hasComponentAttrs && (childProps || extendProps || children || childExtends)) {
+    const logErr = (_a = parent2 || element) == null ? void 0 : _a.error;
+    if (logErr)
+      logErr.call(
+        parent2,
+        element,
+        "Sugar component includes params for builtin components",
+        { verbose: true }
+      );
+  }
+  return !hasComponentAttrs || childProps || extendProps || children || childExtends;
+};
+var extractComponentKeyFromKey = (key) => {
+  return key.includes("+") ? key.split("+") : key.includes("_") ? [key.split("_")[0]] : key.includes(".") && !checkIfKeyIsComponent(key.split(".")[1]) ? [key.split(".")[0]] : [key];
+};
+var extendizeByKey = (element, parent2, key) => {
+  const { context } = parent2;
+  const { tag, extend, childExtends } = element;
+  const isSugar = checkIfSugar(element, parent2, key);
+  const extendFromKey = extractComponentKeyFromKey(key);
+  const isExtendKeyComponent = context && context.components[extendFromKey];
+  if (element === isExtendKeyComponent) return element;
+  else if (isSugar) {
+    const newElem = addAdditionalExtend(element.extends, {
+      extend: extendFromKey,
+      tag,
+      props: __spreadValues2({}, element)
+    });
+    if (newElem.props.data) {
+      newElem.data = newElem.props.data;
+      delete newElem.props.data;
+    }
+    if (newElem.props.state) {
+      newElem.state = newElem.props.state;
+      delete newElem.props.state;
+    }
+    if (newElem.props.attr) {
+      newElem.attr = newElem.props.attr;
+      delete newElem.props.attr;
+    }
+    if (newElem.props.if) {
+      newElem.if = newElem.props.if;
+      delete newElem.props.if;
+    }
+    if (childExtends) newElem.childExtend = childExtends;
+    return newElem;
+  } else if (!extend || extend === true) {
+    return __spreadProps2(__spreadValues2({}, element), {
+      tag,
+      extend: extendFromKey
+    });
+  } else if (extend) {
+    return addAdditionalExtend(extendFromKey, element);
+  } else if (isFunction(element)) {
+    return {
+      extend: extendFromKey,
+      tag,
+      props: __spreadValues2({}, exec(element, parent2))
+    };
+  }
+};
+function getCapitalCaseKeys(obj) {
+  return Object.keys(obj).filter((key) => /^[A-Z]/.test(key));
+}
+var addChildrenIfNotInOriginal = (element, parent2, key) => {
+  const childElems = getCapitalCaseKeys(element.props);
+  if (!childElems.length) return element;
+  for (const i in childElems) {
+    const childKey = childElems[i];
+    const childElem = element[childKey];
+    const newChild = element.props[childKey];
+    const assignChild = (val) => {
+      element[childKey] = val;
+      delete element.props[childKey];
+    };
+    if (newChild == null ? void 0 : newChild.ignoreExtend) continue;
+    if (newChild === null) assignChild(null);
+    else if (!childElem) assignChild(deepClone(newChild));
+    else {
+      const isSugarChildElem = checkIfSugar(childElem, parent2, key);
+      if (isSugarChildElem) continue;
+      assignChild({
+        extend: element[childKey],
+        props: newChild
+      });
+    }
+  }
+};
+var applyKeyComponentAsExtend = (element, parent2, key) => {
+  return extendizeByKey(element, parent2, key) || element;
+};
+var applyComponentFromContext = (element, parent2, options) => {
+  const { context } = element;
+  if (!context || !context.components) return;
+  const { components } = context;
+  const { extend } = element;
+  const execExtend = exec(extend, element);
+  if (isString(execExtend)) {
+    const componentExists = components[execExtend] || components["smbls." + execExtend];
+    if (componentExists) element.extend = componentExists;
+    else {
+      if (isNotProduction() && options.verbose) {
+        console.warn(execExtend, "is not in library", components, element);
+        console.warn("replacing with ", {});
+      }
+      element.extend = {};
+    }
+  }
+};
+var isVariant = (param) => {
+  if (!isString(param)) return;
+  const firstCharKey = param.slice(0, 1);
+  return firstCharKey === ".";
+};
+var hasVariantProp = (element) => {
+  const { props } = element;
+  if (isObject(props) && isString(props.variant)) return true;
+};
+var setContentKey = (el, opts = {}) => {
+  const { __ref: ref } = el;
+  const contentElementKey = opts.contentElementKey;
+  if (contentElementKey !== "content" && contentElementKey !== ref.contentElementKey || !ref.contentElementKey) {
+    ref.contentElementKey = contentElementKey || "content";
+  } else ref.contentElementKey = "content";
+  if (contentElementKey !== "content") opts.contentElementKey = "content";
+  return ref.contentElementKey;
+};
+
+// ../../../domql/plugins/report/dist/esm/index.js
+var ERRORS_REGISTRY = {
+  en: {
+    DocumentNotDefined: {
+      title: "Document is undefined",
+      description: "To tweak with DOM, you should use browser."
+    },
+    OverwriteToBuiltin: {
+      title: "Overwriting to builtin method",
+      description: "Overwriting a builtin method in the window define is not possible, please choose different name"
+    },
+    BrowserNotDefined: {
+      title: "Can't recognize environment",
+      description: "Environment should be browser application, that can run Javascript"
+    },
+    SetQuickPreferancesIsNotObject: {
+      title: "Quick preferances object is required",
+      description: 'Please pass a plain object with "lang", "culture" and "area" properties'
+    },
+    InvalidParams: {
+      title: "Params are invalid",
+      description: 'Please pass a plain object with "lang", "culture" and "area" properties'
+    },
+    CantCreateWithoutNode: {
+      title: "You must provide node",
+      description: "Can't create DOM element without setting node or text"
+    },
+    HTMLInvalidTag: {
+      title: "Element tag name (or DOM nodeName) is invalid",
+      description: "To create element, you must provide valid DOM node. See full list of them at here: http://www.w3schools.com/tags/"
+    },
+    HTMLInvalidAttr: {
+      title: "Attibutes object is invalid",
+      description: "Please pass a valid plain object to apply as an attributes for a DOM node"
+    },
+    HTMLInvalidData: {
+      title: "Data object is invalid",
+      description: "Please pass a valid plain object to apply as an dataset for a DOM node"
+    },
+    HTMLInvalidStyles: {
+      title: "Styles object is invalid",
+      description: "Please pass a valid plain object to apply as an style for a DOM node"
+    },
+    HTMLInvalidText: {
+      title: "Text string is invalid",
+      description: "Please pass a valid string to apply text to DOM node"
+    },
+    ElementOnStateIsNotDefined: {
+      title: "Element on state is not defined",
+      description: "Please check the element object"
+    }
+  }
+};
+var report = (err, arg, element) => {
+  const currentLang = "en";
+  let errObj;
+  if (err && typeof err === "string") errObj = ERRORS_REGISTRY[currentLang][err];
+  return new Error(
+    `"${err}", "${arg}"
+
+`,
+    `${errObj.description}`,
+    element ? `
+
+${element}` : ""
+  );
+};
+
+// ../../../domql/packages/element/props/ignore.js
+var IGNORE_PROPS_PARAMS = ["update", "__element"];
+
+// ../../../domql/packages/element/props/inherit.js
+var objectizeStringProperty = (propValue) => {
+  if (is(propValue)("string", "number")) {
+    return { inheritedString: propValue };
+  }
+  return propValue;
+};
+var inheritParentProps = (element, parent2) => {
+  var _a;
+  let propsStack = [];
+  const parentProps = exec(parent2, parent2.state).props;
+  const matchParent = parent2.props && parentProps[element.key];
+  const matchParentIsString = isString(matchParent);
+  const matchParentChildProps = parentProps && parentProps.childProps;
+  if (matchParent) {
+    if (matchParentIsString) {
+      const inheritedStringExists = propsStack.filter((v) => v.inheritedString)[0];
+      if (inheritedStringExists) inheritedStringExists.inheritedString = matchParent;
+      else {
+        propsStack = [].concat(objectizeStringProperty(matchParent), propsStack);
+      }
+    } else {
+      propsStack.push(objectizeStringProperty(matchParent));
+    }
+  }
+  if (matchParentChildProps && !((_a = element == null ? void 0 : element.props) == null ? void 0 : _a.ignoreChildProps)) propsStack.push(matchParentChildProps);
+  return propsStack;
+};
+
+// ../../../domql/packages/element/props/create.js
+var createPropsStack = (element, parent2) => {
+  const { props, __ref: ref } = element;
+  const propsStack = ref.__props = inheritParentProps(element, parent2);
+  if (isObject(props)) propsStack.push(props);
+  else if (props === "inherit" && parent2.props) propsStack.push(parent2.props);
+  else if (props) propsStack.push(props);
+  if (isArray(ref.__extend)) {
+    ref.__extend.forEach((extend) => {
+      if (extend.props && extend.props !== props) propsStack.push(extend.props);
+    });
+  }
+  ref.__props = propsStack;
+  return propsStack;
+};
+var syncProps = async (props, element, opts) => {
+  element.props = {};
+  const mergedProps = {};
+  props.forEach((v) => {
+    if (IGNORE_PROPS_PARAMS.includes(v)) return;
+    let execProps;
+    try {
+      execProps = exec(v, element, element.state, element.context, opts);
+    } catch (e) {
+      element.error(e, opts);
+    }
+    element.props = deepMerge(
+      mergedProps,
+      deepClone(execProps, { ignore: IGNORE_PROPS_PARAMS }),
+      IGNORE_PROPS_PARAMS
+    );
+  });
+  element.props = mergedProps;
+  const methods = {
+    update: await update.bind(element.props),
+    __element: element
+  };
+  Object.setPrototypeOf(element.props, methods);
+  return element.props;
+};
+var createProps = function(element, parent2, options) {
+  const { __ref: ref } = element;
+  const applyProps = () => {
+    const propsStack = options.cachedProps || createPropsStack(element, parent2);
+    if (propsStack.length) {
+      ref.__props = propsStack;
+      syncProps(propsStack, element, options);
+    } else {
+      ref.__props = options.cachedProps || [];
+      element.props = {};
+    }
+  };
+  if (ref.__if) applyProps();
+  else {
+    try {
+      applyProps();
+    } catch (e) {
+      element.props = {};
+      ref.__props = options.cachedProps || [];
+      element.error("Error applying props", e, options);
+    }
+  }
+  const methods = { update: update.bind(element.props), __element: element };
+  Object.setPrototypeOf(element.props, methods);
+  return element;
+};
+async function update(props, options) {
+  const element = this.__element;
+  await element.update({ props }, options);
+}
+
+// ../../../domql/packages/element/props/update.js
+var updateProps = (newProps, element, parent2, opts) => {
+  const { __ref } = element;
+  let propsStack = __ref.__props;
+  const parentProps = inheritParentProps(element, parent2);
+  if (parentProps.length)
+    propsStack = __ref.__props = [].concat(parentProps, propsStack);
+  if (newProps) propsStack = __ref.__props = [].concat(newProps, propsStack);
+  if (propsStack) syncProps(propsStack, element, opts);
+  return element;
+};
+
+// ../../../domql/packages/element/utils/object.js
+var IGNORE_STATE_PARAMS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "set",
+  "reset",
+  "replace",
+  "quietReplace",
+  "quietUpdate",
+  "applyReplace",
+  "applyFunction",
+  "rootUpdate",
+  "parentUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root",
+  "setByPath",
+  "setPathCollection",
+  "removeByPath",
+  "removePathCollection",
+  "getByPath"
+];
+var METHODS = [
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "getRef",
+  "getPath",
+  "setNodeStyles",
+  "spotByPath",
+  "append",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "nextElement",
+  "previousElement"
+];
+var METHODS_EXL = joinArrays(
+  ["node", "state", "context", "extend", "__element"],
+  METHODS,
+  IGNORE_STATE_PARAMS,
+  IGNORE_PROPS_PARAMS
+);
+var deepMerge2 = (element, extend, exclude = METHODS_EXL) => {
+  for (const e in extend) {
+    if (exclude.includes(e)) continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if (isObjectLike(elementProp) && isObject(extendProp)) {
+      deepMerge2(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+var overwrite2 = (element, params, options) => {
+  const changes = {};
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  for (const e in params) {
+    if (e === "props" || e === "state" || e === "__ref") continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp !== void 0) {
+      __cached[e] = changes[e] = elementProp;
+      element[e] = paramsProp;
+    }
+    if (options.cleanExec) delete __exec[e];
+  }
+  return changes;
+};
+
+// ../../../domql/packages/element/utils/extendUtils.js
+var generateHash = () => Math.random().toString(36).substring(2);
+var extendStackRegistry = {};
+var getHashedExtend = (extend) => {
+  return extendStackRegistry[extend.__hash];
+};
+var setHashedExtend = (extend, stack) => {
+  const hash = generateHash();
+  if (!isString(extend)) {
+    extend.__hash = hash;
+  }
+  extendStackRegistry[hash] = stack;
+  return stack;
+};
+var getExtendStackRegistry = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend(extend));
+  }
+  return setHashedExtend(extend, stack);
+};
+var extractArrayExtend = (extend, stack, context) => {
+  extend.forEach((each) => flattenExtend(each, stack, context));
+  return stack;
+};
+var deepExtend = (extend, stack, context) => {
+  const extendOflattenExtend = extend.extend;
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack, context);
+  }
+  return stack;
+};
+var flattenExtend = (extend, stack, context) => {
+  if (!extend) return stack;
+  if (isArray(extend)) return extractArrayExtend(extend, stack, context);
+  if (isString(extend)) extend = fallbackStringExtend(extend, context);
+  stack.push(extend);
+  if (extend.extend) deepExtend(extend, stack, context);
+  return stack;
+};
+var deepMergeExtend = (element, extend) => {
+  for (const e in extend) {
+    if (["parent", "node", "__element"].indexOf(e) > -1) continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if (isObject(elementProp) && isObject(extendProp)) {
+      deepMergeExtend(elementProp, extendProp);
+    } else if (isArray(elementProp) && isArray(extendProp)) {
+      element[e] = elementProp.concat(extendProp);
+    } else if (isArray(elementProp) && isObject(extendProp)) {
+      const obj = deepMergeExtend({}, elementProp);
+      element[e] = deepMergeExtend(obj, extendProp);
+    } else if (elementProp === void 0 && isFunction(extendProp)) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+var cloneAndMergeArrayExtend = (stack) => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend(a, deepClone(c));
+  }, {});
+};
+var fallbackStringExtend = (extend, context, options = {}, variant) => {
+  const COMPONENTS = context && context.components || options.components;
+  const PAGES = context && context.pages || options.pages;
+  if (isString(extend)) {
+    const componentExists = COMPONENTS && (COMPONENTS[extend + "." + variant] || COMPONENTS[extend] || COMPONENTS["smbls." + extend]);
+    const pageExists = PAGES && extend.startsWith("/") && PAGES[extend];
+    if (componentExists) return componentExists;
+    else if (pageExists) return pageExists;
+    else {
+      if (options.verbose && isNotProduction()) {
+        console.warn("Extend is string but component was not found:", extend);
+      }
+      return {};
+    }
+  }
+  return extend;
+};
+var jointStacks = (extendStack, childExtendStack) => {
+  return [].concat(extendStack.slice(0, 1)).concat(childExtendStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendStack.slice(1));
+};
+var getExtendStack = (extend, context) => {
+  if (!extend) return [];
+  if (extend.__hash) return getHashedExtend(extend) || [];
+  const stack = flattenExtend(extend, [], context);
+  return getExtendStackRegistry(extend, stack);
+};
+
+// ../../../domql/packages/element/extend.js
+var mainExtend;
+var applyExtend = (element, parent2, options = {}) => {
+  if (isFunction(element)) element = exec(element, parent2);
+  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 || parent2.context;
+  extend = fallbackStringExtend(extend, context, options, variant);
+  const extendStack = getExtendStack(extend, context);
+  delete element.extend;
+  let childExtendStack = [];
+  if (parent2) {
+    element.parent = parent2;
+    if (!options.ignoreChildExtend && !(props && props.ignoreChildExtend)) {
+      childExtendStack = getExtendStack(parent2.childExtend, context);
+      const ignoreChildExtendRecursive = props && props.ignoreChildExtendRecursive;
+      if (parent2.childExtendsRecursive && !ignoreChildExtendRecursive) {
+        const canExtendRecursive = element.key !== "__text";
+        if (canExtendRecursive) {
+          const childExtendsRecursiveStack = getExtendStack(
+            parent2.childExtendsRecursive,
+            context
+          );
+          childExtendStack = childExtendStack.concat(childExtendsRecursiveStack);
+          element.childExtendsRecursive = parent2.childExtendsRecursive;
+        }
+      }
+    }
+  }
+  const extendLength = extendStack.length;
+  const childExtendLength = childExtendStack.length;
+  let stack = [];
+  if (extendLength && childExtendLength) {
+    stack = jointStacks(extendStack, childExtendStack);
+  } else if (extendLength) {
+    stack = extendStack;
+  } else if (childExtendLength) {
+    stack = childExtendStack;
+  } else if (!context.defaultExtends) return element;
+  if (context.defaultExtends) {
+    if (!mainExtend) {
+      const defaultOptionsExtend = getExtendStack(
+        context.defaultExtends,
+        context
+      );
+      mainExtend = cloneAndMergeArrayExtend(defaultOptionsExtend);
+      delete mainExtend.extend;
+    }
+    stack = [].concat(stack, mainExtend);
+  }
+  if (__ref) __ref.__extend = stack;
+  let mergedExtend = cloneAndMergeArrayExtend(stack);
+  const COMPONENTS = context && context.components || options.components;
+  const component = exec(element.component || mergedExtend.component, element);
+  if (component && COMPONENTS && COMPONENTS[component]) {
+    const componentExtend = cloneAndMergeArrayExtend(
+      getExtendStack(COMPONENTS[component])
+    );
+    mergedExtend = deepMergeExtend(componentExtend, mergedExtend);
+  }
+  const merged = deepMergeExtend(element, mergedExtend);
+  return merged;
+};
+
+// ../../../domql/packages/element/mixins/classList.js
+var 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) !== "_") {
+    element.class = key.slice(1);
+  }
+};
+var classify = (obj, element, opts) => {
+  let className = "";
+  for (const item in obj) {
+    const param = obj[item];
+    if (typeof param === "boolean" && param) className += ` ${item}`;
+    else if (typeof param === "string") className += ` ${param}`;
+    else if (typeof param === "function") {
+      className += ` ${exec(param, element, element.state, element.context, opts)}`;
+    }
+  }
+  return className;
+};
+var classList = (params, element, opts) => {
+  if (!params) return;
+  const { key } = element;
+  if (params === true) params = element.class = { key };
+  if (isString(params)) params = element.class = { default: params };
+  if (isObject(params)) params = classify(params, element, opts);
+  const className = params.replace(/\s+/g, " ").trim();
+  if (element.ref) element.ref.class = className;
+  return className;
+};
+
+// ../../../domql/packages/element/cache/options.js
+var OPTIONS = {};
+
+// ../../../domql/packages/event/dist/esm/on.js
+var getOnOrPropsEvent = (param, element) => {
+  var _a, _b;
+  const onEvent = (_a = element.on) == null ? void 0 : _a[param];
+  const onPropEvent = (_b = element.props) == null ? void 0 : _b["on" + param.slice(0, 1).toUpperCase() + param.slice(1)];
+  return onEvent || onPropEvent;
+};
+var applyEvent = (fnValue, element, state2, context, options) => {
+  if (isString(fnValue)) fnValue = getContextFunction.call(element, fnValue);
+  if (!fnValue.call) element.warn(`Event is not executable: ${fnValue}`);
+  return fnValue.call(
+    element,
+    element,
+    state2 || element.state,
+    context || element.context,
+    options
+  );
+};
+var triggerEventOn = async (param, element, options) => {
+  const appliedFunction = getOnOrPropsEvent(param, element);
+  const ref = element.__ref;
+  if (ref.__stormAbortion) {
+    return;
+  }
+  if (appliedFunction) {
+    const { state: state2, context } = element;
+    return await applyEvent(appliedFunction, element, state2, context, options);
+  }
+};
+var applyEventUpdate = (fnValue, updatedObj, element, state2, context, options) => {
+  if (isString(fnValue)) fnValue = getContextFunction.call(element, fnValue);
+  if (!fnValue.call) element.warn(`Event is not executable: ${fnValue}`);
+  return fnValue.call(
+    element,
+    updatedObj,
+    element,
+    state2 || element.state,
+    context || element.context,
+    options
+  );
+};
+var triggerEventOnUpdate = async (param, updatedObj, element, options) => {
+  const appliedFunction = getOnOrPropsEvent(param, element);
+  if (appliedFunction) {
+    const { state: state2, context } = element;
+    return await applyEventUpdate(
+      appliedFunction,
+      updatedObj,
+      element,
+      state2,
+      context,
+      options
+    );
+  }
+};
+var applyEventsOnNode = (element, options) => {
+  const { node, on } = element;
+  for (const param in on) {
+    if (param === "init" || param === "beforeClassAssign" || param === "render" || param === "renderRouter" || param === "attachNode" || param === "stateInit" || param === "stateCreated" || param === "beforeStateUpdate" || param === "stateUpdate" || param === "beforeUpdate" || param === "done" || param === "create" || param === "complete" || param === "frame" || param === "update")
+      continue;
+    let fnValue = getOnOrPropsEvent(param, element);
+    if (isString(fnValue)) {
+      fnValue = getContextFunction.call(element, fnValue);
+    }
+    if (isFunction(fnValue)) {
+      node.addEventListener(param, async (event) => {
+        const { state: state2, context } = element;
+        await fnValue.call(element, event, element, state2, context, options);
+      });
+    }
+  }
+};
+
+// ../../../domql/packages/event/dist/esm/can.js
+var canRenderTag = (tag) => {
+  return isValidHtmlTag(tag || "div") || report("HTMLInvalidTag");
+};
+
+// ../../../domql/packages/event/dist/esm/animationFrame.js
+var registerFrameListener = (el) => {
+  const { __ref: ref } = el;
+  const { frameListeners } = ref.root.data;
+  if (frameListeners && !frameListeners.has(el)) {
+    frameListeners.add(el);
+  }
+};
+var applyAnimationFrame = (element, options) => {
+  const { props, on, __ref: ref } = element;
+  const { frameListeners } = ref.root.data;
+  if (frameListeners && ((on == null ? void 0 : on.frame) || (props == null ? void 0 : props.onFrame))) {
+    registerFrameListener(element);
+  }
+};
+
+// ../../../domql/packages/render/dist/esm/cache.js
+var createHTMLNode = (element) => {
+  const { tag, context } = element;
+  const doc = context.document || document2;
+  if (tag) {
+    if (tag === "string") return doc.createTextNode(element.text);
+    else if (tag === "fragment") {
+      return doc.createDocumentFragment();
+    } else if (tag === "svg" || tag === "path") {
+      return doc.createElementNS("http://www.w3.org/2000/svg", tag);
+    } else return doc.createElement(tag);
+  } else {
+    return doc.createElement("div");
+  }
+};
+var detectTag = (element) => {
+  let { tag, key, props } = element;
+  tag = exec(tag, element);
+  if (tag === true) tag = key;
+  if (isObject(props) && isString(props.tag)) {
+    const tagExists = isValidHtmlTag(props.tag);
+    if (tagExists) return props.tag;
+  }
+  if (isString(tag)) {
+    if (isValidHtmlTag(tag)) return tag;
+  } else {
+    let keyAsTag = key.toLowerCase();
+    if (keyAsTag.includes(".")) keyAsTag = keyAsTag.split(".")[0];
+    if (keyAsTag.includes("_")) keyAsTag = keyAsTag.split("_")[0];
+    if (isValidHtmlTag(keyAsTag)) return keyAsTag;
+  }
+  return "div";
+};
+var cacheNode = (element) => {
+  const { context } = element;
+  const win = context.window || window;
+  const tag = element.tag = detectTag(element);
+  if (!canRenderTag(tag)) {
+    return report("HTMLInvalidTag", element.tag, element);
+  }
+  if (!win.nodeCaches) win.nodeCaches = {};
+  let cachedTag = win.nodeCaches[tag];
+  if (!cachedTag) cachedTag = win.nodeCaches[tag] = createHTMLNode(element);
+  const clonedNode = cachedTag.cloneNode(true);
+  if (tag === "string") clonedNode.nodeValue = element.text;
+  return clonedNode;
+};
+
+// ../../../domql/packages/render/dist/esm/append.js
+var appendNode = (node, parentNode, el) => {
+  var _a;
+  const win = ((_a = el == null ? void 0 : el.context) == null ? void 0 : _a.window) || window;
+  try {
+    if (parentNode && typeof parentNode.appendChild === "function") {
+      if (parentNode instanceof win.Node && typeof parentNode.appendChild === "function") {
+        parentNode.appendChild(node);
+      } else {
+        throw new Error(
+          "Invalid parentNode: appendChild is not supported on this node type."
+        );
+      }
+    } else {
+      throw new Error(
+        "Invalid parentNode: appendChild is not supported on this node type."
+      );
+    }
+  } catch (e) {
+    if (node && node.parentNode) {
+      node.parentNode.removeChild(node);
+    }
+    if (node && parentNode && parentNode instanceof win.Element) {
+      parentNode.appendChild(node);
+    }
+  }
+  return node;
+};
+var insertNodeAfter = (node, siblingNode, parentNode) => {
+  const parent2 = parentNode || siblingNode.parentNode;
+  if (siblingNode.nextSibling) {
+    parent2 && parent2.insertBefore(node, siblingNode.nextSibling);
+  } else if (siblingNode == null ? void 0 : siblingNode.insertAdjacentElement) {
+    siblingNode.insertAdjacentElement("afterend", node);
+  } else {
+    parent2.insertBefore(node, siblingNode);
+  }
+};
+var insertNodeBefore = (node, siblingNode, parentNode) => {
+  const parent2 = parentNode || siblingNode.parentNode;
+  parent2 && parent2.insertBefore(node, siblingNode);
+};
+var assignNode = (element, parent2, key, attachOptions) => {
+  parent2[key || element.key] = element;
+  if (element.tag !== "shadow") {
+    if (attachOptions && attachOptions.position) {
+      ;
+      (attachOptions.position === "before" ? insertNodeBefore : insertNodeAfter)(element.node, attachOptions.node || parent2.node);
+    } else {
+      appendNode(element.node, parent2.node, element);
+    }
+  }
+  return element;
+};
+
+// ../../../domql/packages/element/tree.js
+var ROOT = {
+  key: ":root",
+  node: document2 ? document2.body : report("DocumentNotDefined", document2)
+};
+var TREE = ROOT;
+
+// ../../../domql/packages/element/methods/index.js
+function spotByPath(path) {
+  const element = this;
+  const arr = [].concat(path);
+  let active = TREE[arr[0]];
+  if (!arr || !arr.length)
+    return console.log(arr, "on", element.key, "is undefined");
+  while (active.key === arr[0]) {
+    arr.shift();
+    if (!arr.length) break;
+    active = active[arr[0]];
+    if (!active) return;
+  }
+  return active;
+}
+function lookup(param) {
+  const el = this;
+  let { parent: parent2 } = el;
+  if (isFunction(param)) {
+    if (parent2.state && param(parent2, parent2.state, parent2.context))
+      return parent2;
+    else if (parent2.parent) return parent2.lookup(param);
+    else return;
+  }
+  if (el[param]) return el[param];
+  while (parent2.param !== param) {
+    if (parent2[param]) return parent2[param];
+    parent2 = parent2.parent;
+    if (!parent2) return;
+  }
+  return parent2;
+}
+function lookdown(param) {
+  var _a;
+  const el = this;
+  const { __ref: ref } = el;
+  const children = ref == null ? void 0 : ref.__children;
+  if (!children) return;
+  for (let i = 0; i < children.length; i++) {
+    const v = children[i];
+    const childElem = el[v];
+    if (!childElem)
+      return this.warn(
+        "Element found in children array but it does not exist in parent"
+      );
+    if (v === param) return childElem;
+    else if (isFunction(param)) {
+      if (!childElem) {
+        this.error(
+          `"${v}" found in element __children, but content is not defined`
+        );
+        continue;
+      }
+      const exec2 = param(childElem, childElem.state, childElem.context);
+      if (childElem.state && exec2) {
+        return childElem;
+      }
+    }
+    const lookdown2 = (_a = childElem == null ? void 0 : childElem.lookdown) == null ? void 0 : _a.call(childElem, param);
+    if (lookdown2) return lookdown2;
+  }
+}
+function lookdownAll(param, results = []) {
+  var _a;
+  const el = this;
+  const { __ref: ref } = el;
+  const children = ref == null ? void 0 : ref.__children;
+  if (!children) return;
+  for (let i = 0; i < children.length; i++) {
+    const v = children[i];
+    const childElem = el[v];
+    if (v === param) results.push(childElem);
+    else if (isFunction(param)) {
+      if (!childElem) {
+        this.error(
+          `"${v}" found in element __children, but content is not defined`
+        );
+        continue;
+      }
+      const exec2 = param(childElem, childElem.state, childElem.context);
+      if (childElem.state && exec2) results.push(childElem);
+    }
+    (_a = childElem == null ? void 0 : childElem.lookdownAll) == null ? void 0 : _a.call(childElem, param, results);
+  }
+  return results.length ? results : void 0;
+}
+function setNodeStyles(params = {}) {
+  var _a;
+  const el = this;
+  if (!((_a = el.node) == null ? void 0 : _a.style)) return;
+  for (const param in params) {
+    const value = params[param];
+    const childElem = el[param];
+    if (isObject(value) && childElem) setNodeStyles.call(childElem, value);
+    else el.node.style[param] = value;
+  }
+  return el;
+}
+async function remove(opts = {}) {
+  var _a;
+  const element = this;
+  const beforeRemoveReturns = triggerEventOn("beforeRemove", element, opts);
+  if (beforeRemoveReturns === false) return element;
+  if (isFunction(element.node.remove)) element.node.remove();
+  else if ((_a = element.node) == null ? void 0 : _a.parentNode)
+    element.node.parentNode.removeChild(element.node);
+  else if (!isProduction()) {
+    console.warn("This item cant be removed");
+    element.log();
+  }
+  delete element.parent[element.key];
+  if (element.parent.__ref)
+    element.parent.__ref.__children = removeValueFromArray(
+      element.parent.__ref.__children,
+      element.key
+    );
+  await triggerEventOn("remove", element, opts);
+}
+function setProps(param, opts = {}) {
+  const element = this;
+  if (!param || !element.props) return;
+  element.update({ props: param }, opts);
+  return element;
+}
+function getRef(key) {
+  if (key) return this.__ref && this.__ref[key];
+  return this.__ref;
+}
+function getPath() {
+  return this.getRef().path;
+}
+function keys() {
+  const element = this;
+  const keys3 = [];
+  for (const param in element) {
+    if (REGISTRY[param] && !parseFilters.elementKeys.includes(param) || !Object.hasOwnProperty.call(element, param)) {
+      continue;
+    }
+    keys3.push(param);
+  }
+  return keys3;
+}
+function parse(excl = []) {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  keyList.forEach((v) => {
+    if (excl.includes(v)) return;
+    const val = element[v];
+    if (v === "state") {
+      if (element.__ref && !element.__ref.__hasRootState) return;
+      const parsedVal = isFunction(val && val.parse) ? val.parse() : val;
+      obj[v] = isFunction(parsedVal) ? parsedVal : JSON.parse(JSON.stringify(parsedVal || {}));
+    } else if (v === "scope") {
+      if (element.__ref && !element.__ref.__hasRootScope) return;
+      obj[v] = JSON.parse(JSON.stringify(val || {}));
+    } else if (v === "props") {
+      const { __element, update: update3, ...props } = element[v];
+      obj[v] = props;
+    } else if (isDefined(val) && Object.hasOwnProperty.call(element, v))
+      obj[v] = val;
+  });
+  return obj;
+}
+function parseDeep(excl = []) {
+  const element = this;
+  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);
+    }
+  }
+  return obj;
+}
+function verbose(element, ...args) {
+  if (isProduction()) return;
+  const parent2 = this;
+  const { __ref: ref } = parent2;
+  console.groupCollapsed(parent2.key);
+  if (args.length) {
+    args.forEach(
+      (v) => console.log(`%c${v}:
+`, "font-weight: bold", parent2[v])
+    );
+  } else {
+    console.log(ref.path);
+    const keys3 = parent2.keys();
+    keys3.forEach((v) => console.log(`%c${v}:`, "font-weight: bold", parent2[v]));
+  }
+  console.log(parent2);
+  console.groupEnd(parent2.key);
+  return parent2;
+}
+function log(...params) {
+  console.log(...params);
+}
+function warn(...params) {
+  console.warn(...params, this);
+}
+function error(...params) {
+  var _a, _b, _c, _d;
+  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, ...params);
+  if (isFunction((_c = params[params.length - 1]) == null ? void 0 : _c.onError))
+    (_d = params[params.length - 1]) == null ? void 0 : _d.onError.call(this, ...params);
+  console.error(...params, this);
+}
+function nextElement() {
+  const element = this;
+  const { key, parent: parent2 } = element;
+  const { __children } = parent2.__ref;
+  const currentIndex = __children.indexOf(key);
+  const nextChild = __children[currentIndex + 1];
+  return parent2[nextChild];
+}
+async function append(el, key, opts) {
+  return await create(el, this, key, opts);
+}
+function previousElement(el) {
+  const element = el || this;
+  const { key, parent: parent2 } = element;
+  const { __children } = parent2.__ref;
+  if (!__children) return;
+  const currentIndex = __children.indexOf(key);
+  return parent2[__children[currentIndex - 1]];
+}
+function variables(obj = {}) {
+  const element = this;
+  if (!element.data) element.data = {};
+  if (!element.data.varCaches) element.data.varCaches = {};
+  const varCaches = element.data.varCaches;
+  const changes = {};
+  let changed;
+  for (const key in obj) {
+    if (obj[key] !== varCaches[key]) {
+      changed = true;
+      changes[key] = obj[key];
+    }
+  }
+  return {
+    changed: (cb) => {
+      if (!changed || !varCaches) return;
+      const returns = cb(changes, clone(varCaches));
+      for (const key in changes) {
+        varCaches[key] = changes[key];
+      }
+      return returns;
+    },
+    timeout: (cb, timeout) => {
+      if (!changed) return;
+      const t = setTimeout(() => {
+        cb(changes);
+        clearTimeout(t);
+      }, timeout);
+    }
+  };
+}
+function call(fnKey, ...args) {
+  const fn = getContextFunction.call(this, fnKey);
+  if (!fn) return void 0;
+  try {
+    const result = fn.call(this, ...args);
+    if (result && typeof result.then === "function") {
+      return result;
+    }
+    return result;
+  } catch (error2) {
+    console.error(`Error calling function: '${fnKey}'
+`, error2);
+    throw new Error(error2);
+  }
+}
+var METHODS2 = [
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "getRef",
+  "getChildren",
+  "getPath",
+  "setNodeStyles",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "verbose",
+  "groupLog",
+  "groupLogEnd",
+  "warn",
+  "error",
+  "call",
+  "nextElement",
+  "append",
+  "previousElement"
+];
+function isMethod(param, element) {
+  var _a, _b;
+  return METHODS2.includes(param) || ((_b = (_a = element == null ? void 0 : element.context) == null ? void 0 : _a.methods) == null ? void 0 : _b[param]);
+}
+
+// ../../../domql/packages/element/iterate.js
+var throughInitialExec = async (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)) {
+      ref.__exec[param] = prop;
+      element[param] = await prop(element, element.state, element.context);
+    }
+  }
+};
+var throughUpdatedExec = async (element, options = { excludes: METHODS_EXL }) => {
+  const { __ref: ref } = element;
+  const changes = {};
+  for (const param in ref.__exec) {
+    const prop = element[param];
+    const isDefinedParam = ref.__defineCache[param];
+    if (isDefinedParam) continue;
+    const newExec = await ref.__exec[param](
+      element,
+      element.state,
+      element.context
+    );
+    const execReturnsString = isString(newExec) || isNumber(newExec);
+    if (prop && prop.node && execReturnsString) {
+      overwrite2(prop, { text: newExec }, options);
+    } else if (newExec !== prop) {
+      if (checkIfKeyIsComponent(param)) {
+        const { extend, ...newElem } = extendizeByKey(newExec, element, param);
+        overwrite2(prop, newElem, options);
+      } else {
+        ref.__cached[param] = changes[param] = prop;
+        element[param] = newExec;
+      }
+    }
+  }
+  return changes;
+};
+var throughExecProps = (element, opts) => {
+  const { __ref: ref } = element;
+  const { props } = element;
+  for (const k in props) {
+    const isDefine = k.startsWith("is") || k.startsWith("has") || k.startsWith("use");
+    if (!ref.__execProps)
+      return warn.call(element, "Element was not initiated to execute props");
+    const cachedExecProp = ref.__execProps[k];
+    if (isFunction(cachedExecProp)) {
+      props[k] = exec(
+        cachedExecProp,
+        element,
+        element.state,
+        element.context,
+        opts
+      );
+    } else if (isDefine && isFunction(props[k])) {
+      ref.__execProps[k] = props[k];
+      props[k] = exec(props[k], element, element.state, element.context, opts);
+    }
+  }
+};
+var throughInitialDefine = async (element, opts) => {
+  const { define, context, __ref: ref } = element;
+  let defineObj = {};
+  const hasGlobalDefine = context && isObject(context.define);
+  if (isObject(define)) defineObj = { ...define };
+  if (hasGlobalDefine) defineObj = { ...defineObj, ...context.define };
+  for (const param in defineObj) {
+    let elementProp = element[param];
+    if (isFunction(elementProp) && !isMethod(param, element) && !isVariant(param)) {
+      ref.__exec[param] = elementProp;
+      const execParam2 = elementProp = await exec(
+        elementProp,
+        element,
+        element.state,
+        element.context,
+        opts
+      );
+      if (execParam2) {
+        elementProp = element[param] = execParam2.parse ? execParam2.parse() : execParam2;
+        ref.__defineCache[param] = elementProp;
+      }
+    }
+    const execParam = await defineObj[param](
+      elementProp,
+      element,
+      element.state,
+      element.context
+    );
+    if (execParam) element[param] = execParam;
+  }
+  return element;
+};
+var throughUpdatedDefine = async (element, opts) => {
+  const { context, define, __ref: ref } = element;
+  const changes = {};
+  let obj = {};
+  if (isObject(define)) obj = { ...define };
+  if (isObject(context && context.define)) obj = { ...obj, ...context.define };
+  for (const param in obj) {
+    const execParam = ref.__exec[param];
+    if (execParam)
+      ref.__defineCache[param] = await execParam(
+        element,
+        element.state,
+        element.context
+      );
+    const cached = await exec(
+      ref.__defineCache[param],
+      element,
+      element.state,
+      element.context,
+      opts
+    );
+    const newExecParam = await obj[param](
+      cached,
+      element,
+      element.state,
+      element.context
+    );
+    if (newExecParam) element[param] = newExecParam;
+  }
+  return changes;
+};
+
+// ../../../domql/packages/element/utils/applyParam.js
+var applyParam = async (param, element, options) => {
+  const { node, context, __ref: ref } = element;
+  const prop = await exec(
+    element[param],
+    element,
+    element.state,
+    element.context,
+    options
+  );
+  const { onlyUpdate } = options;
+  const DOMQLProperty = REGISTRY[param];
+  const DOMQLPropertyFromContext = context && context.registry && context.registry[param];
+  const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
+  const hasDefine = element.define && element.define[param];
+  const hasContextDefine = context && context.define && context.define[param];
+  if (!ref.__if) return;
+  const hasOnlyUpdate = onlyUpdate ? onlyUpdate === param || element.lookup(onlyUpdate) : true;
+  if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
+    if (isFunction(isGlobalTransformer)) {
+      await isGlobalTransformer(prop, element, node, options);
+    }
+    return;
+  }
+  return { hasDefine, hasContextDefine };
+};
+
+// ../../../domql/packages/element/utils/propEvents.js
+var propagateEventsFromProps = (element) => {
+  const { props, on } = element;
+  const eventKeysFromProps = Object.keys(props).filter((key) => key.startsWith("on"));
+  eventKeysFromProps.forEach((v) => {
+    const eventName = lowercaseFirstLetter(v.split("on")[1]);
+    const origEvent = on[eventName];
+    const funcFromProps = props[v];
+    if (isFunction(origEvent)) {
+      on[eventName] = (...args) => {
+        const originalEventRetunrs = origEvent(...args);
+        if (originalEventRetunrs !== false) return funcFromProps(...args);
+      };
+    } else on[eventName] = funcFromProps;
+  });
+};
+
+// ../../../domql/packages/element/node.js
+var createNode = async (element, options) => {
+  let { node, tag, __ref: ref } = element;
+  let isNewNode;
+  if (options.routerContentElement && options.lastElement) {
+    if (options.routerContentElement !== options.lastElement.content) return;
+  }
+  if (!node) {
+    isNewNode = true;
+    if (!ref.__if) return element;
+    if (tag === "shadow") {
+      node = element.node = element.parent.node.attachShadow({ mode: "open" });
+    } else node = element.node = cacheNode(element);
+    await triggerEventOn("attachNode", element, options);
+  }
+  node.ref = element;
+  if (isFunction(node.setAttribute)) node.setAttribute("key", element.key);
+  throughExecProps(element, options);
+  await throughInitialDefine(element, options);
+  await throughInitialExec(element);
+  if (element.tag !== "string" && element.tag !== "fragment") {
+    propagateEventsFromProps(element);
+    if (isNewNode && isObject(element.on)) {
+      applyEventsOnNode(element, options);
+    }
+  }
+  const keys3 = Object.keys(element);
+  for (const param of keys3) {
+    const value = element[param];
+    if (!Object.hasOwnProperty.call(element, param)) continue;
+    if (isUndefined(value) || isMethod(param, element) || isVariant(param) || isObject(REGISTRY[param]))
+      continue;
+    if (param === "onClick") {
+      debugger;
+    }
+    const isElement = await applyParam(param, element, options);
+    if (!isElement) continue;
+    const { hasDefine, hasContextDefine } = isElement;
+    if (value && isElement && !hasDefine && !hasContextDefine) {
+      const createAsync = async () => {
+        try {
+          const val = await exec(value, element);
+          await create(val, element, param, options);
+        } catch (error2) {
+          element.error("An unexpected error occurred:", error2);
+        }
+      };
+      if (element.props && element.props.lazyLoad || options.lazyLoad) {
+        window.requestAnimationFrame(async () => {
+          await createAsync();
+          if (!options.preventUpdateListener) {
+            await triggerEventOn("lazyLoad", element, options);
+          }
+        });
+      } else await createAsync();
+    }
+  }
+  return element;
+};
+
+// ../../../domql/packages/state/dist/esm/ignore.js
+var IGNORE_STATE_PARAMS2 = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "set",
+  "reset",
+  "replace",
+  "quietReplace",
+  "quietUpdate",
+  "applyReplace",
+  "applyFunction",
+  "keys",
+  "values",
+  "ref",
+  "rootUpdate",
+  "parentUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root",
+  "setByPath",
+  "setPathCollection",
+  "removeByPath",
+  "removePathCollection",
+  "getByPath"
+];
+
+// ../../../domql/packages/state/dist/esm/methods.js
+var __defProp4 = Object.defineProperty;
+var __defProps3 = Object.defineProperties;
+var __getOwnPropDescs3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols3 = Object.getOwnPropertySymbols;
+var __hasOwnProp4 = Object.prototype.hasOwnProperty;
+var __propIsEnum3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp4.call(b, prop))
+      __defNormalProp3(a, prop, b[prop]);
+  if (__getOwnPropSymbols3)
+    for (var prop of __getOwnPropSymbols3(b)) {
+      if (__propIsEnum3.call(b, prop))
+        __defNormalProp3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps3 = (a, b) => __defProps3(a, __getOwnPropDescs3(b));
+var parse2 = function() {
+  const state2 = this;
+  if (isObject(state2)) {
+    const obj = {};
+    for (const param in state2) {
+      if (!IGNORE_STATE_PARAMS2.includes(param)) {
+        obj[param] = state2[param];
+      }
+    }
+    return obj;
+  } else {
+  }
+};
+var clean = async function(options = {}) {
+  const state2 = this;
+  for (const param in state2) {
+    if (!IGNORE_STATE_PARAMS2.includes(param) && Object.hasOwnProperty.call(state2, param)) {
+      delete state2[param];
+    }
+  }
+  if (!options.preventStateUpdate) {
+    await state2.update(state2, __spreadValues3({ replace: true }, options));
+  }
+  return state2;
+};
+var destroy = async function(options = {}) {
+  const state2 = this;
+  const element = state2.__element;
+  const stateKey = element.__ref.__state;
+  if (isString(stateKey)) {
+    await element.parent.state.remove(stateKey, __spreadValues3({ isHoisted: true }, options));
+    return element.state;
+  }
+  delete element.state;
+  element.state = state2.parent;
+  if (state2.parent) {
+    delete state2.parent.__children[element.key];
+  }
+  if (state2.__children) {
+    for (const key in state2.__children) {
+      const child = state2.__children[key];
+      if (child.state) {
+        if (isArray(child.state)) {
+          Object.defineProperty(child.state, "parent", {
+            value: state2.parent,
+            enumerable: false,
+            // Set this to true if you want the method to appear in for...in loops
+            configurable: true,
+            // Set this to true if you want to allow redefining/removing the property later
+            writable: true
+            // Set this to true if you want to allow changing the function later
+          });
+        } else {
+          Object.setPrototypeOf(child, { parent: state2.parent });
+        }
+      }
+    }
+  }
+  await element.state.update({}, __spreadValues3({ isHoisted: true }, options));
+  return element.state;
+};
+var parentUpdate = async function(obj, options = {}) {
+  const state2 = this;
+  if (!state2 || !state2.parent) return;
+  return await state2.parent.update(obj, __spreadValues3({ isHoisted: true }, options));
+};
+var rootUpdate = async function(obj, options = {}) {
+  const state2 = this;
+  if (!state2) return;
+  const rootState = state2.__element.__ref.root.state;
+  return await rootState.update(obj, __spreadValues3({ isHoisted: false }, options));
+};
+var add = async function(value, options = {}) {
+  const state2 = this;
+  if (isArray(state2)) {
+    await state2.push(value);
+    return await state2.update(state2.parse(), __spreadValues3({ overwrite: true }, options));
+  } else if (isObject(state2)) {
+    const key = Object.keys(state2).length;
+    return await state2.update({ [key]: value }, options);
+  }
+};
+var toggle = async function(key, options = {}) {
+  const state2 = this;
+  return await state2.update({ [key]: !Boolean(state2[key]) }, options);
+};
+var remove2 = async function(key, options = {}) {
+  const state2 = this;
+  if (isArray(state2)) removeFromArray(state2, key);
+  if (isObject(state2)) removeFromObject(state2, key);
+  if (options.applyReset)
+    return await state2.set(state2.parse(), __spreadValues3({ replace: true }, options));
+  return await state2.update();
+};
+var set = async function(val, options = {}) {
+  const state2 = this;
+  const value = deepClone(val);
+  await state2.clean(__spreadValues3({ preventStateUpdate: true }, options));
+  await state2.replace(value, options);
+  return state2;
+};
+var setByPath = async function(path, val, options = {}) {
+  const state2 = this;
+  const value = deepClone(val);
+  if (!options.preventReplace) setInObjectByPath(state2, path, val);
+  const update3 = createNestedObject(path, value);
+  if (options.preventStateUpdate) return update3;
+  return await state2.update(update3, options);
+};
+var setPathCollection = async function(changes, options = {}) {
+  const state2 = this;
+  const update3 = await changes.reduce(async (promacc, change) => {
+    const acc = await promacc;
+    if (change[0] === "update") {
+      const result = await setByPath.call(state2, change[1], change[2], __spreadProps3(__spreadValues3({}, options), {
+        preventStateUpdate: true
+      }));
+      return overwriteDeep(acc, result);
+    } else if (change[0] === "delete") {
+      await removeByPath.call(state2, change[1], options);
+      const removedFromPath = change[1].slice(0, -1);
+      const removedFromValue = getInObjectByPath(state2, removedFromPath);
+      const result = createNestedObject(
+        removedFromPath,
+        isObject(removedFromValue) ? {} : []
+      );
+      return deepMerge(acc, result);
+    }
+    return acc;
+  }, {});
+  return await state2.update(update3, options);
+};
+var removeByPath = async function(path, options = {}) {
+  const state2 = this;
+  removeNestedKeyByPath(state2, path);
+  if (options.preventUpdate) return path;
+  return await state2.update({}, options);
+};
+var removePathCollection = async function(changes, options = {}) {
+  const state2 = this;
+  changes.forEach(async (item) => {
+    await removeByPath(item, { preventUpdate: true });
+  });
+  return await state2.update({}, options);
+};
+var getByPath = function(path, options = {}) {
+  const state2 = this;
+  return getInObjectByPath(state2, path);
+};
+var reset = async function(options = {}) {
+  const state2 = this;
+  const value = deepClone(state2.parse());
+  return await state2.set(value, __spreadValues3({ replace: true }, options));
+};
+var apply = async function(func, options = {}) {
+  const state2 = this;
+  if (isFunction(func)) {
+    const value = func(state2);
+    return await state2.update(value, __spreadValues3({ replace: true }, options));
+  }
+};
+var applyReplace = async function(func, options = {}) {
+  const state2 = this;
+  if (isFunction(func)) {
+    const value = func(state2);
+    return await state2.replace(value, options);
+  }
+};
+var applyFunction = async function(func, options = {}) {
+  const state2 = this;
+  if (isFunction(func)) {
+    const result = func(state2);
+    if (result instanceof Promise) await result;
+    else result;
+    return await state2.update(state2.parse(), __spreadValues3({ replace: true }, options));
+  }
+};
+var quietUpdate = async function(obj, options = {}) {
+  const state2 = this;
+  return await state2.update(obj, __spreadValues3({ preventUpdate: true }, options));
+};
+var replace = async function(obj, options = {}) {
+  const state2 = this;
+  for (const param in obj) {
+    state2[param] = obj[param];
+  }
+  return await state2.update(obj, options);
+};
+var quietReplace = async function(obj, options = {}) {
+  const state2 = this;
+  return await state2.replace(obj, __spreadValues3({ preventUpdate: true }, options));
+};
+var keys2 = function(obj, options = {}) {
+  const state2 = this;
+  return Object.keys(state2);
+};
+var values = function(obj, options = {}) {
+  const state2 = this;
+  return Object.values(state2);
+};
+
+// ../../../domql/packages/state/dist/esm/inherit.js
+var getRootStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("~/")) return;
+  const arr = stateKey.split("~/");
+  if (arr.length > 1) return parentState.root;
+};
+var getParentStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("../")) return;
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent) return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+var getChildStateInKey = (stateKey, parentState, options = {}) => {
+  const arr = stateKey.split("/");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    if (childKey === "__proto__" || grandChildKey === "__proto__") return;
+    let childInParent = parentState[childKey];
+    if (!childInParent) childInParent = parentState[childKey] = {};
+    if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {};
+    stateKey = grandChildKey;
+    parentState = childInParent;
+  }
+  if (options.returnParent) return parentState;
+  return parentState[stateKey];
+};
+var findInheritedState = (element, parent2, options = {}) => {
+  const ref = element.__ref;
+  let stateKey = ref.__state;
+  if (!checkIfInherits(element)) return;
+  const rootState = getRootStateInKey(stateKey, parent2.state);
+  let parentState = parent2.state;
+  if (rootState) {
+    parentState = rootState;
+    stateKey = stateKey.replaceAll("~/", "");
+  } else {
+    const findGrandParentState = getParentStateInKey(stateKey, parent2.state);
+    if (findGrandParentState) {
+      parentState = findGrandParentState;
+      stateKey = stateKey.replaceAll("../", "");
+    }
+  }
+  if (!parentState) return;
+  return getChildStateInKey(stateKey, parentState, options);
+};
+var createInheritedState = (element, parent2) => {
+  const ref = element.__ref;
+  const inheritedState = findInheritedState(element, parent2);
+  if (isUndefined(inheritedState)) return element.state;
+  if (is(inheritedState)("object", "array")) {
+    return deepClone(inheritedState, { exclude: IGNORE_STATE_PARAMS2 });
+  } else if (is(inheritedState)("string", "number", "boolean")) {
+    ref.__stateType = typeof inheritedState;
+    return { value: inheritedState };
+  }
+  console.warn(ref.__state, "is not present. Replacing with", {});
+};
+var checkIfInherits = (element) => {
+  const ref = element.__ref;
+  const stateKey = ref.__state;
+  if (stateKey && is(stateKey)("number", "string", "boolean")) return true;
+  return false;
+};
+var createNestedObjectByKeyPath = (path, value) => {
+  if (!path) {
+    return value || {};
+  }
+  const keys3 = path.split("/");
+  const obj = {};
+  let ref = obj;
+  keys3.forEach((key, index) => {
+    ref[key] = index === keys3.length - 1 ? value || {} : {};
+    ref = ref[key];
+  });
+  return obj;
+};
+
+// ../../../domql/packages/state/dist/esm/updateState.js
+var __defProp5 = Object.defineProperty;
+var __defProps4 = Object.defineProperties;
+var __getOwnPropDescs4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols4 = Object.getOwnPropertySymbols;
+var __hasOwnProp5 = Object.prototype.hasOwnProperty;
+var __propIsEnum4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp4 = (obj, key, value) => key in obj ? __defProp5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp5.call(b, prop))
+      __defNormalProp4(a, prop, b[prop]);
+  if (__getOwnPropSymbols4)
+    for (var prop of __getOwnPropSymbols4(b)) {
+      if (__propIsEnum4.call(b, prop))
+        __defNormalProp4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps4 = (a, b) => __defProps4(a, __getOwnPropDescs4(b));
+var STATE_UPDATE_OPTIONS = {
+  overwrite: true,
+  preventHoistElementUpdate: false,
+  updateByState: true,
+  isHoisted: true
+};
+var updateState = async function(obj, options = STATE_UPDATE_OPTIONS) {
+  const state2 = this;
+  const element = state2.__element;
+  if (options.onEach) options.onEach(element, state2, element.context, options);
+  if (!options.updateByState) merge(options, STATE_UPDATE_OPTIONS);
+  if (!state2.__element) report("ElementOnStateIsNotDefined");
+  if (options.preventInheritAtCurrentState === true) {
+    options.preventInheritAtCurrentState = state2;
+  } else if (options.preventInheritAtCurrentState) return;
+  if (!options.preventBeforeStateUpdateListener) {
+    const beforeStateUpdateReturns = await triggerEventOnUpdate(
+      "beforeStateUpdate",
+      obj,
+      element,
+      options
+    );
+    if (beforeStateUpdateReturns === false) return element;
+  }
+  applyOverwrite(state2, obj, options);
+  const updateIsHoisted = await hoistStateUpdate(state2, obj, options);
+  if (updateIsHoisted) return state2;
+  await updateDependentState(state2, obj, options);
+  const updated = await applyElementUpdate(state2, obj, options);
+  if (updated === false) return false;
+  if (!options.preventStateUpdateListener) {
+    await triggerEventOnUpdate("stateUpdate", obj, element, options);
+  }
+  return state2;
+};
+var applyOverwrite = (state2, obj, options) => {
+  const { overwrite: overwrite3 } = options;
+  if (!overwrite3) return;
+  const shallow = overwrite3 === "shallow" || overwrite3 === "shallow-once";
+  const merge2 = overwrite3 === "merge";
+  if (merge2) {
+    deepMerge(state2, obj, IGNORE_STATE_PARAMS2);
+    return;
+  }
+  const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
+  if (options.overwrite === "shallow-once") options.overwrite = true;
+  overwriteFunc(state2, obj, IGNORE_STATE_PARAMS2);
+};
+var hoistStateUpdate = async (state2, obj, options) => {
+  const element = state2.__element;
+  const { parent: parent2, __ref: ref } = element;
+  const stateKey = ref == null ? void 0 : ref.__state;
+  const stateType = ref == null ? void 0 : ref.__stateType;
+  if (!stateKey) return;
+  const asksForInherit = checkIfInherits(element);
+  const inheritedState = findInheritedState(element, parent2, {
+    returnParent: true
+  });
+  const shouldPropagateState = asksForInherit && inheritedState && !options.stopStatePropagation;
+  if (!shouldPropagateState) return;
+  const isStringState = stateType === "string" || stateType === "number" || stateType === "boolean";
+  const value = isStringState ? state2.value : state2.parse();
+  const passedValue = isStringState ? state2.value : obj;
+  const findRootState = getRootStateInKey(stateKey, parent2.state);
+  const findGrandParentState = getParentStateInKey(stateKey, parent2.state);
+  const changesValue = createNestedObjectByKeyPath(stateKey, passedValue);
+  const targetParent = findRootState || findGrandParentState || parent2.state;
+  if (options.replace) overwriteDeep(targetParent, changesValue || value);
+  await targetParent.update(changesValue, __spreadValues4({
+    isHoisted: true,
+    preventUpdate: options.preventHoistElementUpdate,
+    overwrite: !options.replace
+  }, options));
+  const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate;
+  if (!options.preventStateUpdateListener && hasNotUpdated) {
+    await triggerEventOnUpdate("stateUpdate", obj, element, options);
+  }
+  return true;
+};
+var updateDependentState = async (state2, obj, options) => {
+  if (!state2.__depends) return;
+  for (const el in state2.__depends) {
+    const dependentState = state2.__depends[el];
+    await dependentState.set(state2.parse(), options);
+  }
+};
+var applyElementUpdate = async (state2, obj, options) => {
+  const element = state2.__element;
+  if (options.preventUpdate !== true) {
+    return await element.update(
+      {},
+      __spreadProps4(__spreadValues4({}, options), {
+        updateByState: true
+      })
+    );
+  } else if (options.preventUpdate === "recursive") {
+    return await element.update(
+      {},
+      __spreadProps4(__spreadValues4({}, options), {
+        isHoisted: false,
+        updateByState: true,
+        preventUpdate: true
+      })
+    );
+  }
+};
+
+// ../../../domql/packages/state/dist/esm/create.js
+var __defProp6 = Object.defineProperty;
+var __defProps5 = Object.defineProperties;
+var __getOwnPropDescs5 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols5 = Object.getOwnPropertySymbols;
+var __hasOwnProp6 = Object.prototype.hasOwnProperty;
+var __propIsEnum5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp5 = (obj, key, value) => key in obj ? __defProp6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp6.call(b, prop))
+      __defNormalProp5(a, prop, b[prop]);
+  if (__getOwnPropSymbols5)
+    for (var prop of __getOwnPropSymbols5(b)) {
+      if (__propIsEnum5.call(b, prop))
+        __defNormalProp5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps5 = (a, b) => __defProps5(a, __getOwnPropDescs5(b));
+var createState = async function(element, parent2, options) {
+  element.state = await applyInitialState(element, parent2, options);
+  return element.state;
+};
+var applyInitialState = async function(element, parent2, options) {
+  const objectizeState = await checkForTypes(element);
+  if (objectizeState === false) return parent2.state || {};
+  else element.state = objectizeState;
+  const whatInitReturns = await triggerEventOn("stateInit", element, options);
+  if (whatInitReturns === false) return element.state;
+  if (checkIfInherits(element)) {
+    const inheritedState = createInheritedState(element, parent2);
+    element.state = isUndefined(inheritedState) ? {} : inheritedState;
+  }
+  const dependentState = applyDependentState(
+    element,
+    element.state || parent2.state || {}
+  );
+  if (dependentState) element.state = dependentState;
+  applyMethods(element);
+  await triggerEventOn("stateCreated", element, options);
+  return element.state;
+};
+var applyDependentState = (element, state2) => {
+  const { __ref, ref, __element } = state2;
+  const origState = exec(__ref || ref || (__element == null ? void 0 : __element.state), element);
+  if (!origState) return;
+  const dependentState = deepClone(origState, IGNORE_STATE_PARAMS2);
+  const newDepends = { [element.key + Math.random()]: dependentState };
+  const __depends = isObject(origState.__depends) ? __spreadValues5(__spreadValues5({}, origState.__depends), newDepends) : newDepends;
+  if (Array.isArray(origState)) {
+    addProtoToArray(origState, __spreadProps5(__spreadValues5({}, Object.getPrototypeOf(origState)), {
+      __depends
+    }));
+  } else {
+    Object.setPrototypeOf(origState, __spreadProps5(__spreadValues5({}, Object.getPrototypeOf(origState)), {
+      __depends
+    }));
+  }
+  return dependentState;
+};
+var checkForTypes = async (element) => {
+  const { state: orig, props, __ref: ref } = element;
+  const state2 = (props == null ? void 0 : props.state) || orig;
+  if (isFunction(state2)) {
+    ref.__state = state2;
+    return await exec(state2, element);
+  } else if (is(state2)("string", "number")) {
+    ref.__state = state2;
+    return { value: state2 };
+  } else if (state2 === true) {
+    ref.__state = element.key;
+    return {};
+  } else if (state2) {
+    ref.__hasRootState = true;
+    return state2;
+  } else {
+    return false;
+  }
+};
+var addProtoToArray = (state2, proto) => {
+  for (const key in proto) {
+    Object.defineProperty(state2, key, {
+      value: proto[key],
+      enumerable: false,
+      // Set this to true if you want the method to appear in for...in loops
+      configurable: true,
+      // Set this to true if you want to allow redefining/removing the property later
+      writable: true
+      // Set this to true if you want to allow changing the function later
+    });
+  }
+};
+var applyMethods = (element) => {
+  const state2 = element.state;
+  const ref = element.__ref;
+  const proto = {
+    clean: clean.bind(state2),
+    parse: parse2.bind(state2),
+    destroy: destroy.bind(state2),
+    update: updateState.bind(state2),
+    rootUpdate: rootUpdate.bind(state2),
+    parentUpdate: parentUpdate.bind(state2),
+    create: createState.bind(state2),
+    add: add.bind(state2),
+    toggle: toggle.bind(state2),
+    remove: remove2.bind(state2),
+    apply: apply.bind(state2),
+    applyReplace: applyReplace.bind(state2),
+    applyFunction: applyFunction.bind(state2),
+    set: set.bind(state2),
+    quietUpdate: quietUpdate.bind(state2),
+    replace: replace.bind(state2),
+    quietReplace: quietReplace.bind(state2),
+    reset: reset.bind(state2),
+    parent: element.parent.state || state2,
+    setByPath: setByPath.bind(state2),
+    setPathCollection: setPathCollection.bind(state2),
+    removeByPath: removeByPath.bind(state2),
+    removePathCollection: removePathCollection.bind(state2),
+    getByPath: getByPath.bind(state2),
+    keys: keys2.bind(state2),
+    values: values.bind(state2),
+    __element: element,
+    __children: {},
+    root: ref.root ? ref.root.state : state2
+  };
+  if (isArray(state2)) {
+    addProtoToArray(state2, proto);
+  } else {
+    Object.setPrototypeOf(state2, proto);
+  }
+  if (state2.parent && state2.parent.__children) {
+    state2.parent.__children[element.key] = state2;
+  }
+};
+
+// ../../../domql/packages/element/update.js
+var snapshot = {
+  snapshotId: createSnapshotId
+};
+var UPDATE_DEFAULT_OPTIONS = {
+  stackChanges: false,
+  cleanExec: true,
+  preventRecursive: false,
+  currentSnapshot: false,
+  calleeElement: false,
+  excludes: METHODS_EXL
+};
+var update2 = async function(params = {}, opts) {
+  const calleeElementCache = opts == null ? void 0 : opts.calleeElement;
+  const options = deepClone(
+    typeof opts === "object" ? deepMerge2(opts, UPDATE_DEFAULT_OPTIONS) : UPDATE_DEFAULT_OPTIONS,
+    { exclude: ["calleeElement", "updatingCalleeElement"] }
+  );
+  const element = this;
+  options.calleeElement = calleeElementCache;
+  const { parent: parent2, node, key } = element;
+  const { excludes, preventInheritAtCurrentState } = options;
+  let ref = element.__ref;
+  if (!ref) ref = element.__ref = {};
+  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(
+    element,
+    options
+  );
+  if (snapshotHasUpdated) return false;
+  if (checkIfStorm(element, options)) return false;
+  if (!options.preventListeners)
+    await triggerEventOn("eventStart", element, options);
+  if (!options.preventListeners)
+    await triggerEventOnUpdate("startUpdate", params, element, options);
+  if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element)
+    return false;
+  if (!excludes) merge(options, UPDATE_DEFAULT_OPTIONS);
+  if (isString(params) || isNumber(params)) {
+    params = { text: params };
+  }
+  const inheritState = await inheritStateUpdates(element, options);
+  if (inheritState === false) return false;
+  const ifFails = checkIfOnUpdate(element, parent2, options);
+  if (ifFails) return false;
+  if (ref.__if && !options.preventPropsUpdate) {
+    const hasParentProps = parent2.props && (parent2.props[key] || parent2.props.childProps);
+    const hasFunctionInProps = ref.__props.filter((v) => isFunction(v));
+    const props = params.props || hasParentProps || hasFunctionInProps.length;
+    if (props) updateProps(props, element, parent2, options);
+  }
+  if (!options.preventBeforeUpdateListener && !options.preventListeners) {
+    const beforeUpdateReturns = await triggerEventOnUpdate(
+      "beforeUpdate",
+      params,
+      element,
+      options
+    );
+    if (beforeUpdateReturns === false) return element;
+  }
+  overwriteDeep(element, params, { exclude: METHODS_EXL });
+  throughExecProps(element, options);
+  await throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS });
+  await throughUpdatedDefine(element, options);
+  if (!options.isForced && !options.preventListeners) {
+    await triggerEventOn("beforeClassAssign", element, options);
+  }
+  if (!ref.__if) return false;
+  if (!node) {
+    return false;
+  }
+  if (element.tag !== "fragment" && !document.body.contains(node)) {
+  }
+  const {
+    preventUpdate,
+    preventDefineUpdate,
+    preventContentUpdate,
+    preventStateUpdate,
+    preventRecursive,
+    preventUpdateListener,
+    preventUpdateAfter,
+    preventUpdateAfterCount
+  } = options;
+  if (preventUpdateAfter) {
+    if (isNumber(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount)
+      return;
+    else if (options.preventUpdateAfterCount === void 0)
+      options.preventUpdateAfterCount = 1;
+    else options.preventUpdateAfterCount++;
+  }
+  const keys3 = Object.keys(element);
+  for (const param of keys3) {
+    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 (preventStateUpdate === "once") options.preventStateUpdate = false;
+    const isElement = await applyParam(param, element, options);
+    if (isElement) {
+      const { hasDefine, hasContextDefine } = isElement;
+      const canUpdate = isObject(prop) && !hasDefine && !hasContextDefine && !preventRecursive;
+      if (!canUpdate) continue;
+      const lazyLoad = element.props.lazyLoad || options.lazyLoad;
+      if (options.onEachUpdate) {
+        options.onEachUpdate(param, element, element.state, element.context);
+      }
+      const childUpdateCall = async () => await update2.call(prop, params[prop], {
+        ...options,
+        currentSnapshot: snapshotOnCallee,
+        calleeElement
+      });
+      lazyLoad ? window2.requestAnimationFrame(async () => {
+        await childUpdateCall();
+        if (!options.preventUpdateListener) {
+          await triggerEventOn("lazyLoad", element, options);
+        }
+      }) : await childUpdateCall();
+    }
+  }
+  if (!options.preventListeners) {
+    if (!preventUpdateListener) await triggerEventOn("update", element, options);
+    await triggerEventOn("eventComplete", element, options);
+  }
+};
+var checkIfStorm = (element, options) => {
+  let ref = element.__ref;
+  if (!options.updatingCalleeElement) options.updatingCalleeElement = element;
+  if (ref.__stormAbortion && !options.allowStorm) {
+    const stormAbortion = setTimeout(() => {
+      delete ref.__stormAbortion;
+      clearTimeout(stormAbortion);
+    }, 1e3);
+    element.error("Potential storm update detected", options);
+    return true;
+  }
+  if (element === options.updatingCalleeElement && !options.allowStorm) {
+    if (ref.__selfCallIteration === void 0) ref.__selfCallIteration = 0;
+    else ref.__selfCallIteration++;
+    if (ref.__selfCallIteration > 100) {
+      ref.__selfCallIteration = 0;
+      ref.__stormAbortion = true;
+      element.error("Potential self calling loop in update detected", options);
+      return true;
+    }
+    const stormTimeout = setTimeout(() => {
+      ref.__selfCallIteration = 0;
+      clearTimeout(stormTimeout);
+    }, 350);
+  }
+};
+var 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];
+};
+var checkIfOnUpdate = (element, parent2, options) => {
+  var _a, _b;
+  const ifFn = ((_a = element.props) == null ? void 0 : _a.if) || element.if;
+  if (!isFunction(ifFn) || !parent2) return;
+  const ref = element.__ref;
+  const ifPassed = ifFn(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;
+      if (!ref.__hasRootState) {
+        delete element.state;
+      }
+      if (ref.__state) {
+        element.state = ref.__state;
+      } else if (!ref.__hasRootState) {
+        delete element.state;
+      }
+      if (element.node) {
+        element.node.remove();
+        delete element.node;
+      }
+      const contentKey = ref.contentElementKey;
+      if (element.$collection || element.$stateCollection || element.$propsCollection) {
+        element.removeContent();
+      } else if ((_b = element[contentKey]) == null ? void 0 : _b.parseDeep)
+        element[contentKey] = element[contentKey].parseDeep();
+      const previousElement2 = element.previousElement();
+      const previousNode = previousElement2 == null ? void 0 : previousElement2.node;
+      const hasPrevious = previousNode == null ? void 0 : previousNode.parentNode;
+      const nextElement2 = element.nextElement();
+      const nextNode = nextElement2 == null ? void 0 : nextElement2.node;
+      const hasNext = nextNode == null ? void 0 : nextNode.parentNode;
+      const attachOptions = (hasPrevious || hasNext) && {
+        position: hasPrevious ? "after" : hasNext ? "before" : null,
+        node: hasPrevious && previousNode || hasNext && nextNode
+      };
+      delete element.__ref;
+      delete element.parent;
+      const createdElement = create(
+        element,
+        parent2,
+        element.key,
+        OPTIONS.create,
+        attachOptions
+      );
+      if (options.preventUpdate !== true && element.on && isFunction(element.on.update)) {
+        applyEvent(element.on.update, createdElement, createdElement.state);
+      }
+      return createdElement;
+    }
+  } else if (element.node && !ifPassed) {
+    element.node.remove();
+    delete ref.__if;
+  }
+};
+var inheritStateUpdates = async (element, options) => {
+  const { __ref: ref } = element;
+  const stateKey = ref.__state;
+  const { parent: parent2 } = element;
+  const { preventUpdateTriggerStateUpdate } = options;
+  if (preventUpdateTriggerStateUpdate) return;
+  if (!stateKey && !ref.__hasRootState) {
+    element.state = parent2 && parent2.state || {};
+    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
+    );
+    if (initStateReturns === false) return element;
+  }
+  const newState = await createStateUpdate(element, parent2, options);
+  if (!options.preventStateUpdateListener && !options.preventListeners) {
+    await triggerEventOnUpdate(
+      "stateUpdate",
+      newState.parse(),
+      element,
+      options
+    );
+  }
+};
+var createStateUpdate = async (element, parent2, options) => {
+  const __stateChildren = element.state.__children;
+  const newState = await createState(element, parent2, options);
+  element.state = newState;
+  for (const child in __stateChildren) {
+    if (newState[child]) newState.__children[child] = __stateChildren[child];
+    Object.getPrototypeOf(__stateChildren[child]).parent = newState;
+  }
+  return newState;
+};
+
+// ../../../domql/packages/element/methods/set.js
+var addMethods = (element, parent2, options = {}) => {
+  const proto = {
+    set: set2,
+    reset: reset2,
+    update: update2,
+    variables,
+    remove,
+    updateContent,
+    removeContent,
+    setProps,
+    lookup,
+    lookdown,
+    lookdownAll,
+    getRef,
+    getPath,
+    setNodeStyles,
+    spotByPath,
+    parse,
+    parseDeep,
+    keys,
+    nextElement,
+    previousElement,
+    log,
+    verbose,
+    warn,
+    error,
+    append,
+    call
+  };
+  if (element.context.methods)
+    (options.strict ? merge : overwrite)(proto, element.context.methods);
+  Object.setPrototypeOf(element, proto);
+};
+
+// ../../../domql/packages/utils/env.js
+var NODE_ENV2 = "development";
+var isProduction2 = (env = NODE_ENV2) => env === "production";
+var isNotProduction2 = (env = NODE_ENV2) => !isProduction2(env);
+
+// ../../../domql/packages/element/create.js
+var create = async (element, parent2, key, options = OPTIONS.create || {}, attachOptions) => {
+  const isValid = validateElement(element, options);
+  if (!isValid) {
+    error.call(
+      element,
+      "Error while creating element: Not valid type",
+      element,
+      options
+    );
+    return;
+  }
+  cacheOptions(element, options);
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent2, key);
+  }
+  element = redefineElement(element, parent2, key, options);
+  parent2 = redefineParent(element, parent2, key);
+  key = createKey(element, parent2, key);
+  const ref = addRef(element, parent2, key);
+  ref.__initialProps = deepClone(element.props);
+  applyContext(element, parent2, options);
+  applyComponentFromContext(element, parent2, options);
+  if (!ref.__skipCreate) {
+    applyExtend(element, parent2, options);
+  }
+  element.key = key;
+  if (options.onlyResolveExtends) {
+    return await onlyResolveExtends(element, parent2, key, options);
+  }
+  await triggerEventOn("eventStart", element, options);
+  await triggerEventOn("start", element, options);
+  switchDefaultOptions(element, parent2, options);
+  addCaching(element, parent2, options);
+  addMethods(element, parent2, options);
+  createScope(element, parent2, options);
+  await createState(element, parent2, options);
+  if (element.scope === "state") element.scope = element.state;
+  createIfConditionFlag(element, parent2);
+  createProps(element, parent2, options);
+  if (element.scope === "props" || element.scope === true)
+    element.scope = element.props;
+  createIfConditionFlag(element, parent2);
+  if (element.node && ref.__if) {
+    return assignNode(element, parent2, key, attachOptions);
+  }
+  applyVariant(element, parent2);
+  addChildrenIfNotInOriginal(element, parent2, key);
+  const onInit = await triggerEventOn("init", element, options);
+  if (onInit === false) return element;
+  const onEventInit = await triggerEventOn("eventInit", element, options);
+  if (onEventInit === false) return element;
+  await triggerEventOn("beforeClassAssign", element, options);
+  assignKeyAsClassname(element);
+  await renderElement(element, parent2, options, attachOptions);
+  addElementIntoParentChildren(element, parent2);
+  await triggerEventOn("complete", element, options);
+  await triggerEventOn("eventComplete", element, options);
+  return element;
+};
+var createBasedOnType = (element, parent2, key, options) => {
+  if (element === void 0) {
+    if (isNotProduction2()) {
+      console.warn(
+        key,
+        "element is undefined in",
+        parent2 && parent2.__ref && parent2.__ref.path
+      );
+    }
+    return {};
+  }
+  if (isString(key) && key.slice(0, false)) {
+    if (isNotProduction2()) {
+      console.warn(key, "seems like to be in __ref");
+    }
+  }
+  if (element === null) return;
+  if (element === true) return { text: true };
+  if (element.__hash) {
+    return { extend: element };
+  }
+  if (typeof Node !== "undefined" && element instanceof Node || typeof DocumentFragment !== "undefined" && element instanceof DocumentFragment)
+    return { node: element };
+  return element;
+};
+var redefineElement = (element, parent2, key, options) => {
+  const elementWrapper = createBasedOnType(element, parent2, key, options);
+  if (options.syntaxv3 || element.props && element.props.syntaxv3 || parent2 && parent2.props && parent2.props.syntaxv3) {
+    if (element.props) element.props.syntaxv3 = true;
+    else element.syntaxv3 = true;
+    return createValidDomqlObjectFromSugar(element, parent2, key, options);
+  } else if (checkIfKeyIsComponent(key)) {
+    return applyKeyComponentAsExtend(elementWrapper, parent2, key);
+  }
+  if (checkIfMedia(key)) {
+    return applyMediaProps(elementWrapper, parent2, key);
+  }
+  return elementWrapper;
+};
+var redefineParent = (element, parent2, key, options) => {
+  if (!parent2) return ROOT;
+  if (isNode(parent2)) {
+    const parentNodeWrapper = { key: ":root", node: parent2 };
+    ROOT[`${key}_parent`] = parentNodeWrapper;
+    return parentNodeWrapper;
+  }
+  return parent2;
+};
+var validateElement = (value, options) => {
+  if (value == null) return false;
+  const t = typeof value;
+  if (t === "function" || t === "symbol" || t === "bigint") return false;
+  if (Number.isNaN(value) || value === Infinity || value === -Infinity)
+    return false;
+  const unsafeGlobals = [
+    typeof window !== "undefined" && window,
+    typeof document !== "undefined" && document,
+    typeof globalThis !== "undefined" && globalThis,
+    typeof navigator !== "undefined" && navigator,
+    typeof location !== "undefined" && location,
+    typeof history !== "undefined" && history,
+    typeof screen !== "undefined" && screen,
+    typeof frames !== "undefined" && frames,
+    typeof parent !== "undefined" && parent,
+    typeof self !== "undefined" && self,
+    typeof top !== "undefined" && top,
+    typeof performance !== "undefined" && performance,
+    typeof console !== "undefined" && console,
+    typeof indexedDB !== "undefined" && indexedDB,
+    typeof caches !== "undefined" && caches,
+    typeof localStorage !== "undefined" && localStorage,
+    typeof sessionStorage !== "undefined" && sessionStorage,
+    typeof crypto !== "undefined" && crypto,
+    typeof visualViewport !== "undefined" && visualViewport,
+    typeof customElements !== "undefined" && customElements
+  ].filter(Boolean);
+  if (unsafeGlobals.includes(value)) return false;
+  if (typeof EventTarget !== "undefined" && value instanceof EventTarget)
+    return false;
+  if (typeof Event !== "undefined" && value instanceof Event) return false;
+  if (value === Object.prototype || value === Array.prototype || value === Function.prototype || value === Map.prototype || value === Set.prototype || value === WeakMap.prototype || value === WeakSet.prototype || value === Promise.prototype || value === Symbol.prototype)
+    return false;
+  const unsafeConstructors = [
+    typeof Worker !== "undefined" && Worker,
+    typeof SharedWorker !== "undefined" && SharedWorker,
+    typeof MessagePort !== "undefined" && MessagePort,
+    typeof BroadcastChannel !== "undefined" && BroadcastChannel,
+    typeof ReadableStream !== "undefined" && ReadableStream,
+    typeof WritableStream !== "undefined" && WritableStream,
+    typeof TransformStream !== "undefined" && TransformStream,
+    typeof File !== "undefined" && File,
+    typeof Blob !== "undefined" && Blob,
+    typeof FormData !== "undefined" && FormData,
+    typeof XMLHttpRequest !== "undefined" && XMLHttpRequest,
+    typeof AbortController !== "undefined" && AbortController,
+    typeof AbortSignal !== "undefined" && AbortSignal
+  ].filter(Boolean);
+  for (const Ctor of unsafeConstructors) {
+    if (value instanceof Ctor) return false;
+  }
+  return true;
+};
+var cacheOptions = (element, options) => {
+  if (options && !OPTIONS.create) {
+    OPTIONS.create = options;
+    OPTIONS.create.context = element.context || options.context;
+  }
+};
+var createKey = (element, parent2, key) => {
+  return (exec(key, element) || key || element.key || generateKey()).toString();
+};
+var addRef = (element, parent2) => {
+  if (element.__ref) element.__ref.origin = element;
+  else element.__ref = { origin: element };
+  return element.__ref;
+};
+var switchDefaultOptions = (element, parent2, options) => {
+  if (Object.keys(options).length) {
+    REGISTRY.defaultOptions = options;
+    if (options.ignoreChildExtend) delete options.ignoreChildExtend;
+  }
+};
+var addElementIntoParentChildren = (element, parent2) => {
+  if (parent2.__ref && parent2.__ref.__children)
+    parent2.__ref.__children.push(element.key);
+};
+var visitedElements = /* @__PURE__ */ new WeakMap();
+var renderElement = async (element, parent2, options, attachOptions) => {
+  var _a, _b, _c, _d;
+  if (visitedElements.has(element)) {
+    if (isNotProduction2())
+      console.warn("Cyclic rendering detected:", element.__ref.path);
+  }
+  visitedElements.set(element, true);
+  const { __ref: ref, key } = element;
+  const createNestedChild = async () => {
+    const isInfiniteLoopDetected = detectInfiniteLoop(ref.path);
+    if (ref.__uniqId || isInfiniteLoopDetected) return;
+    await createNode(element, options);
+    ref.__uniqId = Math.random();
+  };
+  if (isNotProduction2()) {
+    await createNestedChild();
+  } else {
+    try {
+      await createNestedChild();
+    } catch (e) {
+      const path = ref.path;
+      if (path.includes("ComponentsGrid"))
+        path.splice(0, path.indexOf("ComponentsGrid") + 2);
+      if (path.includes("demoComponent"))
+        path.splice(0, path.indexOf("demoComponent") + 1);
+      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 (!ref.__if) {
+    parent2[key || element.key] = element;
+    return element;
+  }
+  assignNode(element, parent2, key, attachOptions);
+  applyAnimationFrame(element, options);
+  await triggerEventOn("render", element, options);
+  await triggerEventOn("renderRouter", element, options);
+  await triggerEventOn("done", element, options);
+  await triggerEventOn("create", element, options);
+};
+var checkIfPrimitive = (element) => is(element)("string", "number");
+var applyValueAsText = (element, parent2, key) => {
+  const extendTag = element.extend && element.extend.tag;
+  const childExtendTag = parent2.childExtend && parent2.childExtend.tag;
+  const childPropsTag = parent2.props.childProps && parent2.props.childProps.tag;
+  const isKeyValidHTMLTag = HTML_TAGS.body.indexOf(key) > -1 && key;
+  return {
+    text: element,
+    tag: extendTag || childExtendTag || childPropsTag || isKeyValidHTMLTag || "string"
+  };
+};
+var applyContext = (element, parent2, options) => {
+  const forcedOptionsContext = options.context && !ROOT.context && !element.context;
+  if (forcedOptionsContext) ROOT.context = options.context;
+  if (!element.context)
+    element.context = parent2.context || options.context || ROOT.context;
+};
+var createScope = (element, parent2) => {
+  const { __ref: ref } = element;
+  if (!element.scope) element.scope = parent2.scope || ref.root.scope || {};
+};
+var createIfConditionFlag = (element, parent2) => {
+  var _a;
+  const { __ref: ref } = element;
+  const ifFn = ((_a = element.props) == null ? void 0 : _a.if) || element.if;
+  if (isFunction(ifFn) && !ifFn(element, element.state, element.context)) {
+    delete ref.__if;
+  } else ref.__if = true;
+};
+var addCaching = (element, parent2) => {
+  const { __ref: ref, key } = element;
+  let { __ref: parentRef } = parent2;
+  if (!element.transform) element.transform = {};
+  if (!ref.__cached) ref.__cached = {};
+  if (!ref.__cachedContent) ref.__cachedContent = null;
+  if (!ref.__defineCache) ref.__defineCache = {};
+  if (!ref.__exec) ref.__exec = {};
+  if (!ref.__execProps) ref.__execProps = {};
+  if (!ref.__class) ref.__class = {};
+  if (!ref.__classNames) ref.__classNames = {};
+  if (!ref.__attr) ref.__attr = {};
+  if (!ref.__changes) ref.__changes = [];
+  if (!ref.__children) ref.__children = [];
+  if (checkIfKeyIsComponent(key))
+    ref.__componentKey = key.split("_")[0].split(".")[0].split("+")[0];
+  const hasRoot = parent2 && parent2.key === ":root";
+  if (!ref.root) ref.root = hasRoot ? element : parentRef.root;
+  if (!parentRef) parentRef = parent2.ref = {};
+  if (!parentRef.path) parentRef.path = [];
+  ref.path = parentRef.path.concat(element.key);
+};
+var onlyResolveExtends = async (element, parent2, key, options) => {
+  const { __ref: ref } = element;
+  if (!ref.__skipCreate) {
+    addCaching(element, parent2);
+    addMethods(element, parent2, options);
+    createScope(element, parent2);
+    createState(element, parent2, options);
+    if (element.scope === "state") element.scope = element.state;
+    createIfConditionFlag(element, parent2);
+    createProps(element, parent2, options);
+    if (element.scope === "props" || element.scope === true)
+      element.scope = element.props;
+    if (element.node && ref.__if) {
+      parent2[key || element.key] = element;
+    }
+    if (!element.props) element.props = {};
+    applyVariant(element, parent2);
+    addElementIntoParentChildren(element, parent2);
+  }
+  if (element.tag !== "string" && element.tag !== "fragment") {
+    await throughInitialDefine(element);
+    await throughInitialExec(element);
+    for (const k in element) {
+      if (isUndefined(element[k]) || isMethod(k, element) || isObject((REGISTRY.default || REGISTRY)[k]) || isVariant(k))
+        continue;
+      const hasDefine = element.define && element.define[k];
+      const contextHasDefine = element.context && element.context.define && element.context.define[k];
+      const optionsHasDefine = options.define && options.define[k];
+      if (!ref.__skipCreate && REGISTRY[k] && !optionsHasDefine) {
+        continue;
+      } else if (element[k] && !hasDefine && !optionsHasDefine && !contextHasDefine) {
+        create(exec(element[k], element), element, k, options);
+      }
+    }
+  }
+  parent2[key || element.key] = element;
+  delete element.update;
+  delete element.__element;
+  if (element.props) {
+    delete element.props.update;
+    delete element.props.__element;
+  }
+  return element;
+};
+var checkIfMedia = (key) => key.slice(0, 1) === "@";
+var applyMediaProps = (element, parent2, 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" }
+      }
+    };
+  }
+};
+
+// ../../../domql/packages/element/set.js
+var resetElement = async (params, element, options) => {
+  if (!options.preventRemove) removeContent(element, options);
+  const { __ref: ref } = element;
+  const newContent = await create(
+    params,
+    element,
+    ref.contentElementKey || "content",
+    {
+      ignoreChildExtend: true,
+      ...REGISTRY.defaultOptions,
+      ...OPTIONS.create,
+      ...options
+    }
+  );
+  ref.__cachedContent = newContent;
+};
+var reset2 = async (options) => {
+  const element = void 0;
+  await create(element, element.parent, void 0, {
+    ignoreChildExtend: true,
+    ...REGISTRY.defaultOptions,
+    ...OPTIONS.create,
+    ...options
+  });
+};
+var set2 = async function(params, options = {}, el) {
+  var _a, _b, _c, _d;
+  const element = el || this;
+  const { __ref: ref } = element;
+  if (options.preventContentUpdate || options.preventUpdate && ((_b = (_a = options.preventUpdate).includes) == null ? void 0 : _b.call(_a, "content")))
+    return;
+  if (options.routerContentElement && options.lastElement) {
+    if (options.routerContentElement !== options.lastElement.content) return;
+  }
+  const contentKey = setContentKey(element, options);
+  const content = element[contentKey];
+  const __contentRef = content && content.__ref;
+  const lazyLoad = element.props && element.props.lazyLoad;
+  const hasCollection = element.$collection || element.$stateCollection || element.$propsCollection || ((_c = element.props) == null ? void 0 : _c.children);
+  if (options.preventContentUpdate === true && !hasCollection) return;
+  if (options.forceUpdate && !options.forceReset && (ref.__noCollectionDifference || __contentRef && __contentRef.__cached && deepContains(params, content))) {
+    if (!options.preventBeforeUpdateListener && !options.preventListeners) {
+      const beforeUpdateReturns = await triggerEventOnUpdate(
+        "beforeUpdate",
+        params,
+        element,
+        options
+      );
+      if (beforeUpdateReturns === false) return element;
+    }
+    if (content == null ? void 0 : content.update) await content.update({}, options);
+    if (!options.preventUpdateListener)
+      await triggerEventOn("update", element, options);
+    return;
+  }
+  if (params) {
+    let { childExtend, childExtendRecursive, props } = params;
+    if (!props) props = params.props = {};
+    if (!childExtend && element.childExtend) {
+      params.childExtend = element.childExtend;
+      props.ignoreChildExtend = true;
+    }
+    if (!childExtendRecursive && element.childExtendRecursive) {
+      params.childExtendRecursive = element.childExtendRecursive;
+      props.ignoreChildExtendRecursive = true;
+    }
+    if (!(props == null ? void 0 : props.childProps) && ((_d = element.props) == null ? void 0 : _d.childProps)) {
+      props.childProps = element.props.childProps;
+      props.ignoreChildProps = true;
+    }
+    if (lazyLoad) {
+      window.requestAnimationFrame(async () => {
+        await resetElement(params, element, options);
+        if (!options.preventUpdateListener) {
+          await triggerEventOn("lazyLoad", element, options);
+        }
+      });
+    } else await resetElement(params, element, options);
+  } else {
+    if (!options.preventRemove) removeContent(element, options);
+  }
+  return element;
+};
+
+// ../../../domql/packages/element/mixins/content.js
+var updateContent = async function(params, options) {
+  const element = this;
+  const ref = element.__ref;
+  const contentKey = ref.contentElementKey;
+  if (!element[contentKey]) return;
+  if (element[contentKey].update)
+    await element[contentKey].update(params, options);
+};
+var removeContent = function(el, opts = {}) {
+  const element = el || this;
+  const { __ref: ref } = element;
+  const contentElementKey = setContentKey(element, opts);
+  if (opts.contentElementKey !== "content") opts.contentElementKey = "content";
+  const contentElement = element[contentElementKey];
+  if (contentElement) {
+    if (contentElement.node && element.node) {
+      if (contentElement.tag === "fragment")
+        element.node.innerHTML = "";
+      else {
+        const contentNode = contentElement.node;
+        if (contentNode.parentNode === element.node)
+          element.node.removeChild(contentElement.node);
+      }
+    }
+    const { __cachedContent } = ref;
+    if (__cachedContent) {
+      if (__cachedContent.tag === "fragment")
+        __cachedContent.parent.node.innerHTML = "";
+      else if (__cachedContent && isFunction(__cachedContent.remove))
+        __cachedContent.remove();
+      delete ref.__cachedContent;
+    }
+    ref.__children.splice(ref.__children.indexOf(contentElementKey), 1);
+    delete element[contentElementKey];
+  }
+};
+async function setContent(param, element, node, opts) {
+  var _a;
+  const contentElementKey = setContentKey(element, opts);
+  if (!element) this.warn("No element to set content on");
+  if (param) {
+    if ((_a = element[contentElementKey]) == null ? void 0 : _a.update) {
+      await element[contentElementKey].update({}, opts);
+    } else {
+      await set2.call(element, param, opts);
+    }
+  } else {
+    removeContent(element, opts);
+  }
+}
+
+// ../../../domql/packages/element/mixins/data.js
+function data(params, element, node) {
+  if (params) {
+    if (element.props.data) deepMerge(params, element.props.data);
+    if (params.showOnNode) {
+      if (!isObject(params)) report("HTMLInvalidData", params);
+      for (const dataset in params) {
+        if (dataset !== "showOnNode") {
+          node.dataset[dataset] = exec(params[dataset], element);
+        }
+      }
+    }
+  }
+}
+
+// ../../../domql/packages/element/mixins/html.js
+function html(param, element, node, opts) {
+  var _a;
+  const prop = element.call(
+    "exec",
+    param,
+    element,
+    element.state,
+    element.context,
+    opts
+  ) || element.call(
+    "exec",
+    (_a = element == null ? void 0 : element.props) == null ? void 0 : _a.html,
+    element,
+    element.state,
+    element.context,
+    opts
+  );
+  const { __ref } = element;
+  if (prop !== __ref.__html) {
+    if (node.nodeName === "SVG") node.textContent = prop;
+    else node.innerHTML = prop;
+    __ref.__html = prop;
+  }
+}
+
+// ../../../domql/packages/element/mixins/style.js
+function style(params, element, node) {
+  if (params) {
+    if (isObject(params)) map(node.style, params, element);
+    else report("HTMLInvalidStyles", params);
+  }
+}
+
+// ../../../domql/packages/element/mixins/text.js
+function text(param, element, node, opts) {
+  let prop = exec(param, element, element.state, element.context, opts);
+  if (isString(prop) && prop.includes("{{")) {
+    prop = element.call("replaceLiteralsWithObjectFields", prop);
+  }
+  if (element.tag === "string") {
+    node.nodeValue = prop;
+  } else if (param !== void 0 || param !== null) {
+    if (element.__text) {
+      if (element.__text.text === prop) return;
+      element.__text.text = prop;
+      if (element.__text.node) element.__text.node.nodeValue = prop;
+    } else create({ tag: "string", text: prop }, element, "__text");
+  }
+}
+
+// ../../../domql/packages/element/mixins/state.js
+async function state(params, element, node, opts) {
+  const state2 = exec(params, element, element.state, element.context, opts);
+  if (isObject(state2)) {
+    const keys3 = Object.keys(state2);
+    for (const param of keys3) {
+      if (IGNORE_STATE_PARAMS2.includes(param)) continue;
+      if (!Object.hasOwnProperty.call(state2, param)) continue;
+    }
+  }
+  return element;
+}
+
+// ../../../domql/packages/element/mixins/scope.js
+function scope(params, element, node) {
+  if (!isObject(params)) return;
+  for (const scopeItem in params) {
+    const value = params[scopeItem];
+    if (isFunction(value)) {
+      element.scope[scopeItem] = value.bind(element);
+    } else {
+      element.scope[scopeItem] = value;
+    }
+  }
+}
+
+// ../../../domql/packages/element/utils/component.js
+var createValidDomqlObjectFromSugar = (el, parent2, key, options) => {
+  const newElem = {
+    props: {},
+    define: {}
+  };
+  const allowedKeys = ["data", "state", "attr", "if"];
+  for (const k in el) {
+    const value = el[k];
+    const isComponent = checkIfKeyIsComponent(k);
+    const isRegistry = REGISTRY[k];
+    if (isComponent || isRegistry || allowedKeys.includes(k)) {
+      newElem[k] = value;
+    } else {
+      newElem.props[k] = value;
+    }
+  }
+  return newElem;
+};
+var overwriteVariant = (element, variant, variantProps) => {
+  let variantElement = element[variant];
+  if (!variantElement) return;
+  const props = isObject(variantProps) ? variantProps : {};
+  if (isString(variantElement)) {
+    variantElement = {
+      extend: [{ props }, variantElement]
+    };
+  } else if (variantElement.extend) {
+    variantElement = addAdditionalExtend({ props }, variantElement);
+  }
+  const extendedVariant = applyExtend(variantElement, element.parent);
+  const { parent: parent2, ...rest } = extendedVariant;
+  return overwriteDeep(element, rest);
+};
+var applyVariant = (element) => {
+  const { props } = element;
+  if (!hasVariantProp(element)) return element;
+  const { variant } = props;
+  overwriteVariant(element, `.${variant}`);
+  const elKeys = Object.keys(element).filter((key) => isVariant(key));
+  elKeys.forEach((variant2) => {
+    const slicedVariantElementKey = variant2.slice(1);
+    const variantElementProps = props[slicedVariantElementKey];
+    if (variantElementProps) overwriteVariant(element, variant2, variantElementProps);
+  });
+  return element;
+};
+
+// ../../../domql/packages/element/mixins/attr.js
+function attr(params, element, node, opts) {
+  const { __ref: ref, props } = element;
+  const { __attr } = ref;
+  if (isNot("object")) report("HTMLInvalidAttr", params);
+  if (params) {
+    if (props.attr) deepMerge2(params, props.attr);
+    for (const attr2 in params) {
+      const val = exec(
+        params[attr2],
+        element,
+        element.state,
+        element.context,
+        opts
+      );
+      if (val !== false && !isUndefined(val) && !isNull(val) && node.setAttribute)
+        node.setAttribute(
+          attr2,
+          exec(val, element, element.state, element.context, opts)
+        );
+      else if (node.removeAttribute) node.removeAttribute(attr2);
+      __attr[attr2] = val;
+    }
+  }
+}
+
+// ../../../domql/packages/element/mixins/registry.js
+var REGISTRY = {
+  attr,
+  style,
+  text,
+  html,
+  content: setContent,
+  data,
+  class: classList,
+  state,
+  scope,
+  deps: (param, el) => param || el.parent.deps,
+  extend: {},
+  extends: {},
+  childExtend: {},
+  childExtends: {},
+  childExtendsRecursive: {},
+  helmet: {},
+  metadata: {},
+  props: {},
+  path: {},
+  if: {},
+  define: {},
+  transform: {},
+  __name: {},
+  __ref: {},
+  __hash: {},
+  __text: {},
+  nextElement: {},
+  previousElement: {},
+  key: {},
+  tag: {},
+  query: {},
+  parent: {},
+  node: {},
+  set: {},
+  reset: {},
+  update: {},
+  error: {},
+  warn: {},
+  call: {},
+  setProps: {},
+  remove: {},
+  updateContent: {},
+  removeContent: {},
+  variables: {},
+  lookup: {},
+  lookdown: {},
+  getRef: {},
+  getPath: {},
+  lookdownAll: {},
+  setNodeStyles: {},
+  spotByPath: {},
+  append: {},
+  routes: {},
+  keys: {},
+  log: {},
+  parse: {},
+  parseDeep: {},
+  on: {},
+  component: {},
+  context: {},
+  $collection: {},
+  $stateCollection: {},
+  $propsCollection: {},
+  $setCollection: {},
+  $setStateCollection: {},
+  $setPropsCollection: {}
+};
+var parseFilters = {
+  elementKeys: [
+    "tag",
+    "text",
+    "style",
+    "attr",
+    "class",
+    "state",
+    "props",
+    "data",
+    "content",
+    "html",
+    "on",
+    "key",
+    "extend",
+    "childExtend",
+    "childExtendsRecursive",
+    "scope",
+    "query",
+    "$collection",
+    "$stateCollection",
+    "$propsCollection"
+  ],
+  propsKeys: ["__element", "update"],
+  stateKeys: []
+};
+
+// src/domqlv3hacks.js
+function temporaryDomqlHack(value) {
+  var _a;
+  if (this && !((_a = this.getUserSettings) == null ? void 0 : _a.call(this, "useDomql3"))) return value;
+  let obj = { ...value };
+  const on = obj.on;
+  if (this.call("isObject", on)) {
+    delete obj.on;
+    const transformedOn = {};
+    for (const key in on) {
+      const transformedKey = "on" + key.charAt(0).toUpperCase() + key.slice(1);
+      transformedOn[transformedKey] = on[key];
+    }
+    obj = { ...transformedOn, ...obj };
+  }
+  const props = obj.props;
+  if (this.call("isObject", props)) {
+    delete obj.props;
+    obj = { ...props, ...obj };
+  }
+  const extendObj = {};
+  if (obj.extend) {
+    extendObj.extends = obj.extend;
+    delete obj.extend;
+  }
+  if (obj.childExtend) {
+    extendObj.childExtends = obj.childExtend;
+    delete obj.childExtend;
+  }
+  return { ...extendObj, ...obj };
+}
+function temporaryDomqlHackReverse(value) {
+  var _a;
+  if (this && !((_a = this.getUserSettings) == null ? void 0 : _a.call(this, "useDomql3"))) return value;
+  const obj = { ...value };
+  if (obj.extends) {
+    obj.extend = obj.extends;
+    delete obj.extends;
+  }
+  if (obj.childExtends) {
+    obj.childExtend = obj.childExtends;
+    delete obj.childExtends;
+  }
+  for (const key in obj) {
+    const allowed = ["transform", "class"];
+    if (REGISTRY[key] && !allowed.includes(key) || /^[A-Z]/.test(key))
+      continue;
+    else {
+      obj.props = obj.props || {};
+      obj.props[key] = obj[key];
+      delete obj[key];
+    }
+  }
+  return obj;
+}
+// @preserve-env