domql 1.5.136 → 1.6.0

package/dist/esm/element/applyParam.js

@@ -0,0 +1,2614 @@
+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 __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
+));
+
+// node_modules/@domql/globals/dist/cjs/index.js
+var require_cjs = __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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var globals_exports = {};
+    __export2(globals_exports, {
+      document: () => document4,
+      global: () => global,
+      self: () => self,
+      window: () => window4
+    });
+    module.exports = __toCommonJS(globals_exports);
+    var global = globalThis;
+    var self = globalThis;
+    var window4 = globalThis;
+    var document4 = window4.document;
+  }
+});
+
+// node_modules/@domql/tags/dist/cjs/htmlTags.js
+var require_htmlTags = __commonJS({
+  "node_modules/@domql/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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var htmlTags_exports = {};
+    __export2(htmlTags_exports, {
+      HTML_TAGS: () => HTML_TAGS
+    });
+    module.exports = __toCommonJS(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"
+      ]
+    };
+  }
+});
+
+// node_modules/@domql/tags/dist/cjs/index.js
+var require_cjs2 = __commonJS({
+  "node_modules/@domql/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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var tags_exports = {};
+    module.exports = __toCommonJS(tags_exports);
+    __reExport(tags_exports, require_htmlTags(), module.exports);
+  }
+});
+
+// node_modules/@domql/utils/dist/cjs/types.js
+var require_types = __commonJS({
+  "node_modules/@domql/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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var types_exports = {};
+    __export2(types_exports, {
+      TYPES: () => TYPES,
+      is: () => is4,
+      isArray: () => isArray4,
+      isBoolean: () => isBoolean,
+      isDefined: () => isDefined,
+      isFunction: () => isFunction13,
+      isHtmlElement: () => isHtmlElement,
+      isNode: () => isNode2,
+      isNot: () => isNot2,
+      isNull: () => isNull,
+      isNumber: () => isNumber3,
+      isObject: () => isObject13,
+      isObjectLike: () => isObjectLike3,
+      isString: () => isString10,
+      isUndefined: () => isUndefined2,
+      isValidHtmlTag: () => isValidHtmlTag
+    });
+    module.exports = __toCommonJS(types_exports);
+    var import_globals6 = require_cjs();
+    var import_tags = require_cjs2();
+    var isValidHtmlTag = (arg) => import_tags.HTML_TAGS.body.indexOf(arg);
+    var isObject13 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object" && arg.constructor === Object;
+    };
+    var isString10 = (arg) => typeof arg === "string";
+    var isNumber3 = (arg) => typeof arg === "number";
+    var isFunction13 = (arg) => typeof arg === "function";
+    var isBoolean = (arg) => arg === true || arg === false;
+    var isNull = (arg) => arg === null;
+    var isArray4 = (arg) => Array.isArray(arg);
+    var isObjectLike3 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object";
+    };
+    var isNode2 = (obj) => {
+      return typeof import_globals6.window.Node === "object" ? obj instanceof import_globals6.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+    };
+    var isHtmlElement = (obj) => {
+      return typeof import_globals6.window.HTMLElement === "object" ? obj instanceof import_globals6.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
+    };
+    var isDefined = (arg) => {
+      return isObject13(arg) || isObjectLike3(arg) || isString10(arg) || isNumber3(arg) || isFunction13(arg) || isArray4(arg) || isObjectLike3(arg) || isBoolean(arg) || isNull(arg);
+    };
+    var isUndefined2 = (arg) => {
+      return arg === void 0;
+    };
+    var TYPES = {
+      boolean: isBoolean,
+      array: isArray4,
+      object: isObject13,
+      string: isString10,
+      number: isNumber3,
+      null: isNull,
+      function: isFunction13,
+      objectLike: isObjectLike3,
+      node: isNode2,
+      htmlElement: isHtmlElement,
+      defined: isDefined
+    };
+    var is4 = (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;
+      };
+    };
+  }
+});
+
+// node_modules/@domql/utils/dist/cjs/object.js
+var require_object = __commonJS({
+  "node_modules/@domql/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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var object_exports = {};
+    __export2(object_exports, {
+      clone: () => clone,
+      deepClone: () => deepClone2,
+      deepCloneExclude: () => deepCloneExclude,
+      deepDestringify: () => deepDestringify,
+      deepMerge: () => deepMerge2,
+      deepStringify: () => deepStringify,
+      diff: () => diff2,
+      exec: () => exec16,
+      flattenRecursive: () => flattenRecursive,
+      isEqualDeep: () => isEqualDeep2,
+      map: () => map2,
+      merge: () => merge2,
+      mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+      mergeArray: () => mergeArray2,
+      mergeArrayExclude: () => mergeArrayExclude,
+      mergeIfExisted: () => mergeIfExisted,
+      overwrite: () => overwrite2,
+      overwriteDeep: () => overwriteDeep2,
+      overwriteObj: () => overwriteObj
+    });
+    module.exports = __toCommonJS(object_exports);
+    var import_globals6 = require_cjs();
+    var import_types = require_types();
+    var exec16 = (param, element, state, context) => {
+      if ((0, import_types.isFunction)(param)) {
+        return param(
+          element,
+          state || element.state,
+          context || element.context
+        );
+      }
+      return param;
+    };
+    var map2 = (obj, extention, element) => {
+      for (const e in extention) {
+        obj[e] = exec16(extention[e], element);
+      }
+    };
+    var merge2 = (element, obj) => {
+      for (const e in obj) {
+        const elementProp = element[e];
+        const objProp = obj[e];
+        if (elementProp === void 0) {
+          element[e] = objProp;
+        }
+      }
+      return element;
+    };
+    var deepMerge2 = (element, extend) => {
+      for (const e in extend) {
+        const extendProp = extend[e];
+        if (e === "parent" || e === "props")
+          continue;
+        if (element[e] === void 0) {
+          element[e] = extendProp;
+        } else if ((0, import_types.isObjectLike)(element[e]) && (0, import_types.isObjectLike)(extendProp)) {
+          deepMerge2(element[e], extendProp);
+        } else {
+          element[e] = extendProp;
+        }
+      }
+      return element;
+    };
+    var clone = (obj) => {
+      const o = {};
+      for (const prop in obj) {
+        if (prop === "node")
+          continue;
+        o[prop] = obj[prop];
+      }
+      return o;
+    };
+    var deepCloneExclude = (obj, exclude = []) => {
+      if ((0, import_types.isArray)(obj)) {
+        return obj.map((x) => deepCloneExclude(x, exclude));
+      }
+      const o = {};
+      for (const k in obj) {
+        if (exclude.indexOf(k) > -1)
+          continue;
+        let v = obj[k];
+        if (k === "extend" && (0, import_types.isArray)(v)) {
+          v = mergeArrayExclude(v, exclude);
+        }
+        if ((0, import_types.isArray)(v)) {
+          o[k] = v.map((x) => deepCloneExclude(x, exclude));
+        } else if ((0, import_types.isObject)(v)) {
+          o[k] = deepCloneExclude(v, exclude);
+        } else
+          o[k] = v;
+      }
+      return o;
+    };
+    var mergeArrayExclude = (arr, excl = []) => {
+      return arr.reduce((acc, curr) => deepMerge2(acc, deepCloneExclude(curr, excl)), {});
+    };
+    var deepClone2 = (obj) => {
+      if ((0, import_types.isArray)(obj)) {
+        return obj.map(deepClone2);
+      }
+      const o = {};
+      for (const prop in obj) {
+        let objProp = obj[prop];
+        if (prop === "extend" && (0, import_types.isArray)(objProp)) {
+          objProp = mergeArray2(objProp);
+        }
+        if ((0, import_types.isArray)(objProp)) {
+          o[prop] = objProp.map((v) => (0, import_types.isObject)(v) ? deepClone2(v) : v);
+        } else if ((0, import_types.isObject)(objProp)) {
+          o[prop] = deepClone2(objProp);
+        } 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 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_globals6.window.eval(`(${objProp})`);
+              stringified[prop] = evalProp;
+            } catch (e) {
+              if (e)
+                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_globals6.window.eval(`(${arrProp})`);
+                  stringified[prop].push(evalProp);
+                } catch (e) {
+                  if (e)
+                    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, options) => {
+      const { ref } = element;
+      const changes = {};
+      for (const e in params) {
+        if (e === "props")
+          continue;
+        const elementProp = element[e];
+        const paramsProp = params[e];
+        if (paramsProp) {
+          ref.__cache[e] = changes[e] = elementProp;
+          ref[e] = paramsProp;
+        }
+      }
+      return changes;
+    };
+    var diff2 = (obj, original, cache) => {
+      const changes = cache || {};
+      for (const e in obj) {
+        if (e === "ref")
+          continue;
+        const originalProp = original[e];
+        const objProp = obj[e];
+        if ((0, import_types.isObjectLike)(originalProp) && (0, import_types.isObjectLike)(objProp)) {
+          changes[e] = {};
+          diff2(originalProp, objProp, changes[e]);
+        } else if (objProp !== void 0) {
+          changes[e] = objProp;
+        }
+      }
+      return changes;
+    };
+    var overwriteObj = (params, obj) => {
+      const changes = {};
+      for (const e in params) {
+        const objProp = obj[e];
+        const paramsProp = params[e];
+        if (paramsProp) {
+          obj[e] = changes[e] = objProp;
+        }
+      }
+      return changes;
+    };
+    var overwriteDeep2 = (params, obj) => {
+      for (const e in params) {
+        const objProp = obj[e];
+        const paramsProp = params[e];
+        if ((0, import_types.isObjectLike)(objProp) && (0, import_types.isObjectLike)(paramsProp)) {
+          overwriteDeep2(paramsProp, objProp);
+        } else if (paramsProp !== void 0) {
+          obj[e] = paramsProp;
+        }
+      }
+      return obj;
+    };
+    var mergeIfExisted = (a, b) => {
+      if ((0, import_types.isObjectLike)(a) && (0, import_types.isObjectLike)(b))
+        return deepMerge2(a, b);
+      return a || b;
+    };
+    var mergeArray2 = (arr) => {
+      return arr.reduce((a, c) => deepMerge2(a, deepClone2(c)), {});
+    };
+    var mergeAndCloneIfArray = (obj) => {
+      return (0, import_types.isArray)(obj) ? mergeArray2(obj) : deepClone2(obj);
+    };
+    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;
+    };
+  }
+});
+
+// node_modules/@domql/utils/dist/cjs/function.js
+var require_function = __commonJS({
+  "node_modules/@domql/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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var function_exports = {};
+    __export2(function_exports, {
+      debounce: () => debounce,
+      memoize: () => memoize
+    });
+    module.exports = __toCommonJS(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;
+        }
+      };
+    };
+  }
+});
+
+// node_modules/@domql/utils/dist/cjs/array.js
+var require_array = __commonJS({
+  "node_modules/@domql/utils/dist/cjs/array.js"() {
+    "use strict";
+  }
+});
+
+// node_modules/@domql/utils/dist/cjs/node.js
+var require_node = __commonJS({
+  "node_modules/@domql/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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var node_exports = {};
+    __export2(node_exports, {
+      cleanWithNode: () => cleanWithNode,
+      createID: () => createID2,
+      createSnapshotId: () => createSnapshotId2
+    });
+    module.exports = __toCommonJS(node_exports);
+    var cleanWithNode = (extend) => delete extend.node && extend;
+    var createID2 = function() {
+      let index = 0;
+      function newId() {
+        index++;
+        return index;
+      }
+      return newId;
+    }();
+    var createSnapshotId2 = createID2;
+  }
+});
+
+// node_modules/@domql/utils/dist/cjs/log.js
+var require_log = __commonJS({
+  "node_modules/@domql/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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var log_exports = {};
+    __export2(log_exports, {
+      logGroupIf: () => logGroupIf,
+      logIf: () => logIf
+    });
+    module.exports = __toCommonJS(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);
+      }
+    };
+  }
+});
+
+// node_modules/@domql/utils/dist/cjs/index.js
+var require_cjs3 = __commonJS({
+  "node_modules/@domql/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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var utils_exports = {};
+    module.exports = __toCommonJS(utils_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);
+  }
+});
+
+// node_modules/@domql/report/dist/cjs/index.js
+var require_cjs4 = __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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var report_exports = {};
+    __export2(report_exports, {
+      ERRORS_REGISTRY: () => ERRORS_REGISTRY,
+      report: () => report8
+    });
+    module.exports = __toCommonJS(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}` : ""
+      );
+    };
+  }
+});
+
+// src/element/applyParam.js
+var import_utils30 = __toESM(require_cjs3());
+
+// src/element/mixins/attr.js
+var import_utils = __toESM(require_cjs3());
+var import_report = __toESM(require_cjs4());
+var attr_default = (params, element, node) => {
+  const { __ref } = element;
+  const { __attr } = __ref;
+  if ((0, import_utils.isNot)("object"))
+    (0, import_report.report)("HTMLInvalidAttr", params);
+  if (params) {
+    for (const attr in params) {
+      const val = (0, import_utils.exec)(params[attr], element);
+      if (val && node.setAttribute)
+        node.setAttribute(attr, val);
+      else if (node.removeAttribute)
+        node.removeAttribute(attr);
+      __attr[attr] = val;
+    }
+  }
+  console.groupEnd(params, __attr);
+};
+
+// node_modules/@domql/classlist/index.js
+var import_utils2 = __toESM(require_cjs3());
+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_utils2.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_utils2.isString)(params))
+    params = element.class = { default: params };
+  if ((0, import_utils2.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/mixins/classList.js
+var classList_default = (params, element, node) => {
+  applyClassListOnNode(params, element, node);
+};
+
+// src/element/set.js
+var import_utils24 = __toESM(require_cjs3());
+
+// src/element/remove.js
+var import_utils3 = __toESM(require_cjs3());
+var removeContentElement = 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_utils3.isFunction)(__cached.content.remove))
+        __cached.content.remove();
+    }
+    delete element.content;
+  }
+};
+
+// src/element/create.js
+var import_utils23 = __toESM(require_cjs3());
+
+// node_modules/@domql/registry/methods.js
+var import_utils4 = __toESM(require_cjs3());
+
+// node_modules/@domql/registry/tags.js
+var 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"
+  ]
+};
+
+// node_modules/@domql/event/on.js
+var import_utils5 = __toESM(require_cjs3());
+var applyEvent = (param, element, state, context) => {
+  return param(element, state || element.state, context || element.context);
+};
+var triggerEventOn = (param, element) => {
+  if (element.on && (0, import_utils5.isFunction)(element.on[param])) {
+    return applyEvent(element.on[param], element);
+  }
+};
+
+// node_modules/@domql/event/is.js
+var import_globals = __toESM(require_cjs());
+
+// node_modules/@domql/event/index.js
+var applyEvent2 = applyEvent;
+var triggerEventOn2 = triggerEventOn;
+
+// src/element/root.js
+var import_globals2 = __toESM(require_cjs());
+var import_report2 = __toESM(require_cjs4());
+var root = {
+  key: ":root",
+  node: import_globals2.document ? import_globals2.document.body : (0, import_report2.report)("DocumentNotDefined", import_globals2.document)
+};
+var root_default = root;
+
+// src/element/node.js
+var import_utils14 = __toESM(require_cjs3());
+
+// src/element/cache.js
+var import_globals4 = __toESM(require_cjs());
+var import_utils9 = __toESM(require_cjs3());
+var import_report4 = __toESM(require_cjs4());
+
+// src/event/on.js
+var on_exports2 = {};
+__export(on_exports2, {
+  initStateUpdated: () => initStateUpdated,
+  initUpdate: () => initUpdate,
+  stateUpdated: () => stateUpdated
+});
+var initUpdate = (param, element, state, changes) => {
+  return param(element, state, changes);
+};
+var initStateUpdated = (param, element, state, changes) => {
+  return param(element, state, changes);
+};
+var stateUpdated = (param, element, state, changes) => {
+  return param(element, state, changes);
+};
+
+// src/event/can.js
+var can_exports = {};
+__export(can_exports, {
+  render: () => render
+});
+var import_report3 = __toESM(require_cjs4());
+var render = (element) => {
+  const tag = element.tag || "div";
+  const isValid = TAGS.body.indexOf(tag) > -1;
+  return isValid || (0, import_report3.report)("HTMLInvalidTag");
+};
+
+// src/event/is.js
+var import_globals3 = __toESM(require_cjs());
+
+// src/utils/object.js
+var import_utils6 = __toESM(require_cjs3());
+var isTagRegistered = (arg) => TAGS.body.indexOf(arg);
+var merge = (element, obj) => {
+  for (const e in obj) {
+    const elementProp = element[e];
+    const objProp = obj[e];
+    if (elementProp === void 0) {
+      element[e] = objProp;
+    }
+  }
+  return element;
+};
+var deepMerge = (element, extend) => {
+  for (const e in extend) {
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (e === "parent" || e === "props" || e === "state")
+      continue;
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if ((0, import_utils6.isObjectLike)(elementProp) && (0, import_utils6.isObject)(extendProp)) {
+      deepMerge(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+var deepClone = (obj, excluding = ["parent", "node", "__element", "state", "context", "extend", "__ref"]) => {
+  const o = (0, import_utils6.isArray)(obj) ? [] : {};
+  for (const prop in obj) {
+    if (excluding.indexOf(prop) > -1)
+      continue;
+    let objProp = obj[prop];
+    if (prop === "extend" && (0, import_utils6.isArray)(objProp)) {
+      objProp = mergeArray(objProp, excluding);
+    }
+    if ((0, import_utils6.isObjectLike)(objProp)) {
+      o[prop] = deepClone(objProp, excluding);
+    } else
+      o[prop] = objProp;
+  }
+  return o;
+};
+var overwrite = (element, params, options) => {
+  const changes = {};
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  for (const e in params) {
+    if (e === "props" || e === "state" || e === "__ref")
+      continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp !== void 0) {
+      __cached[e] = changes[e] = elementProp;
+      element[e] = paramsProp;
+    }
+    if (options.cleanExec)
+      delete __exec[e];
+  }
+  return changes;
+};
+var overwriteShallow = (obj, params, excluding = ["node", "__ref"]) => {
+  for (const e in params) {
+    if (excluding.indexOf(e) > -1)
+      continue;
+    obj[e] = params[e];
+  }
+  return obj;
+};
+var overwriteDeep = (obj, params, excluding = ["node", "__ref"]) => {
+  for (const e in params) {
+    if (excluding.indexOf(e) > -1)
+      continue;
+    const objProp = obj[e];
+    const paramsProp = params[e];
+    if ((0, import_utils6.isObjectLike)(objProp) && (0, import_utils6.isObjectLike)(paramsProp)) {
+      overwriteDeep(objProp, paramsProp);
+    } else if (paramsProp !== void 0) {
+      obj[e] = paramsProp;
+    }
+  }
+  return obj;
+};
+var mergeArray = (arr, excluding = ["parent", "node", "__element", "state", "context", "__ref"]) => {
+  return arr.reduce((a, c) => deepMerge(a, deepClone(c, excluding)), {});
+};
+
+// src/utils/extendUtils.js
+var import_utils7 = __toESM(require_cjs3());
+var generateHash = () => Math.random().toString(36).substring(2);
+var extendStackRegistry = {};
+var getHashedExtend = (extend) => {
+  return extendStackRegistry[extend.__hash];
+};
+var setHashedExtend = (extend, stack) => {
+  const hash = generateHash();
+  extend.__hash = hash;
+  extendStackRegistry[hash] = stack;
+  return stack;
+};
+var getExtendStackRegistry = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend(extend));
+  }
+  return setHashedExtend(extend, stack);
+};
+var extractArrayExtend = (extend, stack) => {
+  extend.forEach((each) => flattenExtend(each, stack));
+  return stack;
+};
+var deepExtend = (extend, stack) => {
+  const extendOflattenExtend = extend.extend;
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack);
+  }
+  return stack;
+};
+var flattenExtend = (extend, stack) => {
+  if (!extend)
+    return stack;
+  if ((0, import_utils7.isArray)(extend))
+    return extractArrayExtend(extend, stack);
+  stack.push(extend);
+  if (extend.extend)
+    deepExtend(extend, stack);
+  return stack;
+};
+var deepCloneExtend = (obj) => {
+  const o = {};
+  for (const prop in obj) {
+    if (["parent", "node", "__element"].indexOf(prop) > -1)
+      continue;
+    const objProp = obj[prop];
+    if ((0, import_utils7.isObject)(objProp)) {
+      o[prop] = deepCloneExtend(objProp);
+    } else if ((0, import_utils7.isArray)(objProp)) {
+      o[prop] = objProp.map((x) => x);
+    } else
+      o[prop] = objProp;
+  }
+  return o;
+};
+var deepMergeExtend = (element, extend) => {
+  for (const e in extend) {
+    if (["parent", "node", "__element"].indexOf(e) > -1)
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if ((0, import_utils7.isObject)(elementProp) && (0, import_utils7.isObject)(extendProp)) {
+      deepMergeExtend(elementProp, extendProp);
+    } else if ((0, import_utils7.isArray)(elementProp) && (0, import_utils7.isArray)(extendProp)) {
+      element[e] = elementProp.concat(extendProp);
+    } else if ((0, import_utils7.isArray)(elementProp) && (0, import_utils7.isObject)(extendProp)) {
+      const obj = deepMergeExtend({}, elementProp);
+      element[e] = deepMergeExtend(obj, extendProp);
+    } else if (elementProp === void 0 && (0, import_utils7.isFunction)(extendProp)) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+var cloneAndMergeArrayExtend = (stack) => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend(a, deepCloneExtend(c));
+  }, {});
+};
+var replaceStringsWithComponents = (stack, components) => {
+  return stack.map((v) => {
+    if ((0, import_utils7.isString)(v))
+      return components[v];
+    else
+      return v;
+  });
+};
+var jointStacks = (extendStack, childExtendStack) => {
+  return [].concat(extendStack.slice(0, 1)).concat(childExtendStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendStack.slice(1));
+};
+var getExtendStack = (extend) => {
+  if (!extend)
+    return [];
+  if (extend.__hash)
+    return getHashedExtend(extend) || [];
+  const stack = flattenExtend(extend, []);
+  return getExtendStackRegistry(extend, stack);
+};
+
+// src/utils/component.js
+var import_utils8 = __toESM(require_cjs3());
+var ENV = "development";
+var checkIfKeyIsComponent = (key) => {
+  const isFirstKeyString = (0, import_utils8.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, childExtend, childProps } = element;
+  const hasComponentAttrs = extend || childExtend || props || state || 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_utils8.isFunction)(element)) {
+    console.log(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_utils8.exec)(extend, element);
+  if ((0, import_utils8.isString)(execExtend)) {
+    if (components[execExtend])
+      element.extend = components[execExtend];
+    else {
+      if ((ENV === "test" || ENV === "development") && options.verbose) {
+        console.warn(execExtend, "is not in library", components, element);
+        console.warn("replacing with ", {});
+      }
+      element.extend = {};
+    }
+  }
+};
+
+// src/element/cache.js
+var cachedElements = {};
+var createNode = (element) => {
+  const { tag } = element;
+  if (tag) {
+    if (tag === "string")
+      return import_globals4.document.createTextNode(element.text);
+    else if (tag === "fragment") {
+      return import_globals4.document.createDocumentFragment();
+    } else if (tag === "svg" || tag === "path") {
+      return import_globals4.document.createElementNS("http://www.w3.org/2000/svg", tag);
+    } else
+      return import_globals4.document.createElement(tag);
+  } else {
+    return import_globals4.document.createElement("div");
+  }
+};
+var detectTag = (element) => {
+  let { tag, key } = element;
+  tag = (0, import_utils9.exec)(tag, element);
+  if (tag === true)
+    tag = key;
+  if ((0, import_utils9.isString)(tag)) {
+    const tagExists = isTagRegistered(tag) > -1;
+    if (tagExists)
+      return tag;
+  } else {
+    const isKeyATag = isTagRegistered(key) > -1;
+    if (isKeyATag)
+      return key;
+  }
+  return "div";
+};
+var cache_default = (element) => {
+  const tag = element.tag = detectTag(element);
+  if (!can_exports.render(element)) {
+    return (0, import_report4.report)("HTMLInvalidTag");
+  }
+  let cachedTag = cachedElements[tag];
+  if (!cachedTag)
+    cachedTag = cachedElements[tag] = createNode(element);
+  const clonedNode = cachedTag.cloneNode(true);
+  if (tag === "string")
+    clonedNode.nodeValue = element.text;
+  return clonedNode;
+};
+
+// src/element/iterate.js
+var import_utils12 = __toESM(require_cjs3());
+
+// src/element/methods.js
+var import_utils11 = __toESM(require_cjs3());
+var ENV2 = "development";
+var lookup = 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 spotByPath = function(path) {
+  const element = this;
+  const arr = [].concat(path);
+  let active = root_default[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 remove = function(params) {
+  const element = this;
+  if ((0, import_utils11.isFunction)(element.node.remove))
+    element.node.remove();
+  else if (ENV2 === "test" || ENV2 === "development") {
+    console.warn("This item cant be removed");
+    element.log();
+  }
+  delete element.parent[element.key];
+};
+var setProps = function(param, options) {
+  const element = this;
+  if (!param || !element.props)
+    return;
+  element.update({ props: param }, options);
+  return element;
+};
+var keys = function() {
+  const element = this;
+  const keys2 = [];
+  for (const param in element) {
+    if (registry_default[param] && !parseFilters.elementKeys.includes(param)) {
+      continue;
+    }
+    keys2.push(param);
+  }
+  return keys2;
+};
+var parse = function() {
+  const element = this;
+  const obj = {};
+  const keyList = keys.call(element);
+  keyList.forEach((v) => obj[v] = element[v]);
+  return obj;
+};
+var parseDeep = function() {
+  const element = this;
+  const obj = parse.call(element);
+  for (const k in obj) {
+    if ((0, import_utils11.isObjectLike)(obj[k])) {
+      obj[k] = parseDeep.call(obj[k]);
+    }
+  }
+  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 isMethod = function(param) {
+  return param === "set" || param === "update" || param === "remove" || param === "removeContent" || param === "lookup" || param === "spotByPath" || param === "keys" || param === "parse" || param === "setProps" || param === "parseDeep" || param === "if" || param === "log" || param === "nextElement" || param === "previousElement";
+};
+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/iterate.js
+var applyEvents = (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_utils12.isFunction)(appliedFunction)) {
+      node.addEventListener(param, (event) => appliedFunction(event, element, element.state, element.context));
+    }
+  }
+};
+var throughInitialExec = (element) => {
+  const { __ref } = element;
+  const { __exec } = __ref;
+  for (const param in element) {
+    const prop = element[param];
+    if ((0, import_utils12.isFunction)(prop) && !isMethod(param)) {
+      __exec[param] = prop;
+      element[param] = prop(element, element.state);
+    }
+  }
+};
+var throughUpdatedExec = (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_utils12.isString)(newExec) || (0, import_utils12.isNumber)(newExec))) {
+      overwrite(prop, { text: newExec }, options);
+    } else if (newExec !== prop) {
+      __cached[param] = changes[param] = prop;
+      element[param] = newExec;
+    }
+  }
+  return changes;
+};
+var throughInitialDefine = (element) => {
+  const { define, context, __ref } = element;
+  const { __exec, __cached } = __ref;
+  let obj = {};
+  if ((0, import_utils12.isObject)(define))
+    obj = { ...define };
+  if (context && (0, import_utils12.isObject)(context.define))
+    obj = { ...obj, ...context.define };
+  for (const param in obj) {
+    let prop = element[param];
+    if ((0, import_utils12.isFunction)(prop) && !isMethod(param)) {
+      __exec[param] = prop;
+      element[param] = prop = (0, import_utils12.exec)(prop, element);
+    }
+    __cached[param] = prop;
+    element[param] = obj[param](prop, element, element.state);
+  }
+  return element;
+};
+var throughUpdatedDefine = (element) => {
+  const { context, define, __ref } = element;
+  const { __exec, __cached } = __ref;
+  const changes = {};
+  let obj = {};
+  if ((0, import_utils12.isObject)(define))
+    obj = { ...define };
+  if ((0, import_utils12.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_utils12.exec)(__cached[param], element);
+    element[param] = obj[param](cached, element, element.state);
+  }
+  return changes;
+};
+
+// src/element/node.js
+var ENV3 = "development";
+var createNode2 = (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 = cache_default(element);
+    triggerEventOn2("attachNode", element);
+  }
+  if (ENV3 === "test" || ENV3 === "development" || options.alowRefReference) {
+    node.ref = element;
+    if ((0, import_utils14.isFunction)(node.setAttribute))
+      node.setAttribute("key", element.key);
+  }
+  if (!__ref.__if)
+    return element;
+  if (element.tag !== "string" || element.tag !== "fragment") {
+    throughInitialDefine(element);
+    throughInitialExec(element);
+    if (isNewNode && (0, import_utils14.isObject)(element.on))
+      applyEvents(element);
+    for (const param in element) {
+      const prop = element[param];
+      if (isMethod(param) || (0, import_utils14.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_utils14.exec)(prop, element), element, param, options);
+        }
+      }
+    }
+  }
+  return element;
+};
+var node_default = createNode2;
+
+// src/element/assign.js
+var appendNode = (node, parentNode) => {
+  parentNode.appendChild(node);
+  return node;
+};
+var assignNode = (element, parent, key) => {
+  parent[key || element.key] = element;
+  if (element.tag !== "shadow") {
+    appendNode(element.node, parent.node);
+  }
+  return element;
+};
+
+// src/element/extend.js
+var import_utils15 = __toESM(require_cjs3());
+var ENV4 = "development";
+var applyExtend = (element, parent, options = {}) => {
+  if ((0, import_utils15.isFunction)(element))
+    element = (0, import_utils15.exec)(element, parent);
+  let { extend, props, context, __ref } = element;
+  const COMPONENTS = context && context.components || options.components;
+  if ((0, import_utils15.isString)(extend))
+    extend = COMPONENTS[extend];
+  const extendStack = getExtendStack(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 = getExtendStack(parent.childExtend);
+      if (parent.childExtendRecursive) {
+        const childExtendRecursiveStack = getExtendStack(parent.childExtendRecursive);
+        childExtendStack = childExtendStack.concat(childExtendRecursiveStack);
+        element.childExtendRecursive = parent.childExtendRecursive;
+      }
+    }
+  }
+  const extendLength = extendStack.length;
+  const childExtendLength = childExtendStack.length;
+  let stack = [];
+  if (extendLength && childExtendLength) {
+    stack = jointStacks(extendStack, childExtendStack);
+  } else if (extendLength) {
+    stack = extendStack;
+  } else if (childExtendLength) {
+    stack = childExtendStack;
+  } else if (!options.extend)
+    return element;
+  if (options.extend) {
+    const defaultOptionsExtend = getExtendStack(options.extend);
+    stack = [].concat(stack, defaultOptionsExtend);
+  }
+  __ref.__extend = stack;
+  const findAndReplaceStrings = replaceStringsWithComponents(stack, COMPONENTS);
+  let mergedExtend = cloneAndMergeArrayExtend(findAndReplaceStrings);
+  const component = (0, import_utils15.exec)(element.component || mergedExtend.component, element);
+  if (component && COMPONENTS && COMPONENTS[component]) {
+    const componentExtend = cloneAndMergeArrayExtend(getExtendStack(COMPONENTS[component]));
+    mergedExtend = deepMergeExtend(componentExtend, mergedExtend);
+  }
+  return deepMergeExtend(element, mergedExtend);
+};
+
+// src/element/state.js
+var import_utils17 = __toESM(require_cjs3());
+var IGNORE_STATE_PARAMS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__root",
+  "rootUpdate"
+];
+var parseState = function() {
+  const state = this;
+  const parseState2 = {};
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param)) {
+      parseState2[param] = state[param];
+    }
+  }
+  return parseState2;
+};
+var cleanState = function() {
+  const state = this;
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param)) {
+      delete state[param];
+    }
+  }
+  state.update();
+  return state;
+};
+var rootUpdate = function(obj, options = {}) {
+  const state = this;
+  if (!state)
+    return;
+  const rootState = state.__element.__ref.__root.state;
+  return rootState.update(obj, options);
+};
+var updateState = function(obj, options = {}) {
+  const state = this;
+  const element = state.__element;
+  const __elementRef = element.__ref;
+  state.parent = element.parent.state;
+  for (const param in state)
+    if ((0, import_utils17.isUndefined)(state[param]))
+      delete state[param];
+  if (!state.__element)
+    createState(element, element.parent);
+  if (element.on && (0, import_utils17.isFunction)(element.on.initStateUpdated)) {
+    const initReturns = on_exports2.initStateUpdated(element.on.initStateUpdated, element, state, obj);
+    if (initReturns === false)
+      return;
+  }
+  const stateKey = __elementRef.__state;
+  if (stateKey) {
+    console.log(stateKey);
+    if (state.parent && state.parent[stateKey]) {
+      const keyInParentState = state.parent[stateKey];
+      console.log(keyInParentState);
+      if (keyInParentState && !options.stopStatePropogation) {
+        if (__elementRef.__stateType === "string") {
+          return state.parent.update({ [stateKey]: obj.value }, options);
+        }
+        return state.parent.update({ [stateKey]: obj }, options);
+      }
+      console.warn(state.parent);
+    }
+  } else {
+    if (options && options.shallow) {
+      overwriteShallow(state, obj, IGNORE_STATE_PARAMS);
+    } else {
+      overwriteDeep(state, obj, IGNORE_STATE_PARAMS);
+    }
+  }
+  if (!options.preventUpdate) {
+    element.update({}, options);
+  } else if (options.preventUpdate === "recursive") {
+    element.update({}, { ...options, preventUpdate: true });
+  }
+  if (state.__depends) {
+    for (const el in state.__depends) {
+      const findElement = state.__depends[el];
+      findElement.clean().update(state.parse(), options);
+    }
+  }
+  if (!options.preventUpdateListener && element.on && (0, import_utils17.isFunction)(element.on.stateUpdated)) {
+    on_exports2.stateUpdated(element.on.stateUpdated, element, state, obj);
+  }
+  return state;
+};
+var createState = function(element, parent, opts) {
+  const skip = opts && opts.skip ? opts.skip : false;
+  let { state, __ref: __elementRef } = element;
+  if ((0, import_utils17.isFunction)(state))
+    state = (0, import_utils17.exec)(state, element);
+  if ((0, import_utils17.is)(state)("string", "number")) {
+    __elementRef.__state = state;
+    state = {};
+  }
+  if (state === true) {
+    __elementRef.__state = element.key;
+    state = {};
+  }
+  if (!state) {
+    if (parent && parent.state)
+      return parent.state;
+    return {};
+  } else {
+    __elementRef.__hasRootState = true;
+  }
+  triggerEventOn2("stateInit", element);
+  let stateKey = __elementRef.__state;
+  if (stateKey) {
+    let parentState = parent.state;
+    const parentKeysArr = stateKey.split("../");
+    for (let i = 1; i < parentKeysArr.length; i++) {
+      stateKey = parentKeysArr[i];
+      parentState = parentState.parent;
+    }
+    const childrenKeysArr = stateKey.split(".");
+    for (let i = 0; i < childrenKeysArr.length; i++) {
+      const childKey = childrenKeysArr[i];
+      const grandChildKey = childrenKeysArr[i + 1];
+      const childInParent = parentState[childKey];
+      if (childInParent && childInParent[grandChildKey]) {
+        stateKey = grandChildKey;
+        parentState = childInParent;
+      }
+    }
+    if (parentState && parentState[stateKey]) {
+      const keyInParentState = parentState[stateKey];
+      if ((0, import_utils17.is)(keyInParentState)("object", "array")) {
+        state = deepClone(keyInParentState);
+      } else if ((0, import_utils17.is)(keyInParentState)("string", "number")) {
+        state = { value: keyInParentState };
+        __elementRef.__stateType = "string";
+      } else if ((0, import_utils17.isUndefined)(keyInParentState)) {
+        console.warn(stateKey, "is not in present", "replacing with ", {});
+        state = {};
+      }
+    }
+  }
+  const { __ref } = state;
+  if (__ref) {
+    state = deepClone(__ref, IGNORE_STATE_PARAMS);
+    if ((0, import_utils17.isObject)(__ref.__depends)) {
+      __ref.__depends[element.key] = state;
+    } else
+      __ref.__depends = { [element.key]: state };
+  } else {
+    state = deepClone(state, IGNORE_STATE_PARAMS);
+  }
+  element.state = state;
+  if (skip)
+    return state;
+  state.clean = cleanState;
+  state.parse = parseState;
+  state.update = updateState;
+  state.rootUpdate = rootUpdate;
+  state.create = createState;
+  state.parent = element.parent.state;
+  state.__element = element;
+  state.__root = __elementRef.__root ? __elementRef.__root.state : state;
+  triggerEventOn2("stateCreated", element);
+  return state;
+};
+var state_default = createState;
+
+// src/element/props.js
+var import_utils19 = __toESM(require_cjs3());
+var objectizeStringProperty = (propValue) => {
+  if ((0, import_utils19.is)(propValue)("string", "number"))
+    return { inheritedString: propValue };
+  return propValue;
+};
+var inheritParentProps = (element, parent) => {
+  let propsStack = [];
+  const parentProps = (0, import_utils19.exec)(parent, parent.state).props;
+  const matchParent = parent.props && parentProps[element.key];
+  const matchParentIsString = (0, import_utils19.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;
+};
+var createPropsStack = (element, parent) => {
+  const { props, __ref } = element;
+  const propsStack = __ref.__props = inheritParentProps(element, parent);
+  if ((0, import_utils19.isObject)(props))
+    propsStack.push(props);
+  else if (props === "inherit" && parent.props)
+    propsStack.push(parent.props);
+  else if (props)
+    propsStack.push(props);
+  if ((0, import_utils19.isArray)(__ref.__extend)) {
+    __ref.__extend.map((extend) => {
+      if (extend.props)
+        propsStack.push(extend.props);
+      return extend.props;
+    });
+  }
+  __ref.__props = propsStack;
+  return propsStack;
+};
+var syncProps = (props, element) => {
+  element.props = {};
+  const mergedProps = { update, __element: element };
+  props.forEach((v) => {
+    if (v === "update" || v === "__element")
+      return;
+    const execProps = (0, import_utils19.exec)(v, element);
+    if ((0, import_utils19.isObject)(execProps) && execProps.__element)
+      return;
+    element.props = deepMerge(mergedProps, deepClone(execProps));
+  });
+  element.props = mergedProps;
+  return element.props;
+};
+var 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;
+};
+var updateProps = (newProps, element, parent) => {
+  const { __ref } = element;
+  let propsStack = __ref.__props;
+  const parentProps = inheritParentProps(element, parent);
+  if (parentProps)
+    propsStack = __ref.__props = [].concat(parentProps, propsStack);
+  if (newProps)
+    propsStack = __ref.__props = [].concat(newProps, propsStack);
+  if (propsStack)
+    syncProps(propsStack, element);
+  return element;
+};
+function update(props, options) {
+  const element = this.__element;
+  element.update({ props }, options);
+}
+var props_default = createProps;
+
+// src/element/update.js
+var import_globals5 = __toESM(require_cjs());
+var import_utils21 = __toESM(require_cjs3());
+var snapshot = {
+  snapshotId: import_utils21.createSnapshotId
+};
+var UPDATE_DEFAULT_OPTIONS = {
+  stackChanges: false,
+  cleanExec: true,
+  preventRecursive: false,
+  currentSnapshot: false,
+  calleeElement: false
+};
+var update2 = function(params = {}, options = UPDATE_DEFAULT_OPTIONS) {
+  const element = this;
+  const { parent, node, key } = element;
+  let __ref = element.__ref;
+  if (!__ref)
+    __ref = element.__ref = {};
+  const { currentSnapshot, calleeElement } = options;
+  if (!calleeElement) {
+    __ref.__currentSnapshot = snapshot.snapshotId();
+  }
+  const snapshotOnCallee = __ref.__currentSnapshot || calleeElement && calleeElement.__ref && calleeElement.__currentSnapshot;
+  if (snapshotOnCallee && currentSnapshot < snapshotOnCallee) {
+  }
+  if ((0, import_utils21.isString)(params) || (0, import_utils21.isNumber)(params)) {
+    params = { text: params };
+  }
+  if ((0, import_utils21.isFunction)(element.if)) {
+    const ifPassed = element.if(element, element.state);
+    const itWasFalse = __ref.__if !== true;
+    if (ifPassed)
+      __ref.__if = true;
+    if (itWasFalse && ifPassed) {
+      delete element.__hash;
+      delete element.extend;
+      if (!__ref.__hasRootState)
+        delete element.state;
+      if (__ref.__state)
+        element.state = __ref.__state;
+      const created = create_default(element, element.parent, element.key);
+      if (!options.preventUpdate) {
+        if (element.on && (0, import_utils21.isFunction)(element.on.update)) {
+          applyEvent2(element.on.update, created, created.state);
+        }
+      }
+      return created;
+    } else if (element.node && !ifPassed) {
+      element.node.remove();
+      delete __ref.__if;
+    }
+  }
+  if (__ref.__state) {
+    const keyInParentState = parent.state[__ref.__state];
+    if (keyInParentState) {
+      const newState = __ref.__stateType === "string" ? state_default(element, parent) : state_default(element, parent);
+      const changes = (0, import_utils21.diff)(newState.parse(), element.state.parse());
+      if (element.on && (0, import_utils21.isFunction)(element.on.initStateUpdated)) {
+        const initReturns = on_exports2.initStateUpdated(element.on.initStateUpdated, element, element.state, changes);
+        if (initReturns === false)
+          return;
+      }
+      element.state = newState;
+      if (!options.preventUpdateListener && element.on && (0, import_utils21.isFunction)(element.on.stateUpdated)) {
+        on_exports2.stateUpdated(element.on.stateUpdated, element, element.state, changes);
+      }
+    }
+  } else if (!__ref.__hasRootState)
+    element.state = parent && parent.state || {};
+  if (__ref.__if && !options.preventPropsUpdate) {
+    const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
+    updateProps(params.props || hasParentProps && {}, element, parent);
+  }
+  if (element.on && (0, import_utils21.isFunction)(element.on.initUpdate) && !options.ignoreInitUpdate) {
+    const whatinitreturns = on_exports2.initUpdate(element.on.initUpdate, element, element.state);
+    if (whatinitreturns === false)
+      return;
+  }
+  const overwriteChanges = overwrite(element, params, UPDATE_DEFAULT_OPTIONS);
+  const execChanges = throughUpdatedExec(element, UPDATE_DEFAULT_OPTIONS);
+  const definedChanges = throughUpdatedDefine(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" || isMethod(param) || (0, import_utils21.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;
+      if (prop && (0, import_utils21.isObject)(prop) && !hasDefine && !hasContextDefine) {
+        if (!options.preventRecursive) {
+          const childUpdateCall = () => update2.call(prop, params[prop], {
+            ...options,
+            currentSnapshot: snapshotOnCallee,
+            calleeElement: element
+          });
+          if (element.props.lazyLoad || options.lazyLoad) {
+            import_globals5.window.requestAnimationFrame(() => childUpdateCall());
+          } else
+            childUpdateCall();
+        }
+      }
+    }
+  }
+  if (!options.preventUpdate) {
+    triggerEventOn2("update", element);
+  }
+};
+var update_default = update2;
+
+// src/element/options.js
+var options_default = {};
+
+// src/element/create.js
+var ENV5 = "development";
+var create = (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_utils23.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 = root_default;
+  if ((0, import_utils23.isNode)(parent))
+    parent = root_default[`${key}_parent`] = { key: ":root", node: parent };
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent, key);
+  }
+  const assignedKey = (element.key || key || (0, import_utils23.createID)()).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 assignNode(element, parent, assignedKey);
+  }
+  if (__ref.__if)
+    props_default(element, parent);
+  const initReturns = triggerEventOn2("init", element);
+  if (initReturns === false)
+    return element;
+  triggerEventOn2("beforeClassAssign", element);
+  assignClass(element);
+  console.log(element);
+  node_default(element, options);
+  if (!__ref.__if)
+    return element;
+  assignNode(element, parent, key);
+  triggerEventOn2("renderRouter", element);
+  triggerEventOn2("render", element);
+  if (parent.__ref && parent.__ref.__children)
+    parent.__ref.__children.push(element.key);
+  return element;
+};
+var checkIfPrimitive = (element) => {
+  return (0, import_utils23.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 = 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 = remove;
+  element.removeContent = removeContentElement;
+  element.setProps = setProps;
+  element.lookup = lookup;
+  element.spotByPath = spotByPath;
+  element.parse = parse;
+  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 && !root_default.context && !element.context)
+    root_default.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || root_default.context;
+};
+var checkIf = (element, parent) => {
+  const { __ref } = element;
+  if ((0, import_utils23.isFunction)(element.if)) {
+    const ifPassed = element.if(element, element.state);
+    if (!ifPassed) {
+      const ifFragment = cache_default({ tag: "fragment" });
+      __ref.__ifFragment = 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 : parent.__ref.__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 = 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 });
+  throughInitialExec(element);
+  for (const param in element) {
+    const prop = element[param];
+    if (isMethod(param) || (0, import_utils23.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) {
+      create((0, import_utils23.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 = create;
+
+// src/element/set.js
+var set = function(params, options = {}, el) {
+  const element = el || this;
+  const __contentRef = element.content && element.content.__ref;
+  const isEqual = (0, import_utils24.isEqualDeep)(params, element.content);
+  if (isEqual && __contentRef && __contentRef.__cached)
+    return element;
+  removeContentElement(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 = set;
+
+// src/element/mixins/content.js
+var content_default = (param, element, node, options) => {
+  if (param && element) {
+    if (element.$setCollection || element.$setStateCollection || element.$setPropsCollection)
+      return;
+    if (param.__hash === element.content.__hash && element.content.update) {
+      if (!element.content.__ref)
+        element.content.__ref = {};
+      element.content.update(param);
+    } else {
+      set_default.call(element, param, options);
+    }
+  }
+};
+
+// src/element/mixins/data.js
+var import_utils25 = __toESM(require_cjs3());
+var import_report5 = __toESM(require_cjs4());
+var data_default = (params, element, node) => {
+  if (params && params.showOnNode) {
+    if (!(0, import_utils25.isObject)(params))
+      (0, import_report5.report)("HTMLInvalidData", params);
+    for (const dataset in params) {
+      if (dataset !== "showOnNode") {
+        node.dataset[dataset] = (0, import_utils25.exec)(params[dataset], element);
+      }
+    }
+  }
+};
+
+// src/element/mixins/html.js
+var import_utils26 = __toESM(require_cjs3());
+var html_default = (param, element, node) => {
+  const prop = (0, import_utils26.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_utils27 = __toESM(require_cjs3());
+var import_report6 = __toESM(require_cjs4());
+var style_default = (params, element, node) => {
+  if (params) {
+    if ((0, import_utils27.isObject)(params))
+      (0, import_utils27.map)(node.style, params, element);
+    else
+      (0, import_report6.report)("HTMLInvalidStyles", params);
+  }
+};
+
+// src/element/define.js
+var import_report7 = __toESM(require_cjs4());
+
+// src/element/mixins/text.js
+var import_utils28 = __toESM(require_cjs3());
+var text_default = (param, element, node) => {
+  const prop = (0, import_utils28.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_utils29 = __toESM(require_cjs3());
+var state_default2 = (params, element, node) => {
+  const state = (0, import_utils29.exec)(params, element);
+  if ((0, import_utils29.isObject)(state)) {
+    for (const param in state) {
+      if (IGNORE_STATE_PARAMS.includes(param))
+        continue;
+      element.state[param] = (0, import_utils29.exec)(state[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 parseFilters = {
+  elementKeys: [
+    "tag",
+    "text",
+    "style",
+    "attr",
+    "class",
+    "state",
+    "class",
+    "data",
+    "content",
+    "html",
+    "on"
+  ],
+  propsKeys: ["__element"],
+  stateKeys: []
+};
+
+// src/element/applyParam.js
+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_utils30.isFunction)(isGlobalTransformer)) {
+      isGlobalTransformer(prop, element, node, options);
+      return;
+    }
+  }
+  return { hasDefine, hasContextDefine };
+};
+export {
+  applyParam
+};