domql 1.6.4 → 1.6.6

package/dist/esm/element/index.js

@@ -0,0 +1,4675 @@
+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/globals/dist/cjs/index.js
+var require_cjs = __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/report/dist/cjs/index.js
+var require_cjs2 = __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/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_cjs();
+    var import_report8 = require_cjs2();
+    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_cjs3 = __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/key/dist/cjs/index.js
+var require_cjs4 = __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_cjs5 = __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/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_cjs();
+    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_cjs5();
+    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_cjs();
+    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: () => mergeArray3,
+      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 mergeArray3 = (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) ? mergeArray3(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_cjs6 = __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_cjs4(), 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/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_cjs6();
+    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_cjs7 = __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/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_cjs6();
+    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/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_cjs2();
+    var import_utils40 = require_cjs6();
+    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_cjs8 = __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/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: () => parse5,
+      parseDeep: () => parseDeep2,
+      remove: () => remove5,
+      setProps: () => setProps2,
+      spotByPath: () => spotByPath2
+    });
+    module.exports = __toCommonJS2(methods_exports);
+    var import_tree4 = require_cjs3();
+    var import_utils40 = require_cjs6();
+    var import_registry4 = require_cjs7();
+    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 remove5 = 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, set3) => Object.defineProperty(element, key, { get: get22, set: set3 });
+    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 parse5 = 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_cjs6());
+    import_report = __toESM(require_cjs2());
+    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_cjs6());
+    import_report2 = __toESM(require_cjs2());
+    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_cjs6());
+    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_cjs6());
+    import_report3 = __toESM(require_cjs2());
+    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_cjs8());
+    import_utils6 = __toESM(require_cjs6());
+    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_cjs6());
+    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_cjs6());
+    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_cjs6());
+    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_cjs7());
+    import_tree = __toESM(require_cjs3());
+    import_key = __toESM(require_cjs4());
+    import_utils10 = __toESM(require_cjs6());
+    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_cjs6());
+    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_cjs6());
+    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, assignClass2, classify2, classList2;
+var init_classList = __esm({
+  "../refactor/domql/packages/mixins/classList.js"() {
+    "use strict";
+    import_utils13 = __toESM(require_cjs6());
+    assignClass2 = (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);
+      }
+    };
+    classify2 = (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;
+    };
+    classList2 = (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 = classify2(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: classList2,
+      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: () => assignClass2,
+  attr: () => attr,
+  classList: () => classList2,
+  classify: () => classify2,
+  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_cjs2();
+    var import_event6 = require_cjs8();
+    var import_utils40 = require_cjs6();
+    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_cjs6());
+    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: () => createNode2
+    });
+    module.exports = __toCommonJS2(create_exports2);
+    var import_utils40 = require_cjs6();
+    var import_event6 = require_cjs8();
+    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 ENV6 = "development";
+    var createNode2 = (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 (ENV6 === "test" || ENV6 === "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/index.js
+var import_tree3 = __toESM(require_cjs3());
+
+// src/element/create.js
+var import_utils39 = __toESM(require_cjs6());
+var import_tree2 = __toESM(require_cjs3());
+var import_key3 = __toESM(require_cjs4());
+var import_registry3 = __toESM(require_cjs7());
+var import_event5 = __toESM(require_cjs8());
+var import_render = __toESM(require_cjs9());
+var import_methods6 = __toESM(require_cjs11());
+
+// node_modules/@domql/classlist/index.js
+var import_utils = __toESM(require_cjs6());
+var assignClass = (element) => {
+  const { key } = element;
+  if (element.class === true)
+    element.class = key;
+  else if (!element.class && typeof key === "string" && key.charAt(0) === "_" && key.charAt(1) !== "_") {
+    element.class = key.slice(1);
+  }
+};
+var classify = (obj, element) => {
+  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_utils.exec)(param, element)}`;
+    }
+  }
+  return className;
+};
+var classList = (params, element) => {
+  if (!params)
+    return;
+  const { key } = element;
+  if (params === true)
+    params = element.class = { key };
+  if ((0, import_utils.isString)(params))
+    params = element.class = { default: params };
+  if ((0, import_utils.isObject)(params))
+    params = classify(params, element);
+  const className = params.replace(/\s+/g, " ").trim();
+  if (element.ref)
+    element.ref.class = className;
+  return className;
+};
+var applyClassListOnNode = (params, element, node) => {
+  const className = classList(params, element);
+  node.classList = className;
+  return className;
+};
+
+// src/element/create.js
+var import_node2 = __toESM(require_cjs13());
+
+// src/element/node.js
+var import_utils33 = __toESM(require_cjs6());
+var import_event3 = __toESM(require_cjs8());
+var import_methods4 = __toESM(require_cjs11());
+var import_node = __toESM(require_cjs13());
+
+// src/element/iterate.js
+var import_utils22 = __toESM(require_cjs6());
+
+// src/utils/object.js
+var import_utils19 = __toESM(require_cjs6());
+
+// src/element/state.js
+var import_event2 = __toESM(require_cjs8());
+var import_utils15 = __toESM(require_cjs6());
+var IGNORE_STATE_PARAMS3 = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "remove",
+  "apply",
+  "rootUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "__root"
+];
+var parse2 = function() {
+  const state2 = this;
+  if ((0, import_utils15.isObject)(state2)) {
+    const obj = {};
+    for (const param in state2) {
+      if (!IGNORE_STATE_PARAMS3.includes(param)) {
+        obj[param] = state2[param];
+      }
+    }
+    return obj;
+  } else if ((0, import_utils15.isArray)(state2)) {
+    return state2.filter((item) => !IGNORE_STATE_PARAMS3.includes(item));
+  }
+};
+var clean2 = function(options = {}) {
+  const state2 = this;
+  for (const param in state2) {
+    if (!IGNORE_STATE_PARAMS3.includes(param)) {
+      delete state2[param];
+    }
+  }
+  state2.update(state2, { skipOverwrite: true, options });
+  return state2;
+};
+var destroy2 = 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;
+};
+var rootUpdate2 = function(obj, options = {}) {
+  const state2 = this;
+  if (!state2)
+    return;
+  const rootState = state2.__element.__ref.__root.state;
+  return rootState.update(obj, options);
+};
+var updateState2 = 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_utils15.isUndefined)(state2[param])) {
+      delete state2[param];
+    }
+  }
+  if (!state2.__element) {
+    create_default(element, element.parent);
+  }
+  const initStateUpdateReturns = (0, import_event2.triggerEventOn)("initStateUpdated", element, obj);
+  if (initStateUpdateReturns === false)
+    return element;
+  if (!options.skipOverwrite) {
+    if (options.shallow) {
+      overwriteShallow2(state2, obj, IGNORE_STATE_PARAMS3);
+    } else {
+      overwriteDeep2(state2, obj, IGNORE_STATE_PARAMS3);
+    }
+  }
+  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_event2.triggerEventOn)("stateUpdated", element, obj);
+  }
+  return state2;
+};
+var remove2 = function(key, options) {
+  const state2 = this;
+  if ((0, import_utils15.isArray)(state2))
+    (0, import_utils15.removeFromArray)(state2, key);
+  if ((0, import_utils15.isObject)(state2))
+    (0, import_utils15.removeFromObject)(state2, key);
+  return state2.update(state2, { skipOverwrite: true, options });
+};
+var apply2 = function(func, options) {
+  const state2 = this;
+  if ((0, import_utils15.isFunction)(func)) {
+    func(state2);
+    return state2.update(state2, { skipOverwrite: true, options });
+  }
+};
+var getParentStateInKey2 = (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;
+};
+var getChildStateInKey2 = (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];
+};
+var createInheritedState2 = function(element, parent) {
+  const __elementRef = element.__ref;
+  let stateKey = __elementRef.__state;
+  if (!stateKey)
+    return element.state;
+  let parentState = parent.state;
+  if (stateKey.includes("../")) {
+    parentState = getParentStateInKey2(stateKey, parent.state);
+    stateKey = stateKey.replaceAll("../", "");
+  }
+  if (!parentState)
+    return {};
+  const keyInParentState = getChildStateInKey2(stateKey, parentState);
+  if (!keyInParentState)
+    return {};
+  if ((0, import_utils15.is)(keyInParentState)("object", "array")) {
+    return deepClone3(keyInParentState);
+  } else if ((0, import_utils15.is)(keyInParentState)("string", "number")) {
+    __elementRef.__stateType = "string";
+    return { value: keyInParentState };
+  }
+  console.warn(stateKey, "is not present. Replacing with", {});
+  return {};
+};
+var createState2 = function(element, parent, opts) {
+  const skip = opts && opts.skip ? opts.skip : false;
+  let { state: state2, __ref: __elementRef } = element;
+  if ((0, import_utils15.isFunction)(state2))
+    element.state = (0, import_utils15.exec)(state2, element);
+  if ((0, import_utils15.is)(state2)("string", "number")) {
+    __elementRef.__state = state2;
+    element.state = {};
+  }
+  if (state2 === true) {
+    __elementRef.__state = element.key;
+    element.state = {};
+  }
+  (0, import_event2.triggerEventOn)("stateInit", element);
+  state2 = element.state = createInheritedState2(element, parent);
+  if (!state2) {
+    if (parent && parent.state)
+      return parent.state;
+    return {};
+  } else {
+    __elementRef.__hasRootState = true;
+  }
+  const { __ref } = state2;
+  if (__ref) {
+    state2 = deepClone3(__ref, IGNORE_STATE_PARAMS3);
+    if ((0, import_utils15.isObject)(__ref.__depends)) {
+      __ref.__depends[element.key] = state2;
+    } else
+      __ref.__depends = { [element.key]: state2 };
+  } else {
+    state2 = deepClone3(state2, IGNORE_STATE_PARAMS3);
+  }
+  element.state = state2;
+  if (skip)
+    return state2;
+  applyMethods2(element, state2);
+  (0, import_event2.triggerEventOn)("stateCreated", element);
+  return state2;
+};
+var applyMethods2 = (element, state2) => {
+  const __elementRef = element.__ref;
+  state2.clean = clean2;
+  state2.parse = parse2;
+  state2.destroy = destroy2;
+  state2.update = updateState2;
+  state2.rootUpdate = rootUpdate2;
+  state2.create = createState2;
+  state2.remove = remove2;
+  state2.apply = apply2;
+  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;
+};
+var state_default = createState2;
+
+// src/element/props.js
+var import_utils17 = __toESM(require_cjs6());
+var IGNORE_PROPS_PARAMS2 = ["update", "__element"];
+var objectizeStringProperty2 = (propValue) => {
+  if ((0, import_utils17.is)(propValue)("string", "number"))
+    return { inheritedString: propValue };
+  return propValue;
+};
+var inheritParentProps2 = (element, parent) => {
+  let propsStack = [];
+  const parentProps = (0, import_utils17.exec)(parent, parent.state).props;
+  const matchParent = parent.props && parentProps[element.key];
+  const matchParentIsString = (0, import_utils17.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(objectizeStringProperty2(matchParent), propsStack);
+      }
+    } else {
+      propsStack.push(objectizeStringProperty2(matchParent));
+    }
+  }
+  if (matchParentChildProps)
+    propsStack.push(matchParentChildProps);
+  return propsStack;
+};
+var createPropsStack2 = (element, parent) => {
+  const { props, __ref } = element;
+  const propsStack = __ref.__props = inheritParentProps2(element, parent);
+  if ((0, import_utils17.isObject)(props))
+    propsStack.push(props);
+  else if (props === "inherit" && parent.props)
+    propsStack.push(parent.props);
+  else if (props)
+    propsStack.push(props);
+  if ((0, import_utils17.isArray)(__ref.__extend)) {
+    __ref.__extend.map((extend) => {
+      if (extend.props)
+        propsStack.push(extend.props);
+      return extend.props;
+    });
+  }
+  __ref.__props = propsStack;
+  return propsStack;
+};
+var syncProps2 = (props, element) => {
+  element.props = {};
+  const mergedProps = { update: update2, __element: element };
+  props.forEach((v) => {
+    if (IGNORE_PROPS_PARAMS2.includes(v))
+      return;
+    const execProps = (0, import_utils17.exec)(v, element);
+    if ((0, import_utils17.isObject)(execProps) && execProps.__element)
+      return;
+    element.props = deepMerge2(mergedProps, deepClone3(execProps));
+  });
+  element.props = mergedProps;
+  return element.props;
+};
+var createProps2 = function(element, parent, cached) {
+  const propsStack = cached || createPropsStack2(element, parent);
+  const { __ref } = element;
+  if (propsStack.length) {
+    __ref.__props = propsStack;
+    syncProps2(propsStack, element);
+    element.props.update = update2;
+  }
+  return element;
+};
+var updateProps = (newProps, element, parent) => {
+  const { __ref } = element;
+  let propsStack = __ref.__props;
+  const parentProps = inheritParentProps2(element, parent);
+  if (parentProps)
+    propsStack = __ref.__props = [].concat(parentProps, propsStack);
+  if (newProps)
+    propsStack = __ref.__props = [].concat(newProps, propsStack);
+  if (propsStack)
+    syncProps2(propsStack, element);
+  return element;
+};
+function update2(props, options) {
+  const element = this.__element;
+  element.update({ props }, options);
+}
+var props_default = createProps2;
+
+// src/utils/object.js
+var import_methods2 = __toESM(require_cjs11());
+var METHODS_EXL = (0, import_utils19.joinArrays)(
+  ["node", "state", "context", "extend"],
+  import_methods2.METHODS,
+  IGNORE_STATE_PARAMS3,
+  IGNORE_PROPS_PARAMS2
+);
+var merge = (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 deepMerge2 = (element, extend, exclude = METHODS_EXL) => {
+  for (const e2 in extend) {
+    if (exclude.includes(e2))
+      continue;
+    const elementProp = element[e2];
+    const extendProp = extend[e2];
+    if (elementProp === void 0) {
+      element[e2] = extendProp;
+    } else if ((0, import_utils19.isObjectLike)(elementProp) && (0, import_utils19.isObject)(extendProp)) {
+      deepMerge2(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+var deepClone3 = (obj, exclude = METHODS_EXL) => {
+  const o = (0, import_utils19.isArray)(obj) ? [] : {};
+  for (const e2 in obj) {
+    if (exclude.includes(e2))
+      continue;
+    let objProp = obj[e2];
+    if (e2 === "extend" && (0, import_utils19.isArray)(objProp)) {
+      objProp = mergeArray2(objProp, exclude);
+    }
+    if ((0, import_utils19.isObjectLike)(objProp)) {
+      o[e2] = deepClone3(objProp, exclude);
+    } else
+      o[e2] = objProp;
+  }
+  return o;
+};
+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;
+};
+var overwriteShallow2 = (obj, params, exclude = METHODS_EXL) => {
+  for (const e2 in params) {
+    if (exclude.includes(e2))
+      continue;
+    obj[e2] = params[e2];
+  }
+  return obj;
+};
+var overwriteDeep2 = (obj, params, exclude = METHODS_EXL) => {
+  for (const e2 in params) {
+    if (exclude.includes(e2))
+      continue;
+    const objProp = obj[e2];
+    const paramsProp = params[e2];
+    if ((0, import_utils19.isObjectLike)(objProp) && (0, import_utils19.isObjectLike)(paramsProp)) {
+      overwriteDeep2(objProp, paramsProp);
+    } else if (paramsProp !== void 0) {
+      obj[e2] = paramsProp;
+    }
+  }
+  return obj;
+};
+var mergeArray2 = (arr, exclude = ["parent", "node", "__element", "state", "context", "__ref"]) => {
+  return arr.reduce((a, c) => deepMerge2(a, deepClone3(c, exclude)), {});
+};
+
+// src/utils/extendUtils.js
+var import_utils20 = __toESM(require_cjs6());
+var generateHash2 = () => Math.random().toString(36).substring(2);
+var extendStackRegistry2 = {};
+var getHashedExtend2 = (extend) => {
+  return extendStackRegistry2[extend.__hash];
+};
+var setHashedExtend2 = (extend, stack) => {
+  const hash = generateHash2();
+  extend.__hash = hash;
+  extendStackRegistry2[hash] = stack;
+  return stack;
+};
+var getExtendStackRegistry2 = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend2(extend));
+  }
+  return setHashedExtend2(extend, stack);
+};
+var extractArrayExtend2 = (extend, stack) => {
+  extend.forEach((each) => flattenExtend2(each, stack));
+  return stack;
+};
+var deepExtend2 = (extend, stack) => {
+  const extendOflattenExtend = extend.extend;
+  if (extendOflattenExtend) {
+    flattenExtend2(extendOflattenExtend, stack);
+  }
+  return stack;
+};
+var flattenExtend2 = (extend, stack) => {
+  if (!extend)
+    return stack;
+  if ((0, import_utils20.isArray)(extend))
+    return extractArrayExtend2(extend, stack);
+  stack.push(extend);
+  if (extend.extend)
+    deepExtend2(extend, stack);
+  return stack;
+};
+var deepCloneExtend2 = (obj) => {
+  const o = {};
+  for (const prop in obj) {
+    if (["parent", "node", "__element"].indexOf(prop) > -1)
+      continue;
+    const objProp = obj[prop];
+    if ((0, import_utils20.isObject)(objProp)) {
+      o[prop] = deepCloneExtend2(objProp);
+    } else if ((0, import_utils20.isArray)(objProp)) {
+      o[prop] = objProp.map((x) => x);
+    } else
+      o[prop] = objProp;
+  }
+  return o;
+};
+var deepMergeExtend2 = (element, extend) => {
+  for (const e2 in extend) {
+    if (["parent", "node", "__element"].indexOf(e2) > -1)
+      continue;
+    const elementProp = element[e2];
+    const extendProp = extend[e2];
+    if (elementProp === void 0) {
+      element[e2] = extendProp;
+    } else if ((0, import_utils20.isObject)(elementProp) && (0, import_utils20.isObject)(extendProp)) {
+      deepMergeExtend2(elementProp, extendProp);
+    } else if ((0, import_utils20.isArray)(elementProp) && (0, import_utils20.isArray)(extendProp)) {
+      element[e2] = elementProp.concat(extendProp);
+    } else if ((0, import_utils20.isArray)(elementProp) && (0, import_utils20.isObject)(extendProp)) {
+      const obj = deepMergeExtend2({}, elementProp);
+      element[e2] = deepMergeExtend2(obj, extendProp);
+    } else if (elementProp === void 0 && (0, import_utils20.isFunction)(extendProp)) {
+      element[e2] = extendProp;
+    }
+  }
+  return element;
+};
+var cloneAndMergeArrayExtend2 = (stack) => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend2(a, deepCloneExtend2(c));
+  }, {});
+};
+var replaceStringsWithComponents = (stack, components) => {
+  return stack.map((v) => {
+    if ((0, import_utils20.isString)(v))
+      return components[v];
+    else
+      return v;
+  });
+};
+var jointStacks2 = (extendStack, childExtendStack) => {
+  return [].concat(extendStack.slice(0, 1)).concat(childExtendStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendStack.slice(1));
+};
+var getExtendStack2 = (extend) => {
+  if (!extend)
+    return [];
+  if (extend.__hash)
+    return getHashedExtend2(extend) || [];
+  const stack = flattenExtend2(extend, []);
+  return getExtendStackRegistry2(extend, stack);
+};
+
+// src/utils/component.js
+var import_utils21 = __toESM(require_cjs6());
+var ENV2 = "development";
+var checkIfKeyIsComponent = (key) => {
+  const isFirstKeyString = (0, import_utils21.isString)(key);
+  if (!isFirstKeyString)
+    return;
+  const firstCharKey = key.slice(0, 1);
+  return /^[A-Z]*$/.test(firstCharKey);
+};
+var extendizeByKey = (element, parent, key) => {
+  const { extend, props, state: state2, childExtend, childProps } = element;
+  const hasComponentAttrs = extend || childExtend || props || state2 || element.on;
+  const componentKey = key.split("_")[0];
+  if (!hasComponentAttrs || childProps) {
+    return {
+      extend: componentKey || key,
+      props: { ...element }
+    };
+  } else if (!extend || extend === true) {
+    return {
+      ...element,
+      extend: componentKey || key
+    };
+  } else if ((0, import_utils21.isFunction)(element)) {
+    return {
+      extend: componentKey || key,
+      props: { ...element }
+    };
+  }
+};
+var applyKeyComponentAsExtend = (element, parent, key) => {
+  return extendizeByKey(element, parent, key) || element;
+};
+var applyComponentFromContext = (element, parent, options) => {
+  const { context } = element;
+  const { components } = context;
+  const { extend } = element;
+  const execExtend = (0, import_utils21.exec)(extend, element);
+  if ((0, import_utils21.isString)(execExtend)) {
+    if (components[execExtend])
+      element.extend = components[execExtend];
+    else {
+      if ((ENV2 === "test" || ENV2 === "development") && options.verbose) {
+        console.warn(execExtend, "is not in library", components, element);
+        console.warn("replacing with ", {});
+      }
+      element.extend = {};
+    }
+  }
+};
+
+// src/element/iterate.js
+var import_methods3 = __toESM(require_cjs11());
+var throughInitialExec2 = (element) => {
+  const { __ref } = element;
+  const { __exec } = __ref;
+  for (const param in element) {
+    const prop = element[param];
+    if ((0, import_utils22.isFunction)(prop) && !(0, import_methods3.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_utils22.isString)(newExec) || (0, import_utils22.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_utils22.isObject)(define))
+    obj = { ...define };
+  if (context && (0, import_utils22.isObject)(context.define))
+    obj = { ...obj, ...context.define };
+  for (const param in obj) {
+    let prop = element[param];
+    if ((0, import_utils22.isFunction)(prop) && !(0, import_methods3.isMethod)(param)) {
+      __exec[param] = prop;
+      const execParam2 = prop = (0, import_utils22.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_utils22.isObject)(define))
+    obj = { ...define };
+  if ((0, import_utils22.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_utils22.exec)(__cached[param], element);
+    const newExecParam = obj[param](cached, element, element.state);
+    if (newExecParam)
+      element[param] = newExecParam;
+  }
+  return changes;
+};
+
+// src/element/mixins/attr.js
+var import_utils24 = __toESM(require_cjs6());
+var import_report4 = __toESM(require_cjs14());
+var attr_default = (params, element, node) => {
+  const { __ref } = element;
+  const { __attr } = __ref;
+  if ((0, import_utils24.isNot)("object"))
+    (0, import_report4.report)("HTMLInvalidAttr", params);
+  if (params) {
+    for (const attr2 in params) {
+      const val = (0, import_utils24.exec)(params[attr2], element);
+      if (val && node.setAttribute)
+        node.setAttribute(attr2, val);
+      else if (node.removeAttribute)
+        node.removeAttribute(attr2);
+      __attr[attr2] = val;
+    }
+  }
+  console.groupEnd(params, __attr);
+};
+
+// src/element/mixins/classList.js
+var classList_default = (params, element, node) => {
+  applyClassListOnNode(params, element, node);
+};
+
+// src/element/set.js
+var import_utils26 = __toESM(require_cjs6());
+
+// src/element/remove.js
+var import_utils25 = __toESM(require_cjs6());
+var removeContentElement2 = function(el) {
+  const element = el || this;
+  const { __ref } = element;
+  if (element.content) {
+    if (element.content.node) {
+      if (element.content.tag === "fragment")
+        element.node.innerHTML = "";
+      else
+        element.node.removeChild(element.content.node);
+    }
+    const { __cached } = __ref;
+    if (__cached && __cached.content) {
+      if (__cached.content.tag === "fragment")
+        __cached.content.parent.node.innerHTML = "";
+      else if (__cached.content && (0, import_utils25.isFunction)(__cached.content.remove))
+        __cached.content.remove();
+    }
+    delete element.content;
+  }
+};
+
+// src/element/options.js
+var options_default = {};
+
+// src/element/set.js
+var set2 = function(params, options = {}, el) {
+  const element = el || this;
+  const __contentRef = element.content && element.content.__ref;
+  const isEqual = (0, import_utils26.isEqualDeep)(params, element.content);
+  if (isEqual && __contentRef && __contentRef.__cached)
+    return element;
+  removeContentElement2(element);
+  if (params) {
+    const { childExtend } = params;
+    if (!childExtend && element.childExtend)
+      params.childExtend = element.childExtend;
+    create_default(params, element, "content", {
+      ignoreChildExtend: true,
+      ...registry_default.defaultOptions,
+      ...options_default.create,
+      ...options
+    });
+  }
+  return element;
+};
+var set_default = set2;
+
+// src/element/mixins/content.js
+var content_default = (param, element, node, options) => {
+  if (param && element) {
+    if (element.content.update) {
+      element.content.update();
+    } else {
+      set_default.call(element, param, options);
+    }
+  }
+};
+
+// src/element/mixins/data.js
+var import_utils27 = __toESM(require_cjs6());
+var import_report5 = __toESM(require_cjs14());
+var data_default = (params, element, node) => {
+  if (params && params.showOnNode) {
+    if (!(0, import_utils27.isObject)(params))
+      (0, import_report5.report)("HTMLInvalidData", params);
+    for (const dataset in params) {
+      if (dataset !== "showOnNode") {
+        node.dataset[dataset] = (0, import_utils27.exec)(params[dataset], element);
+      }
+    }
+  }
+};
+
+// src/element/mixins/html.js
+var import_utils28 = __toESM(require_cjs6());
+var html_default = (param, element, node) => {
+  const prop = (0, import_utils28.exec)(param, element);
+  const { __ref } = element;
+  if (prop !== __ref.__html) {
+    if (node.nodeName === "SVG")
+      node.textContent = prop;
+    else
+      node.innerHTML = prop;
+    __ref.__html = prop;
+  }
+};
+
+// src/element/mixins/style.js
+var import_utils29 = __toESM(require_cjs6());
+var import_report6 = __toESM(require_cjs14());
+var style_default = (params, element, node) => {
+  if (params) {
+    if ((0, import_utils29.isObject)(params))
+      (0, import_utils29.map)(node.style, params, element);
+    else
+      (0, import_report6.report)("HTMLInvalidStyles", params);
+  }
+};
+
+// src/element/mixins/text.js
+var import_utils30 = __toESM(require_cjs6());
+var text_default = (param, element, node) => {
+  const prop = (0, import_utils30.exec)(param, element);
+  if (element.tag === "string") {
+    if (element.text === prop)
+      return;
+    node.nodeValue = prop;
+  } else if (param !== void 0 || param !== null) {
+    if (element.__text) {
+      if (element.__text.text === prop)
+        return;
+      element.__text.text = prop;
+      if (element.__text.node)
+        element.__text.node.nodeValue = prop;
+    } else
+      create_default({ tag: "string", text: prop }, element, "__text");
+  }
+};
+
+// src/element/mixins/state.js
+var import_utils31 = __toESM(require_cjs6());
+var state_default2 = (params, element, node) => {
+  const state2 = (0, import_utils31.exec)(params, element);
+  if ((0, import_utils31.isObject)(state2)) {
+    for (const param in state2) {
+      if (IGNORE_STATE_PARAMS3.includes(param))
+        continue;
+      element.state[param] = (0, import_utils31.exec)(state2[param], element);
+    }
+  }
+  return element;
+};
+
+// src/element/mixins/registry.js
+var registry_default = {
+  attr: attr_default,
+  style: style_default,
+  text: text_default,
+  html: html_default,
+  content: content_default,
+  data: data_default,
+  class: classList_default,
+  state: state_default2,
+  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: {}
+};
+var parseFilters2 = {
+  elementKeys: [
+    "tag",
+    "text",
+    "style",
+    "attr",
+    "class",
+    "state",
+    "props",
+    "data",
+    "content",
+    "html",
+    "on",
+    "key"
+  ],
+  propsKeys: ["__element", "update"],
+  stateKeys: []
+};
+
+// src/element/applyParam.js
+var import_utils32 = __toESM(require_cjs6());
+var applyParam = (param, element, options) => {
+  const { node, context } = element;
+  const prop = element[param];
+  const DOMQLProperty = registry_default[param];
+  const DOMQLPropertyFromContext = context && context.registry && context.registry[param];
+  const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
+  const hasDefine = element.define && element.define[param];
+  const hasContextDefine = context && context.define && context.define[param];
+  if (isGlobalTransformer && !hasContextDefine) {
+    if ((0, import_utils32.isFunction)(isGlobalTransformer)) {
+      isGlobalTransformer(prop, element, node, options);
+      return;
+    }
+  }
+  return { hasDefine, hasContextDefine };
+};
+
+// src/element/node.js
+var ENV3 = "development";
+var createNode = (element, options) => {
+  let { node, tag, __ref } = element;
+  let isNewNode;
+  if (!node) {
+    isNewNode = true;
+    if (!__ref.__if)
+      return element;
+    if (tag === "shadow") {
+      node = element.node = element.parent.node.attachShadow({ mode: "open" });
+    } else
+      node = element.node = (0, import_node.cacheNode)(element);
+    (0, import_event3.triggerEventOn)("attachNode", element);
+  }
+  if (ENV3 === "test" || ENV3 === "development" || options.alowRefReference) {
+    node.ref = element;
+    if ((0, import_utils33.isFunction)(node.setAttribute))
+      node.setAttribute("key", element.key);
+  }
+  if (!__ref.__if)
+    return element;
+  if (element.tag !== "string" || element.tag !== "fragment") {
+    throughInitialDefine2(element);
+    throughInitialExec2(element);
+    if (isNewNode && (0, import_utils33.isObject)(element.on))
+      (0, import_event3.applyEventsOnNode)(element);
+    for (const param in element) {
+      const prop = element[param];
+      if ((0, import_methods4.isMethod)(param) || (0, import_utils33.isObject)(registry_default[param]) || prop === void 0)
+        continue;
+      const isElement = applyParam(param, element, options);
+      if (isElement) {
+        const { hasDefine, hasContextDefine } = isElement;
+        if (element[param] && !hasDefine && !hasContextDefine) {
+          create_default((0, import_utils33.exec)(prop, element), element, param, options);
+        }
+      }
+    }
+  }
+  return element;
+};
+var node_default = createNode;
+
+// src/element/extend.js
+var import_utils34 = __toESM(require_cjs6());
+var ENV4 = "development";
+var applyExtend = (element, parent, options = {}) => {
+  if ((0, import_utils34.isFunction)(element))
+    element = (0, import_utils34.exec)(element, parent);
+  let { extend, props, context, __ref } = element;
+  const COMPONENTS = context && context.components || options.components;
+  if ((0, import_utils34.isString)(extend))
+    extend = COMPONENTS[extend];
+  const extendStack = getExtendStack2(extend);
+  if (ENV4 !== "test" || ENV4 !== "development")
+    delete element.extend;
+  let childExtendStack = [];
+  if (parent) {
+    element.parent = parent;
+    if (!options.ignoreChildExtend) {
+      if (props && props.ignoreChildExtend)
+        return;
+      childExtendStack = getExtendStack2(parent.childExtend);
+      if (parent.childExtendRecursive) {
+        const childExtendRecursiveStack = getExtendStack2(parent.childExtendRecursive);
+        childExtendStack = childExtendStack.concat(childExtendRecursiveStack);
+        element.childExtendRecursive = parent.childExtendRecursive;
+      }
+    }
+  }
+  const extendLength = extendStack.length;
+  const childExtendLength = childExtendStack.length;
+  let stack = [];
+  if (extendLength && childExtendLength) {
+    stack = jointStacks2(extendStack, childExtendStack);
+  } else if (extendLength) {
+    stack = extendStack;
+  } else if (childExtendLength) {
+    stack = childExtendStack;
+  } else if (!options.extend)
+    return element;
+  if (options.extend) {
+    const defaultOptionsExtend = getExtendStack2(options.extend);
+    stack = [].concat(stack, defaultOptionsExtend);
+  }
+  __ref.__extend = stack;
+  const findAndReplaceStrings = replaceStringsWithComponents(stack, COMPONENTS);
+  let mergedExtend = cloneAndMergeArrayExtend2(findAndReplaceStrings);
+  const component = (0, import_utils34.exec)(element.component || mergedExtend.component, element);
+  if (component && COMPONENTS && COMPONENTS[component]) {
+    const componentExtend = cloneAndMergeArrayExtend2(getExtendStack2(COMPONENTS[component]));
+    mergedExtend = deepMergeExtend2(componentExtend, mergedExtend);
+  }
+  return deepMergeExtend2(element, mergedExtend);
+};
+
+// src/element/update.js
+var import_globals = __toESM(require_cjs15());
+var import_utils36 = __toESM(require_cjs6());
+var import_event4 = __toESM(require_cjs8());
+var import_methods5 = __toESM(require_cjs11());
+var import_key2 = __toESM(require_cjs4());
+var snapshot = {
+  snapshotId: import_key2.createSnapshotId
+};
+var UPDATE_DEFAULT_OPTIONS = {
+  stackChanges: false,
+  cleanExec: true,
+  preventRecursive: false,
+  currentSnapshot: false,
+  calleeElement: false
+};
+var update3 = function(params = {}, options = UPDATE_DEFAULT_OPTIONS) {
+  const element = this;
+  const { parent, node, key } = element;
+  let __ref = element.__ref;
+  if (!__ref)
+    __ref = element.__ref = {};
+  const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(element, options);
+  if (snapshotHasUpdated)
+    return;
+  if ((0, import_utils36.isString)(params) || (0, import_utils36.isNumber)(params)) {
+    params = { text: params };
+  }
+  const ifFails = checkIfOnUpdate(element, options);
+  if (ifFails)
+    return;
+  const inheritState = inheritStateUpdates(element, options);
+  if (inheritState === false)
+    return;
+  if (__ref.__if && !options.preventPropsUpdate) {
+    const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
+    const hasFunctionInProps = element.__ref.__props.filter((v) => (0, import_utils36.isFunction)(v));
+    const props = params.props || hasParentProps || hasFunctionInProps.length;
+    if (props)
+      updateProps(props, element, parent);
+  }
+  if (!options.preventInitUpdateListener) {
+    const initUpdateReturns = (0, import_event4.triggerEventOn)("initUpdate", element, params);
+    if (initUpdateReturns === false)
+      return element;
+  }
+  const overwriteChanges = overwriteDeep2(params, element);
+  const execChanges = throughUpdatedExec2(element, UPDATE_DEFAULT_OPTIONS);
+  const definedChanges = throughUpdatedDefine2(element);
+  if (options.stackChanges && element.__stackChanges) {
+    const stackChanges = merge(definedChanges, merge(execChanges, overwriteChanges));
+    element.__stackChanges.push(stackChanges);
+  }
+  if (!__ref.__if)
+    return false;
+  if (!node) {
+    return;
+  }
+  for (const param in element) {
+    const prop = element[param];
+    if (options.preventDefineUpdate === true || options.preventDefineUpdate === param || options.preventContentUpdate && param === "content" || (options.preventStateUpdate && param) === "state" || (0, import_methods5.isMethod)(param) || (0, import_utils36.isObject)(registry_default[param]) || prop === void 0)
+      continue;
+    if (options.preventStateUpdate === "once")
+      options.preventStateUpdate = false;
+    const isElement = applyParam(param, element, options);
+    if (isElement) {
+      const { hasDefine, hasContextDefine } = isElement;
+      const canUpdate = (0, import_utils36.isObject)(prop) && !hasDefine && !hasContextDefine && !options.preventRecursive;
+      if (!canUpdate)
+        continue;
+      const childUpdateCall = () => update3.call(prop, params[prop], {
+        ...options,
+        currentSnapshot: snapshotOnCallee,
+        calleeElement
+      });
+      if (element.props && element.props.lazyLoad || options.lazyLoad) {
+        import_globals.window.requestAnimationFrame(() => childUpdateCall());
+      } else
+        childUpdateCall();
+    }
+  }
+  if (!options.preventUpdateListener)
+    (0, import_event4.triggerEventOn)("update", element);
+};
+var captureSnapshot = (element, options) => {
+  const __ref = element.__ref;
+  const { currentSnapshot, calleeElement } = options;
+  const isCallee = calleeElement === element;
+  if (!calleeElement || isCallee) {
+    const createdStanpshot = snapshot.snapshotId();
+    __ref.__currentSnapshot = createdStanpshot;
+    return [createdStanpshot, element];
+  }
+  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
+  if (currentSnapshot < snapshotOnCallee) {
+    return [snapshotOnCallee, calleeElement, true];
+  }
+  return [snapshotOnCallee, calleeElement];
+};
+var checkIfOnUpdate = (element, options) => {
+  if (!(0, import_utils36.isFunction)(element.if))
+    return;
+  const __ref = element.__ref;
+  const ifPassed = element.if(element, element.state);
+  const itWasFalse = __ref.__if !== true;
+  if (ifPassed) {
+    __ref.__if = true;
+    if (itWasFalse) {
+      delete element.__hash;
+      delete element.extend;
+      if (!__ref.__hasRootState) {
+        delete element.state;
+      }
+      if (__ref.__state) {
+        element.state = __ref.__state;
+      }
+      const created = create_default(element, element.parent, element.key);
+      if (!options.preventUpdate && element.on && (0, import_utils36.isFunction)(element.on.update)) {
+        (0, import_event4.applyEvent)(element.on.update, created, created.state);
+      }
+      return created;
+    }
+  } else if (element.node && !ifPassed) {
+    element.node.remove();
+    delete __ref.__if;
+  }
+};
+var inheritStateUpdates = (element, options) => {
+  const { __ref } = element;
+  const stateKey = __ref.__state;
+  const { parent } = element;
+  if (!stateKey && !__ref.__hasRootState) {
+    element.state = (parent == null ? void 0 : parent.state) || {};
+    return;
+  }
+  const parentState = (parent == null ? void 0 : parent.state) || {};
+  const keyInParentState = parentState[stateKey];
+  if (!keyInParentState)
+    return;
+  const initStateReturns = (0, import_event4.triggerEventOn)("initStateUpdated", element, keyInParentState);
+  if (initStateReturns === false)
+    return element;
+  const newState = state_default(element, parent);
+  element.state = newState;
+  (0, import_event4.triggerEventOn)("stateUpdated", element, newState.parse());
+};
+var update_default = update3;
+
+// src/element/methods.js
+var import_utils38 = __toESM(require_cjs6());
+var keys = function() {
+  const element = this;
+  const keys2 = [];
+  for (const param in element) {
+    if (registry_default[param] && !parseFilters2.elementKeys.includes(param)) {
+      continue;
+    }
+    keys2.push(param);
+  }
+  return keys2;
+};
+var parse3 = function(excl = []) {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  keyList.forEach((v) => {
+    if (excl.includes(v))
+      return;
+    let val = element[v];
+    if (v === "state") {
+      if (element.__ref && element.__ref.__hasRootState)
+        return;
+      if ((0, import_utils38.isFunction)(val == null ? void 0 : val.parse))
+        val = val.parse();
+    } else if (v === "props") {
+      const { __element, update: update4, ...props } = element[v];
+      obj[v] = props;
+    } else if ((0, import_utils38.isDefined)(val))
+      obj[v] = val;
+  });
+  return obj;
+};
+var parseDeep = function(excl = []) {
+  const element = this;
+  const obj = parse3.call(element, excl);
+  for (const v in obj) {
+    if (excl.includes(v))
+      return;
+    if ((0, import_utils38.isObjectLike)(obj[v])) {
+      obj[v] = parseDeep.call(obj[v], excl);
+    }
+  }
+  return obj;
+};
+var log = function(...args) {
+  const element = this;
+  const { __ref } = element;
+  console.group(element.key);
+  if (args.length) {
+    args.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+  } else {
+    console.log(__ref.path);
+    const keys2 = element.keys();
+    keys2.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+  }
+  console.groupEnd(element.key);
+  return element;
+};
+var nextElement = function() {
+  const element = this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  const currentIndex = __children.indexOf(key);
+  const nextChild = __children[currentIndex + 1];
+  console.log(nextChild);
+  return parent[nextChild];
+};
+var previousElement = function(el) {
+  const element = el || this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  if (!__children)
+    return;
+  const currentIndex = __children.indexOf(key);
+  return parent[__children[currentIndex - 1]];
+};
+
+// src/element/create.js
+var ENV5 = "development";
+var create3 = (element, parent, key, options = options_default.create || {}) => {
+  if (options && !options_default.create)
+    options_default.create = options;
+  if (element === void 0) {
+    if (ENV5 === "test" || ENV5 === "development") {
+      console.warn(key, "element is undefined in", parent && parent.__ref && parent.__ref.path);
+    }
+    element = {};
+  }
+  if ((0, import_utils39.isString)(key) && key.slice(0, 2 === "__")) {
+    if (ENV5 === "test" || ENV5 === "development") {
+      console.warn(key, "seems like to be in __ref");
+    }
+  }
+  if (element === null)
+    return;
+  if (element === true)
+    element = { text: true };
+  if (element.__hash) {
+    element = { extend: element };
+  }
+  if (!parent)
+    parent = import_tree2.ROOT;
+  if ((0, import_utils39.isNode)(parent)) {
+    parent = import_tree2.ROOT[`${key}_parent`] = { key: ":root", node: parent };
+  }
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent, key);
+  }
+  const assignedKey = (element.key || key || (0, import_key3.createKey)()).toString();
+  if (checkIfKeyIsComponent(assignedKey)) {
+    element = applyKeyComponentAsExtend(element, parent, assignedKey);
+  }
+  if (checkIfMedia(assignedKey)) {
+    element = applyMediaProps(element, parent, assignedKey);
+  }
+  if (element.__ref)
+    element.__ref.origin = element;
+  else
+    element.__ref = { origin: element };
+  const __ref = element.__ref;
+  applyContext(element, parent, options);
+  const { context } = element;
+  if (context && context.components)
+    applyComponentFromContext(element, parent, options);
+  applyExtend(element, parent, options);
+  element.key = assignedKey;
+  if (options.onlyResolveExtends)
+    return resolveExtends(element, parent, options);
+  if (Object.keys(options).length) {
+    registry_default.defaultOptions = options;
+    if (options.ignoreChildExtend)
+      delete options.ignoreChildExtend;
+  }
+  addCaching(element, parent);
+  addMethods(element, parent);
+  element.state = state_default(element, parent);
+  checkIf(element, parent);
+  if (element.node && __ref.__if) {
+    return (0, import_render.assignNode)(element, parent, assignedKey);
+  }
+  if (__ref.__if)
+    props_default(element, parent);
+  const initReturns = (0, import_event5.triggerEventOn)("init", element);
+  if (initReturns === false)
+    return element;
+  (0, import_event5.triggerEventOn)("beforeClassAssign", element);
+  assignClass(element);
+  node_default(element, options);
+  if (!__ref.__if)
+    return element;
+  (0, import_render.assignNode)(element, parent, key);
+  (0, import_event5.triggerEventOn)("renderRouter", element);
+  (0, import_event5.triggerEventOn)("render", element);
+  if (parent.__ref && parent.__ref.__children)
+    parent.__ref.__children.push(element.key);
+  return element;
+};
+var checkIfPrimitive = (element) => {
+  return (0, import_utils39.is)(element)("string", "number");
+};
+var applyValueAsText = (element, parent, key) => {
+  const extendTag = element.extend && element.extend.tag;
+  const childExtendTag = parent.childExtend && parent.childExtend.tag;
+  const isKeyValidHTMLTag = import_registry3.TAGS.body.indexOf(key) > -1 && key;
+  return {
+    text: element,
+    tag: extendTag || childExtendTag || isKeyValidHTMLTag || "string"
+  };
+};
+var addMethods = (element, parent) => {
+  element.set = set_default;
+  element.update = update_default;
+  element.remove = import_methods6.remove;
+  element.removeContent = removeContentElement2;
+  element.setProps = import_methods6.setProps;
+  element.lookup = import_methods6.lookup;
+  element.spotByPath = import_methods6.spotByPath;
+  element.parse = parse3;
+  element.parseDeep = parseDeep;
+  element.keys = keys;
+  element.nextElement = nextElement;
+  element.previousElement = previousElement;
+  if (ENV5 === "test" || ENV5 === "development") {
+    element.log = log;
+  }
+};
+var applyContext = (element, parent, options) => {
+  if (options.context && !import_tree2.ROOT.context && !element.context)
+    import_tree2.ROOT.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || import_tree2.ROOT.context;
+};
+var checkIf = (element, parent) => {
+  const { __ref } = element;
+  if ((0, import_utils39.isFunction)(element.if)) {
+    const ifPassed = element.if(element, element.state);
+    if (!ifPassed) {
+      const ifFragment = (0, import_node2.cacheNode)({ tag: "fragment" });
+      __ref.__ifFragment = (0, import_render.appendNode)(ifFragment, parent.node);
+      delete __ref.__if;
+    } else
+      __ref.__if = true;
+  } else
+    __ref.__if = true;
+};
+var addCaching = (element, parent) => {
+  const { __ref } = element;
+  let { __ref: __parentRef } = parent;
+  if (!element.transform)
+    element.transform = {};
+  if (!__ref.__cached)
+    __ref.__cached = {};
+  if (!__ref.__exec)
+    __ref.__exec = {};
+  if (!__ref.__class)
+    __ref.__class = {};
+  if (!__ref.__classNames)
+    __ref.__classNames = {};
+  if (!__ref.__attr)
+    __ref.__attr = {};
+  if (!__ref.__changes)
+    __ref.__changes = [];
+  if (!__ref.__children)
+    __ref.__children = [];
+  const hasRoot = parent && parent.key === ":root";
+  if (!__ref.__root)
+    __ref.__root = hasRoot ? element : __parentRef.__root;
+  if (ENV5 === "test" || ENV5 === "development") {
+    if (!__parentRef)
+      __parentRef = parent.__ref = {};
+    if (!__parentRef.__path)
+      __parentRef.__path = [];
+    __ref.__path = __parentRef.__path.concat(element.key);
+  }
+};
+var resolveExtends = (element, parent, options) => {
+  const { __ref } = element;
+  element.tag = (0, import_node2.detectTag)(element);
+  if (!__ref.__exec)
+    __ref.__exec = {};
+  if (!__ref.__attr)
+    __ref.__attr = {};
+  if (!element.props)
+    element.props = {};
+  if (!element.state)
+    element.state = {};
+  element = props_default(element, parent);
+  state_default(element, parent, { skip: true });
+  throughInitialExec2(element);
+  for (const param in element) {
+    const prop = element[param];
+    if ((0, import_methods6.isMethod)(param) || (0, import_utils39.isObject)(registry_default[param]) || prop === void 0)
+      continue;
+    const hasDefined = element.define && element.define[param];
+    const ourParam = registry_default[param];
+    const hasOptionsDefine = options.define && options.define[param];
+    if (ourParam && !hasOptionsDefine)
+      continue;
+    else if (element[param] && !hasDefined && !hasOptionsDefine) {
+      create3((0, import_utils39.exec)(prop, element), element, param, options);
+    }
+  }
+  delete element.parent;
+  delete element.update;
+  delete element.__element;
+  delete element.props.update;
+  delete element.props.__element;
+  delete element.state.__element;
+  delete element.state.__element;
+  delete element.__hasRootState;
+  delete element.__ref;
+  return element;
+};
+var checkIfMedia = (key) => key.slice(0, 1) === "@";
+var applyMediaProps = (element, parent, key) => {
+  const { props } = element;
+  if (props) {
+    props.display = "none";
+    if (props[key])
+      props[key].display = props.display;
+    else
+      props[key] = { display: props.display || "block" };
+    return element;
+  } else {
+    return {
+      ...element,
+      props: {
+        display: "none",
+        [key]: { display: "block" }
+      }
+    };
+  }
+};
+var create_default = create3;
+
+// src/element/define.js
+var import_report7 = __toESM(require_cjs14());
+var define_default = (params, options = {}) => {
+  const { overwrite: overwrite2 } = options;
+  for (const param in params) {
+    if (registry_default[param] && !overwrite2) {
+      (0, import_report7.report)("OverwriteToBuiltin", param);
+    } else
+      registry_default[param] = params[param];
+  }
+};
+
+// src/element/parse.js
+var import_render2 = __toESM(require_cjs9());
+var parse4 = (element) => {
+  const virtualTree = {
+    node: document.createElement("div")
+  };
+  if (element && element.node)
+    (0, import_render2.assignNode)(element, virtualTree);
+  else
+    create_default(element, virtualTree);
+  return virtualTree.node.innerHTML;
+};
+var parse_default = parse4;
+
+// src/element/index.js
+var import_methods9 = __toESM(require_cjs11());
+var export_TREE = import_tree3.TREE;
+var export_get = import_methods9.get;
+var export_lookup = import_methods9.lookup;
+var export_remove = import_methods9.remove;
+export {
+  export_TREE as TREE,
+  create_default as create,
+  node_default as createNode,
+  define_default as define,
+  export_get as get,
+  keys,
+  log,
+  export_lookup as lookup,
+  parse_default as parse,
+  export_remove as remove,
+  set_default as set,
+  update_default as update
+};