domql 1.6.4 → 1.6.6

package/dist/esm/element/iterate.js

@@ -0,0 +1,3338 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../refactor/domql/packages/key/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "../refactor/domql/packages/key/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var key_exports = {};
+    __export2(key_exports, {
+      createKey: () => createKey3,
+      createSnapshotId: () => createSnapshotId2
+    });
+    module.exports = __toCommonJS2(key_exports);
+    var createKey3 = function() {
+      let index = 0;
+      function newId() {
+        index++;
+        return index;
+      }
+      return newId;
+    }();
+    var createSnapshotId2 = createKey3;
+  }
+});
+
+// ../refactor/domql/packages/tags/dist/cjs/htmlTags.js
+var require_htmlTags = __commonJS({
+  "../refactor/domql/packages/tags/dist/cjs/htmlTags.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var htmlTags_exports = {};
+    __export2(htmlTags_exports, {
+      HTML_TAGS: () => HTML_TAGS
+    });
+    module.exports = __toCommonJS2(htmlTags_exports);
+    var HTML_TAGS = {
+      root: [
+        "body",
+        "html"
+      ],
+      head: [
+        "title",
+        "base",
+        "meta",
+        "style"
+      ],
+      body: [
+        "string",
+        "fragment",
+        "a",
+        "abbr",
+        "acronym",
+        "address",
+        "applet",
+        "area",
+        "article",
+        "aside",
+        "audio",
+        "b",
+        "basefont",
+        "bdi",
+        "bdo",
+        "big",
+        "blockquote",
+        "br",
+        "button",
+        "canvas",
+        "caption",
+        "center",
+        "cite",
+        "code",
+        "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",
+        "q",
+        "rp",
+        "rt",
+        "ruby",
+        "s",
+        "samp",
+        "script",
+        "section",
+        "select",
+        "small",
+        "source",
+        "span",
+        "strike",
+        "strong",
+        "sub",
+        "summary",
+        "sup",
+        "table",
+        "tbody",
+        "td",
+        "template",
+        "textarea",
+        "tfoot",
+        "th",
+        "thead",
+        "time",
+        "tr",
+        "track",
+        "tt",
+        "u",
+        "ul",
+        "var",
+        "video",
+        "wbr",
+        "svg",
+        "path"
+      ]
+    };
+  }
+});
+
+// ../refactor/domql/packages/tags/dist/cjs/index.js
+var require_cjs2 = __commonJS({
+  "../refactor/domql/packages/tags/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var tags_exports = {};
+    module.exports = __toCommonJS2(tags_exports);
+    __reExport(tags_exports, require_htmlTags(), module.exports);
+  }
+});
+
+// ../refactor/domql/packages/globals/dist/cjs/index.js
+var require_cjs3 = __commonJS({
+  "../refactor/domql/packages/globals/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var globals_exports = {};
+    __export2(globals_exports, {
+      document: () => document2,
+      global: () => global,
+      self: () => self,
+      window: () => window2
+    });
+    module.exports = __toCommonJS2(globals_exports);
+    var global = globalThis;
+    var self = globalThis;
+    var window2 = globalThis;
+    var document2 = window2.document;
+  }
+});
+
+// ../refactor/domql/packages/utils/dist/cjs/node.js
+var require_node = __commonJS({
+  "../refactor/domql/packages/utils/dist/cjs/node.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var node_exports = {};
+    __export2(node_exports, {
+      isHtmlElement: () => isHtmlElement,
+      isNode: () => isNode3
+    });
+    module.exports = __toCommonJS2(node_exports);
+    var import_globals2 = require_cjs3();
+    var isNode3 = (obj) => {
+      return (typeof Node === "object" ? obj instanceof import_globals2.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+    };
+    var isHtmlElement = (obj) => {
+      return (typeof HTMLElement === "object" ? obj instanceof import_globals2.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+    };
+  }
+});
+
+// ../refactor/domql/packages/utils/dist/cjs/types.js
+var require_types = __commonJS({
+  "../refactor/domql/packages/utils/dist/cjs/types.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var types_exports = {};
+    __export2(types_exports, {
+      TYPES: () => TYPES,
+      is: () => is6,
+      isArray: () => isArray9,
+      isBoolean: () => isBoolean,
+      isDefined: () => isDefined2,
+      isFunction: () => isFunction17,
+      isNot: () => isNot2,
+      isNull: () => isNull,
+      isNumber: () => isNumber4,
+      isObject: () => isObject21,
+      isObjectLike: () => isObjectLike5,
+      isString: () => isString12,
+      isUndefined: () => isUndefined3,
+      isValidHtmlTag: () => isValidHtmlTag
+    });
+    module.exports = __toCommonJS2(types_exports);
+    var import_tags = require_cjs2();
+    var import_node5 = require_node();
+    var isValidHtmlTag = (arg) => import_tags.HTML_TAGS.body.includes(arg);
+    var isObject21 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object" && arg.constructor === Object;
+    };
+    var isString12 = (arg) => typeof arg === "string";
+    var isNumber4 = (arg) => typeof arg === "number";
+    var isFunction17 = (arg) => typeof arg === "function";
+    var isBoolean = (arg) => arg === true || arg === false;
+    var isNull = (arg) => arg === null;
+    var isArray9 = (arg) => Array.isArray(arg);
+    var isObjectLike5 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object";
+    };
+    var isDefined2 = (arg) => {
+      return isObject21(arg) || isObjectLike5(arg) || isString12(arg) || isNumber4(arg) || isFunction17(arg) || isArray9(arg) || isObjectLike5(arg) || isBoolean(arg) || isNull(arg);
+    };
+    var isUndefined3 = (arg) => {
+      return arg === void 0;
+    };
+    var TYPES = {
+      boolean: isBoolean,
+      array: isArray9,
+      object: isObject21,
+      string: isString12,
+      number: isNumber4,
+      null: isNull,
+      function: isFunction17,
+      objectLike: isObjectLike5,
+      node: import_node5.isNode,
+      htmlElement: import_node5.isHtmlElement,
+      defined: isDefined2
+    };
+    var is6 = (arg) => {
+      return (...args) => {
+        return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+      };
+    };
+    var isNot2 = (arg) => {
+      return (...args) => {
+        return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+      };
+    };
+  }
+});
+
+// ../refactor/domql/packages/utils/dist/cjs/object.js
+var require_object = __commonJS({
+  "../refactor/domql/packages/utils/dist/cjs/object.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var object_exports = {};
+    __export2(object_exports, {
+      clone: () => clone,
+      deepClone: () => deepClone4,
+      deepCloneExclude: () => deepCloneExclude,
+      deepDestringify: () => deepDestringify,
+      deepMerge: () => deepMerge3,
+      deepStringify: () => deepStringify,
+      detachFunctionsFromObject: () => detachFunctionsFromObject,
+      diff: () => diff,
+      diffArrays: () => diffArrays,
+      diffObjects: () => diffObjects,
+      exec: () => exec25,
+      flattenRecursive: () => flattenRecursive,
+      isEqualDeep: () => isEqualDeep2,
+      map: () => map3,
+      merge: () => merge2,
+      mergeIfExisted: () => mergeIfExisted,
+      overwrite: () => overwrite2,
+      overwriteDeep: () => overwriteDeep3,
+      overwriteObj: () => overwriteObj,
+      overwriteShallow: () => overwriteShallow3,
+      removeFromObject: () => removeFromObject3
+    });
+    module.exports = __toCommonJS2(object_exports);
+    var import_globals2 = require_cjs3();
+    var import_types = require_types();
+    var exec25 = (param, element, state2, context) => {
+      if ((0, import_types.isFunction)(param)) {
+        return param(
+          element,
+          state2 || element.state,
+          context || element.context
+        );
+      }
+      return param;
+    };
+    var map3 = (obj, extention, element) => {
+      for (const e2 in extention) {
+        obj[e2] = exec25(extention[e2], element);
+      }
+    };
+    var merge2 = (element, obj) => {
+      for (const e2 in obj) {
+        const elementProp = element[e2];
+        const objProp = obj[e2];
+        if (elementProp === void 0) {
+          element[e2] = objProp;
+        }
+      }
+      return element;
+    };
+    var deepMerge3 = (element, extend, excludeFrom = []) => {
+      for (const e2 in extend) {
+        if (excludeFrom.includes(e2) || e2.includes("__"))
+          continue;
+        const elementProp = element[e2];
+        const extendProp = extend[e2];
+        if ((0, import_types.isObjectLike)(elementProp) && (0, import_types.isObjectLike)(extendProp)) {
+          deepMerge3(elementProp, extendProp);
+        } else if (elementProp === void 0) {
+          element[e2] = extendProp;
+        }
+      }
+      return element;
+    };
+    var clone = (obj, excludeFrom = []) => {
+      const o = {};
+      for (const prop in obj) {
+        if (excludeFrom.includes(e) || e.includes("__"))
+          continue;
+        o[prop] = obj[prop];
+      }
+      return o;
+    };
+    var deepCloneExclude = (obj, excludeFrom = []) => {
+      if ((0, import_types.isArray)(obj)) {
+        return obj.map((x) => deepCloneExclude(x, excludeFrom));
+      }
+      const o = {};
+      for (const k in obj) {
+        if (excludeFrom.includes(k) || k.includes("__"))
+          continue;
+        let v = obj[k];
+        if (k === "extend" && (0, import_types.isArray)(v)) {
+          v = mergeArrayExclude(v, excludeFrom);
+        }
+        if ((0, import_types.isArray)(v)) {
+          o[k] = v.map((x) => deepCloneExclude(x, excludeFrom));
+        } else if ((0, import_types.isObject)(v)) {
+          o[k] = deepCloneExclude(v, excludeFrom);
+        } else
+          o[k] = v;
+      }
+      return o;
+    };
+    var deepClone4 = (obj, excludeFrom = []) => {
+      const o = (0, import_types.isArray)(obj) ? [] : {};
+      for (const prop in obj) {
+        if (excludeFrom.includes(prop) || prop.includes("__"))
+          continue;
+        let objProp = obj[prop];
+        if (prop === "extend" && (0, import_types.isArray)(objProp)) {
+          objProp = mergeArray(objProp);
+        }
+        if ((0, import_types.isObjectLike)(objProp)) {
+          o[prop] = deepClone4(objProp, excludeFrom);
+        } else
+          o[prop] = objProp;
+      }
+      return o;
+    };
+    var deepStringify = (obj, stringified = {}) => {
+      for (const prop in obj) {
+        const objProp = obj[prop];
+        if ((0, import_types.isFunction)(objProp)) {
+          stringified[prop] = objProp.toString();
+        } else if ((0, import_types.isObject)(objProp)) {
+          stringified[prop] = {};
+          deepStringify(objProp, stringified[prop]);
+        } else if ((0, import_types.isArray)(objProp)) {
+          stringified[prop] = [];
+          objProp.forEach((v, i) => {
+            if ((0, import_types.isObject)(v)) {
+              stringified[prop][i] = {};
+              deepStringify(v, stringified[prop][i]);
+            } else if ((0, import_types.isFunction)(v)) {
+              stringified[prop][i] = v.toString();
+            } else {
+              stringified[prop][i] = v;
+            }
+          });
+        } else {
+          stringified[prop] = objProp;
+        }
+      }
+      return stringified;
+    };
+    var detachFunctionsFromObject = (obj, detached = {}) => {
+      for (const prop in obj) {
+        const objProp = obj[prop];
+        if ((0, import_types.isFunction)(objProp))
+          continue;
+        else if ((0, import_types.isObject)(objProp)) {
+          detached[prop] = {};
+          deepStringify(objProp, detached[prop]);
+        } else if ((0, import_types.isArray)(objProp)) {
+          detached[prop] = [];
+          objProp.forEach((v, i) => {
+            if ((0, import_types.isFunction)(v))
+              return;
+            if ((0, import_types.isObject)(v)) {
+              detached[prop][i] = {};
+              detachFunctionsFromObject(v, detached[prop][i]);
+            } else {
+              detached[prop][i] = v;
+            }
+          });
+        } else {
+          detached[prop] = objProp;
+        }
+      }
+      return detached;
+    };
+    var deepDestringify = (obj, stringified = {}) => {
+      for (const prop in obj) {
+        const objProp = obj[prop];
+        if ((0, import_types.isString)(objProp)) {
+          if (objProp.includes("=>") || objProp.includes("function") || objProp.startsWith("(")) {
+            try {
+              const evalProp = import_globals2.window.eval(`(${objProp})`);
+              stringified[prop] = evalProp;
+            } catch (e2) {
+              if (e2)
+                stringified[prop] = objProp;
+            }
+          } else {
+            stringified[prop] = objProp;
+          }
+        } else if ((0, import_types.isArray)(objProp)) {
+          stringified[prop] = [];
+          objProp.forEach((arrProp) => {
+            if ((0, import_types.isString)(arrProp)) {
+              if (arrProp.includes("=>") || arrProp.includes("function") || arrProp.startsWith("(")) {
+                try {
+                  const evalProp = import_globals2.window.eval(`(${arrProp})`);
+                  stringified[prop].push(evalProp);
+                } catch (e2) {
+                  if (e2)
+                    stringified[prop].push(arrProp);
+                }
+              } else {
+                stringified[prop].push(arrProp);
+              }
+            } else if ((0, import_types.isObject)(arrProp)) {
+              stringified[prop].push(deepDestringify(arrProp));
+            } else {
+              stringified[prop].push(arrProp);
+            }
+          });
+        } else if ((0, import_types.isObject)(objProp)) {
+          stringified[prop] = deepDestringify(objProp, stringified[prop]);
+        } else {
+          stringified[prop] = objProp;
+        }
+      }
+      return stringified;
+    };
+    var overwrite2 = (element, params, excludeFrom = []) => {
+      const { ref } = element;
+      const changes = {};
+      for (const e2 in params) {
+        if (excludeFrom.includes(e2) || e2.includes("__"))
+          continue;
+        const elementProp = element[e2];
+        const paramsProp = params[e2];
+        if (paramsProp) {
+          ref.__cache[e2] = changes[e2] = elementProp;
+          ref[e2] = paramsProp;
+        }
+      }
+      return changes;
+    };
+    var diffObjects = (original, objToDiff, cache) => {
+      for (const e2 in objToDiff) {
+        if (e2 === "ref")
+          continue;
+        const originalProp = original[e2];
+        const objToDiffProp = objToDiff[e2];
+        if ((0, import_types.isObject)(originalProp) && (0, import_types.isObject)(objToDiffProp)) {
+          cache[e2] = {};
+          diff(originalProp, objToDiffProp, cache[e2]);
+        } else if (objToDiffProp !== void 0) {
+          cache[e2] = objToDiffProp;
+        }
+      }
+      return cache;
+    };
+    var diffArrays = (original, objToDiff, cache) => {
+      if (original.length !== objToDiff.length) {
+        cache = objToDiff;
+      } else {
+        const diffArr = [];
+        for (let i = 0; i < original.length; i++) {
+          const diffObj = diff(original[i], objToDiff[i]);
+          if (Object.keys(diffObj).length > 0) {
+            diffArr.push(diffObj);
+          }
+        }
+        if (diffArr.length > 0) {
+          cache = diffArr;
+        }
+      }
+      return cache;
+    };
+    var diff = (original, objToDiff, cache = {}) => {
+      if ((0, import_types.isArray)(original) && (0, import_types.isArray)(objToDiff)) {
+        cache = [];
+        diffArrays(original, objToDiff, cache);
+      } else {
+        diffObjects(original, objToDiff, cache);
+      }
+      return cache;
+    };
+    var overwriteObj = (params, obj) => {
+      const changes = {};
+      for (const e2 in params) {
+        const objProp = obj[e2];
+        const paramsProp = params[e2];
+        if (paramsProp) {
+          obj[e2] = changes[e2] = objProp;
+        }
+      }
+      return changes;
+    };
+    var overwriteShallow3 = (obj, params, excludeFrom = []) => {
+      for (const e2 in params) {
+        if (excludeFrom.includes(e2) || e2.includes("__"))
+          continue;
+        obj[e2] = params[e2];
+      }
+      return obj;
+    };
+    var overwriteDeep3 = (params, obj, excludeFrom = []) => {
+      for (const e2 in params) {
+        if (excludeFrom.includes(e2) || e2.includes("__"))
+          continue;
+        const objProp = obj[e2];
+        const paramsProp = params[e2];
+        if ((0, import_types.isObjectLike)(objProp) && (0, import_types.isObjectLike)(paramsProp)) {
+          overwriteDeep3(paramsProp, objProp);
+        } else if (paramsProp !== void 0) {
+          obj[e2] = paramsProp;
+        }
+      }
+      return obj;
+    };
+    var mergeIfExisted = (a, b) => {
+      if ((0, import_types.isObjectLike)(a) && (0, import_types.isObjectLike)(b))
+        return deepMerge3(a, b);
+      return a || b;
+    };
+    var flattenRecursive = (param, prop, stack = []) => {
+      const objectized = mergeAndCloneIfArray(param);
+      stack.push(objectized);
+      const extendOfExtend = objectized[prop];
+      if (extendOfExtend)
+        flattenRecursive(extendOfExtend, prop, stack);
+      delete objectized[prop];
+      return stack;
+    };
+    var isEqualDeep2 = (param, element) => {
+      if (param === element)
+        return true;
+      if (!param || !element)
+        return false;
+      for (const prop in param) {
+        const paramProp = param[prop];
+        const elementProp = element[prop];
+        if ((0, import_types.isObjectLike)(paramProp)) {
+          const isEqual = isEqualDeep2(paramProp, elementProp);
+          if (!isEqual)
+            return false;
+        } else {
+          const isEqual = paramProp === elementProp;
+          if (!isEqual)
+            return false;
+        }
+      }
+      return true;
+    };
+    var removeFromObject3 = (obj, props) => {
+      if (props === void 0 || props === null)
+        return obj;
+      if ((0, import_types.is)(props)("string", "number")) {
+        delete obj[props];
+      } else if ((0, import_types.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;
+    };
+  }
+});
+
+// ../refactor/domql/packages/utils/dist/cjs/function.js
+var require_function = __commonJS({
+  "../refactor/domql/packages/utils/dist/cjs/function.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var function_exports = {};
+    __export2(function_exports, {
+      debounce: () => debounce,
+      memoize: () => memoize
+    });
+    module.exports = __toCommonJS2(function_exports);
+    var debounce = (element, func, timeout = 300) => {
+      let timer;
+      return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+          func.apply(element, args);
+        }, timeout);
+      };
+    };
+    var memoize = (fn) => {
+      const cache = {};
+      return (...args) => {
+        const n = args[0];
+        if (n in cache) {
+          return cache[n];
+        } else {
+          const result = fn(n);
+          cache[n] = result;
+          return result;
+        }
+      };
+    };
+  }
+});
+
+// ../refactor/domql/packages/utils/dist/cjs/array.js
+var require_array = __commonJS({
+  "../refactor/domql/packages/utils/dist/cjs/array.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var array_exports = {};
+    __export2(array_exports, {
+      arrayContainsOtherArray: () => arrayContainsOtherArray3,
+      joinArrays: () => joinArrays2,
+      mergeAndCloneIfArray: () => mergeAndCloneIfArray2,
+      mergeArray: () => mergeArray2,
+      removeFromArray: () => removeFromArray3,
+      swapItemsInArray: () => swapItemsInArray
+    });
+    module.exports = __toCommonJS2(array_exports);
+    var import_object = require_object();
+    var import_types = require_types();
+    var arrayContainsOtherArray3 = (arr1, arr2) => {
+      return arr2.every((val) => arr1.includes(val));
+    };
+    var removeFromArray3 = (arr, index) => {
+      if ((0, import_types.isString)(index))
+        index = parseInt(index);
+      if ((0, import_types.isNumber)(index)) {
+        if (index < 0 || index >= arr.length || isNaN(index)) {
+          throw new Error("Invalid index");
+        }
+        arr.splice(index, 1);
+      } else if ((0, import_types.isArray)(index)) {
+        index.forEach((idx) => removeFromArray3(arr, idx));
+      } else {
+        throw new Error("Invalid index");
+      }
+      return arr;
+    };
+    var swapItemsInArray = (arr, i, j) => {
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    };
+    var joinArrays2 = (...arrays) => {
+      return [].concat(...arrays);
+    };
+    var mergeArray2 = (arr, excludeFrom = []) => {
+      return arr.reduce((a, c) => (0, import_object.deepMerge)(a, (0, import_object.deepClone)(c, excludeFrom), excludeFrom), {});
+    };
+    var mergeAndCloneIfArray2 = (obj) => {
+      return (0, import_types.isArray)(obj) ? mergeArray2(obj) : (0, import_object.deepClone)(obj);
+    };
+  }
+});
+
+// ../refactor/domql/packages/utils/dist/cjs/log.js
+var require_log = __commonJS({
+  "../refactor/domql/packages/utils/dist/cjs/log.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var log_exports = {};
+    __export2(log_exports, {
+      logGroupIf: () => logGroupIf,
+      logIf: () => logIf
+    });
+    module.exports = __toCommonJS2(log_exports);
+    var logIf = (bool, ...arg) => {
+      if (bool)
+        arg.map((v) => console.log(v));
+    };
+    var logGroupIf = (bool, key, ...arg) => {
+      if (bool) {
+        console.group(key);
+        arg.map((v) => console.log(v));
+        console.groupEnd(key);
+      }
+    };
+  }
+});
+
+// ../refactor/domql/packages/utils/dist/cjs/index.js
+var require_cjs4 = __commonJS({
+  "../refactor/domql/packages/utils/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var utils_exports = {};
+    module.exports = __toCommonJS2(utils_exports);
+    __reExport(utils_exports, require_cjs(), module.exports);
+    __reExport(utils_exports, require_types(), module.exports);
+    __reExport(utils_exports, require_object(), module.exports);
+    __reExport(utils_exports, require_function(), module.exports);
+    __reExport(utils_exports, require_array(), module.exports);
+    __reExport(utils_exports, require_node(), module.exports);
+    __reExport(utils_exports, require_log(), module.exports);
+  }
+});
+
+// ../refactor/domql/packages/event/dist/cjs/on.js
+var require_on = __commonJS({
+  "../refactor/domql/packages/event/dist/cjs/on.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var on_exports = {};
+    __export2(on_exports, {
+      applyEvent: () => applyEvent2,
+      applyEventsOnNode: () => applyEventsOnNode2,
+      triggerEventOn: () => triggerEventOn7
+    });
+    module.exports = __toCommonJS2(on_exports);
+    var import_utils40 = require_cjs4();
+    var applyEvent2 = (param, element, state2, context, updatedObj) => {
+      if (updatedObj)
+        return param(updatedObj, element, state2 || element.state, context || element.context);
+      return param(element, state2 || element.state, context || element.context);
+    };
+    var triggerEventOn7 = (param, element, updatedObj) => {
+      if (element.on && (0, import_utils40.isFunction)(element.on[param])) {
+        if (updatedObj) {
+          const { state: state2, context } = element;
+          return applyEvent2(element.on[param], element, state2, context, updatedObj);
+        }
+        return applyEvent2(element.on[param], element);
+      }
+    };
+    var applyEventsOnNode2 = (element) => {
+      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 === "initStateUpdated" || param === "stateUpdated" || param === "initUpdate" || param === "update")
+          continue;
+        const appliedFunction = element.on[param];
+        if ((0, import_utils40.isFunction)(appliedFunction)) {
+          const { state: state2, context } = element;
+          node.addEventListener(param, (event) => appliedFunction(event, element, state2, context));
+        }
+      }
+    };
+  }
+});
+
+// ../refactor/domql/packages/report/dist/cjs/index.js
+var require_cjs5 = __commonJS({
+  "../refactor/domql/packages/report/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var report_exports = {};
+    __export2(report_exports, {
+      ERRORS_REGISTRY: () => ERRORS_REGISTRY,
+      report: () => report8
+    });
+    module.exports = __toCommonJS2(report_exports);
+    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"
+        }
+      }
+    };
+    var report8 = (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}` : ""
+      );
+    };
+  }
+});
+
+// ../refactor/domql/packages/event/dist/cjs/can.js
+var require_can = __commonJS({
+  "../refactor/domql/packages/event/dist/cjs/can.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var can_exports = {};
+    __export2(can_exports, {
+      canRender: () => canRender
+    });
+    module.exports = __toCommonJS2(can_exports);
+    var import_report8 = require_cjs5();
+    var import_utils40 = require_cjs4();
+    var canRender = (element) => {
+      const tag = element.tag || "div";
+      return (0, import_utils40.isValidHtmlTag)(tag) || (0, import_report8.report)("HTMLInvalidTag");
+    };
+  }
+});
+
+// ../refactor/domql/packages/event/dist/cjs/index.js
+var require_cjs6 = __commonJS({
+  "../refactor/domql/packages/event/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var event_exports = {};
+    module.exports = __toCommonJS2(event_exports);
+    __reExport(event_exports, require_on(), module.exports);
+    __reExport(event_exports, require_can(), module.exports);
+  }
+});
+
+// ../refactor/domql/packages/tree/dist/cjs/root.js
+var require_root = __commonJS({
+  "../refactor/domql/packages/tree/dist/cjs/root.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var root_exports = {};
+    __export2(root_exports, {
+      ROOT: () => ROOT3
+    });
+    module.exports = __toCommonJS2(root_exports);
+    var import_globals2 = require_cjs3();
+    var import_report8 = require_cjs5();
+    var ROOT3 = {
+      key: ":root",
+      node: import_globals2.document ? import_globals2.document.body : (0, import_report8.report)("DocumentNotDefined", import_globals2.document)
+    };
+  }
+});
+
+// ../refactor/domql/packages/tree/dist/cjs/index.js
+var require_cjs7 = __commonJS({
+  "../refactor/domql/packages/tree/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var tree_exports = {};
+    __export2(tree_exports, {
+      ROOT: () => import_root2.ROOT,
+      TREE: () => TREE2
+    });
+    module.exports = __toCommonJS2(tree_exports);
+    var import_root = require_root();
+    var import_root2 = require_root();
+    var TREE2 = import_root.ROOT;
+  }
+});
+
+// ../refactor/domql/packages/registry/dist/cjs/methods.js
+var require_methods = __commonJS({
+  "../refactor/domql/packages/registry/dist/cjs/methods.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var methods_exports = {};
+    __export2(methods_exports, {
+      DEFAULT_METHODS: () => DEFAULT_METHODS2
+    });
+    module.exports = __toCommonJS2(methods_exports);
+    var import_utils40 = require_cjs4();
+    var DEFAULT_METHODS2 = {
+      key: {},
+      tag: {},
+      if: {},
+      define: {},
+      attr: {},
+      style: {},
+      content: {},
+      class: {},
+      props: {},
+      state: {},
+      method: {},
+      transform: {},
+      on: {},
+      ref: {},
+      extend: {},
+      childExtend: {},
+      text: (element, state2) => {
+        element.ref.text = {
+          tag: "text",
+          text: (0, import_utils40.exec)(element.text, element, state2)
+        };
+      },
+      innerHTML: {},
+      set: {},
+      update: {},
+      remove: {}
+    };
+  }
+});
+
+// ../refactor/domql/packages/registry/dist/cjs/tags.js
+var require_tags = __commonJS({
+  "../refactor/domql/packages/registry/dist/cjs/tags.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var tags_exports = {};
+    __export2(tags_exports, {
+      TAGS: () => TAGS3
+    });
+    module.exports = __toCommonJS2(tags_exports);
+    var TAGS3 = {
+      root: [
+        "body",
+        "html"
+      ],
+      head: [
+        "title",
+        "base",
+        "meta",
+        "style"
+      ],
+      body: [
+        "html",
+        "body",
+        "string",
+        "fragment",
+        "a",
+        "abbr",
+        "acronym",
+        "address",
+        "applet",
+        "area",
+        "article",
+        "aside",
+        "audio",
+        "b",
+        "basefont",
+        "bdi",
+        "bdo",
+        "big",
+        "blockquote",
+        "br",
+        "button",
+        "canvas",
+        "caption",
+        "center",
+        "cite",
+        "code",
+        "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",
+        "q",
+        "rp",
+        "rt",
+        "ruby",
+        "s",
+        "samp",
+        "script",
+        "section",
+        "select",
+        "small",
+        "source",
+        "span",
+        "strike",
+        "strong",
+        "sub",
+        "summary",
+        "sup",
+        "table",
+        "tbody",
+        "td",
+        "template",
+        "textarea",
+        "tfoot",
+        "th",
+        "thead",
+        "time",
+        "tr",
+        "track",
+        "tt",
+        "u",
+        "ul",
+        "var",
+        "video",
+        "wbr",
+        "svg",
+        "path"
+      ]
+    };
+  }
+});
+
+// ../refactor/domql/packages/registry/dist/cjs/index.js
+var require_cjs8 = __commonJS({
+  "../refactor/domql/packages/registry/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var registry_exports = {};
+    module.exports = __toCommonJS2(registry_exports);
+    __reExport(registry_exports, require_methods(), module.exports);
+    __reExport(registry_exports, require_tags(), module.exports);
+  }
+});
+
+// ../refactor/domql/packages/render/dist/cjs/index.js
+var require_cjs9 = __commonJS({
+  "../refactor/domql/packages/render/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var render_exports = {};
+    __export2(render_exports, {
+      appendNode: () => appendNode2,
+      assignNode: () => assignNode3,
+      insertNodeAfter: () => insertNodeAfter
+    });
+    module.exports = __toCommonJS2(render_exports);
+    var appendNode2 = (node, parentNode) => {
+      parentNode.appendChild(node);
+      return node;
+    };
+    var insertNodeAfter = (node, siblingNode) => {
+      siblingNode.parentNode.insertBefore(node, siblingNode.nextSibling);
+    };
+    var assignNode3 = (element, parent, key, insertAfter) => {
+      parent[key || element.key] = element;
+      if (element.tag !== "shadow") {
+        (insertAfter ? insertNodeAfter : appendNode2)(element.node, parent.node);
+      }
+      return element;
+    };
+  }
+});
+
+// ../refactor/domql/packages/env/dist/cjs/index.js
+var require_cjs10 = __commonJS({
+  "../refactor/domql/packages/env/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var env_exports = {};
+    __export2(env_exports, {
+      NODE_ENV: () => NODE_ENV,
+      getNev: () => getNev,
+      isDevelopment: () => isDevelopment,
+      isProduction: () => isProduction,
+      isTest: () => isTest
+    });
+    module.exports = __toCommonJS2(env_exports);
+    var NODE_ENV = "development";
+    var isProduction = (env = NODE_ENV) => env === "production" || env === "prod" || env !== "development" && env !== "dev" && env !== "test";
+    var isTest = (env = NODE_ENV) => env === "test";
+    var isDevelopment = (env = NODE_ENV) => env === "development" || env === "dev";
+    var getNev = (key, env = NODE_ENV) => env[key];
+  }
+});
+
+// ../refactor/domql/packages/methods/dist/cjs/index.js
+var require_cjs11 = __commonJS({
+  "../refactor/domql/packages/methods/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var methods_exports = {};
+    __export2(methods_exports, {
+      METHODS: () => METHODS2,
+      defineSetter: () => defineSetter,
+      get: () => get2,
+      isMethod: () => isMethod6,
+      keys: () => keys2,
+      log: () => log2,
+      lookup: () => lookup3,
+      parse: () => parse3,
+      parseDeep: () => parseDeep2,
+      remove: () => remove4,
+      setProps: () => setProps2,
+      spotByPath: () => spotByPath2
+    });
+    module.exports = __toCommonJS2(methods_exports);
+    var import_tree4 = require_cjs7();
+    var import_utils40 = require_cjs4();
+    var import_registry4 = require_cjs8();
+    var import_env = require_cjs10();
+    var spotByPath2 = function(path) {
+      const element = this;
+      const arr = [].concat(path);
+      let active = import_tree4.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;
+    };
+    var lookup3 = function(key) {
+      const element = this;
+      let { parent } = element;
+      while (parent.key !== key) {
+        if (parent[key])
+          return parent[key];
+        parent = parent.parent;
+        if (!parent)
+          return;
+      }
+      return parent;
+    };
+    var remove4 = function(params) {
+      const element = this;
+      if ((0, import_utils40.isFunction)(element.node.remove))
+        element.node.remove();
+      else if (!(0, import_env.isProduction)()) {
+        console.warn("This item cant be removed");
+        element.log();
+      }
+      delete element.parent[element.key];
+    };
+    var get2 = function(param) {
+      const element = this;
+      return element[param];
+    };
+    var setProps2 = function(param, options) {
+      const element = this;
+      if (!param || !element.props)
+        return;
+      element.update({ props: param }, options);
+      return element;
+    };
+    var defineSetter = (element, key, get22, set2) => Object.defineProperty(element, key, { get: get22, set: set2 });
+    var keys2 = function() {
+      const element = this;
+      const keys22 = [];
+      for (const param in element) {
+        if (!(0, import_utils40.isObject)(import_registry4.DEFAULT_METHODS[param])) {
+          keys22.push(param);
+        }
+      }
+      return keys22;
+    };
+    var parse3 = function() {
+      const element = this;
+      const obj = {};
+      const keys22 = element.keys();
+      keys22.forEach((v) => obj[v] = element[v]);
+      return obj;
+    };
+    var parseDeep2 = function(param) {
+      const element = this;
+      const orig = param || element;
+      const obj = {};
+      const keys22 = orig.keys && orig.keys();
+      if (!keys22)
+        return;
+      keys22.forEach((v) => {
+        const prop = orig[v];
+        if ((0, import_utils40.isObjectLike)(prop))
+          parseDeep2(prop);
+        else
+          obj[v] = prop;
+      });
+      return obj;
+    };
+    var log2 = function(...args) {
+      const element = this;
+      console.group(element.key);
+      if (args.length) {
+        args.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+      } else {
+        console.log(element.path);
+        const keys22 = element.keys();
+        keys22.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+      }
+      console.groupEnd(element.key);
+      return element;
+    };
+    var METHODS2 = [
+      "set",
+      "update",
+      "remove",
+      "removeContent",
+      "lookup",
+      "spotByPath",
+      "keys",
+      "parse",
+      "setProps",
+      "parseDeep",
+      "if",
+      "log",
+      "nextElement",
+      "previousElement"
+    ];
+    var isMethod6 = function(param) {
+      return METHODS2.includes(param);
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/attr.js
+var import_utils2, import_report, attr;
+var init_attr = __esm({
+  "../refactor/domql/packages/mixins/attr.js"() {
+    "use strict";
+    import_utils2 = __toESM(require_cjs4());
+    import_report = __toESM(require_cjs5());
+    attr = (params, element, node) => {
+      if (params) {
+        if (!(typeof params === "object"))
+          (0, import_report.report)("HTMLInvalidAttr", params);
+        for (const attr2 in params) {
+          const val = (0, import_utils2.exec)(params[attr2], element);
+          if (val && node.setAttribute)
+            node.setAttribute(attr2, val);
+          else if (node.removeAttribute)
+            node.removeAttribute(attr2);
+        }
+      }
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/data.js
+var import_utils3, import_report2, data;
+var init_data = __esm({
+  "../refactor/domql/packages/mixins/data.js"() {
+    "use strict";
+    import_utils3 = __toESM(require_cjs4());
+    import_report2 = __toESM(require_cjs5());
+    data = (params, element, node) => {
+      if (params && params.showOnNode) {
+        if (!(0, import_utils3.isObject)(params))
+          (0, import_report2.report)("HTMLInvalidData", params);
+        for (const dataset in params) {
+          if (dataset !== "showOnNode") {
+            node.dataset[dataset] = (0, import_utils3.exec)(params[dataset], element);
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/html.js
+var import_utils4, html;
+var init_html = __esm({
+  "../refactor/domql/packages/mixins/html.js"() {
+    "use strict";
+    import_utils4 = __toESM(require_cjs4());
+    html = (param, element, node) => {
+      const prop = (0, import_utils4.exec)(param, element);
+      const { __ref } = element;
+      if (prop !== __ref.__html) {
+        if (node.nodeName === "SVG")
+          node.textContent = prop;
+        else
+          node.innerHTML = prop;
+        __ref.__html = prop;
+      }
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/style.js
+var import_utils5, import_report3, style;
+var init_style = __esm({
+  "../refactor/domql/packages/mixins/style.js"() {
+    "use strict";
+    import_utils5 = __toESM(require_cjs4());
+    import_report3 = __toESM(require_cjs5());
+    style = (params, element, node) => {
+      if (params) {
+        if ((0, import_utils5.isObject)(params))
+          (0, import_utils5.map)(node.style, params, element);
+        else
+          (0, import_report3.report)("HTMLInvalidStyles", params);
+      }
+    };
+  }
+});
+
+// ../refactor/domql/packages/state/ignore.js
+var IGNORE_STATE_PARAMS2;
+var init_ignore = __esm({
+  "../refactor/domql/packages/state/ignore.js"() {
+    "use strict";
+    IGNORE_STATE_PARAMS2 = [
+      "update",
+      "parse",
+      "clean",
+      "create",
+      "destroy",
+      "remove",
+      "apply",
+      "rootUpdate",
+      "parent",
+      "__element",
+      "__depends",
+      "__ref",
+      "__children",
+      "__root"
+    ];
+  }
+});
+
+// ../refactor/domql/packages/state/index.js
+var import_event, import_utils6, parse, clean, destroy, rootUpdate, updateState, remove, apply, getParentStateInKey, getChildStateInKey, createInheritedState, createState, applyMethods;
+var init_state = __esm({
+  "../refactor/domql/packages/state/index.js"() {
+    "use strict";
+    init_ignore();
+    import_event = __toESM(require_cjs6());
+    import_utils6 = __toESM(require_cjs4());
+    parse = function() {
+      const state2 = this;
+      if ((0, import_utils6.isObject)(state2)) {
+        const obj = {};
+        for (const param in state2) {
+          if (!IGNORE_STATE_PARAMS2.includes(param)) {
+            obj[param] = state2[param];
+          }
+        }
+        return obj;
+      } else if ((0, import_utils6.isArray)(state2)) {
+        return state2.filter((item) => !IGNORE_STATE_PARAMS2.includes(item));
+      }
+    };
+    clean = function(options = {}) {
+      const state2 = this;
+      for (const param in state2) {
+        if (!IGNORE_STATE_PARAMS2.includes(param)) {
+          delete state2[param];
+        }
+      }
+      state2.update(state2, { skipOverwrite: true, options });
+      return state2;
+    };
+    destroy = function() {
+      const state2 = this;
+      const element = state2.__element;
+      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) {
+            child.parent = state2.parent;
+          }
+        }
+      }
+      element.state.update();
+      return element.state;
+    };
+    rootUpdate = function(obj, options = {}) {
+      const state2 = this;
+      if (!state2)
+        return;
+      const rootState = state2.__element.__ref.__root.state;
+      return rootState.update(obj, options);
+    };
+    updateState = function(obj, options = {}) {
+      const state2 = this;
+      const element = state2.__element;
+      const __elementRef = element.__ref;
+      const parentState = element.parent.state;
+      state2.parent = parentState;
+      for (const param in state2) {
+        if ((0, import_utils6.isUndefined)(state2[param])) {
+          delete state2[param];
+        }
+      }
+      if (!state2.__element) {
+        create(element, element.parent);
+      }
+      const initStateUpdateReturns = (0, import_event.triggerEventOn)("initStateUpdated", element, obj);
+      if (initStateUpdateReturns === false)
+        return element;
+      if (!options.skipOverwrite) {
+        if (options.shallow) {
+          (0, import_utils6.overwriteShallow)(state2, obj, IGNORE_STATE_PARAMS2);
+        } else {
+          (0, import_utils6.overwriteDeep)(state2, obj, IGNORE_STATE_PARAMS2);
+        }
+      }
+      const stateKey = __elementRef.__state;
+      const shouldPropagateState = stateKey && parentState && parentState[stateKey] && !options.stopStatePropagation;
+      if (shouldPropagateState) {
+        const isStringState = __elementRef.__stateType === "string";
+        const value = isStringState ? state2.value : state2.parse();
+        parentState[stateKey] = value;
+        parentState.update(value, { skipOverwrite: true, ...options });
+        return state2;
+      }
+      if (!options.preventUpdate) {
+        element.update({}, options);
+      } else if (options.preventUpdate === "recursive") {
+        element.update({}, { ...options, preventUpdate: true });
+      }
+      if (state2.__depends) {
+        for (const el in state2.__depends) {
+          const findElement = state2.__depends[el];
+          findElement.clean().update(state2.parse(), options);
+        }
+      }
+      if (!options.preventUpdateListener) {
+        (0, import_event.triggerEventOn)("stateUpdated", element, obj);
+      }
+      return state2;
+    };
+    remove = function(key, options) {
+      const state2 = this;
+      if ((0, import_utils6.isArray)(state2))
+        (0, import_utils6.removeFromArray)(state2, key);
+      if ((0, import_utils6.isObject)(state2))
+        (0, import_utils6.removeFromObject)(state2, key);
+      return state2.update(state2, { skipOverwrite: true, options });
+    };
+    apply = function(func, options) {
+      const state2 = this;
+      if ((0, import_utils6.isFunction)(func)) {
+        func(state2);
+        return state2.update(state2, { skipOverwrite: true, options });
+      }
+    };
+    getParentStateInKey = (stateKey, parentState) => {
+      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;
+    };
+    getChildStateInKey = (stateKey, parentState) => {
+      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];
+        const childInParent = parentState[childKey];
+        if (childInParent && childInParent[grandChildKey]) {
+          stateKey = grandChildKey;
+          parentState = childInParent;
+        } else
+          return;
+      }
+      return parentState[stateKey];
+    };
+    createInheritedState = function(element, parent) {
+      const __elementRef = element.__ref;
+      let stateKey = __elementRef.__state;
+      if (!stateKey)
+        return element.state;
+      let parentState = parent.state;
+      if (stateKey.includes("../")) {
+        parentState = getParentStateInKey(stateKey, parent.state);
+        stateKey = stateKey.replaceAll("../", "");
+      }
+      if (!parentState)
+        return {};
+      const keyInParentState = getChildStateInKey(stateKey, parentState);
+      if (!keyInParentState)
+        return {};
+      if ((0, import_utils6.is)(keyInParentState)("object", "array")) {
+        return (0, import_utils6.deepClone)(keyInParentState, IGNORE_STATE_PARAMS2);
+      } else if ((0, import_utils6.is)(keyInParentState)("string", "number")) {
+        __elementRef.__stateType = "string";
+        return { value: keyInParentState };
+      }
+      console.warn(stateKey, "is not present. Replacing with", {});
+      return {};
+    };
+    createState = function(element, parent, opts) {
+      const skip = opts && opts.skip ? opts.skip : false;
+      let { state: state2, __ref: __elementRef } = element;
+      if ((0, import_utils6.isFunction)(state2))
+        element.state = (0, import_utils6.exec)(state2, element);
+      if ((0, import_utils6.is)(state2)("string", "number")) {
+        __elementRef.__state = state2;
+        element.state = {};
+      }
+      if (state2 === true) {
+        __elementRef.__state = element.key;
+        element.state = {};
+      }
+      (0, import_event.triggerEventOn)("stateInit", element);
+      state2 = element.state = createInheritedState(element, parent);
+      if (!state2) {
+        if (parent && parent.state)
+          return parent.state;
+        return {};
+      } else {
+        __elementRef.__hasRootState = true;
+      }
+      const { __ref } = state2;
+      if (__ref) {
+        state2 = (0, import_utils6.deepClone)(__ref, IGNORE_STATE_PARAMS2);
+        if ((0, import_utils6.isObject)(__ref.__depends)) {
+          __ref.__depends[element.key] = state2;
+        } else
+          __ref.__depends = { [element.key]: state2 };
+      } else {
+        state2 = (0, import_utils6.deepClone)(state2, IGNORE_STATE_PARAMS2);
+      }
+      element.state = state2;
+      if (skip)
+        return state2;
+      applyMethods(element, state2);
+      (0, import_event.triggerEventOn)("stateCreated", element);
+      return state2;
+    };
+    applyMethods = (element, state2) => {
+      const __elementRef = element.__ref;
+      state2.clean = clean;
+      state2.parse = parse;
+      state2.destroy = destroy;
+      state2.update = updateState;
+      state2.rootUpdate = rootUpdate;
+      state2.create = createState;
+      state2.remove = remove;
+      state2.apply = apply;
+      state2.parent = element.parent.state;
+      state2.__element = element;
+      state2.__children = {};
+      state2.__root = __elementRef.__root ? __elementRef.__root.state : state2;
+      if (state2.parent)
+        state2.parent.__children[element.key] = state2;
+    };
+  }
+});
+
+// ../refactor/domql/packages/props/index.js
+function update(props, options) {
+  const element = this.__element;
+  element.update({ props }, options);
+}
+var import_utils7, IGNORE_PROPS_PARAMS, objectizeStringProperty, inheritParentProps, createPropsStack, syncProps, createProps;
+var init_props = __esm({
+  "../refactor/domql/packages/props/index.js"() {
+    "use strict";
+    import_utils7 = __toESM(require_cjs4());
+    IGNORE_PROPS_PARAMS = ["update", "__element"];
+    objectizeStringProperty = (propValue) => {
+      if ((0, import_utils7.is)(propValue)("string", "number"))
+        return { inheritedString: propValue };
+      return propValue;
+    };
+    inheritParentProps = (element, parent) => {
+      let propsStack = [];
+      const parentProps = (0, import_utils7.exec)(parent, parent.state).props;
+      const matchParent = parent.props && parentProps[element.key];
+      const matchParentIsString = (0, import_utils7.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)
+        propsStack.push(matchParentChildProps);
+      return propsStack;
+    };
+    createPropsStack = (element, parent) => {
+      const { props, __ref } = element;
+      const propsStack = __ref.__props = inheritParentProps(element, parent);
+      if ((0, import_utils7.isObject)(props))
+        propsStack.push(props);
+      else if (props === "inherit" && parent.props)
+        propsStack.push(parent.props);
+      else if (props)
+        propsStack.push(props);
+      if ((0, import_utils7.isArray)(__ref.__extend)) {
+        __ref.__extend.map((extend) => {
+          if (extend.props)
+            propsStack.push(extend.props);
+          return extend.props;
+        });
+      }
+      __ref.__props = propsStack;
+      return propsStack;
+    };
+    syncProps = (props, element) => {
+      element.props = {};
+      const mergedProps = { update, __element: element };
+      props.forEach((v) => {
+        if (IGNORE_PROPS_PARAMS.includes(v))
+          return;
+        const execProps = (0, import_utils7.exec)(v, element);
+        if ((0, import_utils7.isObject)(execProps) && execProps.__element)
+          return;
+        element.props = (0, import_utils7.deepMerge)(mergedProps, (0, import_utils7.deepClone)(execProps, IGNORE_PROPS_PARAMS), IGNORE_PROPS_PARAMS);
+      });
+      element.props = mergedProps;
+      return element.props;
+    };
+    createProps = function(element, parent, cached) {
+      const propsStack = cached || createPropsStack(element, parent);
+      const { __ref } = element;
+      if (propsStack.length) {
+        __ref.__props = propsStack;
+        syncProps(propsStack, element);
+        element.props.update = update;
+      }
+      return element;
+    };
+  }
+});
+
+// ../refactor/domql/packages/extends/extendUtils.js
+var import_utils8, generateHash, extendStackRegistry, getHashedExtend, setHashedExtend, getExtendStackRegistry, extractArrayExtend, deepExtend, flattenExtend, deepCloneExtend, deepMergeExtend, cloneAndMergeArrayExtend, jointStacks, getExtendStack;
+var init_extendUtils = __esm({
+  "../refactor/domql/packages/extends/extendUtils.js"() {
+    "use strict";
+    import_utils8 = __toESM(require_cjs4());
+    generateHash = () => Math.random().toString(36).substring(2);
+    extendStackRegistry = {};
+    getHashedExtend = (extend) => {
+      return extendStackRegistry[extend.__hash];
+    };
+    setHashedExtend = (extend, stack) => {
+      const hash = generateHash();
+      extend.__hash = hash;
+      extendStackRegistry[hash] = stack;
+      return extendStackRegistry[hash];
+    };
+    getExtendStackRegistry = (extend, stack) => {
+      if (extend.__hash) {
+        return stack.concat(getHashedExtend(extend));
+      } else {
+        setHashedExtend(extend, stack);
+      }
+      return stack;
+    };
+    extractArrayExtend = (extend, stack) => {
+      extend.forEach((each) => flattenExtend(each, stack));
+      return stack;
+    };
+    deepExtend = (extend, stack) => {
+      const extendOflattenExtend = extend.extends;
+      if (extendOflattenExtend) {
+        flattenExtend(extendOflattenExtend, stack);
+      }
+      return stack;
+    };
+    flattenExtend = (extend, stack) => {
+      if (!extend)
+        return stack;
+      if ((0, import_utils8.isArray)(extend))
+        return extractArrayExtend(extend, stack);
+      stack.push(extend);
+      if (extend.extends)
+        deepExtend(extend, stack);
+      return stack;
+    };
+    deepCloneExtend = (obj) => {
+      const o = {};
+      for (const prop in obj) {
+        if (["ref"].indexOf(prop) > -1)
+          continue;
+        const objProp = obj[prop];
+        if ((0, import_utils8.isObject)(objProp)) {
+          o[prop] = deepCloneExtend(objProp);
+        } else if ((0, import_utils8.isArray)(objProp)) {
+          o[prop] = objProp.map((x) => x);
+        } else
+          o[prop] = objProp;
+      }
+      return o;
+    };
+    deepMergeExtend = (element, extend) => {
+      for (const e2 in extend) {
+        if (e2 === "ref")
+          continue;
+        const elementProp = element[e2];
+        const extendProp = extend[e2];
+        if (elementProp === void 0) {
+          element[e2] = extendProp;
+        } else if ((0, import_utils8.isObject)(elementProp) && (0, import_utils8.isObject)(extendProp)) {
+          deepMergeExtend(elementProp, extendProp);
+        } else if ((0, import_utils8.isArray)(elementProp) && (0, import_utils8.isArray)(extendProp)) {
+          element[e2] = elementProp.concat(extendProp);
+        } else if ((0, import_utils8.isArray)(elementProp) && (0, import_utils8.isObject)(extendProp)) {
+          const obj = deepMergeExtend({}, elementProp);
+          element[e2] = deepMergeExtend(obj, extendProp);
+        } else if (elementProp === void 0 && (0, import_utils8.isFunction)(extendProp)) {
+          element[e2] = extendProp;
+        }
+      }
+      return element;
+    };
+    cloneAndMergeArrayExtend = (stack) => {
+      return stack.reduce((a, c) => {
+        return deepMergeExtend(a, deepCloneExtend(c));
+      }, {});
+    };
+    jointStacks = (extendStack, childExtendStack) => {
+      return [].concat(extendStack.slice(0, 1)).concat(childExtendStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendStack.slice(1));
+    };
+    getExtendStack = (extend) => {
+      if (!extend)
+        return [];
+      if (extend.__hash)
+        return getHashedExtend(extend);
+      const stack = flattenExtend(extend, []);
+      return getExtendStackRegistry(extend, stack);
+    };
+  }
+});
+
+// ../refactor/domql/packages/extends/index.js
+var import_utils9, ENV, extendElement;
+var init_extends = __esm({
+  "../refactor/domql/packages/extends/index.js"() {
+    "use strict";
+    import_utils9 = __toESM(require_cjs4());
+    init_extendUtils();
+    ENV = "development";
+    extendElement = (element, parent, options = {}) => {
+      if ((0, import_utils9.isFunction)(element))
+        element = (0, import_utils9.exec)(element, parent);
+      const { extend: ext } = element;
+      const extendStack = getExtendStack(ext);
+      if (ENV !== "development")
+        delete element.extends;
+      let childExtendStack = [];
+      if (!options.ignoreChildExtend) {
+        childExtendStack = getExtendStack(parent.childExtends);
+      }
+      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
+        return element;
+      if (options.extends) {
+        const defaultOptionsExtend = getExtendStack(options.extends);
+        stack = [].concat(defaultOptionsExtend, stack);
+      }
+      element.ref.extends = stack;
+      const mergedExtend = cloneAndMergeArrayExtend(stack);
+      delete mergedExtend.__hash;
+      return deepMergeExtend(element, mergedExtend);
+    };
+  }
+});
+
+// ../refactor/domql/packages/create/index.js
+var create_exports = {};
+__export(create_exports, {
+  applyTransform: () => applyTransform,
+  create: () => create2,
+  onEach: () => onEach
+});
+var import_registry, import_tree, import_key, import_utils10, OPTIONS, init, assignKey, applyParent, applyState, applyExtends, applyTag, applyProps, applyAttr, onEachAvailable, onEach, applyTransform, addChildren, applyGlobalTransform, create2;
+var init_create = __esm({
+  "../refactor/domql/packages/create/index.js"() {
+    "use strict";
+    import_registry = __toESM(require_cjs8());
+    import_tree = __toESM(require_cjs7());
+    import_key = __toESM(require_cjs());
+    import_utils10 = __toESM(require_cjs4());
+    init_state();
+    init_props();
+    init_extends();
+    OPTIONS = {};
+    init = (element, key, options, parent) => {
+      const ref = {};
+      if (!element)
+        return { ref };
+      if ((0, import_utils10.isString)(element) || (0, import_utils10.isNumber)(element)) {
+        return {
+          key,
+          ref,
+          tag: "string",
+          text: element
+        };
+      } else if ((0, import_utils10.isArray)(element))
+        return Object.assign({}, element);
+      else if ((0, import_utils10.isObject)(element)) {
+        const { extendLibrary } = options;
+        const extendFromLibrary = (0, import_utils10.isString)(element.extends) && extendLibrary[element.extends];
+        if (extendFromLibrary && extendLibrary) {
+          element = {
+            props: element,
+            ref,
+            extend: extendFromLibrary
+          };
+        }
+        if (!element.ref)
+          element.ref = ref;
+        if (element.on && element.on.init)
+          element.on.init(element, element.state);
+        return element;
+      } else if ((0, import_utils10.isFunction)(element))
+        return { ref, ...(0, import_utils10.exec)(parent, parent.ref.state) };
+      return element;
+    };
+    assignKey = (element, key) => {
+      if (element.key)
+        return element;
+      element.key = key || import_key.createKey.next().value;
+      return element;
+    };
+    applyParent = (element, key) => {
+      const { ref } = element;
+      const { parent } = ref;
+      if ((0, import_utils10.isNode)(parent)) {
+        ref.parent = import_tree.ROOT.ref.parent = { node: parent };
+      }
+      if (!parent)
+        ref.parent = import_tree.ROOT;
+      return element;
+    };
+    applyState = (element, key) => {
+      const { ref } = element;
+      ref.state = createState(element, element.ref.parent);
+      return element;
+    };
+    applyExtends = (element, key, options) => {
+      extendElement(element, element.ref.parent, options);
+      return element;
+    };
+    applyTag = (element, key) => {
+      if (element.tag) {
+        element.ref.tag = element.tag;
+        return element;
+      }
+      const keyIsTag = import_registry.TAGS.body.indexOf(key) > -1;
+      element.tag = element.ref.tag = keyIsTag ? key : "div";
+      return element;
+    };
+    applyProps = (element, key) => {
+      const { ref } = element;
+      ref.props = createProps(element, ref.parent);
+      return element;
+    };
+    applyAttr = (element, key) => {
+      if (!(0, import_utils10.isObject)(element.attr))
+        return element;
+      const { ref } = element;
+      if (!ref.attr)
+        ref.attr = {};
+      for (const attrKey in element.attr) {
+        ref.attr[attrKey] = (0, import_utils10.exec)(element.attr[attrKey], element, element.state);
+      }
+      return element;
+    };
+    onEachAvailable = (element, key, options) => {
+      const { ref } = element;
+      const value = element[key];
+      let { children, childrenKeys } = ref;
+      if (!children)
+        children = ref.children = [];
+      if (!childrenKeys)
+        childrenKeys = ref.childrenKeys = [];
+      children.push(value);
+      childrenKeys.push(key);
+      const useOption = options[onEachAvailable];
+      if (useOption)
+        useOption(element, key);
+    };
+    onEach = (element, key, options) => {
+      for (const key2 in element) {
+        const isMethod6 = import_registry.DEFAULT_METHODS[key2];
+        if (isMethod6 && (0, import_utils10.isFunction)(isMethod6))
+          isMethod6(element, element.ref.state);
+        const hasDefine = element.define && element.define[key2];
+        if (hasDefine && (0, import_utils10.isFunction)(hasDefine))
+          element.ref[key2] = hasDefine(element, element.ref.state);
+        if (!isMethod6 && !hasDefine)
+          onEachAvailable(element, key2, options);
+      }
+      return element;
+    };
+    applyTransform = (element, key, options) => {
+      const { ref, transform } = element;
+      if (!transform)
+        return element;
+      if (!ref.transform)
+        ref.transform = {};
+      const keys2 = Object.keys(transform || {});
+      keys2.map((key2) => {
+        const transformer = transform[key2];
+        ref.transform[key2] = transformer(element, key2);
+        return key2;
+      });
+      return element;
+    };
+    addChildren = (element, key, options) => {
+      const { ref } = element;
+      const { children, childrenKeys } = ref;
+      if (children && children.length) {
+        ref.children = children.map((child, key2) => {
+          return create2(child, element, childrenKeys[key2], options);
+        });
+      }
+      return element;
+    };
+    applyGlobalTransform = (element, key, options) => {
+      const { ref } = element;
+      const { transform } = options;
+      if (!transform)
+        return element;
+      if (!ref.transform)
+        ref.transform = {};
+      const keys2 = Object.keys(transform || {});
+      keys2.map((key2) => {
+        const transformer = transform[key2];
+        ref.transform[key2] = transformer(element, key2);
+        return key2;
+      });
+      return element;
+    };
+    create2 = (element, parent, key, options = OPTIONS) => [
+      init,
+      assignKey,
+      applyParent,
+      applyState,
+      applyExtends,
+      applyTag,
+      applyProps,
+      applyAttr,
+      onEach,
+      applyTransform,
+      addChildren,
+      applyGlobalTransform
+    ].reduce((prev, current) => current(prev, key, options, parent), element);
+  }
+});
+
+// ../refactor/domql/packages/mixins/text.js
+var import_utils11, text;
+var init_text = __esm({
+  "../refactor/domql/packages/mixins/text.js"() {
+    "use strict";
+    import_utils11 = __toESM(require_cjs4());
+    init_create();
+    text = (param, element, node) => {
+      const prop = (0, import_utils11.exec)(param, element);
+      if (element.tag === "string")
+        node.nodeValue = prop;
+      else if (param) {
+        if (element.__text) {
+          element.__text.text = prop;
+          if (element.__text.node)
+            element.__text.node.nodeValue = prop;
+        } else
+          create2({ tag: "string", text: prop }, element, "__text");
+      }
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/state.js
+var import_utils12, state;
+var init_state2 = __esm({
+  "../refactor/domql/packages/mixins/state.js"() {
+    "use strict";
+    import_utils12 = __toESM(require_cjs4());
+    state = (params, element, node) => {
+      const state2 = (0, import_utils12.exec)(params, element);
+      if ((0, import_utils12.isObject)(state2)) {
+        for (const param in state2) {
+          if (IGNORE_STATE_PARAMS.includes(param))
+            continue;
+          element.state[param] = (0, import_utils12.exec)(state2[param], element);
+        }
+      }
+      return element;
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/classList.js
+var import_utils13, assignClass, classify, classList;
+var init_classList = __esm({
+  "../refactor/domql/packages/mixins/classList.js"() {
+    "use strict";
+    import_utils13 = __toESM(require_cjs4());
+    assignClass = (element) => {
+      const { key } = element;
+      if (element.class === true)
+        element.class = keyw;
+      else if (!element.class && typeof key === "string" && key.charAt(0) === "_" && key.charAt(1) !== "_") {
+        element.class = key.slice(1);
+      }
+    };
+    classify = (obj, element) => {
+      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 += ` ${(0, import_utils13.exec)(param, element)}`;
+        }
+      }
+      return className;
+    };
+    classList = (params, element) => {
+      if (!params)
+        return;
+      const { key } = element;
+      if (params === true)
+        params = element.class = { key };
+      if ((0, import_utils13.isString)(params))
+        params = element.class = { default: params };
+      if ((0, import_utils13.isObject)(params))
+        params = classify(params, element);
+      const className = params.replace(/\s+/g, " ").trim();
+      element.ref.class = className;
+      return className;
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/methods.js
+var defaultMethods, parseFilters;
+var init_methods = __esm({
+  "../refactor/domql/packages/mixins/methods.js"() {
+    "use strict";
+    init_mixins();
+    defaultMethods = {
+      attr,
+      style,
+      text,
+      html,
+      content,
+      data,
+      class: classList,
+      state,
+      extend: {},
+      childExtend: {},
+      childExtendRecursive: {},
+      props: {},
+      path: {},
+      if: {},
+      define: {},
+      transform: {},
+      __ref: {},
+      __hash: {},
+      __text: {},
+      nextElement: {},
+      previousElement: {},
+      key: {},
+      tag: {},
+      query: {},
+      parent: {},
+      node: {},
+      set: {},
+      update: {},
+      setProps: {},
+      remove: {},
+      removeContent: {},
+      lookup: {},
+      spotByPath: {},
+      keys: {},
+      log: {},
+      parse: {},
+      parseDeep: {},
+      on: {},
+      component: {},
+      context: {}
+    };
+    parseFilters = {
+      elementKeys: [
+        "tag",
+        "text",
+        "style",
+        "attr",
+        "class",
+        "state",
+        "class",
+        "data",
+        "content",
+        "html",
+        "on"
+      ],
+      propsKeys: ["__element"],
+      stateKeys: []
+    };
+  }
+});
+
+// ../refactor/domql/packages/set/index.js
+var removeContentElement, set;
+var init_set = __esm({
+  "../refactor/domql/packages/set/index.js"() {
+    "use strict";
+    init_create();
+    removeContentElement = (params, element) => {
+      if (params && element.content) {
+        if (element.content.node) {
+          if (element.content.tag === "fragment")
+            element.node.innerHTML = "";
+          else
+            element.node.removeChild(element.content.node);
+        }
+        if (element.__cache && element.__cache.content) {
+          if (element.__cache.content.tag === "fragment")
+            element.__cache.content.parent.node.innerHTML = "";
+          else
+            element.__cache.content.remove();
+        }
+        delete element.content;
+      }
+    };
+    set = function(params, enter, leave) {
+      const element = this;
+      removeContentElement(params, element);
+      if (params) {
+        const { childExtend } = params;
+        if (!childExtend && element.childExtend)
+          params.childExtend = element.childExtend;
+        create2(params, element, "content", {
+          ignoreChildExtend: true
+        });
+      }
+      return element;
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/content.js
+var content;
+var init_content = __esm({
+  "../refactor/domql/packages/mixins/content.js"() {
+    "use strict";
+    init_set();
+    content = (param, element, node) => {
+      if (param && element) {
+        if (param.__hash === element.content.__hash && element.content.update) {
+          element.content.update(param);
+        } else {
+          set.call(element, param);
+        }
+      }
+    };
+  }
+});
+
+// ../refactor/domql/packages/mixins/index.js
+var mixins_exports = {};
+__export(mixins_exports, {
+  assignClass: () => assignClass,
+  attr: () => attr,
+  classList: () => classList,
+  classify: () => classify,
+  content: () => content,
+  data: () => data,
+  defaultMethods: () => defaultMethods,
+  html: () => html,
+  parseFilters: () => parseFilters,
+  state: () => state,
+  style: () => style,
+  text: () => text
+});
+var init_mixins = __esm({
+  "../refactor/domql/packages/mixins/index.js"() {
+    "use strict";
+    init_attr();
+    init_data();
+    init_html();
+    init_style();
+    init_text();
+    init_state2();
+    init_classList();
+    init_methods();
+    init_content();
+  }
+});
+
+// ../refactor/domql/packages/cache/dist/cjs/index.js
+var require_cjs12 = __commonJS({
+  "../refactor/domql/packages/cache/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var cache_exports = {};
+    __export2(cache_exports, {
+      cache: () => cache
+    });
+    module.exports = __toCommonJS2(cache_exports);
+    var cache = {};
+  }
+});
+
+// ../refactor/domql/packages/node/dist/cjs/cache.js
+var require_cache = __commonJS({
+  "../refactor/domql/packages/node/dist/cjs/cache.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var cache_exports = {};
+    __export2(cache_exports, {
+      cacheNode: () => cacheNode3,
+      createHTMLNode: () => createHTMLNode,
+      detectTag: () => detectTag2
+    });
+    module.exports = __toCommonJS2(cache_exports);
+    var import_report8 = require_cjs5();
+    var import_event6 = require_cjs6();
+    var import_utils40 = require_cjs4();
+    var import_cache = require_cjs12();
+    var createHTMLNode = (element) => {
+      const { tag } = element;
+      if (tag) {
+        if (tag === "string")
+          return document.createTextNode(element.text);
+        else if (tag === "fragment") {
+          return document.createDocumentFragment();
+        } else if (tag === "svg" || tag === "path") {
+          return document.createElementNS("http://www.w3.org/2000/svg", tag);
+        } else
+          return document.createElement(tag);
+      } else {
+        return document.createElement("div");
+      }
+    };
+    var detectTag2 = (element) => {
+      let { tag, key } = element;
+      tag = (0, import_utils40.exec)(tag, element);
+      if (tag === true)
+        tag = key;
+      if ((0, import_utils40.isString)(tag)) {
+        const tagExists = (0, import_utils40.isValidHtmlTag)(tag);
+        if (tagExists)
+          return tag;
+      } else {
+        const isKeyATag = (0, import_utils40.isValidHtmlTag)(key);
+        if (isKeyATag)
+          return key;
+      }
+      return "div";
+    };
+    var cacheNode3 = (element) => {
+      const tag = element.tag = detectTag2(element);
+      if (!(0, import_event6.canRender)(element)) {
+        return (0, import_report8.report)("HTMLInvalidTag", element.tag, element);
+      }
+      let cachedTag = import_cache.cache[tag];
+      if (!cachedTag)
+        cachedTag = import_cache.cache[tag] = createHTMLNode(element);
+      const clonedNode = cachedTag.cloneNode(true);
+      if (tag === "string")
+        clonedNode.nodeValue = element.text;
+      return clonedNode;
+    };
+  }
+});
+
+// ../refactor/domql/packages/iterate/index.js
+var iterate_exports = {};
+__export(iterate_exports, {
+  throughInitialDefine: () => throughInitialDefine,
+  throughInitialExec: () => throughInitialExec,
+  throughUpdatedDefine: () => throughUpdatedDefine,
+  throughUpdatedExec: () => throughUpdatedExec
+});
+var import_utils14, import_methods, throughInitialDefine, throughUpdatedDefine, throughInitialExec, throughUpdatedExec;
+var init_iterate = __esm({
+  "../refactor/domql/packages/iterate/index.js"() {
+    "use strict";
+    import_utils14 = __toESM(require_cjs4());
+    import_methods = __toESM(require_cjs11());
+    throughInitialDefine = (element) => {
+      const { define } = element;
+      for (const param in define) {
+        let prop = element[param];
+        if ((0, import_utils14.isFunction)(prop) && !(0, import_methods.isMethod)(param)) {
+          element.__exec[param] = prop;
+          element[param] = prop = (0, import_utils14.exec)(prop, element);
+        }
+        element.__cache[param] = prop;
+        element[param] = define[param](prop, element, element.state);
+      }
+      return element;
+    };
+    throughUpdatedDefine = (element) => {
+      const { define, __exec } = element;
+      const changes = {};
+      for (const param in define) {
+        const execParam = __exec[param];
+        if (execParam)
+          element.__cache[param] = execParam(element, element.state);
+        const cached = (0, import_utils14.exec)(element.__cache[param], element);
+        element[param] = define[param](cached, element, element.state);
+      }
+      return changes;
+    };
+    throughInitialExec = (element) => {
+    };
+    throughUpdatedExec = (element, options) => {
+    };
+  }
+});
+
+// ../refactor/domql/packages/node/dist/cjs/create.js
+var require_create = __commonJS({
+  "../refactor/domql/packages/node/dist/cjs/create.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var create_exports2 = {};
+    __export2(create_exports2, {
+      createNode: () => createNode
+    });
+    module.exports = __toCommonJS2(create_exports2);
+    var import_utils40 = require_cjs4();
+    var import_event6 = require_cjs6();
+    var import_mixins8 = (init_mixins(), __toCommonJS(mixins_exports));
+    var import_cache = require_cache();
+    var import_create8 = (init_create(), __toCommonJS(create_exports));
+    var import_methods10 = require_cjs11();
+    var import_iterate4 = (init_iterate(), __toCommonJS(iterate_exports));
+    var ENV2 = "development";
+    var createNode = (element) => {
+      let { node, tag } = element;
+      let isNewNode;
+      if (!node) {
+        isNewNode = true;
+        if (tag === "shadow") {
+          node = element.node = element.parent.node.attachShadow({ mode: "open" });
+        } else
+          node = element.node = (0, import_cache.cacheNode)(element);
+        triggerEventOn("attachNode", element);
+      }
+      if (ENV2 === "test" || ENV2 === "development") {
+        node.ref = element;
+        if ((0, import_utils40.isFunction)(node.setAttribute))
+          node.setAttribute("key", element.key);
+      }
+      if (element.tag !== "string" || element.tag !== "fragment") {
+        if ((0, import_utils40.isObject)(element.define))
+          (0, import_iterate4.throughInitialDefine)(element);
+        (0, import_iterate4.throughInitialExec)(element);
+        if (isNewNode && (0, import_utils40.isObject)(element.on))
+          (0, import_event6.applyEventsOnNode)(element);
+        for (const param in element) {
+          const prop = element[param];
+          if ((0, import_methods10.isMethod)(param) || (0, import_utils40.isObject)(import_mixins8.defaultMethods[param]) || prop === void 0)
+            continue;
+          const hasDefined = element.define && element.define[param];
+          const ourMethod = import_mixins8.defaultMethods[param];
+          if (ourMethod) {
+            if ((0, import_utils40.isFunction)(ourMethod))
+              ourMethod(prop, element, node);
+          } else if (element[param] && !hasDefined) {
+            (0, import_create8.create)(prop, element, param);
+          }
+        }
+      }
+      return element;
+    };
+  }
+});
+
+// ../refactor/domql/packages/node/dist/cjs/index.js
+var require_cjs13 = __commonJS({
+  "../refactor/domql/packages/node/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var node_exports = {};
+    module.exports = __toCommonJS2(node_exports);
+    __reExport(node_exports, require_create(), module.exports);
+    __reExport(node_exports, require_cache(), module.exports);
+  }
+});
+
+// node_modules/@domql/report/dist/cjs/index.js
+var require_cjs14 = __commonJS({
+  "node_modules/@domql/report/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var report_exports = {};
+    __export2(report_exports, {
+      ERRORS_REGISTRY: () => ERRORS_REGISTRY,
+      report: () => report8
+    });
+    module.exports = __toCommonJS2(report_exports);
+    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"
+        }
+      }
+    };
+    var report8 = (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}` : ""
+      );
+    };
+  }
+});
+
+// node_modules/@domql/globals/dist/cjs/index.js
+var require_cjs15 = __commonJS({
+  "node_modules/@domql/globals/dist/cjs/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var globals_exports = {};
+    __export2(globals_exports, {
+      document: () => document2,
+      global: () => global,
+      self: () => self,
+      window: () => window2
+    });
+    module.exports = __toCommonJS2(globals_exports);
+    var global = globalThis;
+    var self = globalThis;
+    var window2 = globalThis;
+    var document2 = window2.document;
+  }
+});
+
+// src/element/iterate.js
+var import_utils38 = __toESM(require_cjs4());
+
+// src/utils/object.js
+var import_utils36 = __toESM(require_cjs4());
+
+// src/element/state.js
+var import_event5 = __toESM(require_cjs6());
+var import_utils34 = __toESM(require_cjs4());
+
+// src/element/index.js
+var import_tree3 = __toESM(require_cjs7());
+
+// src/element/create.js
+var import_utils33 = __toESM(require_cjs4());
+var import_tree2 = __toESM(require_cjs7());
+var import_key3 = __toESM(require_cjs());
+var import_registry3 = __toESM(require_cjs8());
+var import_event4 = __toESM(require_cjs6());
+var import_render = __toESM(require_cjs9());
+var import_methods4 = __toESM(require_cjs11());
+
+// node_modules/@domql/classlist/index.js
+var import_utils = __toESM(require_cjs4());
+
+// src/element/create.js
+var import_node2 = __toESM(require_cjs13());
+
+// src/element/node.js
+var import_utils24 = __toESM(require_cjs4());
+var import_event2 = __toESM(require_cjs6());
+var import_methods2 = __toESM(require_cjs11());
+var import_node = __toESM(require_cjs13());
+
+// src/element/mixins/attr.js
+var import_utils15 = __toESM(require_cjs4());
+var import_report4 = __toESM(require_cjs14());
+
+// src/element/set.js
+var import_utils17 = __toESM(require_cjs4());
+
+// src/element/remove.js
+var import_utils16 = __toESM(require_cjs4());
+
+// src/element/mixins/data.js
+var import_utils18 = __toESM(require_cjs4());
+var import_report5 = __toESM(require_cjs14());
+
+// src/element/mixins/html.js
+var import_utils19 = __toESM(require_cjs4());
+
+// src/element/mixins/style.js
+var import_utils20 = __toESM(require_cjs4());
+var import_report6 = __toESM(require_cjs14());
+
+// src/element/mixins/text.js
+var import_utils21 = __toESM(require_cjs4());
+
+// src/element/mixins/state.js
+var import_utils22 = __toESM(require_cjs4());
+
+// src/element/applyParam.js
+var import_utils23 = __toESM(require_cjs4());
+
+// src/element/extend.js
+var import_utils25 = __toESM(require_cjs4());
+
+// src/element/props.js
+var import_utils27 = __toESM(require_cjs4());
+var IGNORE_PROPS_PARAMS2 = ["update", "__element"];
+
+// src/element/update.js
+var import_globals = __toESM(require_cjs15());
+var import_utils29 = __toESM(require_cjs4());
+var import_event3 = __toESM(require_cjs6());
+var import_methods3 = __toESM(require_cjs11());
+var import_key2 = __toESM(require_cjs());
+
+// src/element/methods.js
+var import_utils31 = __toESM(require_cjs4());
+
+// src/utils/component.js
+var import_utils32 = __toESM(require_cjs4());
+
+// src/element/define.js
+var import_report7 = __toESM(require_cjs14());
+
+// src/element/parse.js
+var import_render2 = __toESM(require_cjs9());
+
+// src/element/index.js
+var import_methods7 = __toESM(require_cjs11());
+
+// src/element/state.js
+var IGNORE_STATE_PARAMS3 = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "remove",
+  "apply",
+  "rootUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "__root"
+];
+
+// src/utils/object.js
+var import_methods8 = __toESM(require_cjs11());
+var METHODS_EXL = (0, import_utils36.joinArrays)(
+  ["node", "state", "context", "extend"],
+  import_methods8.METHODS,
+  IGNORE_STATE_PARAMS3,
+  IGNORE_PROPS_PARAMS2
+);
+var overwrite = (element, params, options) => {
+  const changes = {};
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  for (const e2 in params) {
+    if (e2 === "props" || e2 === "state" || e2 === "__ref")
+      continue;
+    const elementProp = element[e2];
+    const paramsProp = params[e2];
+    if (paramsProp !== void 0) {
+      __cached[e2] = changes[e2] = elementProp;
+      element[e2] = paramsProp;
+    }
+    if (options.cleanExec)
+      delete __exec[e2];
+  }
+  return changes;
+};
+
+// src/utils/extendUtils.js
+var import_utils37 = __toESM(require_cjs4());
+
+// src/element/iterate.js
+var import_methods9 = __toESM(require_cjs11());
+var throughInitialExec2 = (element) => {
+  const { __ref } = element;
+  const { __exec } = __ref;
+  for (const param in element) {
+    const prop = element[param];
+    if ((0, import_utils38.isFunction)(prop) && !(0, import_methods9.isMethod)(param)) {
+      __exec[param] = prop;
+      element[param] = prop(element, element.state);
+    }
+  }
+};
+var throughUpdatedExec2 = (element, options) => {
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  const changes = {};
+  for (const param in __exec) {
+    const prop = element[param];
+    const newExec = __exec[param](element, element.state);
+    if (prop && prop.node && ((0, import_utils38.isString)(newExec) || (0, import_utils38.isNumber)(newExec))) {
+      overwrite(prop, { text: newExec }, options);
+    } else if (newExec !== prop) {
+      __cached[param] = changes[param] = prop;
+      element[param] = newExec;
+    }
+  }
+  return changes;
+};
+var throughInitialDefine2 = (element) => {
+  const { define, context, __ref } = element;
+  const { __exec, __cached } = __ref;
+  let obj = {};
+  if ((0, import_utils38.isObject)(define))
+    obj = { ...define };
+  if (context && (0, import_utils38.isObject)(context.define))
+    obj = { ...obj, ...context.define };
+  for (const param in obj) {
+    let prop = element[param];
+    if ((0, import_utils38.isFunction)(prop) && !(0, import_methods9.isMethod)(param)) {
+      __exec[param] = prop;
+      const execParam2 = prop = (0, import_utils38.exec)(prop, element);
+      if (execParam2)
+        element[param] = execParam2;
+    }
+    __cached[param] = prop;
+    const execParam = obj[param](prop, element, element.state);
+    if (execParam)
+      element[param] = execParam;
+  }
+  return element;
+};
+var throughUpdatedDefine2 = (element) => {
+  const { context, define, __ref } = element;
+  const { __exec, __cached } = __ref;
+  const changes = {};
+  let obj = {};
+  if ((0, import_utils38.isObject)(define))
+    obj = { ...define };
+  if ((0, import_utils38.isObject)(context && context.define))
+    obj = { ...obj, ...context.define };
+  for (const param in obj) {
+    const execParam = __exec[param];
+    if (execParam)
+      __cached[param] = execParam(element, element.state);
+    const cached = (0, import_utils38.exec)(__cached[param], element);
+    const newExecParam = obj[param](cached, element, element.state);
+    if (newExecParam)
+      element[param] = newExecParam;
+  }
+  return changes;
+};
+export {
+  throughInitialDefine2 as throughInitialDefine,
+  throughInitialExec2 as throughInitialExec,
+  throughUpdatedDefine2 as throughUpdatedDefine,
+  throughUpdatedExec2 as throughUpdatedExec
+};