domql 1.5.136 → 1.6.0

package/dist/esm/element/state.js

@@ -0,0 +1,1209 @@
+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: () => document,
+      global: () => global,
+      self: () => self,
+      window: () => window3
+    });
+    module.exports = __toCommonJS(globals_exports);
+    var global = globalThis;
+    var self = globalThis;
+    var window3 = globalThis;
+    var document = window3.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: () => is2,
+      isArray: () => isArray3,
+      isBoolean: () => isBoolean,
+      isDefined: () => isDefined,
+      isFunction: () => isFunction5,
+      isHtmlElement: () => isHtmlElement,
+      isNode: () => isNode,
+      isNot: () => isNot,
+      isNull: () => isNull,
+      isNumber: () => isNumber,
+      isObject: () => isObject4,
+      isObjectLike: () => isObjectLike2,
+      isString: () => isString3,
+      isUndefined: () => isUndefined2,
+      isValidHtmlTag: () => isValidHtmlTag
+    });
+    module.exports = __toCommonJS(types_exports);
+    var import_globals3 = require_cjs();
+    var import_tags = require_cjs2();
+    var isValidHtmlTag = (arg) => import_tags.HTML_TAGS.body.indexOf(arg);
+    var isObject4 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object" && arg.constructor === Object;
+    };
+    var isString3 = (arg) => typeof arg === "string";
+    var isNumber = (arg) => typeof arg === "number";
+    var isFunction5 = (arg) => typeof arg === "function";
+    var isBoolean = (arg) => arg === true || arg === false;
+    var isNull = (arg) => arg === null;
+    var isArray3 = (arg) => Array.isArray(arg);
+    var isObjectLike2 = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object";
+    };
+    var isNode = (obj) => {
+      return typeof import_globals3.window.Node === "object" ? obj instanceof import_globals3.window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+    };
+    var isHtmlElement = (obj) => {
+      return typeof import_globals3.window.HTMLElement === "object" ? obj instanceof import_globals3.window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
+    };
+    var isDefined = (arg) => {
+      return isObject4(arg) || isObjectLike2(arg) || isString3(arg) || isNumber(arg) || isFunction5(arg) || isArray3(arg) || isObjectLike2(arg) || isBoolean(arg) || isNull(arg);
+    };
+    var isUndefined2 = (arg) => {
+      return arg === void 0;
+    };
+    var TYPES = {
+      boolean: isBoolean,
+      array: isArray3,
+      object: isObject4,
+      string: isString3,
+      number: isNumber,
+      null: isNull,
+      function: isFunction5,
+      objectLike: isObjectLike2,
+      node: isNode,
+      htmlElement: isHtmlElement,
+      defined: isDefined
+    };
+    var is2 = (arg) => {
+      return (...args) => {
+        return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+      };
+    };
+    var isNot = (arg) => {
+      return (...args) => {
+        return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+      };
+    };
+  }
+});
+
+// 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: () => diff,
+      exec: () => exec4,
+      flattenRecursive: () => flattenRecursive,
+      isEqualDeep: () => isEqualDeep,
+      map: () => map,
+      merge: () => merge,
+      mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+      mergeArray: () => mergeArray2,
+      mergeArrayExclude: () => mergeArrayExclude,
+      mergeIfExisted: () => mergeIfExisted,
+      overwrite: () => overwrite,
+      overwriteDeep: () => overwriteDeep2,
+      overwriteObj: () => overwriteObj
+    });
+    module.exports = __toCommonJS(object_exports);
+    var import_globals3 = require_cjs();
+    var import_types = require_types();
+    var exec4 = (param, element, state, context) => {
+      if ((0, import_types.isFunction)(param)) {
+        return param(
+          element,
+          state || element.state,
+          context || element.context
+        );
+      }
+      return param;
+    };
+    var map = (obj, extention, element) => {
+      for (const e in extention) {
+        obj[e] = exec4(extention[e], element);
+      }
+    };
+    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 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_globals3.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_globals3.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 overwrite = (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 diff = (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] = {};
+          diff(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 isEqualDeep = (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 = isEqualDeep(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: () => createID,
+      createSnapshotId: () => createSnapshotId
+    });
+    module.exports = __toCommonJS(node_exports);
+    var cleanWithNode = (extend) => delete extend.node && extend;
+    var createID = function() {
+      let index = 0;
+      function newId() {
+        index++;
+        return index;
+      }
+      return newId;
+    }();
+    var createSnapshotId = createID;
+  }
+});
+
+// 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: () => report2
+    });
+    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 report2 = (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/event/on.js
+var on_exports = {};
+__export(on_exports, {
+  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);
+};
+
+// node_modules/@domql/registry/methods.js
+var import_utils = __toESM(require_cjs3());
+
+// src/event/can.js
+var import_report = __toESM(require_cjs4());
+
+// src/event/is.js
+var import_globals = __toESM(require_cjs());
+
+// node_modules/@domql/event/on.js
+var import_utils2 = __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_utils2.isFunction)(element.on[param])) {
+    return applyEvent(element.on[param], element);
+  }
+};
+
+// node_modules/@domql/event/is.js
+var import_globals2 = __toESM(require_cjs());
+
+// node_modules/@domql/event/index.js
+var triggerEventOn2 = triggerEventOn;
+
+// src/element/state.js
+var import_utils6 = __toESM(require_cjs3());
+
+// src/utils/object.js
+var import_utils3 = __toESM(require_cjs3());
+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_utils3.isObjectLike)(elementProp) && (0, import_utils3.isObject)(extendProp)) {
+      deepMerge(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+var deepClone = (obj, excluding = ["parent", "node", "__element", "state", "context", "extend", "__ref"]) => {
+  const o = (0, import_utils3.isArray)(obj) ? [] : {};
+  for (const prop in obj) {
+    if (excluding.indexOf(prop) > -1)
+      continue;
+    let objProp = obj[prop];
+    if (prop === "extend" && (0, import_utils3.isArray)(objProp)) {
+      objProp = mergeArray(objProp, excluding);
+    }
+    if ((0, import_utils3.isObjectLike)(objProp)) {
+      o[prop] = deepClone(objProp, excluding);
+    } else
+      o[prop] = objProp;
+  }
+  return o;
+};
+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_utils3.isObjectLike)(objProp) && (0, import_utils3.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_utils4 = __toESM(require_cjs3());
+
+// src/utils/component.js
+var import_utils5 = __toESM(require_cjs3());
+
+// src/element/state.js
+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_utils6.isUndefined)(state[param]))
+      delete state[param];
+  if (!state.__element)
+    createState(element, element.parent);
+  if (element.on && (0, import_utils6.isFunction)(element.on.initStateUpdated)) {
+    const initReturns = on_exports.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_utils6.isFunction)(element.on.stateUpdated)) {
+    on_exports.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_utils6.isFunction)(state))
+    state = (0, import_utils6.exec)(state, element);
+  if ((0, import_utils6.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_utils6.is)(keyInParentState)("object", "array")) {
+        state = deepClone(keyInParentState);
+      } else if ((0, import_utils6.is)(keyInParentState)("string", "number")) {
+        state = { value: keyInParentState };
+        __elementRef.__stateType = "string";
+      } else if ((0, import_utils6.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_utils6.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 isState = function(state) {
+  if ((0, import_utils6.is)(state)("object", "array"))
+    return false;
+  if (!state)
+    return false;
+};
+var state_default = createState;
+export {
+  IGNORE_STATE_PARAMS,
+  cleanState,
+  createState,
+  state_default as default,
+  isState,
+  parseState,
+  rootUpdate,
+  updateState
+};