domql 3.2.3 → 3.2.8

package/dist/iife/index.js

@@ -0,0 +1,4720 @@
+"use strict";
+var Domql = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // index.js
+  var index_exports = {};
+  __export(index_exports, {
+    default: () => index_default
+  });
+
+  // ../utils/dist/esm/globals.js
+  var window2 = globalThis;
+  var document2 = window2.document;
+
+  // ../utils/dist/esm/node.js
+  var isNode = (obj) => {
+    return (typeof Node === "object" ? obj instanceof window2.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string") || false;
+  };
+  var isHtmlElement = (obj) => {
+    return (typeof HTMLElement === "object" ? obj instanceof window2.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string") || false;
+  };
+  var isDOMNode = (obj) => {
+    return typeof window2 !== "undefined" && (obj instanceof window2.Node || obj instanceof window2.Window || obj === window2 || obj === document);
+  };
+
+  // ../utils/dist/esm/types.js
+  var isObject = (arg) => {
+    if (arg === null) return false;
+    return typeof arg === "object" && arg.constructor === Object;
+  };
+  var isString = (arg) => typeof arg === "string";
+  var isNumber = (arg) => typeof arg === "number";
+  var isFunction = (arg) => typeof arg === "function";
+  var isBoolean = (arg) => arg === true || arg === false;
+  var isNull = (arg) => arg === null;
+  var isArray = (arg) => Array.isArray(arg);
+  var isDate = (d) => d instanceof Date;
+  var isObjectLike = (arg) => {
+    if (arg === null) return false;
+    return typeof arg === "object";
+  };
+  var isDefined = (arg) => arg !== void 0;
+  var isUndefined = (arg) => arg === void 0;
+  var TYPES = {
+    boolean: isBoolean,
+    array: isArray,
+    object: isObject,
+    string: isString,
+    date: isDate,
+    number: isNumber,
+    null: isNull,
+    function: isFunction,
+    objectLike: isObjectLike,
+    node: isNode,
+    htmlElement: isHtmlElement,
+    defined: isDefined
+  };
+  var is = (arg) => {
+    return (...args) => args.some((val) => TYPES[val](arg));
+  };
+  var isNot = (arg) => {
+    return (...args) => !args.some((val) => TYPES[val](arg));
+  };
+
+  // ../utils/dist/esm/array.js
+  var removeFromArray = (arr, index) => {
+    if (isString(index)) index = parseInt(index);
+    if (isNumber(index)) {
+      if (index < 0 || index >= arr.length || isNaN(index)) {
+        throw new Error("Invalid index");
+      }
+      arr.splice(index, 1);
+    } else {
+      throw new Error("Invalid index");
+    }
+    return arr;
+  };
+  var joinArrays = (...arrays) => {
+    return [].concat(...arrays);
+  };
+  var unstackArrayOfObjects = (arr, exclude = []) => {
+    return arr.reduce(
+      (a, c) => deepMerge(a, deepClone(c, { exclude }), exclude),
+      {}
+    );
+  };
+  var removeValueFromArray = (arr, value) => {
+    const index = arr.indexOf(value);
+    if (index > -1) {
+      const newArray = [...arr];
+      newArray.splice(index, 1);
+      return newArray;
+    }
+    return arr;
+  };
+  var removeDuplicatesInArray = (arr) => {
+    if (!isArray(arr)) return arr;
+    return [...new Set(arr)];
+  };
+  var addProtoToArray = (state2, proto) => {
+    for (const key in proto) {
+      Object.defineProperty(state2, key, {
+        value: proto[key],
+        enumerable: false,
+        // Set this to true if you want the method to appear in for...in loops
+        configurable: true,
+        // Set this to true if you want to allow redefining/removing the property later
+        writable: true
+        // Set this to true if you want to allow changing the function later
+      });
+    }
+  };
+
+  // ../utils/dist/esm/string.js
+  var lowercaseFirstLetter = (inputString) => {
+    return `${inputString.charAt(0).toLowerCase()}${inputString.slice(1)}`;
+  };
+
+  // ../utils/dist/esm/keys.js
+  var DOMQ_PROPERTIES = /* @__PURE__ */ new Set([
+    "attr",
+    "style",
+    "text",
+    "html",
+    "content",
+    "data",
+    "classlist",
+    "state",
+    "scope",
+    "root",
+    "deps",
+    "extend",
+    "extends",
+    "$router",
+    "routes",
+    "children",
+    "childExtend",
+    "childExtends",
+    "childExtendRecursive",
+    "childExtendsRecursive",
+    "props",
+    "if",
+    "define",
+    "__name",
+    "__ref",
+    "__hash",
+    "__text",
+    "key",
+    "tag",
+    "query",
+    "parent",
+    "node",
+    "variables",
+    "on",
+    "component",
+    "context"
+  ]);
+  var PARSED_DOMQ_PROPERTIES = /* @__PURE__ */ new Set([
+    "attr",
+    "style",
+    "text",
+    "html",
+    "content",
+    "data",
+    "class",
+    "state",
+    "scope",
+    "children",
+    "props",
+    "if",
+    "key",
+    "tag",
+    "query",
+    "on",
+    "context"
+  ]);
+  var STATE_METHODS = /* @__PURE__ */ new Set([
+    "update",
+    "parse",
+    "clean",
+    "create",
+    "destroy",
+    "add",
+    "toggle",
+    "remove",
+    "apply",
+    "set",
+    "reset",
+    "replace",
+    "quietReplace",
+    "quietUpdate",
+    "applyReplace",
+    "applyFunction",
+    "keys",
+    "values",
+    "ref",
+    "rootUpdate",
+    "parentUpdate",
+    "parent",
+    "__element",
+    "__depends",
+    "__ref",
+    "__children",
+    "root",
+    "setByPath",
+    "setPathCollection",
+    "removeByPath",
+    "removePathCollection",
+    "getByPath"
+  ]);
+  var PROPS_METHODS = /* @__PURE__ */ new Set(["update", "__element"]);
+  var METHODS = /* @__PURE__ */ new Set([
+    "set",
+    "reset",
+    "update",
+    "remove",
+    "updateContent",
+    "removeContent",
+    "lookup",
+    "lookdown",
+    "lookdownAll",
+    "getRef",
+    "getPath",
+    "setNodeStyles",
+    "spotByPath",
+    "keys",
+    "parse",
+    "setProps",
+    "parseDeep",
+    "variables",
+    "if",
+    "log",
+    "verbose",
+    "warn",
+    "error",
+    "call",
+    "nextElement",
+    "previousElement",
+    "getRootState",
+    "getRoot",
+    "getRootData",
+    "getRootContext",
+    "getContext",
+    "getChildren"
+  ]);
+  var METHODS_EXL = /* @__PURE__ */ new Set([
+    "node",
+    "context",
+    "extends",
+    "__element",
+    "__ref",
+    ...METHODS,
+    ...STATE_METHODS,
+    ...PROPS_METHODS
+  ]);
+  var DOMQL_EVENTS = /* @__PURE__ */ new Set([
+    "init",
+    "beforeClassAssign",
+    "render",
+    "renderRouter",
+    "attachNode",
+    "stateInit",
+    "stateCreated",
+    "beforeStateUpdate",
+    "stateUpdate",
+    "beforeUpdate",
+    "done",
+    "create",
+    "complete",
+    "frame",
+    "update"
+  ]);
+
+  // ../utils/dist/esm/object.js
+  var ENV = process.env.NODE_ENV;
+  var _startsWithDunder = (e) => e.charCodeAt(0) === 95 && e.charCodeAt(1) === 95;
+  var exec = (param, element, state2, context) => {
+    if (isFunction(param)) {
+      if (!element) return;
+      const result = param.call(
+        element,
+        element,
+        state2 || element.state,
+        context || element.context
+      );
+      if (result && typeof result.then === "function") {
+        let resolved;
+        result.then((value) => {
+          resolved = value;
+        });
+        return resolved;
+      }
+      return result;
+    }
+    return param;
+  };
+  var merge = (element, obj, excludeFrom = []) => {
+    const useSet = excludeFrom instanceof Set;
+    for (const e in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, e)) continue;
+      if (_startsWithDunder(e)) continue;
+      if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+      if (element[e] === void 0) {
+        element[e] = obj[e];
+      }
+    }
+    return element;
+  };
+  var deepMerge = (element, extend, excludeFrom = METHODS_EXL) => {
+    const useSet = excludeFrom instanceof Set;
+    for (const e in extend) {
+      if (!Object.prototype.hasOwnProperty.call(extend, e)) continue;
+      if (_startsWithDunder(e)) continue;
+      if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+      const elementProp = element[e];
+      const extendProp = extend[e];
+      if (isObjectLike(elementProp) && isObjectLike(extendProp)) {
+        deepMerge(elementProp, extendProp, excludeFrom);
+      } else if (elementProp === void 0) {
+        element[e] = extendProp;
+      }
+    }
+    return element;
+  };
+  var deepClone = (obj, options = {}) => {
+    const {
+      exclude = [],
+      cleanUndefined = false,
+      cleanNull = false,
+      window: targetWindow,
+      visited = /* @__PURE__ */ new WeakMap(),
+      handleExtends = false
+    } = options;
+    const contentWindow = targetWindow || window2 || globalThis;
+    if (!isObjectLike(obj) || isDOMNode(obj)) {
+      return obj;
+    }
+    if (visited.has(obj)) {
+      return visited.get(obj);
+    }
+    const isArr = isArray(obj);
+    const clone2 = isArr ? [] : {};
+    visited.set(obj, clone2);
+    const excludeSet = exclude instanceof Set ? exclude : exclude.length > 3 ? new Set(exclude) : null;
+    for (const key in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+      if (_startsWithDunder(key) || key === "__proto__") continue;
+      if (excludeSet ? excludeSet.has(key) : exclude.includes(key)) continue;
+      const value = obj[key];
+      if (cleanUndefined && value === void 0) continue;
+      if (cleanNull && value === null) continue;
+      if (isDOMNode(value)) {
+        clone2[key] = value;
+        continue;
+      }
+      if (handleExtends && key === "extends" && isArray(value)) {
+        clone2[key] = unstackArrayOfObjects(value, exclude);
+        continue;
+      }
+      if (isFunction(value) && options.window) {
+        clone2[key] = contentWindow.eval("(" + value.toString() + ")");
+        continue;
+      }
+      if (isObjectLike(value)) {
+        clone2[key] = deepClone(value, {
+          ...options,
+          visited
+        });
+      } else {
+        clone2[key] = value;
+      }
+    }
+    return clone2;
+  };
+  var overwrite = (element, params, opts = {}) => {
+    const excl = opts.exclude || [];
+    const allowUnderscore = opts.preventUnderscore;
+    for (const e in params) {
+      if (excl.includes(e) || !allowUnderscore && _startsWithDunder(e)) continue;
+      if (params[e] !== void 0) {
+        element[e] = params[e];
+      }
+    }
+    return element;
+  };
+  var overwriteShallow = (obj, params, excludeFrom = []) => {
+    const useSet = excludeFrom instanceof Set;
+    for (const e in params) {
+      if (_startsWithDunder(e)) continue;
+      if (useSet ? excludeFrom.has(e) : excludeFrom.includes(e)) continue;
+      obj[e] = params[e];
+    }
+    return obj;
+  };
+  var overwriteDeep = (obj, params, opts = {}, visited = /* @__PURE__ */ new WeakMap()) => {
+    if (!isObjectLike(obj) || !isObjectLike(params) || isDOMNode(obj) || isDOMNode(params)) {
+      return params;
+    }
+    if (visited.has(obj)) return visited.get(obj);
+    visited.set(obj, obj);
+    const excl = opts.exclude;
+    const exclSet = excl ? excl instanceof Set ? excl : new Set(excl) : null;
+    const forcedExclude = !opts.preventForce;
+    for (const e in params) {
+      if (!Object.prototype.hasOwnProperty.call(params, e)) continue;
+      if (exclSet && exclSet.has(e) || forcedExclude && _startsWithDunder(e)) continue;
+      const objProp = obj[e];
+      const paramsProp = params[e];
+      if (isDOMNode(paramsProp)) {
+        obj[e] = paramsProp;
+      } else if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
+        obj[e] = overwriteDeep(objProp, paramsProp, opts, visited);
+      } else if (paramsProp !== void 0) {
+        obj[e] = paramsProp;
+      }
+    }
+    return obj;
+  };
+  var DEEP_CONTAINS_IGNORED = /* @__PURE__ */ new Set(["node", "__ref"]);
+  var deepContains = (obj1, obj2, ignoredKeys = DEEP_CONTAINS_IGNORED) => {
+    if (obj1 === obj2) return true;
+    if (!isObjectLike(obj1) || !isObjectLike(obj2)) return obj1 === obj2;
+    if (isDOMNode(obj1) || isDOMNode(obj2)) return obj1 === obj2;
+    const ignored = ignoredKeys instanceof Set ? ignoredKeys : new Set(ignoredKeys);
+    const visited = /* @__PURE__ */ new WeakSet();
+    function checkContains(target, source) {
+      if (visited.has(source)) return true;
+      visited.add(source);
+      for (const key in source) {
+        if (!Object.prototype.hasOwnProperty.call(source, key)) continue;
+        if (ignored.has(key)) continue;
+        if (!Object.prototype.hasOwnProperty.call(target, key)) return false;
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        if (isDOMNode(sourceValue) || isDOMNode(targetValue)) {
+          if (sourceValue !== targetValue) return false;
+        } else if (isObjectLike(sourceValue) && isObjectLike(targetValue)) {
+          if (!checkContains(targetValue, sourceValue)) return false;
+        } else if (sourceValue !== targetValue) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return checkContains(obj1, obj2);
+  };
+  var removeFromObject = (obj, props) => {
+    if (props === void 0 || props === null) return obj;
+    if (is(props)("string", "number")) {
+      delete obj[props];
+    } else if (isArray(props)) {
+      for (let i = 0; i < props.length; i++) delete obj[props[i]];
+    } else {
+      throw new Error(
+        "Invalid input: props must be a string or an array of strings"
+      );
+    }
+    return obj;
+  };
+  var createNestedObject = (arr, lastValue) => {
+    if (arr.length === 0) return lastValue;
+    const nestedObject = {};
+    let current = nestedObject;
+    for (let i = 0; i < arr.length; i++) {
+      if (i === arr.length - 1 && lastValue) {
+        current[arr[i]] = lastValue;
+      } else {
+        current[arr[i]] = {};
+        current = current[arr[i]];
+      }
+    }
+    return nestedObject;
+  };
+  var removeNestedKeyByPath = (obj, path) => {
+    if (!Array.isArray(path)) {
+      throw new Error("Path must be an array.");
+    }
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+      if (current[path[i]] === void 0) return;
+      current = current[path[i]];
+    }
+    const lastKey = path[path.length - 1];
+    if (current && Object.prototype.hasOwnProperty.call(current, lastKey)) {
+      delete current[lastKey];
+    }
+  };
+  var setInObjectByPath = (obj, path, value) => {
+    if (!Array.isArray(path)) {
+      throw new Error("Path must be an array.");
+    }
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+      if (!current[path[i]] || typeof current[path[i]] !== "object") {
+        current[path[i]] = {};
+      }
+      current = current[path[i]];
+    }
+    current[path[path.length - 1]] = value;
+    return obj;
+  };
+  var getInObjectByPath = (obj, path) => {
+    if (!Array.isArray(path)) {
+      throw new Error("Path must be an array.");
+    }
+    let current = obj;
+    for (let i = 0; i < path.length; i++) {
+      if (current === void 0 || current === null) {
+        return void 0;
+      }
+      current = current[path[i]];
+    }
+    return current;
+  };
+  var detectInfiniteLoop = (arr) => {
+    const maxRepeats = 10;
+    let pattern = [];
+    let repeatCount = 0;
+    for (let i = 0; i < arr.length; i++) {
+      if (pattern.length < 2) {
+        pattern.push(arr[i]);
+      } else {
+        if (arr[i] === pattern[i % 2]) {
+          repeatCount++;
+        } else {
+          pattern = [arr[i - 1], arr[i]];
+          repeatCount = 1;
+        }
+        if (repeatCount >= maxRepeats * 2) {
+          if (ENV === "test" || ENV === "development") {
+            console.warn(
+              "Warning: Potential infinite loop detected due to repeated sequence:",
+              pattern
+            );
+          }
+          return true;
+        }
+      }
+    }
+  };
+
+  // ../utils/dist/esm/key.js
+  var generateKey = /* @__PURE__ */ (function() {
+    let index = 0;
+    function newId() {
+      index++;
+      return index;
+    }
+    return newId;
+  })();
+  var createSnapshotId = generateKey;
+  var createKey = (element, parent, key) => {
+    return (exec(key, element) || key || element.key || generateKey()).toString();
+  };
+
+  // ../utils/dist/esm/env.js
+  var NODE_ENV = process.env.NODE_ENV;
+  var isProduction = (env = NODE_ENV) => env === "production";
+
+  // ../utils/dist/esm/if.js
+  var createIfConditionFlag = (element, parent) => {
+    const { __ref: ref } = element;
+    if (isFunction(element.if) && !element.if(element, element.state, element.context)) {
+      delete ref.__if;
+    } else ref.__if = true;
+  };
+
+  // ../utils/dist/esm/tags.js
+  var HTML_TAGS = {
+    root: ["body", "html"],
+    head: ["title", "base", "meta", "style", "noscript", "script"],
+    body: /* @__PURE__ */ new Set([
+      "string",
+      "style",
+      "fragment",
+      "a",
+      "abbr",
+      "acronym",
+      "address",
+      "applet",
+      "area",
+      "article",
+      "aside",
+      "audio",
+      "b",
+      "basefont",
+      "bdi",
+      "bdo",
+      "big",
+      "blockquote",
+      "br",
+      "button",
+      "canvas",
+      "caption",
+      "center",
+      "cite",
+      "code",
+      "search",
+      "col",
+      "colgroup",
+      "data",
+      "datalist",
+      "dd",
+      "del",
+      "details",
+      "dfn",
+      "dialog",
+      "dir",
+      "div",
+      "dl",
+      "dt",
+      "em",
+      "embed",
+      "fieldset",
+      "figcaption",
+      "figure",
+      "font",
+      "footer",
+      "form",
+      "frame",
+      "frameset",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "head",
+      "header",
+      "hr",
+      "i",
+      "iframe",
+      "img",
+      "input",
+      "ins",
+      "kbd",
+      "label",
+      "legend",
+      "li",
+      "link",
+      "main",
+      "map",
+      "mark",
+      "meter",
+      "nav",
+      "noframes",
+      "noscript",
+      "object",
+      "ol",
+      "optgroup",
+      "option",
+      "output",
+      "p",
+      "param",
+      "picture",
+      "pre",
+      "progress",
+      "hgroup",
+      "q",
+      "rp",
+      "rt",
+      "ruby",
+      "s",
+      "samp",
+      "script",
+      "section",
+      "select",
+      "small",
+      "source",
+      "span",
+      "strike",
+      "strong",
+      "sub",
+      "summary",
+      "sup",
+      "table",
+      "tbody",
+      "td",
+      "template",
+      "hgroup",
+      "textarea",
+      "tfoot",
+      "th",
+      "thead",
+      "time",
+      "tr",
+      "track",
+      "tt",
+      "u",
+      "ul",
+      "var",
+      "video",
+      "wbr",
+      // SVG
+      "svg",
+      "path",
+      "circle",
+      "ellipse",
+      "line",
+      "polygon",
+      "polyline",
+      "rect",
+      "g",
+      "defs",
+      "symbol",
+      "use",
+      "text",
+      "tspan",
+      "image",
+      "clipPath",
+      "mask",
+      "pattern",
+      "marker",
+      "linearGradient",
+      "radialGradient",
+      "stop",
+      "filter",
+      "feGaussianBlur",
+      "feOffset",
+      "feMerge",
+      "feMergeNode",
+      "feBlend",
+      "feColorMatrix",
+      "feFlood",
+      "feComposite",
+      "foreignObject"
+    ])
+  };
+  var SVG_TAGS = /* @__PURE__ */ new Set([
+    "svg",
+    "path",
+    "circle",
+    "ellipse",
+    "line",
+    "polygon",
+    "polyline",
+    "rect",
+    "g",
+    "defs",
+    "symbol",
+    "use",
+    "text",
+    "tspan",
+    "image",
+    "clipPath",
+    "mask",
+    "pattern",
+    "marker",
+    "linearGradient",
+    "radialGradient",
+    "stop",
+    "filter",
+    "feGaussianBlur",
+    "feOffset",
+    "feMerge",
+    "feMergeNode",
+    "feBlend",
+    "feColorMatrix",
+    "feFlood",
+    "feComposite",
+    "foreignObject"
+  ]);
+  var isValidHtmlTag = (arg) => HTML_TAGS.body.has(arg);
+
+  // ../utils/dist/esm/extends.js
+  var ENV2 = process.env.NODE_ENV;
+  var createExtendsFromKeys = (key) => {
+    if (key.includes("+")) {
+      return key.split("+").filter(matchesComponentNaming);
+    }
+    if (key.includes("_")) {
+      const [first] = key.split("_");
+      return [first];
+    }
+    if (key.includes(".") && !matchesComponentNaming(key.split(".")[1])) {
+      const [first] = key.split(".");
+      return [first];
+    }
+    return [key];
+  };
+  var createExtends = (element, parent, key) => {
+    let __extends = [];
+    const keyExtends = createExtendsFromKeys(key);
+    if (keyExtends) __extends = [...keyExtends];
+    const elementExtends = element.extends;
+    if (elementExtends) {
+      __extends = isArray(elementExtends) ? [...__extends, ...elementExtends] : [...__extends, elementExtends];
+    }
+    return __extends;
+  };
+  var addExtends = (newExtends, element) => {
+    const { __ref: ref } = element;
+    let { __extends } = ref;
+    if (!newExtends) return __extends;
+    const variant = element.props?.variant;
+    const context = element.context;
+    if (variant && context?.components && !Array.isArray(newExtends) && typeof newExtends === "string") {
+      const variantKey = `${newExtends}.${variant}`;
+      if (context.components[variantKey]) {
+        newExtends = variantKey;
+      }
+    }
+    if (!__extends.includes(newExtends)) {
+      __extends = Array.isArray(newExtends) ? [...__extends, ...newExtends] : [...__extends, newExtends];
+      ref.__extends = __extends;
+    }
+    return __extends;
+  };
+  var concatAddExtends = (newExtend, element) => {
+    if (!newExtend) return element;
+    const { extends: elementExtend } = element;
+    const originalArray = isArray(elementExtend) ? elementExtend : [elementExtend];
+    const receivedArray = isArray(newExtend) ? newExtend : [newExtend];
+    return {
+      ...element,
+      extends: joinArrays(receivedArray, originalArray)
+    };
+  };
+  var generateHash = () => Math.random().toString(36).substring(2);
+  var extendStackRegistry = {};
+  var getHashedExtend = (extend) => {
+    return extendStackRegistry[extend.__hash];
+  };
+  var setHashedExtend = (extend, stack) => {
+    const hash = generateHash();
+    if (!isString(extend)) {
+      extend.__hash = hash;
+    }
+    if (hash !== "__proto__" && hash !== "constructor" && hash !== "prototype") {
+      extendStackRegistry[hash] = stack;
+    }
+    return stack;
+  };
+  var getExtendsStackRegistry = (extend, stack) => {
+    if (extend.__hash) {
+      return stack.concat(getHashedExtend(extend));
+    }
+    return setHashedExtend(extend, stack);
+  };
+  var extractArrayExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+    for (const each of extend) {
+      if (isArray(each)) {
+        extractArrayExtend(each, stack, context, processed);
+      } else {
+        flattenExtend(each, stack, context, processed);
+      }
+    }
+    return stack;
+  };
+  var deepExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+    const extendOflattenExtend = extend.extends || extend.extend;
+    const cleanExtend = { ...extend };
+    delete cleanExtend.extends;
+    delete cleanExtend.extend;
+    let hasKeys = false;
+    for (const _k in cleanExtend) {
+      hasKeys = true;
+      break;
+    }
+    if (hasKeys) {
+      stack.push(cleanExtend);
+    }
+    if (extendOflattenExtend) {
+      flattenExtend(extendOflattenExtend, stack, context, processed);
+    }
+    return stack;
+  };
+  var flattenExtend = (extend, stack, context, processed = /* @__PURE__ */ new Set()) => {
+    if (!extend) return stack;
+    if (processed.has(extend)) return stack;
+    if (isArray(extend)) {
+      return extractArrayExtend(extend, stack, context, processed);
+    }
+    if (isString(extend)) {
+      extend = mapStringsWithContextComponents(extend, context);
+    }
+    processed.add(extend);
+    if (extend?.extends || extend?.extend) {
+      deepExtend(extend, stack, context, processed);
+    } else if (extend) {
+      stack.push(extend);
+    }
+    return stack;
+  };
+  var MERGE_EXTENDS_SKIP = /* @__PURE__ */ new Set([
+    "parent",
+    "node",
+    "__ref",
+    "__proto__",
+    "extend",
+    "childExtend",
+    "childExtendRecursive"
+  ]);
+  var deepMergeExtends = (element, extend) => {
+    extend = deepClone(extend);
+    for (const e in extend) {
+      if (MERGE_EXTENDS_SKIP.has(e)) continue;
+      const elementProp = element[e];
+      const extendProp = extend[e];
+      if (extendProp === void 0) continue;
+      if (Object.prototype.hasOwnProperty.call(extend, e) && e !== "__proto__" && e !== "constructor" && e !== "prototype") {
+        if (elementProp === void 0) {
+          element[e] = extendProp;
+        } else if (isObject(elementProp) && isObject(extendProp)) {
+          if (matchesComponentNaming(e)) {
+            element[e] = deepMergeExtends(elementProp, extendProp);
+          } else {
+            deepMergeExtends(elementProp, extendProp);
+          }
+        }
+        if (e === "extends" || e === "childExtends" || e === "childExtendsRecursive") {
+          if (isArray(elementProp) && isArray(extendProp)) {
+            element[e] = elementProp.concat(extendProp);
+          } else if (isArray(elementProp) && isObject(extendProp)) {
+            const obj = deepMergeExtends({}, elementProp);
+            element[e] = deepMergeExtends(obj, extendProp);
+          }
+        }
+      }
+    }
+    return element;
+  };
+  var cloneAndMergeArrayExtend = (stack) => {
+    return stack.reduce((acc, current) => {
+      const cloned = deepClone(current);
+      return deepMergeExtends(acc, cloned);
+    }, {});
+  };
+  var mapStringsWithContextComponents = (extend, context, options = {}, variant) => {
+    const COMPONENTS = context?.components || options.components;
+    const PAGES = context?.pages || options.pages;
+    if (isString(extend)) {
+      const componentExists = COMPONENTS && (COMPONENTS[extend + "." + variant] || COMPONENTS[extend] || COMPONENTS["smbls." + extend]);
+      const pageExists = PAGES && extend.charCodeAt(0) === 47 && PAGES[extend];
+      if (componentExists) return componentExists;
+      else if (pageExists) return pageExists;
+      else {
+        if (options.verbose && (ENV2 === "test" || ENV2 === "development")) {
+          console.warn("Extend is string but component was not found:", extend);
+        }
+        return;
+      }
+    }
+    return extend;
+  };
+  var getExtendsStack = (extend, context) => {
+    if (!extend) return [];
+    if (extend.__hash) return getHashedExtend(extend) || [];
+    const processed = /* @__PURE__ */ new Set();
+    const stack = flattenExtend(extend, [], context, processed);
+    return getExtendsStackRegistry(extend, stack);
+  };
+  var createElementExtends = (element, parent, options = {}) => {
+    const { __ref: ref } = element;
+    const context = element.context || parent.context;
+    const variant = element.props?.variant;
+    if (element.extend && !element.extends) element.extends = element.extend;
+    delete element.extend;
+    if (!element.extends && element.props?.extends) element.extends = element.props.extends;
+    if (element.extends) {
+      if (Array.isArray(element.extends) && element.extends.length > 0) {
+        const [firstExtend, ...restExtends] = element.extends;
+        if (typeof firstExtend === "string" && variant && context?.components) {
+          const variantKey = `${firstExtend}.${variant}`;
+          if (context.components[variantKey]) {
+            addExtends([variantKey, ...restExtends], element);
+          } else {
+            addExtends(element.extends, element);
+          }
+        } else {
+          addExtends(element.extends, element);
+        }
+      } else if (typeof element.extends === "string" && variant && context?.components) {
+        const variantKey = `${element.extends}.${variant}`;
+        if (context.components[variantKey]) {
+          addExtends(variantKey, element);
+        } else {
+          addExtends(element.extends, element);
+        }
+      } else {
+        addExtends(element.extends, element);
+      }
+    }
+    inheritChildPropsExtends(element, parent, options);
+    inheritChildExtends(element, parent, options);
+    inheritRecursiveChildExtends(element, parent, options);
+    if (element.component) {
+      addExtends(exec(element.component, element), element);
+    }
+    if (context.defaultExtends) {
+      addExtends(context.defaultExtends, element);
+    }
+    return removeDuplicatesInArray(ref.__extends);
+  };
+  var inheritChildPropsExtends = (element, parent, options = {}) => {
+    const { props, __ref: ref } = element;
+    const ignoreChildExtends = options.ignoreChildExtends || props?.ignoreChildExtends;
+    if (!ignoreChildExtends) {
+      if (parent.props?.childProps?.extends) {
+        addExtends(parent.props?.childProps.extends, element);
+      }
+    }
+    return ref.__extends;
+  };
+  var inheritChildExtends = (element, parent, options = {}) => {
+    const { props, __ref: ref } = element;
+    const ignoreChildExtends = options.ignoreChildExtends || props?.ignoreChildExtends;
+    const childExtends = parent.childExtends || parent.childExtend;
+    if (!ignoreChildExtends && childExtends) {
+      addExtends(childExtends, element);
+    }
+    return ref.__extends;
+  };
+  var inheritRecursiveChildExtends = (element, parent, options = {}) => {
+    const { props, __ref: ref } = element;
+    const childExtendsRecursive = parent.childExtendsRecursive || parent.childExtendRecursive;
+    const ignoreChildExtendsRecursive = options.ignoreChildExtendsRecursive || props?.ignoreChildExtendsRecursive;
+    const isText = element.key === "__text";
+    if (childExtendsRecursive && !isText && !ignoreChildExtendsRecursive) {
+      addExtends(childExtendsRecursive, element);
+    }
+    return ref.__extends;
+  };
+  var createExtendsStack = (element, parent, options = {}) => {
+    const { props, __ref: ref } = element;
+    const context = element.context || parent.context;
+    const variant = element.variant || props?.variant;
+    const __extends = removeDuplicatesInArray(
+      ref.__extends.map((val, i) => {
+        return mapStringsWithContextComponents(
+          val,
+          context,
+          options,
+          i === 0 && variant
+        );
+      })
+    );
+    const stack = getExtendsStack(__extends, context);
+    ref.__extendsStack = stack;
+    return ref.__extendsStack;
+  };
+  var finalizeExtends = (element, parent, options = {}) => {
+    const { __ref: ref } = element;
+    const { __extendsStack } = ref;
+    const flattenExtends = cloneAndMergeArrayExtend(__extendsStack);
+    return deepMergeExtends(element, flattenExtends);
+  };
+  var applyExtends = (element, parent, options = {}) => {
+    createElementExtends(element, parent, options);
+    createExtendsStack(element, parent, options);
+    finalizeExtends(element, parent, options);
+    return element;
+  };
+
+  // ../utils/dist/esm/component.js
+  var matchesComponentNaming = (key) => {
+    if (!isString(key) || !key.length) return false;
+    const code = key.charCodeAt(0);
+    return code >= 65 && code <= 90;
+  };
+  function isContextComponent(element, parent, passedKey) {
+    const { context } = parent || {};
+    const [extendsKey] = createExtendsFromKeys(passedKey);
+    const key = passedKey || extendsKey;
+    return context?.components?.[key] || context?.pages?.[key];
+  }
+
+  // ../utils/dist/esm/events.js
+  function addEventFromProps(key, obj) {
+    const { props, on } = obj;
+    const eventName = lowercaseFirstLetter(key.split("on")[1]);
+    const origEvent = on[eventName];
+    const funcFromProps = props[key];
+    if (isFunction(origEvent)) {
+      on[eventName] = (...args) => {
+        const originalEventRetunrs = origEvent(...args);
+        if (originalEventRetunrs !== false) funcFromProps(...args);
+      };
+    } else on[eventName] = funcFromProps;
+  }
+
+  // ../utils/dist/esm/props.js
+  var RE_UPPER = /^[A-Z]/;
+  var RE_DIGITS = /^\d+$/;
+  var createProps = (element, parent, key) => {
+    const { props, __ref: ref } = element;
+    ref.__propsStack = [];
+    if (props) ref.__initialProps = props;
+    else return {};
+    if (!isObjectLike(props)) {
+      ref.__propsStack.push(props);
+      return {};
+    }
+    return { ...props };
+  };
+  function pickupPropsFromElement(obj, opts = {}) {
+    const cachedKeys = opts.cachedKeys || [];
+    for (const key in obj) {
+      const value = obj[key];
+      const isEventHandler = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key[2] === key[2].toUpperCase() && isFunction(value);
+      if (isEventHandler) {
+        const eventName = lowercaseFirstLetter(key.slice(2));
+        if (obj.on) obj.on[eventName] = value;
+        delete obj[key];
+        continue;
+      }
+      const hasDefine = isObject(this.define?.[key]);
+      const hasGlobalDefine = isObject(this.context?.define?.[key]);
+      const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+      const isBuiltin = DOMQ_PROPERTIES.has(key);
+      if (!isElement && !isBuiltin && !hasDefine && !hasGlobalDefine) {
+        obj.props[key] = value;
+        delete obj[key];
+        cachedKeys.push(key);
+      }
+    }
+    return obj;
+  }
+  function pickupElementFromProps(obj = this, opts) {
+    const cachedKeys = opts.cachedKeys || [];
+    for (const key in obj.props) {
+      const value = obj.props[key];
+      const isEvent = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110;
+      const isFn = isFunction(value);
+      if (isEvent && isFn) {
+        addEventFromProps(key, obj);
+        delete obj.props[key];
+        continue;
+      }
+      if (cachedKeys.includes(key)) continue;
+      const hasDefine = isObject(this.define?.[key]);
+      const hasGlobalDefine = isObject(this.context?.define?.[key]);
+      const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+      const isBuiltin = DOMQ_PROPERTIES.has(key);
+      if (isElement || isBuiltin || hasDefine || hasGlobalDefine) {
+        if (obj[key] === void 0 || value === null) {
+          obj[key] = value;
+          if (obj.props) delete obj.props[key];
+        }
+      }
+    }
+    return obj;
+  }
+  function propertizeElement(element = this) {
+    const cachedKeys = [];
+    pickupPropsFromElement.call(this, element, { cachedKeys });
+    pickupElementFromProps.call(this, element, { cachedKeys });
+    return element;
+  }
+  function propertizeUpdate(params = {}) {
+    if (!params.on) params.on = {};
+    if (!params.props) params.props = {};
+    return propertizeElement.call(this, params);
+  }
+  var objectizeStringProperty = (propValue) => {
+    if (is(propValue)("string", "number")) {
+      return { inheritedString: propValue };
+    }
+    return propValue;
+  };
+  var inheritParentProps = (element, parent) => {
+    const { __ref: ref } = element;
+    const propsStack = ref.__propsStack || [];
+    const parentProps = parent.props;
+    if (!parentProps) return propsStack;
+    const matchParentKeyProps = parentProps[element.key];
+    const matchParentChildProps = parentProps.childProps;
+    const ignoreChildProps = element.props?.ignoreChildProps;
+    if (matchParentChildProps && !ignoreChildProps) {
+      const childProps = objectizeStringProperty(matchParentChildProps);
+      propsStack.unshift(childProps);
+    }
+    if (matchParentKeyProps) {
+      const keyProps = objectizeStringProperty(matchParentKeyProps);
+      propsStack.unshift(keyProps);
+    }
+    return propsStack;
+  };
+  function update(props, options) {
+    const element = this.__element;
+    element.update({ props }, options);
+  }
+  function setPropsPrototype(element) {
+    const methods = { update: update.bind(element.props), __element: element };
+    Object.setPrototypeOf(element.props, methods);
+  }
+  var removeDuplicateProps = (propsStack) => {
+    const seen = /* @__PURE__ */ new Set();
+    return propsStack.filter((prop) => {
+      if (!prop || PROPS_METHODS.has(prop)) return false;
+      if (seen.has(prop)) return false;
+      seen.add(prop);
+      return true;
+    });
+  };
+  var syncProps = (propsStack, element, opts) => {
+    element.props = propsStack.reduce((mergedProps, v) => {
+      if (PROPS_METHODS.has(v)) return mergedProps;
+      while (isFunction(v)) v = exec(v, element);
+      return deepMerge(mergedProps, deepClone(v, { exclude: PROPS_METHODS }));
+    }, {});
+    setPropsPrototype(element);
+    return element.props;
+  };
+  var createPropsStack = (element, parent) => {
+    const { props, __ref: ref } = element;
+    let propsStack = ref.__propsStack || [];
+    if (parent?.props) {
+      const parentStack = inheritParentProps(element, parent);
+      propsStack = [...parentStack];
+    }
+    if (isObject(props)) propsStack.push(props);
+    else if (props === "inherit" && parent?.props) propsStack.push(parent.props);
+    else if (props) propsStack.push(props);
+    if (isArray(ref.__extendsStack)) {
+      for (let i = 0; i < ref.__extendsStack.length; i++) {
+        const _extends = ref.__extendsStack[i];
+        if (_extends.props && _extends.props !== props) {
+          propsStack.push(_extends.props);
+        }
+      }
+    }
+    ref.__propsStack = removeDuplicateProps(propsStack);
+    return ref.__propsStack;
+  };
+  var applyProps = (element, parent) => {
+    const { __ref: ref } = element;
+    const propsStack = createPropsStack(element, parent);
+    if (propsStack.length) {
+      syncProps(propsStack, element);
+    } else {
+      ref.__propsStack = [];
+      element.props = {};
+    }
+  };
+  var initProps = function(element, parent, options) {
+    const { __ref: ref } = element;
+    if (ref.__if) applyProps(element, parent);
+    else {
+      try {
+        applyProps(element, parent);
+      } catch (e) {
+        if (element.context?.designSystem?.verbose) {
+          console.warn("initProps error at", ref.path?.join("."), e);
+        }
+        element.props = {};
+        ref.__propsStack = [];
+      }
+    }
+    setPropsPrototype(element);
+    return element;
+  };
+  var updateProps = (newProps, element, parent) => {
+    const { __ref: ref } = element;
+    const propsStack = ref.__propsStack || [];
+    let newStack = [...propsStack];
+    const parentProps = inheritParentProps(element, parent);
+    if (parentProps.length) {
+      newStack = [...parentProps, ...newStack];
+    }
+    if (newProps) {
+      newStack = [newProps, ...newStack];
+    }
+    ref.__propsStack = removeDuplicateProps(newStack);
+    if (ref.__propsStack.length) {
+      syncProps(ref.__propsStack, element);
+    }
+    return element;
+  };
+
+  // ../utils/dist/esm/element.js
+  var ENV3 = process.env.NODE_ENV;
+  var returnValueAsText = (element, parent, key) => {
+    const childExtendsTag = parent.childExtends && parent.childExtends.tag;
+    const childPropsTag = parent.props.childProps && parent.props.childProps.tag;
+    const isKeyValidHTMLTag = HTML_TAGS.body.has(key) && key;
+    return {
+      text: element,
+      tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || "string"
+    };
+  };
+  var createBasedOnType = (element, parent, key) => {
+    if (element === void 0) {
+      if (ENV3 === "test" || ENV3 === "development") {
+        console.warn(
+          key,
+          "element is undefined in",
+          parent?.__ref?.path
+        );
+      }
+      return {};
+    }
+    if (element === null) return;
+    if (element === true) return {};
+    if (is(element)("string", "number")) {
+      return returnValueAsText(element, parent, key);
+    }
+    if (isFunction(element)) {
+      return { props: element };
+    }
+    return element;
+  };
+  var addRef = (element, parent) => {
+    const ref = {};
+    ref.origin = element;
+    ref.parent = parent;
+    return ref;
+  };
+  var createParent = (element, parent, key, options, root) => {
+    if (!parent) return root;
+    if (isNode(parent)) {
+      const parentNodeWrapper = { key: ":root", node: parent };
+      root[`${key}_parent`] = parentNodeWrapper;
+      return parentNodeWrapper;
+    }
+    return parent;
+  };
+  var createRoot = (element, parent) => {
+    const { __ref: ref } = element;
+    const { __ref: parentRef } = parent;
+    const hasRoot = parent && parent.key === ":root";
+    if (!ref?.root) {
+      ref.root = hasRoot ? element : parentRef?.root;
+    }
+  };
+  var createPath = (element, parent, key) => {
+    let { __ref: parentRef } = parent;
+    if (!parentRef) parentRef = parent.ref = {};
+    if (!parentRef.path) parentRef.path = [];
+    return parentRef.path.concat(key);
+  };
+  var addContext = (element, parent, key, options, root) => {
+    const forcedOptionsContext = options.context && !root.context && !element.context;
+    if (forcedOptionsContext) root.context = options.context;
+    return options.context || parent.context || root.context || element.context;
+  };
+  var addCaching = (element, parent, key) => {
+    const ref = addRef(element, parent);
+    element.__ref = ref;
+    if (!ref.__defineCache) ref.__defineCache = {};
+    if (!ref.__exec) ref.__exec = {};
+    if (!ref.__execProps) ref.__execProps = {};
+    if (!ref.__class) ref.__class = {};
+    if (!ref.__classNames) ref.__classNames = {};
+    if (!ref.__attr) ref.__attr = {};
+    if (!ref.__changes) ref.__changes = [];
+    if (!ref.__children) ref.__children = [];
+    ref.__extends = createExtends(element, parent, key);
+    ref.path = createPath(element, parent, key);
+    return ref;
+  };
+  var createElement = (passedProps, parentEl, passedKey, opts, root) => {
+    const hashed = passedProps?.__hash;
+    const element = hashed ? { extends: [passedProps] } : createBasedOnType(passedProps, parentEl, passedKey);
+    if (!element) return;
+    const parent = createParent(element, parentEl, passedKey, opts, root);
+    const key = createKey(element, parent, passedKey);
+    addCaching(element, parent, key);
+    const props = createProps(element, parent, key);
+    const context = addContext(element, parent, key, opts, root);
+    const on = element.on || {};
+    return {
+      ...element,
+      key,
+      props,
+      parent,
+      context,
+      on
+    };
+  };
+
+  // ../utils/dist/esm/state.js
+  var checkForStateTypes = (element) => {
+    const { state: orig, props, __ref: ref } = element;
+    const state2 = props?.state || orig;
+    if (isFunction(state2)) {
+      ref.__state = state2;
+      return exec(state2, element);
+    } else if (is(state2)("string", "number")) {
+      ref.__state = state2;
+      return { value: state2 };
+    } else if (state2 === true) {
+      ref.__state = element.key;
+      return {};
+    } else if (state2) {
+      ref.__hasRootState = true;
+      return state2;
+    } else {
+      return false;
+    }
+  };
+  var getRootStateInKey = (stateKey, parentState) => {
+    if (!stateKey.includes("~/")) return;
+    const arr = stateKey.split("~/");
+    if (arr.length > 1) return parentState.root;
+  };
+  var getParentStateInKey = (stateKey, parentState) => {
+    if (!stateKey.includes("../")) return;
+    const arr = stateKey.split("../");
+    const arrLength = arr.length - 1;
+    for (let i = 0; i < arrLength; i++) {
+      if (!parentState.parent) return null;
+      parentState = parentState.parent;
+    }
+    return parentState;
+  };
+  var getChildStateInKey = (stateKey, parentState, options = {}) => {
+    const arr = isString(stateKey) ? stateKey.split("/") : [stateKey];
+    const arrLength = arr.length - 1;
+    for (let i = 0; i < arrLength; i++) {
+      const childKey = arr[i];
+      const grandChildKey = arr[i + 1];
+      if (childKey === "__proto__" || grandChildKey === "__proto__") return;
+      let childInParent = parentState[childKey];
+      if (!childInParent) childInParent = parentState[childKey] = {};
+      if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {};
+      stateKey = grandChildKey;
+      parentState = childInParent;
+    }
+    if (options.returnParent) return parentState;
+    return parentState[stateKey];
+  };
+  var findInheritedState = (element, parent, options = {}) => {
+    const ref = element.__ref;
+    let stateKey = ref.__state;
+    if (!checkIfInherits(element)) return;
+    const rootState = getRootStateInKey(stateKey, parent.state);
+    let parentState = parent.state;
+    if (rootState) {
+      parentState = rootState;
+      stateKey = stateKey.replaceAll("~/", "");
+    } else {
+      const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+      if (findGrandParentState) {
+        parentState = findGrandParentState;
+        stateKey = stateKey.replaceAll("../", "");
+      }
+    }
+    if (!parentState) return;
+    return getChildStateInKey(stateKey, parentState, options);
+  };
+  var createInheritedState = (element, parent) => {
+    const ref = element.__ref;
+    const inheritedState = findInheritedState(element, parent);
+    if (inheritedState === void 0) return element.state;
+    if (is(inheritedState)("object", "array")) {
+      return deepClone(inheritedState);
+    } else if (is(inheritedState)("string", "number", "boolean")) {
+      ref.__stateType = typeof inheritedState;
+      return { value: inheritedState };
+    }
+    console.warn(ref.__state, "is not present. Replacing with", {});
+  };
+  var checkIfInherits = (element) => {
+    const { __ref: ref } = element;
+    const stateKey = ref?.__state;
+    if (stateKey && is(stateKey)("number", "string", "boolean")) return true;
+    return false;
+  };
+  var isState = function(state2) {
+    if (!isObjectLike(state2)) return false;
+    return Boolean(
+      state2.update && state2.parse && state2.clean && state2.create && state2.parent && state2.destroy && state2.rootUpdate && state2.parentUpdate && state2.keys && state2.values && state2.toggle && state2.replace && state2.quietUpdate && state2.quietReplace && state2.add && state2.apply && state2.applyReplace && state2.setByPath && state2.setPathCollection && state2.removeByPath && state2.removePathCollection && state2.getByPath && state2.applyFunction && state2.__element && state2.__children
+    );
+  };
+  var createNestedObjectByKeyPath = (path, value) => {
+    if (!path) {
+      return value || {};
+    }
+    const keys3 = path.split("/");
+    const obj = {};
+    let ref = obj;
+    const lastIdx = keys3.length - 1;
+    for (let i = 0; i <= lastIdx; i++) {
+      ref[keys3[i]] = i === lastIdx ? value || {} : {};
+      ref = ref[keys3[i]];
+    }
+    return obj;
+  };
+  var applyDependentState = (element, state2) => {
+    const { __element } = state2;
+    const origState = exec(__element?.state, element);
+    if (!origState) return;
+    const dependentState = deepClone(origState, STATE_METHODS);
+    const newDepends = { [element.key]: dependentState };
+    const __depends = isObject(origState.__depends) ? { ...origState.__depends, ...newDepends } : newDepends;
+    if (Array.isArray(origState)) {
+      addProtoToArray(origState, {
+        ...Object.getPrototypeOf(origState),
+        __depends
+      });
+    } else {
+      Object.setPrototypeOf(origState, {
+        ...Object.getPrototypeOf(origState),
+        __depends
+      });
+    }
+    return dependentState;
+  };
+  var overwriteState = (state2, obj, options = {}) => {
+    const { overwrite: overwrite2 } = options;
+    if (!overwrite2) return;
+    const shallow = overwrite2 === "shallow";
+    const merge2 = overwrite2 === "merge";
+    if (merge2) {
+      deepMerge(state2, obj, STATE_METHODS);
+      return;
+    }
+    const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
+    overwriteFunc(state2, obj, STATE_METHODS);
+  };
+
+  // ../utils/dist/esm/scope.js
+  var createScope = (element, parent) => {
+    const { __ref: ref } = element;
+    if (!element.scope) element.scope = parent.scope || ref.root?.scope || {};
+  };
+
+  // ../utils/dist/esm/triggerEvent.js
+  var getOnOrPropsEvent = (param, element) => {
+    const onEvent = element.on?.[param];
+    if (onEvent) return onEvent;
+    const props = element.props;
+    if (!props) return;
+    const propKey = "on" + param.charAt(0).toUpperCase() + param.slice(1);
+    return props[propKey];
+  };
+  var applyEvent = (param, element, state2, context, options) => {
+    if (!isFunction(param)) return;
+    const result = param.call(
+      element,
+      element,
+      state2 || element.state,
+      context || element.context,
+      options
+    );
+    if (result && typeof result.then === "function") {
+      result.catch(() => {
+      });
+    }
+    return result;
+  };
+  var triggerEventOn = (param, element, options) => {
+    if (!element) {
+      throw new Error("Element is required");
+    }
+    const appliedFunction = getOnOrPropsEvent(param, element);
+    if (appliedFunction) {
+      const { state: state2, context } = element;
+      return applyEvent(appliedFunction, element, state2, context, options);
+    }
+  };
+  var applyEventUpdate = (param, updatedObj, element, state2, context, options) => {
+    if (!isFunction(param)) return;
+    const result = param.call(
+      element,
+      updatedObj,
+      element,
+      state2 || element.state,
+      context || element.context,
+      options
+    );
+    if (result && typeof result.then === "function") {
+      result.catch(() => {
+      });
+    }
+    return result;
+  };
+  var triggerEventOnUpdate = (param, updatedObj, element, options) => {
+    const appliedFunction = getOnOrPropsEvent(param, element);
+    if (appliedFunction) {
+      const { state: state2, context } = element;
+      return applyEventUpdate(
+        appliedFunction,
+        updatedObj,
+        element,
+        state2,
+        context,
+        options
+      );
+    }
+  };
+
+  // ../utils/dist/esm/methods.js
+  var ENV4 = process.env.NODE_ENV;
+  function spotByPath(path) {
+    const element = this;
+    const { __ref: ref } = element;
+    const arr = [].concat(path);
+    let foundelement = ref.root[arr[0]];
+    if (!arr || !arr.length) {
+      return console.log(arr, "on", element.key, "is undefined");
+    }
+    while (foundelement.key === arr[0]) {
+      arr.shift();
+      if (!arr.length) break;
+      foundelement = foundelement[arr[0]];
+      if (!foundelement) return;
+    }
+    return foundelement;
+  }
+  function lookup(param) {
+    const el = this;
+    let { parent } = el;
+    if (isFunction(param)) {
+      if (parent.state && param(parent, parent.state, parent.context)) {
+        return parent;
+      } else if (parent.parent) return parent.lookup(param);
+      else return;
+    }
+    if (el[param]) return el[param];
+    while (parent.param !== param) {
+      if (parent[param]) return parent[param];
+      parent = parent.parent;
+      if (!parent) return;
+    }
+    return parent;
+  }
+  function lookdown(param) {
+    const el = this;
+    const { __ref: ref } = el;
+    const children = ref?.__children;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      const v = children[i];
+      const childElem = el[v];
+      if (v === param) return childElem;
+      else if (isFunction(param)) {
+        const exec2 = param(childElem, childElem.state, childElem.context);
+        if (childElem.state && exec2) {
+          return childElem;
+        }
+      }
+      const lookdown2 = childElem?.lookdown?.(param);
+      if (lookdown2) return lookdown2;
+    }
+  }
+  function lookdownAll(param, results = []) {
+    const el = this;
+    const { __ref: ref } = el;
+    const children = ref?.__children;
+    if (!children) return;
+    for (let i = 0; i < children.length; i++) {
+      const v = children[i];
+      const childElem = el[v];
+      if (v === param) results.push(childElem);
+      else if (isFunction(param)) {
+        const exec2 = param(childElem, childElem.state, childElem.context);
+        if (childElem.state && exec2) results.push(childElem);
+      }
+      childElem?.lookdownAll?.(param, results);
+    }
+    return results.length ? results : void 0;
+  }
+  function setNodeStyles(params = {}) {
+    const el = this;
+    if (!el.node?.style) return;
+    for (const param in params) {
+      const value = params[param];
+      const childElem = el[param];
+      if (isObject(value) && childElem) setNodeStyles.call(childElem, value);
+      else el.node.style[param] = value;
+    }
+    return el;
+  }
+  function remove(opts) {
+    const element = this;
+    const beforeRemoveReturns = triggerEventOn("beforeRemove", element, opts);
+    if (beforeRemoveReturns === false) return element;
+    if (isFunction(element.node.remove)) element.node.remove();
+    else if (!isProduction()) {
+      console.warn("This item cant be removed");
+      element.log();
+    }
+    delete element.parent[element.key];
+    if (element.parent.__ref) {
+      element.parent.__ref.__children = removeValueFromArray(
+        element.parent.__ref.__children,
+        element.key
+      );
+    }
+    triggerEventOn("remove", element, opts);
+  }
+  function setProps(param, options) {
+    const element = this;
+    if (!param || !element.props) return;
+    element.update({ props: param }, options);
+    return element;
+  }
+  function getRef(key) {
+    if (key) return this.__ref && this.__ref[key];
+    return this.__ref;
+  }
+  function getPath() {
+    return this.getRef().path;
+  }
+  function getRootState(param) {
+    let state2 = null;
+    const hasRootState = (obj) => obj.__element && obj.root?.isRootState;
+    if (!this) {
+      state2 = window.platformState || window.smblsApp?.state;
+    } else if (hasRootState(this)) {
+      state2 = this.root;
+    } else if (this.__ref && this.__ref.path) {
+      const hasPlatformState = this.state && hasRootState(this.state);
+      const hasPlatformStateOnParent = isFunction(this.state) && this.parent.state && hasRootState(this.parent.state);
+      if (hasPlatformState || hasPlatformStateOnParent) {
+        state2 = this.state.root || this.parent.state.root;
+      }
+    }
+    if (!state2) {
+      state2 = window.platformState || window.smblsApp?.state;
+    }
+    return param ? state2?.[param] : state2;
+  }
+  function getRoot(key) {
+    const rootElem = this.getRootState()?.__element;
+    return rootElem && Object.keys(rootElem).length > 0 && key ? rootElem[key] : rootElem;
+  }
+  function getRootData(key) {
+    return this.getRoot("data") && Object.keys(this.getRoot("data")).length > 0 && key ? this.getRoot("data")[key] : this.getRoot("data");
+  }
+  function getRootContext(key) {
+    const ctx = this.getRoot()?.context;
+    return key ? ctx[key] : ctx;
+  }
+  function getContext(key) {
+    const ctx = this.context;
+    return key ? ctx[key] : ctx;
+  }
+  function keys() {
+    const element = this;
+    const keys22 = [];
+    for (const param in element) {
+      if (
+        // (REGISTRY[param] && !DOMQ_PROPERTIES.has(param)) ||
+        !Object.prototype.hasOwnProperty.call(element, param) || DOMQ_PROPERTIES.has(param) && !PARSED_DOMQ_PROPERTIES.has(param)
+      ) {
+        continue;
+      }
+      keys22.push(param);
+    }
+    return keys22;
+  }
+  function parse(excl = []) {
+    const element = this;
+    const obj = {};
+    const keyList = keys.call(element);
+    const hasChildren = keyList.includes("children");
+    const exclSet = excl.length ? new Set(excl) : null;
+    for (let i = 0; i < keyList.length; i++) {
+      const v = keyList[i];
+      if (exclSet && exclSet.has(v) || !Object.prototype.hasOwnProperty.call(element, v)) continue;
+      if (hasChildren && v === "content") continue;
+      const val = element[v];
+      if (v === "state") {
+        if (element.__ref && !element.__ref.__hasRootState) continue;
+        const parsedVal = isFunction(val && val.parse) ? val.parse() : val;
+        obj[v] = isFunction(parsedVal) ? parsedVal : JSON.parse(JSON.stringify(parsedVal || {}));
+      } else if (v === "scope") {
+        if (element.__ref && !element.__ref.__hasRootScope) continue;
+        obj[v] = JSON.parse(JSON.stringify(val || {}));
+      } else if (v === "props") {
+        const { __element, update: update3, ...props } = element[v];
+        obj[v] = props;
+      } else if (isDefined(val) && Object.prototype.hasOwnProperty.call(element, v)) {
+        obj[v] = val;
+      }
+    }
+    return obj;
+  }
+  function parseDeep(excl = [], visited = /* @__PURE__ */ new WeakSet()) {
+    const element = this;
+    if (visited.has(element)) return void 0;
+    visited.add(element);
+    const obj = parse.call(element, excl);
+    const exclSet = excl.length ? new Set(excl) : null;
+    for (const v in obj) {
+      if (exclSet && exclSet.has(v) || !Object.prototype.hasOwnProperty.call(element, v)) continue;
+      const val = obj[v];
+      if (Array.isArray(val)) {
+        obj[v] = val.map(
+          (item) => isObjectLike(item) ? parseDeep.call(item, excl, visited) : item
+        );
+      } else if (isObjectLike(val)) {
+        obj[v] = parseDeep.call(val, excl, visited);
+      }
+    }
+    return obj;
+  }
+  function verbose(...args) {
+    if (ENV4 !== "test" && ENV4 !== "development") return;
+    const element = this;
+    const { __ref: ref } = element;
+    console.groupCollapsed(element.key);
+    if (args.length) {
+      args.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+    } else {
+      console.log(ref.path);
+      const keys22 = element.keys();
+      keys22.forEach((v) => console.log(`%c${v}:`, "font-weight: bold", element[v]));
+    }
+    console.log(element);
+    console.groupEnd(element.key);
+    return element;
+  }
+  function log(...params) {
+    if (ENV4 === "test" || ENV4 === "development") {
+      console.log(...params);
+    }
+  }
+  function warn(...params) {
+    if (ENV4 === "test" || ENV4 === "development") {
+      console.warn(...params);
+    }
+  }
+  function error(...params) {
+    if (ENV4 === "test" || ENV4 === "development") {
+      if (params[params.length - 1]?.debugger) debugger;
+      if (params[params.length - 1]?.verbose) verbose.call(this);
+      throw new Error(...params);
+    }
+  }
+  function nextElement() {
+    const element = this;
+    const { key, parent } = element;
+    const { __children } = parent.__ref;
+    const currentIndex = __children.indexOf(key);
+    const nextChild = __children[currentIndex + 1];
+    return parent[nextChild];
+  }
+  function previousElement(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]];
+  }
+  function variables(obj = {}) {
+    const element = this;
+    if (!element.data) element.data = {};
+    if (!element.data.varCaches) element.data.varCaches = {};
+    const varCaches = element.data.varCaches;
+    const changes = {};
+    let changed;
+    for (const key in obj) {
+      if (obj[key] !== varCaches[key]) {
+        changed = true;
+        changes[key] = obj[key];
+      }
+    }
+    return {
+      changed: (cb) => {
+        if (!changed) return;
+        const returns = cb(changes, deepClone(varCaches));
+        for (const key in changes) {
+          varCaches[key] = changes[key];
+        }
+        return returns;
+      },
+      timeout: (cb, timeout) => {
+        if (!changed) return;
+        const t = setTimeout(() => {
+          cb(changes);
+          clearTimeout(t);
+        }, timeout);
+      }
+    };
+  }
+  function call(fnKey, ...args) {
+    const context = this.context;
+    return (context.utils?.[fnKey] || context.functions?.[fnKey] || context.methods?.[fnKey] || context.snippets?.[fnKey])?.call(this, ...args);
+  }
+  function isMethod(param, element) {
+    return Boolean(METHODS.has(param) || element?.context?.methods?.[param]);
+  }
+
+  // ../utils/dist/esm/cache.js
+  var OPTIONS = {};
+
+  // ../utils/dist/esm/update.js
+  var snapshot = {
+    snapshotId: createSnapshotId
+  };
+  var captureSnapshot = (element, options) => {
+    const ref = element.__ref;
+    const { currentSnapshot, calleeElement } = options;
+    const isCallee = calleeElement === element;
+    if (!calleeElement || isCallee) {
+      const createdStanpshot = snapshot.snapshotId();
+      ref.__currentSnapshot = createdStanpshot;
+      return [createdStanpshot, element];
+    }
+    const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
+    if (currentSnapshot < snapshotOnCallee) {
+      return [snapshotOnCallee, calleeElement, true];
+    }
+    return [snapshotOnCallee, calleeElement];
+  };
+
+  // ../../plugins/report/index.js
+  var ERRORS_REGISTRY = {
+    en: {
+      DocumentNotDefined: {
+        title: "Document is undefined",
+        description: "To tweak with DOM, you should use browser."
+      },
+      OverwriteToBuiltin: {
+        title: "Overwriting to builtin method",
+        description: "Overwriting a builtin method in the window define is not possible, please choose different name"
+      },
+      BrowserNotDefined: {
+        title: "Can't recognize environment",
+        description: "Environment should be browser application, that can run Javascript"
+      },
+      SetQuickPreferancesIsNotObject: {
+        title: "Quick preferances object is required",
+        description: 'Please pass a plain object with "lang", "culture" and "area" properties'
+      },
+      InvalidParams: {
+        title: "Params are invalid",
+        description: 'Please pass a plain object with "lang", "culture" and "area" properties'
+      },
+      CantCreateWithoutNode: {
+        title: "You must provide node",
+        description: "Can't create DOM element without setting node or text"
+      },
+      HTMLInvalidTag: {
+        title: "Element tag name (or DOM nodeName) is invalid",
+        description: "To create element, you must provide valid DOM node. See full list of them at here: http://www.w3schools.com/tags/"
+      },
+      HTMLInvalidAttr: {
+        title: "Attibutes object is invalid",
+        description: "Please pass a valid plain object to apply as an attributes for a DOM node"
+      },
+      HTMLInvalidData: {
+        title: "Data object is invalid",
+        description: "Please pass a valid plain object to apply as an dataset for a DOM node"
+      },
+      HTMLInvalidStyles: {
+        title: "Styles object is invalid",
+        description: "Please pass a valid plain object to apply as an style for a DOM node"
+      },
+      HTMLInvalidText: {
+        title: "Text string is invalid",
+        description: "Please pass a valid string to apply text to DOM node"
+      },
+      ElementOnStateIsNotDefined: {
+        title: "Element on state is not defined",
+        description: "Please check the element object"
+      }
+    }
+  };
+  var report = (err, arg, element) => {
+    const currentLang = "en";
+    let errObj;
+    if (err && typeof err === "string") errObj = ERRORS_REGISTRY[currentLang][err];
+    const description = errObj ? `
+
+${errObj.description}` : "";
+    const context = element ? `
+
+${element}` : "";
+    return new Error(`"${err}", "${arg}"${description}${context}`);
+  };
+
+  // ../element/dist/esm/tree.js
+  var ROOT = {
+    key: ":root",
+    node: document2 ? document2.body : report("DocumentNotDefined", document2)
+  };
+  var TREE = ROOT;
+
+  // ../element/dist/esm/event/on.js
+  var getOnOrPropsEvent2 = (param, element) => {
+    const onEvent = element.on?.[param];
+    if (onEvent) return onEvent;
+    const props = element.props;
+    if (!props) return;
+    const propKey = "on" + param.charAt(0).toUpperCase() + param.slice(1);
+    return props[propKey];
+  };
+  var registerNodeEvent = (param, element, node, options) => {
+    const appliedFunction = getOnOrPropsEvent2(param, element);
+    if (isFunction(appliedFunction)) {
+      const { __ref: ref } = element;
+      if (!ref.__eventListeners) ref.__eventListeners = {};
+      if (ref.__eventListeners[param]) {
+        node.removeEventListener(param, ref.__eventListeners[param]);
+      }
+      const handler = (event) => {
+        const { state: state2, context } = element;
+        const result = appliedFunction.call(
+          element,
+          event,
+          element,
+          state2,
+          context,
+          options
+        );
+        if (result && typeof result.then === "function") {
+          result.catch(() => {
+          });
+        }
+      };
+      ref.__eventListeners[param] = handler;
+      node.addEventListener(param, handler);
+    }
+  };
+  var applyEventsOnNode = (element, options) => {
+    const { node, on, props } = element;
+    const handled = /* @__PURE__ */ new Set();
+    for (const param in on) {
+      if (DOMQL_EVENTS.has(param)) continue;
+      handled.add(param);
+      registerNodeEvent(param, element, node, options);
+    }
+    if (props) {
+      for (const key in props) {
+        if (key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && isFunction(props[key])) {
+          const thirdChar = key[2];
+          if (thirdChar !== thirdChar.toUpperCase()) continue;
+          const eventName = thirdChar.toLowerCase() + key.slice(3);
+          if (handled.has(eventName) || DOMQL_EVENTS.has(eventName)) continue;
+          registerNodeEvent(eventName, element, node, options);
+        }
+      }
+    }
+  };
+
+  // ../element/dist/esm/event/can.js
+  var canRenderTag = (tag) => {
+    return isValidHtmlTag(tag || "div") || report("HTMLInvalidTag");
+  };
+
+  // ../element/dist/esm/event/animationFrame.js
+  var registerFrameListener = (el) => {
+    if (!el || !el.__ref) {
+      throw new Error("Element reference is invalid");
+    }
+    const { __ref: ref } = el;
+    if (!ref.root) {
+      throw new Error("Root reference is invalid");
+    }
+    if (!ref.root.data) {
+      throw new Error("Data are undefined");
+    }
+    const { frameListeners } = ref.root.data;
+    if (frameListeners && !frameListeners.has(el)) {
+      frameListeners.add(el);
+    }
+  };
+  var processFrameListeners = (frameListeners) => {
+    for (const element of frameListeners) {
+      if (!element.__ref.__frameHandler) {
+        const handler = element.on?.frame || element.onFrame || element.props?.onFrame;
+        if (handler) element.__ref.__frameHandler = handler;
+        else {
+          frameListeners.delete(element);
+          continue;
+        }
+      }
+      if (!element.node?.parentNode) {
+        frameListeners.delete(element);
+        delete element.__ref.__frameHandler;
+      } else {
+        try {
+          element.__ref.__frameHandler(element, element.state, element.context);
+        } catch (e) {
+          console.warn(e);
+          frameListeners.delete(element);
+          delete element.__ref.__frameHandler;
+        }
+      }
+    }
+  };
+  var startFrameLoop = (frameListeners) => {
+    if (_frameRunning) return;
+    _frameRunning = true;
+    function requestFrame() {
+      if (frameListeners.size === 0) {
+        _frameRunning = false;
+        return;
+      }
+      processFrameListeners(frameListeners);
+      window.requestAnimationFrame(requestFrame);
+    }
+    window.requestAnimationFrame(requestFrame);
+  };
+  var applyAnimationFrame = (element) => {
+    if (!element) {
+      throw new Error("Element is invalid");
+    }
+    const { on, props, __ref: ref } = element;
+    if (!ref.root || !ref.root.data) return;
+    const { frameListeners } = ref.root.data;
+    if (frameListeners && (on?.frame || element.onFrame || props?.onFrame)) {
+      registerFrameListener(element);
+      startFrameLoop(frameListeners);
+    }
+  };
+  var _frameRunning = false;
+
+  // ../element/dist/esm/utils/propEvents.js
+  var propagateEventsFromProps = (element) => {
+    const { props, on } = element;
+    for (const v in props) {
+      if (v.charCodeAt(0) !== 111 || v.charCodeAt(1) !== 110) continue;
+      const eventName = lowercaseFirstLetter(v.slice(2));
+      const origEvent = on[eventName];
+      const funcFromProps = props[v];
+      if (isFunction(origEvent)) {
+        on[eventName] = (...args) => {
+          const originalEventRetunrs = origEvent(...args);
+          if (originalEventRetunrs !== false) return funcFromProps(...args);
+        };
+      } else on[eventName] = funcFromProps;
+    }
+  };
+  var propagateEventsFromElement = (element) => {
+    const { on } = element;
+    for (const param in element) {
+      if (param.charCodeAt(0) !== 111 || param.charCodeAt(1) !== 110 || !Object.prototype.hasOwnProperty.call(element, param)) continue;
+      const fn = element[param];
+      if (!isFunction(fn)) continue;
+      const eventName = lowercaseFirstLetter(param.slice(2));
+      const origEvent = on[eventName];
+      if (isFunction(origEvent)) {
+        on[eventName] = (...args) => {
+          const ret = origEvent(...args);
+          if (ret !== false) return fn(...args);
+        };
+      } else on[eventName] = fn;
+    }
+  };
+
+  // ../element/dist/esm/render/cache.js
+  var SVG_NS = "http://www.w3.org/2000/svg";
+  var createHTMLNode = (element) => {
+    const { tag, context } = element;
+    const doc = context.document || document2;
+    if (tag) {
+      if (tag === "string") return doc.createTextNode(element.text);
+      else if (tag === "fragment") {
+        return doc.createDocumentFragment();
+      } else if (SVG_TAGS.has(tag)) {
+        if (tag === "svg" || element.parent?.node?.namespaceURI === SVG_NS) {
+          return doc.createElementNS(SVG_NS, tag);
+        }
+        return doc.createElement(tag);
+      } else return doc.createElement(tag);
+    } else {
+      return doc.createElement("div");
+    }
+  };
+  var detectTag = (element) => {
+    let { tag, key, props } = element;
+    tag = exec(tag, element);
+    if (tag === true) tag = key;
+    if (isObject(props) && isString(props.tag)) {
+      const tagExists = isValidHtmlTag(props.tag);
+      if (tagExists) return props.tag;
+    }
+    if (isString(tag)) {
+      if (isValidHtmlTag(tag)) return tag;
+    } else {
+      let keyAsTag = key.toLowerCase();
+      if (keyAsTag.includes(".")) keyAsTag = keyAsTag.split(".")[0];
+      if (keyAsTag.includes("_")) keyAsTag = keyAsTag.split("_")[0];
+      if (isValidHtmlTag(keyAsTag)) return keyAsTag;
+    }
+    return "div";
+  };
+  var cacheNode = (element) => {
+    const { context } = element;
+    const win = context.window || window;
+    const tag = element.tag = detectTag(element);
+    if (!canRenderTag(tag)) {
+      return report("HTMLInvalidTag", element.tag, element);
+    }
+    if (!win.nodeCaches) win.nodeCaches = {};
+    const isSvgContext = SVG_TAGS.has(tag) && (tag === "svg" || element.parent?.node?.namespaceURI === SVG_NS);
+    const cacheKey = isSvgContext ? "svg:" + tag : tag;
+    let cachedTag = win.nodeCaches[cacheKey];
+    if (!cachedTag) cachedTag = win.nodeCaches[cacheKey] = createHTMLNode(element);
+    const clonedNode = cachedTag.cloneNode(true);
+    if (tag === "string") clonedNode.nodeValue = element.text;
+    return clonedNode;
+  };
+
+  // ../element/dist/esm/render/append.js
+  var appendNode = (node, parentNode) => {
+    try {
+      parentNode.appendChild(node);
+      return node;
+    } catch (e) {
+      console.error("Does not support to append", parentNode, node);
+    }
+  };
+  var insertNodeAfter = (node, siblingNode, parentNode) => {
+    if (!node) {
+      throw new Error("Node is required");
+    }
+    const parent = parentNode || siblingNode?.parentNode;
+    if (siblingNode?.nextSibling) {
+      parent?.insertBefore(node, siblingNode.nextSibling);
+    } else if (siblingNode?.insertAdjacentElement) {
+      siblingNode.insertAdjacentElement("afterend", node);
+    } else {
+      parent?.insertBefore(node, siblingNode);
+    }
+  };
+  var insertNodeBefore = (node, siblingNode, parentNode) => {
+    if (!node) {
+      throw new Error("Node is required");
+    }
+    const parent = parentNode || siblingNode.parentNode;
+    parent?.insertBefore(node, siblingNode);
+  };
+  var assignNode = (element, parent, key, attachOptions) => {
+    if (!element) {
+      throw new Error("Element is required");
+    }
+    if (!parent) {
+      throw new Error("Parent is required");
+    }
+    parent[key || element.key] = element;
+    if (element.tag !== "shadow") {
+      if (attachOptions && attachOptions.position) {
+        ;
+        (attachOptions.position === "before" ? insertNodeBefore : insertNodeAfter)(element.node, attachOptions.node || parent.node);
+      } else {
+        appendNode(element.node, parent.node, element);
+      }
+    }
+    return element;
+  };
+
+  // ../element/dist/esm/iterate.js
+  var throughInitialExec = (element, exclude = {}) => {
+    const { __ref: ref } = element;
+    for (const param in element) {
+      if (exclude[param]) continue;
+      const prop = element[param];
+      if (isFunction(prop) && !isMethod(param, element)) {
+        ref.__exec[param] = prop;
+        const result = prop(element, element.state, element.context);
+        if (result && typeof result.then === "function") {
+          result.then((resolved) => {
+            element[param] = resolved;
+          });
+        } else {
+          element[param] = result;
+        }
+      }
+    }
+  };
+  var throughUpdatedExec = (element, options = {}) => {
+    const { __ref: ref } = element;
+    const changes = {};
+    for (const param in ref.__exec) {
+      const prop = element[param];
+      const isDefinedParam = ref.__defineCache[param];
+      if (isDefinedParam) continue;
+      const newExec = ref.__exec[param](element, element.state, element.context);
+      if (newExec && typeof newExec.then === "function") {
+        newExec.then((resolved) => {
+          element[param] = resolved;
+        });
+        continue;
+      }
+      const execReturnsString = isString(newExec) || isNumber(newExec);
+      if (prop?.node && execReturnsString) {
+        overwrite(prop, { text: newExec });
+      } else if (newExec !== prop) {
+        if (matchesComponentNaming(param)) {
+          const { extends: extend, ...newElem } = isContextComponent(
+            newExec,
+            element,
+            param
+          );
+          overwrite(prop, newElem);
+        } else {
+          changes[param] = prop;
+          element[param] = newExec;
+        }
+      }
+    }
+    return changes;
+  };
+  var throughExecProps = (element) => {
+    const { __ref: ref } = element;
+    const { props } = element;
+    for (const k in props) {
+      const c0 = k.charCodeAt(0);
+      const c1 = k.charCodeAt(1);
+      const isDefine = c0 === 105 && c1 === 115 || // 'is'
+      c0 === 104 && c1 === 97 && k.charCodeAt(2) === 115 || // 'has'
+      c0 === 117 && c1 === 115 && k.charCodeAt(2) === 101;
+      const cachedExecProp = ref.__execProps[k];
+      if (isFunction(cachedExecProp)) {
+        const result = exec(cachedExecProp, element);
+        if (result && typeof result.then === "function") {
+          result.then((resolved) => {
+            props[k] = resolved;
+          });
+        } else {
+          props[k] = result;
+        }
+      } else if (isDefine && isFunction(props[k])) {
+        ref.__execProps[k] = props[k];
+        const result = exec(props[k], element);
+        if (result && typeof result.then === "function") {
+          result.then((resolved) => {
+            props[k] = resolved;
+          });
+        } else {
+          props[k] = result;
+        }
+      }
+    }
+  };
+  var throughInitialDefine = (element) => {
+    const { define, context, __ref: ref } = element;
+    const hasLocalDefine = isObject(define);
+    const hasGlobalDefine = context && isObject(context.define);
+    if (!hasLocalDefine && !hasGlobalDefine) return element;
+    const defineObj = hasLocalDefine && hasGlobalDefine ? { ...define, ...context.define } : hasLocalDefine ? define : context.define;
+    for (const param in defineObj) {
+      let elementProp = element[param];
+      if (isFunction(elementProp) && !isMethod(param, element)) {
+        ref.__exec[param] = elementProp;
+        let execParam2 = exec(elementProp, element);
+        if (execParam2 && typeof execParam2.then === "function") {
+          execParam2.then((resolved) => {
+            elementProp = element[param] = resolved && resolved.parse ? resolved.parse() : resolved;
+            if (resolved) {
+              ref.__defineCache[param] = elementProp;
+            }
+          });
+        } else {
+          elementProp = element[param] = execParam2 && execParam2.parse ? execParam2.parse() : execParam2;
+          if (execParam2) {
+            ref.__defineCache[param] = elementProp;
+          }
+        }
+      }
+      const execParam = defineObj[param](
+        elementProp,
+        element,
+        element.state,
+        element.context
+      );
+      if (execParam && typeof execParam.then === "function") {
+        execParam.then((resolved) => {
+          if (resolved) element[param] = resolved;
+        });
+      } else if (execParam) {
+        element[param] = execParam;
+      }
+    }
+    return element;
+  };
+  var throughUpdatedDefine = (element) => {
+    const { context, define, __ref: ref } = element;
+    const hasLocalDefine = isObject(define);
+    const hasGlobalDefine = isObject(context?.define);
+    if (!hasLocalDefine && !hasGlobalDefine) return;
+    const obj = hasLocalDefine && hasGlobalDefine ? { ...define, ...context.define } : hasLocalDefine ? define : context.define;
+    for (const param in obj) {
+      const execParam = ref.__exec[param];
+      if (execParam) {
+        const result = execParam(element, element.state, element.context);
+        if (result && typeof result.then === "function") {
+          result.then((resolved) => {
+            ref.__defineCache[param] = resolved;
+          });
+        } else {
+          ref.__defineCache[param] = result;
+        }
+      }
+      const cached = exec(ref.__defineCache[param], element);
+      if (cached && typeof cached.then === "function") {
+        cached.then((resolved) => {
+        });
+        continue;
+      }
+      const newExecParam = typeof obj[param] === "function" ? obj[param](cached, element, element.state, element.context) : void 0;
+      if (newExecParam && typeof newExecParam.then === "function") {
+        newExecParam.then((resolved) => {
+          element[param] = resolved;
+        });
+      } else if (newExecParam) {
+        element[param] = newExecParam;
+      }
+    }
+  };
+
+  // ../element/dist/esm/mixins/attr.js
+  function attr(params, element, node) {
+    const { __ref: ref, props } = element;
+    const { __attr } = ref;
+    if (isNot(params)("object")) report("HTMLInvalidAttr", params);
+    if (params) {
+      const attrs = exec(params, element);
+      if (props.attr) deepMerge(attrs, props.attr);
+      for (const attr2 in attrs) {
+        const val = exec(attrs[attr2], element);
+        if (val === __attr[attr2]) continue;
+        if (val !== false && val !== void 0 && val !== null && node.setAttribute) {
+          node.setAttribute(attr2, val);
+        } else if (node.removeAttribute) node.removeAttribute(attr2);
+        __attr[attr2] = val;
+      }
+    }
+  }
+
+  // ../element/dist/esm/mixins/classList.js
+  var assignKeyAsClassname = (element) => {
+    const { key } = element;
+    if (element.classlist === true) element.classlist = key;
+    else if (!element.classlist && typeof key === "string" && key.charAt(0) === "_" && key.charAt(1) !== "_") {
+      element.classlist = 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 += ` ${exec(param, element)}`;
+      }
+    }
+    return className;
+  };
+  var classList = (params, element) => {
+    if (!params) return;
+    const { key } = element;
+    if (params === true) params = element.classlist = { key };
+    if (isString(params)) params = element.classlist = { default: params };
+    if (isObject(params)) params = classify(params, element);
+    const className = params.replace(/\s+/g, " ").trim();
+    return className;
+  };
+
+  // ../element/dist/esm/mixins/data.js
+  function data(params, element, node) {
+    if (params) {
+      if (element.props.data) deepMerge(params, element.props.data);
+      if (params.showOnNode) {
+        if (!isObject(params)) report("HTMLInvalidData", params);
+        for (const dataset in params) {
+          if (dataset !== "showOnNode") {
+            node.dataset[dataset] = exec(params[dataset], element);
+          }
+        }
+      }
+    }
+  }
+  var data_default = data;
+
+  // ../element/dist/esm/mixins/html.js
+  function html(param, element, node) {
+    const prop = exec(element?.props?.html || param, element);
+    const { __ref } = element;
+    if (prop !== __ref.__html) {
+      if (node.nodeName === "SVG") node.textContent = prop;
+      else node.innerHTML = prop;
+      __ref.__html = prop;
+    }
+  }
+  var html_default = html;
+
+  // ../element/dist/esm/mixins/style.js
+  function style(params, element, node) {
+    if (params) {
+      if (isObject(params)) {
+        const { __ref } = element;
+        if (!__ref.__style) __ref.__style = {};
+        const cache = __ref.__style;
+        for (const prop in params) {
+          const val = exec(params[prop], element);
+          if (val === cache[prop]) continue;
+          cache[prop] = val;
+          node.style[prop] = val;
+        }
+      } else report("HTMLInvalidStyles", params);
+    }
+  }
+  var style_default = style;
+
+  // ../element/dist/esm/mixins/text.js
+  function text(param, element, node) {
+    let prop = exec(element.props.text || param, element);
+    if (isString(prop) && prop.includes("{{")) {
+      prop = element.call("replaceLiteralsWithObjectFields", prop, element.state);
+    }
+    if (element.tag === "string") {
+      node.nodeValue = prop;
+    } else if (param !== void 0 && param !== null) {
+      if (SVG_TAGS.has(element.tag)) {
+        if (node) node.textContent = prop;
+        return;
+      }
+      if (element.__text) {
+        if (element.__text.text === prop) return;
+        element.__text.text = prop;
+        if (element.__text.node) element.__text.node.nodeValue = prop;
+      } else create({ tag: "string", text: prop }, element, "__text");
+    }
+  }
+  var text_default = text;
+
+  // ../element/dist/esm/mixins/state.js
+  function state(params, element, node) {
+    const state2 = exec(params, element);
+    if (isObject(state2)) {
+      for (const param in state2) {
+        if (STATE_METHODS.has(param)) continue;
+        if (!Object.prototype.hasOwnProperty.call(state2, param)) continue;
+      }
+    }
+    return element;
+  }
+  var state_default = state;
+
+  // ../element/dist/esm/mixins/scope.js
+  function scope(params, element, node) {
+    if (!isObject(params)) return;
+    for (const scopeItem in params) {
+      const value = params[scopeItem];
+      if (isFunction(value)) {
+        element.scope[scopeItem] = value.bind(element);
+      } else {
+        element.scope[scopeItem] = value;
+      }
+    }
+  }
+  var scope_default = scope;
+
+  // ../element/dist/esm/mixins/registry.js
+  var REGISTRY = {
+    attr,
+    style: style_default,
+    text: text_default,
+    html: html_default,
+    data: data_default,
+    classlist: classList,
+    state: state_default,
+    scope: scope_default,
+    deps: (param, el) => param || el.parent.deps,
+    extends: {},
+    children: {},
+    content: {},
+    childExtends: {},
+    childExtendsRecursive: {},
+    props: {},
+    if: {},
+    define: {},
+    __name: {},
+    __ref: {},
+    __hash: {},
+    __text: {},
+    key: {},
+    tag: {},
+    query: {},
+    parent: {},
+    node: {},
+    variables: {},
+    on: {},
+    component: {},
+    context: {}
+  };
+
+  // ../element/dist/esm/utils/applyParam.js
+  var applyParam = (param, element, options) => {
+    const { node, context, __ref: ref } = element;
+    const prop = exec(element[param], element);
+    const { onlyUpdate } = options;
+    const DOMQLProperty = REGISTRY[param];
+    const DOMQLPropertyFromContext = context?.registry?.[param];
+    const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
+    const hasDefine = element.define?.[param];
+    const hasContextDefine = context?.define?.[param];
+    if (!ref.__if) return;
+    const hasOnlyUpdate = onlyUpdate ? onlyUpdate === param || element.lookup(onlyUpdate) : true;
+    if (isGlobalTransformer && !hasContextDefine && hasOnlyUpdate) {
+      if (isFunction(isGlobalTransformer)) {
+        isGlobalTransformer(prop, element, node, options);
+      }
+      return;
+    }
+    return { hasDefine, hasContextDefine };
+  };
+
+  // ../element/dist/esm/children.js
+  var shallowChildrenEqual = (a, b) => {
+    if (a === b) return true;
+    if (!a || !b) return false;
+    if (isArray(a) && isArray(b)) {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i]) return false;
+      }
+      return true;
+    }
+    if (isObject(a) && isObject(b)) {
+      const keysA = Object.keys(a);
+      const keysB = Object.keys(b);
+      if (keysA.length !== keysB.length) return false;
+      for (let i = 0; i < keysA.length; i++) {
+        const key = keysA[i];
+        if (a[key] !== b[key]) return false;
+      }
+      return true;
+    }
+    return a === b;
+  };
+  function setChildren(param, element, opts) {
+    let { children, __ref: ref, state: state2 } = element;
+    let { childrenAs } = element.props || {};
+    let execParam = exec(param, element, state2);
+    let execChildren = exec(children, element, state2);
+    children = execParam || execChildren;
+    if (children) {
+      if (isState(children)) children = children.parse();
+      if (isString(children) || isNumber(children)) {
+        if (children === "state") children = state2.parse();
+        else {
+          const pathInState = getChildStateInKey(children, state2);
+          if (pathInState) {
+            childrenAs = "state";
+            children = getChildStateInKey(children, state2) || { value: children };
+          } else {
+            children = { text: children };
+          }
+        }
+      }
+      if (isObject(children)) {
+        if (children.$$typeof) {
+          return element.call("renderReact", children, element);
+        }
+        children = Object.keys(children).map((v) => {
+          const val = children[v];
+          if (matchesComponentNaming(v)) return concatAddExtends(v, val);
+          return val;
+        });
+      }
+    }
+    if (!children || isNot(children)("array", "object")) return;
+    if (isArray(children) && children.some((v) => v?.$$typeof)) {
+      const filterReact = [];
+      const reactComponents = [];
+      for (let i = 0; i < children.length; i++) {
+        if (children[i]?.$$typeof) reactComponents.push(children[i]);
+        else filterReact.push(children[i]);
+      }
+      if (reactComponents.length) {
+        element.call("renderReact", reactComponents, element);
+      }
+      children = filterReact;
+    }
+    let cloned;
+    if (ref.__childrenCache) {
+      if (shallowChildrenEqual(children, ref.__childrenCache)) {
+        ref.__noChildrenDifference = true;
+      } else {
+        cloned = deepClone(children);
+        ref.__childrenCache = cloned;
+        delete ref.__noChildrenDifference;
+      }
+    } else {
+      cloned = deepClone(children);
+      ref.__childrenCache = cloned;
+    }
+    if (isObject(children) || isArray(children)) {
+      children = cloned || deepClone(children);
+    }
+    const content = { tag: "fragment" };
+    for (const key in children) {
+      const value = Object.prototype.hasOwnProperty.call(children, key) && children[key];
+      if (isDefined(value) && value !== null && value !== false) {
+        content[key] = isObjectLike(value) ? childrenAs ? { [childrenAs]: value } : value : childrenAs ? { [childrenAs]: childrenAs === "state" ? { value } : { text: value } } : { text: value };
+      }
+    }
+    return content;
+  }
+  var children_default = setChildren;
+
+  // ../element/dist/esm/set.js
+  var setContentKey = (element, opts = {}) => {
+    const { __ref: ref } = element;
+    const contentElementKey = opts.contentElementKey;
+    if (!ref.contentElementKey || contentElementKey !== ref.contentElementKey) {
+      ref.contentElementKey = contentElementKey || "content";
+    }
+    return ref.contentElementKey;
+  };
+  function reset(options) {
+    const element = this;
+    create(element, element.parent, void 0, {
+      ignoreChildExtends: true,
+      ...OPTIONS.defaultOptions,
+      ...OPTIONS.create,
+      ...options
+    });
+  }
+  var resetContent = (params, element, opts) => {
+    const contentElementKey = setContentKey(element, opts);
+    if (element[contentElementKey]?.node) removeContent(element, opts);
+    const contentElem = create(params, element, contentElementKey || "content", {
+      ignoreChildExtends: true,
+      ...OPTIONS.defaultOptions,
+      ...OPTIONS.create,
+      ...opts
+    });
+    if (contentElementKey !== "content") opts.contentElementKey = "content";
+    return contentElem;
+  };
+  var updateContent = function(params, opts) {
+    const element = this;
+    const contentElementKey = setContentKey(element, opts);
+    if (!element[contentElementKey]) return;
+    if (element[contentElementKey].update) {
+      element[contentElementKey].update(params, opts);
+    }
+  };
+  function setContent(param, element, opts) {
+    const content = exec(param, element);
+    if (content && element) {
+      set.call(element, content, opts);
+    }
+  }
+  var removeContent = function(el, opts = {}) {
+    const element = el || this;
+    const contentElementKey = setContentKey(element, opts);
+    if (opts.contentElementKey !== "content") {
+      opts.contentElementKey = "content";
+    }
+    const content = element[contentElementKey];
+    if (!content) return;
+    if (content.tag === "fragment" && content.__ref?.__children) {
+      const __children = content.__ref.__children;
+      for (let i = 0; i < __children.length; i++) {
+        const child = content[__children[i]];
+        if (child.node && child.node.parentNode) {
+          child.node.parentNode.removeChild(child.node);
+        }
+        if (isFunction(child.remove)) {
+          child.remove();
+        }
+      }
+    } else {
+      if (content.node && content.node.parentNode) {
+        content.node.parentNode.removeChild(content.node);
+      }
+      if (isFunction(content.remove)) {
+        content.remove();
+      }
+    }
+    delete element[contentElementKey];
+  };
+  var set = function(params, options = {}, el) {
+    const element = el || this;
+    const { __ref: ref } = element;
+    const contentElementKey = setContentKey(element, options);
+    const content = element[contentElementKey];
+    const __contentRef = content && content.__ref;
+    const lazyLoad = element.props && element.props.lazyLoad;
+    const hasChildren = element.children;
+    if (options.preventContentUpdate === true && !hasChildren) return;
+    const childHasChanged = !ref.__noChildrenDifference;
+    const childrenIsDifferentFromCache = childHasChanged && __contentRef && Object.keys(params).length === Object.keys(content).length && deepContains(params, content);
+    if (content?.update && !childHasChanged && !childrenIsDifferentFromCache) {
+      if (!options.preventBeforeUpdateListener && !options.preventListeners) {
+        const beforeUpdateReturns = triggerEventOnUpdate(
+          "beforeUpdate",
+          params,
+          element,
+          options
+        );
+        if (beforeUpdateReturns === false) return element;
+      }
+      content.update(params);
+      if (!options.preventUpdateListener && !options.preventListeners) {
+        triggerEventOn("update", element, options);
+      }
+      return;
+    }
+    if (!params) return element;
+    let { childExtends, props, tag } = params;
+    if (!props) props = params.props = {};
+    if (tag === "fragment") {
+      if (!childExtends && element.childExtends) {
+        params.childExtends = element.childExtends;
+        props.ignoreChildExtends = true;
+      }
+      if (!props?.childProps && element.props?.childProps) {
+        props.childProps = element.props.childProps;
+        props.ignoreChildProps = true;
+      }
+    }
+    if (lazyLoad) {
+      window.requestAnimationFrame(() => {
+        resetContent(params, element, options);
+        if (!options.preventUpdateListener) {
+          triggerEventOn("lazyLoad", element, options);
+        }
+      });
+    } else {
+      resetContent(params, element, options);
+    }
+  };
+
+  // ../element/dist/esm/node.js
+  var ENV5 = process.env.NODE_ENV;
+  var createNode = (element, opts) => {
+    let { node, tag, __ref: ref } = element;
+    if (!ref.__if) return element;
+    let isNewNode;
+    if (!node) {
+      isNewNode = true;
+      if (tag === "shadow") {
+        node = element.node = element.parent.node.attachShadow({ mode: "open" });
+      } else node = element.node = cacheNode(element);
+      triggerEventOn("attachNode", element, opts);
+    }
+    if (ENV5 === "test" || ENV5 === "development" || opts.alowRefReference) {
+      node.ref = element;
+      if (isFunction(node.setAttribute)) node.setAttribute("key", element.key);
+    }
+    throughExecProps(element);
+    throughInitialDefine(element);
+    throughInitialExec(element);
+    propagateEventsFromProps(element);
+    propagateEventsFromElement(element);
+    applyEventsOnNode(element, { isNewNode, ...opts });
+    for (const param in element) {
+      const value = element[param];
+      if (!Object.prototype.hasOwnProperty.call(element, param) || value === void 0 || isMethod(param, element) || isObject(REGISTRY[param]) || param.length > 2 && param.charCodeAt(0) === 111 && param.charCodeAt(1) === 110 && param.charCodeAt(2) >= 65 && param.charCodeAt(2) <= 90) {
+        continue;
+      }
+      const isElement = applyParam(param, element, opts);
+      if (isElement) {
+        const { hasDefine, hasContextDefine } = isElement;
+        if (element[param] && !hasDefine && !hasContextDefine) {
+          const createAsync = () => {
+            create(value, element, param, opts);
+          };
+          if (element.props && element.props.lazyLoad || opts.lazyLoad) {
+            window.requestAnimationFrame(() => {
+              createAsync();
+              if (!opts.preventUpdateListener) {
+                triggerEventOn("lazyLoad", element, opts);
+              }
+            });
+          } else createAsync();
+        }
+      }
+    }
+    const content = element.children ? children_default(element.children, element, opts) : element.children || element.content;
+    if (content) {
+      setContent(content, element, opts);
+    }
+    return element;
+  };
+
+  // ../state/dist/esm/updateState.js
+  var STATE_UPDATE_OPTIONS = {
+    overwrite: true,
+    preventHoistElementUpdate: false,
+    updateByState: true,
+    isHoisted: true,
+    execStateFunction: true
+  };
+  var updateState = function(obj, options = STATE_UPDATE_OPTIONS) {
+    const state2 = this;
+    const element = state2.__element;
+    if (options.onEach) options.onEach(element, state2, element.context, options);
+    if (!options.updateByState) merge(options, STATE_UPDATE_OPTIONS);
+    if (!state2.__element) report("ElementOnStateIsNotDefined");
+    if (options.preventInheritAtCurrentState === true) {
+      options.preventInheritAtCurrentState = state2;
+    } else if (options.preventInheritAtCurrentState) return;
+    if (!options.preventBeforeStateUpdateListener) {
+      const beforeStateUpdateReturns = triggerEventOnUpdate(
+        "beforeStateUpdate",
+        obj,
+        element,
+        options
+      );
+      if (beforeStateUpdateReturns === false) return element;
+    }
+    overwriteState(state2, obj, options);
+    const updateIsHoisted = hoistStateUpdate(state2, obj, options);
+    if (updateIsHoisted) return state2;
+    updateDependentState(state2, obj, options);
+    applyElementUpdate(state2, obj, options);
+    if (!options.preventStateUpdateListener) {
+      triggerEventOnUpdate("stateUpdate", obj, element, options);
+    }
+    return state2;
+  };
+  var hoistStateUpdate = (state2, obj, options) => {
+    const element = state2.__element;
+    const { parent, __ref: ref } = element;
+    const stateKey = ref?.__state;
+    const stateType = ref?.__stateType;
+    if (!stateKey) return;
+    const asksForInherit = checkIfInherits(element);
+    const inheritedState = findInheritedState(element, parent, {
+      returnParent: true
+    });
+    const shouldPropagateState = asksForInherit && inheritedState && !options.stopStatePropagation;
+    if (!shouldPropagateState) return;
+    const isStringState = stateType === "string" || stateType === "number" || stateType === "boolean";
+    const value = isStringState ? state2.value : state2.parse();
+    const passedValue = isStringState ? state2.value : obj;
+    const findRootState = getRootStateInKey(stateKey, parent.state);
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    const changesValue = createNestedObjectByKeyPath(stateKey, passedValue);
+    const targetParent = findRootState || findGrandParentState || parent.state;
+    if (options.replace) overwriteDeep(targetParent, changesValue || value);
+    targetParent.update(changesValue, {
+      execStateFunction: false,
+      isHoisted: true,
+      preventUpdate: options.preventHoistElementUpdate,
+      overwrite: !options.replace,
+      ...options
+    });
+    const hasNotUpdated = options.preventUpdate !== true || !options.preventHoistElementUpdate;
+    if (!options.preventStateUpdateListener && hasNotUpdated) {
+      triggerEventOnUpdate("stateUpdate", obj, element, options);
+    }
+    return true;
+  };
+  var updateDependentState = (state2, obj, options) => {
+    if (!state2.__depends) return;
+    for (const el in state2.__depends) {
+      const dependentState = state2.__depends[el];
+      const cleanState = dependentState.clean();
+      cleanState.update(state2.parse(), options);
+    }
+  };
+  var applyElementUpdate = (state2, obj, options) => {
+    const element = state2.__element;
+    if (options.preventUpdate !== true) {
+      element.update(
+        {},
+        {
+          ...options,
+          updateByState: true
+        }
+      );
+    } else if (options.preventUpdate === "recursive") {
+      element.update(
+        {},
+        {
+          ...options,
+          isHoisted: false,
+          updateByState: true,
+          preventUpdate: true
+        }
+      );
+    }
+  };
+
+  // ../state/dist/esm/methods.js
+  var parse2 = function() {
+    const state2 = this;
+    if (isObject(state2)) {
+      const obj = {};
+      for (const param in state2) {
+        if (!STATE_METHODS.has(param)) {
+          obj[param] = state2[param];
+        }
+      }
+      return obj;
+    } else if (isArray(state2)) {
+      return state2.filter((item) => !STATE_METHODS.has(item));
+    }
+  };
+  var clean = function(options = {}) {
+    const state2 = this;
+    for (const param in state2) {
+      if (!STATE_METHODS.has(param) && Object.prototype.hasOwnProperty.call(state2, param)) {
+        delete state2[param];
+      }
+    }
+    if (!options.preventStateUpdate) {
+      state2.update(state2, { replace: true, ...options });
+    }
+    return state2;
+  };
+  var destroy = function(options = {}) {
+    const state2 = this;
+    const element = state2.__element;
+    const stateKey = element.__ref.__state;
+    if (isString(stateKey)) {
+      element.parent.state.remove(stateKey, { isHoisted: true, ...options });
+      return element.state;
+    }
+    delete element.state;
+    element.state = state2.parent;
+    if (state2.parent) {
+      delete state2.parent.__children[element.key];
+    }
+    if (state2.__children) {
+      for (const key in state2.__children) {
+        const child = state2.__children[key];
+        if (child.state) {
+          if (isArray(child.state)) {
+            Object.defineProperty(child.state, "parent", {
+              value: state2.parent,
+              enumerable: false,
+              // Set this to true if you want the method to appear in for...in loops
+              configurable: true,
+              // Set this to true if you want to allow redefining/removing the property later
+              writable: true
+              // Set this to true if you want to allow changing the function later
+            });
+          } else {
+            Object.setPrototypeOf(child, { parent: state2.parent });
+          }
+        }
+      }
+    }
+    element.state.update({}, { isHoisted: true, ...options });
+    return element.state;
+  };
+  var parentUpdate = function(obj, options = {}) {
+    const state2 = this;
+    if (!state2 || !state2.parent) return;
+    return state2.parent.update(obj, { isHoisted: true, ...options });
+  };
+  var rootUpdate = function(obj, options = {}) {
+    const state2 = this;
+    if (!state2) return;
+    const rootState = state2.__element.__ref.root.state;
+    return rootState.update(obj, { isHoisted: false, ...options });
+  };
+  var add = function(value, options = {}) {
+    const state2 = this;
+    if (isArray(state2)) {
+      state2.push(value);
+      state2.update(state2.parse(), { overwrite: true, ...options });
+    } else if (isObject(state2)) {
+      const key = Object.keys(state2).length;
+      state2.update({ [key]: value }, options);
+    }
+  };
+  var toggle = function(key, options = {}) {
+    const state2 = this;
+    state2.update({ [key]: !state2[key] }, options);
+  };
+  var remove2 = function(key, options = {}) {
+    const state2 = this;
+    if (isArray(state2)) removeFromArray(state2, key);
+    else if (isObject(state2)) removeFromObject(state2, key);
+    if (options.applyReset) {
+      return state2.set(state2.parse(), { replace: true, ...options });
+    }
+    return state2.update({}, options);
+  };
+  var set2 = function(val, options = {}) {
+    const state2 = this;
+    const value = deepClone(val);
+    const cleanState = state2.clean({ preventStateUpdate: true, ...options });
+    return cleanState.update(value, { replace: true, ...options });
+  };
+  var setByPath = function(path, val, options = {}) {
+    const state2 = this;
+    const value = deepClone(val);
+    if (!options.preventReplace) setInObjectByPath(state2, path, val);
+    const update3 = createNestedObject(path, value);
+    if (options.preventStateUpdate) return update3;
+    return state2.update(update3, options);
+  };
+  var setPathCollection = function(changes, options = {}) {
+    const state2 = this;
+    const update3 = changes.reduce((acc, change) => {
+      if (change[0] === "update") {
+        const result = setByPath.call(state2, change[1], change[2], {
+          preventStateUpdate: true
+        });
+        return overwriteDeep(acc, result);
+      } else if (change[0] === "delete") {
+        removeByPath.call(state2, change[1], {
+          ...options,
+          preventUpdate: true
+        });
+      }
+      return acc;
+    }, {});
+    return state2.update(update3, options);
+  };
+  var removeByPath = function(path, options = {}) {
+    const state2 = this;
+    removeNestedKeyByPath(state2, path);
+    if (options.preventUpdate) return path;
+    return state2.update({}, options);
+  };
+  var removePathCollection = function(changes, options = {}) {
+    const state2 = this;
+    for (let i = 0; i < changes.length; i++) {
+      removeByPath(changes[i], { preventUpdate: true });
+    }
+    return state2.update({}, options);
+  };
+  var getByPath = function(path, options = {}) {
+    const state2 = this;
+    return getInObjectByPath(state2, path);
+  };
+  var reset2 = function(options = {}) {
+    const state2 = this;
+    const value = deepClone(state2.parse());
+    return state2.set(value, { replace: true, ...options });
+  };
+  var apply = function(func, options = {}) {
+    const state2 = this;
+    if (isFunction(func)) {
+      const value = func(state2);
+      return state2.update(value, { replace: true, ...options });
+    }
+  };
+  var applyReplace = function(func, options = {}) {
+    const state2 = this;
+    if (isFunction(func)) {
+      const value = func(state2);
+      return state2.replace(value, options);
+    }
+  };
+  var applyFunction = function(func, options = {}) {
+    const state2 = this;
+    if (isFunction(func)) {
+      func(state2);
+      return state2.update(state2.parse(), { replace: true, ...options });
+    }
+  };
+  var quietUpdate = function(obj, options = {}) {
+    const state2 = this;
+    return state2.update(obj, { preventUpdate: true, ...options });
+  };
+  var replace = function(obj, options = {}) {
+    const state2 = this;
+    for (const param in obj) {
+      state2[param] = obj[param];
+    }
+    return state2.update(obj, options);
+  };
+  var quietReplace = function(obj, options = {}) {
+    const state2 = this;
+    return state2.replace(obj, { preventUpdate: true, ...options });
+  };
+  var keys2 = function(obj, options = {}) {
+    const state2 = this;
+    return Object.keys(state2);
+  };
+  var values = function(obj, options = {}) {
+    const state2 = this;
+    return Object.values(state2);
+  };
+  var applyStateMethods = (element) => {
+    const state2 = element.state;
+    const ref = element.__ref;
+    const proto = {
+      clean: clean.bind(state2),
+      parse: parse2.bind(state2),
+      destroy: destroy.bind(state2),
+      update: updateState.bind(state2),
+      rootUpdate: rootUpdate.bind(state2),
+      parentUpdate: parentUpdate.bind(state2),
+      create: createState.bind(state2),
+      add: add.bind(state2),
+      toggle: toggle.bind(state2),
+      remove: remove2.bind(state2),
+      apply: apply.bind(state2),
+      applyReplace: applyReplace.bind(state2),
+      applyFunction: applyFunction.bind(state2),
+      set: set2.bind(state2),
+      quietUpdate: quietUpdate.bind(state2),
+      replace: replace.bind(state2),
+      quietReplace: quietReplace.bind(state2),
+      reset: reset2.bind(state2),
+      parent: element.parent?.state || state2,
+      setByPath: setByPath.bind(state2),
+      setPathCollection: setPathCollection.bind(state2),
+      removeByPath: removeByPath.bind(state2),
+      removePathCollection: removePathCollection.bind(state2),
+      getByPath: getByPath.bind(state2),
+      keys: keys2.bind(state2),
+      values: values.bind(state2),
+      __element: element,
+      __children: {},
+      root: ref?.root ? ref.root.state : state2
+    };
+    if (isArray(state2)) {
+      addProtoToArray(state2, proto);
+    } else {
+      Object.setPrototypeOf(state2, proto);
+    }
+    if (state2.parent && state2.parent.__children) {
+      state2.parent.__children[element.key] = state2;
+    }
+  };
+
+  // ../state/dist/esm/create.js
+  var createState = function(element, parent, options) {
+    element.state = applyInitialState(element, parent, options);
+    return element.state;
+  };
+  var applyInitialState = function(element, parent, options) {
+    const objectizeState = checkForStateTypes(element);
+    if (objectizeState === false) return parent.state || {};
+    else element.state = objectizeState;
+    const whatInitReturns = triggerEventOn("stateInit", element, options);
+    if (whatInitReturns === false) return element.state;
+    if (checkIfInherits(element)) {
+      const inheritedState = createInheritedState(element, parent);
+      element.state = isUndefined(inheritedState) ? {} : inheritedState;
+    }
+    const dependentState = applyDependentState(
+      element,
+      element.state || parent.state || {}
+    );
+    if (dependentState) element.state = dependentState;
+    applyStateMethods(element);
+    triggerEventOn("stateCreated", element);
+    return element.state;
+  };
+
+  // ../element/dist/esm/utils/index.js
+  var METHODS_EXL2 = [];
+
+  // ../element/dist/esm/update.js
+  var UPDATE_DEFAULT_OPTIONS = {
+    stackChanges: false,
+    cleanExec: true,
+    preventRecursive: false,
+    currentSnapshot: false,
+    calleeElement: false,
+    exclude: METHODS_EXL2
+  };
+  var update2 = function(params = {}, opts) {
+    const options = isObject(opts) ? { ...UPDATE_DEFAULT_OPTIONS, ...opts } : { ...UPDATE_DEFAULT_OPTIONS };
+    const element = this;
+    let ref = element.__ref;
+    if (!ref) ref = element.__ref = {};
+    const [snapshotOnCallee, calleeElement, snapshotHasUpdated] = captureSnapshot(
+      element,
+      options
+    );
+    if (snapshotHasUpdated) return;
+    if (!options.preventListeners) {
+      triggerEventOnUpdate("startUpdate", params, element, options);
+    }
+    const { parent, node, key } = element;
+    const { exclude, preventInheritAtCurrentState } = options;
+    if (preventInheritAtCurrentState && preventInheritAtCurrentState.__element === element) {
+      return;
+    }
+    if (!exclude) merge(options, UPDATE_DEFAULT_OPTIONS);
+    if (isString(params) || isNumber(params)) {
+      params = { text: params };
+    }
+    params = propertizeUpdate.call(element, params);
+    const inheritState = inheritStateUpdates(element, options);
+    if (inheritState === false) return;
+    const ifFails = checkIfOnUpdate(element, parent, options);
+    if (ifFails) return;
+    if (ref.__if && !options.preventPropsUpdate) {
+      const hasParentProps = parent.props && (parent.props[key] || parent.props.childProps);
+      const hasFunctionInProps = ref.__propsStack.some(isFunction);
+      const props = params.props || hasParentProps || hasFunctionInProps;
+      if (props) updateProps(props, element, parent);
+    }
+    if (!options.preventBeforeUpdateListener && !options.preventListeners) {
+      const hasBeforeUpdate = element.on?.beforeUpdate || element.props?.onBeforeUpdate;
+      if (hasBeforeUpdate) {
+        const simulate = { ...params, ...element };
+        const beforeUpdateReturns = triggerEventOnUpdate(
+          "beforeUpdate",
+          params,
+          simulate,
+          options
+        );
+        if (beforeUpdateReturns === false) return element;
+      }
+    }
+    overwriteDeep(element, params);
+    throughExecProps(element);
+    throughUpdatedExec(element, { ignore: UPDATE_DEFAULT_OPTIONS });
+    throughUpdatedDefine(element);
+    if (!options.isForced && !options.preventListeners) {
+      triggerEventOn("beforeClassAssign", element, options);
+    }
+    if (!ref.__if) return false;
+    if (!node) return;
+    const {
+      preventUpdate,
+      preventDefineUpdate,
+      preventContentUpdate,
+      preventStateUpdate,
+      preventRecursive,
+      preventUpdateListener,
+      preventUpdateAfter,
+      preventUpdateAfterCount
+    } = options;
+    if (preventUpdateAfter) {
+      if (isNumber(preventUpdateAfterCount) && preventUpdateAfter <= preventUpdateAfterCount) {
+        return;
+      } else if (options.preventUpdateAfterCount === void 0) {
+        options.preventUpdateAfterCount = 1;
+      } else options.preventUpdateAfterCount++;
+    }
+    const preventUpdateSet = isArray(preventUpdate) ? new Set(preventUpdate) : null;
+    const preventDefineUpdateSet = isArray(preventDefineUpdate) ? new Set(preventDefineUpdate) : null;
+    for (const param in element) {
+      const prop = element[param];
+      if (!Object.prototype.hasOwnProperty.call(element, param)) continue;
+      const isInPreventUpdate = preventUpdateSet && preventUpdateSet.has(param);
+      const isInPreventDefineUpdate = preventDefineUpdateSet && preventDefineUpdateSet.has(param);
+      const isRootEventHandler = isFunction(prop) && param.length > 2 && param.charCodeAt(0) === 111 && param.charCodeAt(1) === 110 && // 'on'
+      param.charCodeAt(2) >= 65 && param.charCodeAt(2) <= 90;
+      if (isUndefined(prop) || isInPreventUpdate || isInPreventDefineUpdate || preventDefineUpdate === true || preventDefineUpdate === param || preventStateUpdate && param === "state" || isMethod(param, element) || isRootEventHandler || isObject(REGISTRY[param])) {
+        continue;
+      }
+      if (preventStateUpdate === "once") options.preventStateUpdate = false;
+      const isElement = applyParam(param, element, options);
+      if (isElement) {
+        const { hasDefine, hasContextDefine } = isElement;
+        const canUpdate = isObject(prop) && !hasDefine && !hasContextDefine && !preventRecursive;
+        if (!canUpdate) continue;
+        const lazyLoad = element.props.lazyLoad || options.lazyLoad;
+        if (options.onEachUpdate) {
+          options.onEachUpdate(param, element, element.state, element.context);
+        }
+        const childParams = params[param];
+        if (childParams === void 0 && !options.isForced) continue;
+        const childUpdateCall = () => update2.call(prop, childParams, {
+          ...options,
+          currentSnapshot: snapshotOnCallee,
+          calleeElement
+        });
+        if (lazyLoad) {
+          window2.requestAnimationFrame(() => {
+            childUpdateCall();
+            if (!options.preventUpdateListener && !options.preventListeners) {
+              triggerEventOn("lazyLoad", element, options);
+            }
+          });
+        } else childUpdateCall();
+      }
+    }
+    if (!preventContentUpdate) {
+      const contentKey = ref.contentElementKey || "content";
+      const existingContent = element[contentKey];
+      const childrenProp = params.children || element.children;
+      if (childrenProp) {
+        const content = children_default(childrenProp, element, opts);
+        if (content && !ref.__noChildrenDifference) {
+          setContent(content, element, options);
+        } else if (existingContent?.__ref && isFunction(existingContent.update)) {
+          const lazyLoad = element.props?.lazyLoad || options.lazyLoad;
+          const contentUpdateCall = () => update2.call(existingContent, params[contentKey], {
+            ...options,
+            currentSnapshot: snapshotOnCallee,
+            calleeElement
+          });
+          if (lazyLoad) {
+            window2.requestAnimationFrame(() => {
+              contentUpdateCall();
+              if (!options.preventUpdateListener && !options.preventListeners) {
+                triggerEventOn("lazyLoad", element, options);
+              }
+            });
+          } else contentUpdateCall();
+        }
+      } else if (existingContent?.__ref && isFunction(existingContent.update)) {
+        const lazyLoad = element.props?.lazyLoad || options.lazyLoad;
+        const contentUpdateCall = () => update2.call(existingContent, params[contentKey], {
+          ...options,
+          currentSnapshot: snapshotOnCallee,
+          calleeElement
+        });
+        if (lazyLoad) {
+          window2.requestAnimationFrame(() => {
+            contentUpdateCall();
+            if (!options.preventUpdateListener && !options.preventListeners) {
+              triggerEventOn("lazyLoad", element, options);
+            }
+          });
+        } else contentUpdateCall();
+      } else {
+        const content = element.children || params.content;
+        if (content) {
+          setContent(content, element, options);
+        }
+      }
+    }
+    if (!preventUpdateListener && !options.preventListeners) {
+      triggerEventOn("update", element, options);
+    }
+  };
+  var checkIfOnUpdate = (element, parent, options) => {
+    if (!isFunction(element.if) && !isFunction(element.props?.if) || !parent) {
+      return;
+    }
+    const ref = element.__ref;
+    const ifPassed = (element.if || element.props?.if)(
+      element,
+      element.state,
+      element.context,
+      options
+    );
+    const itWasFalse = ref.__if !== true;
+    if (ifPassed) {
+      ref.__if = true;
+      if (itWasFalse) {
+        delete element.__hash;
+        delete element.__text;
+        delete element.extends;
+        if (!ref.__hasRootState) {
+          delete element.state;
+        }
+        if (ref.__state) {
+          element.state = ref.__state;
+        } else if (!ref.__hasRootState) {
+          delete element.state;
+        }
+        if (element.node) {
+          element.node.remove();
+          delete element.node;
+        }
+        const contentKey = ref.contentElementKey;
+        if (element.children) {
+          element.removeContent();
+        } else if (element[contentKey]?.parseDeep) {
+          element[contentKey] = element[contentKey].parseDeep();
+        }
+        const previousElement2 = element.previousElement();
+        const previousNode = previousElement2?.node;
+        const hasPrevious = previousNode?.parentNode;
+        const nextElement2 = element.nextElement();
+        const nextNode = nextElement2?.node;
+        const hasNext = nextNode?.parentNode;
+        const attachOptions = (hasPrevious || hasNext) && {
+          position: hasPrevious ? "after" : hasNext ? "before" : null,
+          node: hasPrevious && previousNode || hasNext && nextNode
+        };
+        delete element.__ref;
+        delete element.parent;
+        const createdElement = create(
+          element,
+          parent,
+          element.key,
+          OPTIONS.create,
+          attachOptions
+        );
+        if (options.preventUpdate !== true && element.on && isFunction(element.on.update)) {
+          applyEvent(element.on.update, createdElement, createdElement.state);
+        }
+        return createdElement;
+      }
+    } else if (element.node && !ifPassed) {
+      element.node.remove();
+      delete ref.__if;
+    }
+  };
+  var inheritStateUpdates = (element, options) => {
+    const { __ref: ref } = element;
+    const stateKey = ref.__state;
+    const { parent, state: state2 } = element;
+    const { preventUpdateTriggerStateUpdate, isHoisted, execStateFunction } = options;
+    if (preventUpdateTriggerStateUpdate) return;
+    if (!stateKey && !ref.__hasRootState) {
+      element.state = parent?.state || {};
+      return;
+    }
+    const shouldForceFunctionState = isFunction(stateKey) && !isHoisted && execStateFunction;
+    if (shouldForceFunctionState) {
+      const execState = exec(stateKey, element);
+      state2.set(execState, {
+        ...options,
+        preventUpdate: true,
+        preventStateUpdateListener: false,
+        updatedByStateFunction: true
+      });
+      return;
+    }
+    const keyInParentState = findInheritedState(element, element.parent);
+    if (!keyInParentState || options.preventInheritedStateUpdate) return;
+    if (!options.preventBeforeStateUpdateListener && !options.preventListeners) {
+      const initStateReturns = triggerEventOnUpdate(
+        "beforeStateUpdate",
+        keyInParentState,
+        element,
+        options
+      );
+      if (initStateReturns === false) return element;
+    }
+    const newState = createStateUpdate(element, parent, options);
+    if (!options.preventStateUpdateListener && !options.preventListeners) {
+      triggerEventOnUpdate("stateUpdate", newState.parse(), element, options);
+    }
+  };
+  var createStateUpdate = (element, parent, options) => {
+    const __stateChildren = element.state.__children;
+    const newState = createState(element, parent);
+    element.state = newState;
+    for (const child in __stateChildren) {
+      if (newState[child]) newState.__children[child] = __stateChildren[child];
+      Object.getPrototypeOf(__stateChildren[child]).parent = newState;
+    }
+    return newState;
+  };
+
+  // ../element/dist/esm/methods/set.js
+  var addMethods = (element, parent, options = {}) => {
+    const proto = {
+      set,
+      reset,
+      update: update2,
+      variables,
+      remove,
+      updateContent,
+      removeContent,
+      setProps,
+      lookup,
+      lookdown,
+      lookdownAll,
+      getRef,
+      getPath,
+      getRootState,
+      getRoot,
+      getRootData,
+      getRootContext,
+      getContext,
+      setNodeStyles,
+      spotByPath,
+      parse,
+      parseDeep,
+      keys,
+      nextElement,
+      previousElement,
+      log,
+      verbose,
+      warn,
+      error,
+      call
+    };
+    if (element.context.methods) {
+      ;
+      (options.strict ? merge : overwrite)(proto, element.context.methods);
+    }
+    Object.setPrototypeOf(element, proto);
+  };
+
+  // ../attrs-in-props/dist/esm/index.js
+  var HTML_ATTRIBUTES = {
+    default: [
+      "accesskey",
+      "autofocus",
+      "class",
+      "contenteditable",
+      "contextmenu",
+      "dir",
+      "draggable",
+      "hidden",
+      "id",
+      "lang",
+      "part",
+      "placeholder",
+      "slot",
+      "spellcheck",
+      "style",
+      "tabindex",
+      "title",
+      "translate",
+      "inert",
+      "radiogroup",
+      "role",
+      "about",
+      "datatype",
+      "inlist",
+      "prefix",
+      "property",
+      "resource",
+      "typeof",
+      "vocab",
+      "autocapitalize",
+      "autocorrect",
+      "autosave",
+      "color",
+      "itemprop",
+      "itemscope",
+      "itemtype",
+      "itemid",
+      "itemref",
+      "results",
+      "security",
+      "unselectable",
+      "is"
+    ],
+    a: [
+      "accesskey",
+      "charset",
+      "coords",
+      "download",
+      "href",
+      "hreflang",
+      "name",
+      "rel",
+      "rev",
+      "shape",
+      "target",
+      "type"
+    ],
+    aria: [
+      "aria-activedescendant",
+      "aria-atomic",
+      "aria-autocomplete",
+      "aria-checked",
+      "aria-colcount",
+      "aria-colindex",
+      "aria-colspan",
+      "aria-controls",
+      "aria-current",
+      "aria-describedby",
+      "aria-details",
+      "aria-dropeffect",
+      "aria-errormessage",
+      "aria-expanded",
+      "aria-flowto",
+      "aria-grabbed",
+      "aria-haspopup",
+      "aria-hidden",
+      "aria-invalid",
+      "aria-keyshortcuts",
+      "aria-label",
+      "aria-labelledby",
+      "aria-level",
+      "aria-live",
+      "aria-modal",
+      "aria-multiline",
+      "aria-multiselectable",
+      "aria-orientation",
+      "aria-owns",
+      "aria-placeholder",
+      "aria-posinset",
+      "aria-pressed",
+      "aria-readonly",
+      "aria-relevant",
+      "aria-required",
+      "aria-roledescription",
+      "aria-rowcount",
+      "aria-rowindex",
+      "aria-rowspan",
+      "aria-selected",
+      "aria-setsize",
+      "aria-sort",
+      "aria-valuemax",
+      "aria-valuemin",
+      "aria-valuenow",
+      "aria-valuetext"
+    ],
+    anchor: [
+      "download",
+      "href",
+      "hreflang",
+      "media",
+      "ping",
+      "rel",
+      "target",
+      "type",
+      "referrerpolicy"
+    ],
+    audio: [
+      "autoplay",
+      "controls",
+      "crossorigin",
+      "loop",
+      "muted",
+      "preload",
+      "src"
+    ],
+    area: [
+      "alt",
+      "coords",
+      "download",
+      "href",
+      "hreflang",
+      "media",
+      "referrerpolicy",
+      "rel",
+      "shape",
+      "target",
+      "ping"
+    ],
+    base: [
+      "href",
+      "target"
+    ],
+    blockquote: [
+      "cite"
+    ],
+    button: [
+      "disabled",
+      "form",
+      "formaction",
+      "formenctype",
+      "formmethod",
+      "formnovalidate",
+      "formtarget",
+      "name",
+      "type",
+      "value"
+    ],
+    canvas: [
+      "height",
+      "width"
+    ],
+    col: [
+      "span",
+      "width"
+    ],
+    colgroup: [
+      "span"
+    ],
+    data: [
+      "value"
+    ],
+    details: [
+      "open"
+    ],
+    del: [
+      "cite",
+      "datetime"
+    ],
+    dialog: [
+      "open"
+    ],
+    embed: [
+      "height",
+      "src",
+      "type",
+      "width"
+    ],
+    fieldset: [
+      "disabled",
+      "form",
+      "name"
+    ],
+    form: [
+      "acceptcharset",
+      "action",
+      "autocomplete",
+      "enctype",
+      "method",
+      "name",
+      "novalidate",
+      "target",
+      "rel"
+    ],
+    html: [
+      "manifest"
+    ],
+    iframe: [
+      "allow",
+      "allowfullscreen",
+      "allowtransparency",
+      "frameborder",
+      "height",
+      "loading",
+      "marginheight",
+      "marginwidth",
+      "mozallowfullscreen",
+      "name",
+      "referrerpolicy",
+      "sandbox",
+      "scrolling",
+      "seamless",
+      "src",
+      "srcdoc",
+      "webkitallowfullscreen",
+      "width"
+    ],
+    img: [
+      "alt",
+      "crossorigin",
+      "decoding",
+      "height",
+      "ismap",
+      "loading",
+      "referrerpolicy",
+      "sizes",
+      "src",
+      "srcset",
+      "usemap",
+      "width"
+    ],
+    ins: [
+      "cite",
+      "datetime"
+    ],
+    input: [
+      "accept",
+      "alt",
+      "autocomplete",
+      "capture",
+      "checked",
+      "crossorigin",
+      "disabled",
+      "form",
+      "formaction",
+      "formenctype",
+      "formmethod",
+      "formnovalidate",
+      "formtarget",
+      "height",
+      "indeterminate",
+      "list",
+      "max",
+      "maxlength",
+      "min",
+      "minlength",
+      "multiple",
+      "name",
+      "pattern",
+      "placeholder",
+      "readonly",
+      "required",
+      "size",
+      "src",
+      "step",
+      "type",
+      "value",
+      "width"
+    ],
+    keygen: [
+      "challenge",
+      "disabled",
+      "form",
+      "keytype",
+      "keyparams",
+      "name"
+    ],
+    label: [
+      "form",
+      "for"
+    ],
+    li: [
+      "value"
+    ],
+    link: [
+      "as",
+      "crossorigin",
+      "href",
+      "hreflang",
+      "integrity",
+      "media",
+      "imagesrcset",
+      "imagesizes",
+      "referrerpolicy",
+      "rel",
+      "sizes",
+      "type",
+      "charset"
+    ],
+    map: [
+      "name"
+    ],
+    menu: [
+      "type"
+    ],
+    media: [
+      "autoplay",
+      "controls",
+      "currenttime",
+      "defaultmuted",
+      "defaultplaybackrate",
+      "loop",
+      "mediagroup",
+      "muted",
+      "playsinline",
+      "preload",
+      "src",
+      "volume"
+    ],
+    meta: [
+      "charset",
+      "content",
+      "http-equiv",
+      "name",
+      "media"
+    ],
+    meter: [
+      "form",
+      "high",
+      "low",
+      "max",
+      "min",
+      "optimum",
+      "value"
+    ],
+    quote: [
+      "cite"
+    ],
+    object: [
+      "classid",
+      "data",
+      "form",
+      "height",
+      "name",
+      "type",
+      "usemap",
+      "width",
+      "wmode"
+    ],
+    ol: [
+      "reversed",
+      "start",
+      "type"
+    ],
+    optgroup: [
+      "disabled",
+      "label"
+    ],
+    option: [
+      "disabled",
+      "label",
+      "selected",
+      "value"
+    ],
+    output: [
+      "form",
+      "for",
+      "name"
+    ],
+    param: [
+      "name",
+      "value"
+    ],
+    progress: [
+      "max",
+      "value"
+    ],
+    slot: [
+      "name"
+    ],
+    script: [
+      "async",
+      "charset",
+      "crossorigin",
+      "defer",
+      "integrity",
+      "nomodule",
+      "nonce",
+      "referrerpolicy",
+      "src",
+      "type"
+    ],
+    select: [
+      "autocomplete",
+      "disabled",
+      "form",
+      "multiple",
+      "name",
+      "required",
+      "size",
+      "value",
+      "onchange"
+    ],
+    source: [
+      "height",
+      "media",
+      "sizes",
+      "src",
+      "srcset",
+      "type",
+      "width"
+    ],
+    style: [
+      "media",
+      "nonce",
+      "scoped",
+      "type"
+    ],
+    table: [
+      "align",
+      "bgcolor",
+      "border",
+      "cellpadding",
+      "cellspacing",
+      "frame",
+      "rules",
+      "summary",
+      "width"
+    ],
+    textarea: [
+      "autocomplete",
+      "cols",
+      "dirname",
+      "disabled",
+      "form",
+      "maxlength",
+      "minlength",
+      "name",
+      "placeholder",
+      "readonly",
+      "required",
+      "rows",
+      "value",
+      "wrap"
+    ],
+    td: [
+      "align",
+      "colspan",
+      "headers",
+      "rowspan",
+      "scope",
+      "abbr",
+      "height",
+      "width",
+      "valign"
+    ],
+    th: [
+      "align",
+      "colspan",
+      "headers",
+      "rowspan",
+      "scope",
+      "abbr"
+    ],
+    time: [
+      "datetime"
+    ],
+    track: [
+      "default",
+      "kind",
+      "label",
+      "src",
+      "srclang"
+    ],
+    video: [
+      "autoplay",
+      "controls",
+      "crossorigin",
+      "disablepictureinpicture",
+      "disableremoteplayback",
+      "height",
+      "loop",
+      "muted",
+      "playsinline",
+      "poster",
+      "preload",
+      "src",
+      "width"
+    ],
+    svg: [
+      "className",
+      "class",
+      "color",
+      "height",
+      "id",
+      "lang",
+      "max",
+      "media",
+      "method",
+      "min",
+      "name",
+      "style",
+      "target",
+      "type",
+      "width",
+      // Other HTML properties supported by SVG elements in browsers
+      "role",
+      "tabindex",
+      "crossorigin",
+      // SVG Specific attributes
+      "accent-height",
+      "accumulate",
+      "additive",
+      "alignment-baseline",
+      "allowReorder",
+      "alphabetic",
+      "amplitude",
+      "arabic-form",
+      "ascent",
+      "attributeName",
+      "attributeType",
+      "autoReverse",
+      "azimuth",
+      "baseFrequency",
+      "baseline-shift",
+      "baseProfile",
+      "bbox",
+      "begin",
+      "bias",
+      "by",
+      "calcMode",
+      "cap-height",
+      "clip",
+      "clip-path",
+      "clipPathUnits",
+      "clip-rule",
+      "color-interpolation",
+      "color-interpolation-filters",
+      "color-profile",
+      "color-rendering",
+      "contentScriptType",
+      "contentStyleType",
+      "cursor",
+      "cx",
+      "cy",
+      "d",
+      "decelerate",
+      "descent",
+      "diffuseConstant",
+      "direction",
+      "display",
+      "divisor",
+      "dominant-baseline",
+      "dur",
+      "dx",
+      "dy",
+      "edgeMode",
+      "elevation",
+      "enable-background",
+      "end",
+      "exponent",
+      "externalResourcesRequired",
+      "fill",
+      "fill-opacity",
+      "fill-rule",
+      "filter",
+      "filterRes",
+      "filterUnits",
+      "flood-color",
+      "flood-opacity",
+      "focusable",
+      "font-family",
+      "font-size",
+      "font-size-adjust",
+      "font-stretch",
+      "font-style",
+      "font-variant",
+      "font-weight",
+      "format",
+      "from",
+      "fx",
+      "fy",
+      "g1",
+      "g2",
+      "glyph-name",
+      "glyph-orientation-horizontal",
+      "glyph-orientation-vertical",
+      "glyphRef",
+      "gradientTransform",
+      "gradientUnits",
+      "hanging",
+      "href",
+      "horiz-adv-x",
+      "horiz-origin-x",
+      "ideographic",
+      "image-rendering",
+      "in2",
+      "in",
+      "intercept",
+      "k1",
+      "k2",
+      "k3",
+      "k4",
+      "k",
+      "kernelMatrix",
+      "kernelUnitLength",
+      "kerning",
+      "keyPoints",
+      "keySplines",
+      "keyTimes",
+      "lengthAdjust",
+      "letter-spacing",
+      "lighting-color",
+      "limitingConeAngle",
+      "local",
+      "marker-end",
+      "markerHeight",
+      "marker-mid",
+      "marker-start",
+      "markerUnits",
+      "markerWidth",
+      "mask",
+      "maskContentUnits",
+      "maskUnits",
+      "mathematical",
+      "mode",
+      "numOctaves",
+      "offset",
+      "opacity",
+      "operator",
+      "order",
+      "orient",
+      "orientation",
+      "origin",
+      "overflow",
+      "overline-position",
+      "overline-thickness",
+      "paint-order",
+      "panose-1",
+      "path",
+      "pathLength",
+      "patternContentUnits",
+      "patternTransform",
+      "patternUnits",
+      "pointer-events",
+      "points",
+      "pointsAtX",
+      "pointsAtY",
+      "pointsAtZ",
+      "preserveAlpha",
+      "preserveAspectRatio",
+      "primitiveUnits",
+      "r",
+      "radius",
+      "refX",
+      "refY",
+      "rendering-intent",
+      "repeatCount",
+      "repeatDur",
+      "requiredExtensions",
+      "requiredFeatures",
+      "restart",
+      "result",
+      "rotate",
+      "rx",
+      "ry",
+      "scale",
+      "seed",
+      "shape-rendering",
+      "slope",
+      "spacing",
+      "specularConstant",
+      "specularExponent",
+      "speed",
+      "spreadMethod",
+      "startOffset",
+      "stdDeviation",
+      "stemh",
+      "stemv",
+      "stitchTiles",
+      "stop-color",
+      "stop-opacity",
+      "strikethrough-position",
+      "strikethrough-thickness",
+      "string",
+      "stroke",
+      "stroke-dasharray",
+      "stroke-dashoffset",
+      "stroke-linecap",
+      "stroke-linejoin",
+      "stroke-miterlimit",
+      "stroke-opacity",
+      "stroke-width",
+      "surfaceScale",
+      "systemLanguage",
+      "tableValues",
+      "targetX",
+      "targetY",
+      "text-anchor",
+      "text-decoration",
+      "textLength",
+      "text-rendering",
+      "to",
+      "transform",
+      "u1",
+      "u2",
+      "underline-position",
+      "underline-thickness",
+      "unicode",
+      "unicode-bidi",
+      "unicode-range",
+      "units-per-em",
+      "v-alphabetic",
+      "values",
+      "vector-effect",
+      "version",
+      "vert-adv-y",
+      "vert-origin-x",
+      "vert-origin-y",
+      "v-hanging",
+      "v-ideographic",
+      "viewBox",
+      "viewTarget",
+      "visibility",
+      "v-mathematical",
+      "widths",
+      "word-spacing",
+      "writing-mode",
+      "x1",
+      "x2",
+      "x",
+      "xChannelSelector",
+      "x-height",
+      "xlink:actuate",
+      "xlink:arcrole",
+      "xlink:href",
+      "xlink:role",
+      "xlink:show",
+      "xlink:title",
+      "xlink:type",
+      "xml:base",
+      "xml:lang",
+      "xmlns",
+      "xmlns:xlink",
+      "xml:space",
+      "y1",
+      "y2",
+      "y",
+      "yChannelSelector",
+      "z",
+      "zoomAndPan"
+    ]
+  };
+  var DOM_EVENTS = [
+    // Clipboard Events
+    "oncopy",
+    "oncut",
+    "onpaste",
+    // Composition Events
+    "oncompositionend",
+    "oncompositionstart",
+    "oncompositionupdate",
+    // Focus Events
+    "onfocus",
+    "onfocusin",
+    "onfocusout",
+    "onblur",
+    // Form Events
+    "onchange",
+    "onbeforeinput",
+    "oninput",
+    "onreset",
+    "onsubmit",
+    "oninvalid",
+    "onformdata",
+    // Image Events
+    "onload",
+    "onerror",
+    // also a Media Event
+    // Detail Events
+    "ontoggle",
+    // Keyboard Events
+    "onkeydown",
+    "onkeypress",
+    "onkeyup",
+    // Media Events
+    "onabort",
+    "oncanplay",
+    "oncanplaythrough",
+    "oncuechange",
+    "ondurationchange",
+    "onemptied",
+    "onencrypted",
+    "onended",
+    "onloadeddata",
+    "onloadedmetadata",
+    "onloadstart",
+    "onpause",
+    "onplay",
+    "onplaying",
+    "onprogress",
+    "onratechange",
+    "onseeked",
+    "onseeking",
+    "onstalled",
+    "onsuspend",
+    "ontimeupdate",
+    "onvolumechange",
+    "onwaiting",
+    // MouseEvents
+    "onauxclick",
+    "onclick",
+    "oncontextmenu",
+    "ondblclick",
+    "ondrag",
+    "ondragend",
+    "ondragenter",
+    "ondragexit",
+    "ondragleave",
+    "ondragover",
+    "ondragstart",
+    "ondrop",
+    "onmousedown",
+    "onmouseenter",
+    "onmouseleave",
+    "onmousemove",
+    "onmouseout",
+    "onmouseover",
+    "onmouseup",
+    // Selection Events
+    "onselect",
+    "onselectionchange",
+    "onselectstart",
+    // Touch Events
+    "ontouchcancel",
+    "ontouchend",
+    "ontouchmove",
+    "ontouchstart",
+    // Pointer Events
+    "ongotpointercapture",
+    "onpointercancel",
+    "onpointerdown",
+    "onpointerenter",
+    "onpointerleave",
+    "onpointermove",
+    "onpointerout",
+    "onpointerover",
+    "onpointerup",
+    "onlostpointercapture",
+    // UI Events
+    "onscroll",
+    "onresize",
+    // Wheel Events
+    "onwheel",
+    // Animation Events
+    "onanimationstart",
+    "onanimationend",
+    "onanimationiteration",
+    // Transition Events
+    "ontransitionstart",
+    "ontransitionrun",
+    "ontransitionend",
+    "ontransitioncancel",
+    // Svelte Transition Events
+    "onoutrostart",
+    "onoutroend",
+    "onintrostart",
+    "onintroend",
+    // Message Events
+    "onmessage",
+    "onmessageerror",
+    // Document Events
+    "onvisibilitychange",
+    // Global Events
+    "oncancel",
+    "onclose",
+    "onfullscreenchange",
+    "onfullscreenerror"
+  ];
+  var checkAttributeByTagName = (tag, attribute) => {
+    if (Object.prototype.hasOwnProperty.call(HTML_ATTRIBUTES, tag)) {
+      const attributes = HTML_ATTRIBUTES[tag];
+      return attributes.includes(attribute) || attributes.includes("default");
+    } else {
+      const defaultAttributes = HTML_ATTRIBUTES.default;
+      return defaultAttributes.includes(attribute);
+    }
+  };
+  var checkEventFunctions = (key) => {
+    if (!isString(key)) return false;
+    const normalizedKey = key.toLowerCase();
+    return DOM_EVENTS.includes(normalizedKey);
+  };
+  var filterAttributesByTagName = (tag, props, cssProps) => {
+    const filteredObject = {};
+    for (const key in props) {
+      if (Object.prototype.hasOwnProperty.call(props, key)) {
+        if (cssProps && key in cssProps) continue;
+        const isAttribute = checkAttributeByTagName(tag, key);
+        const isEvent = checkEventFunctions(key);
+        if (isDefined(props[key]) && (isAttribute || isEvent)) {
+          filteredObject[key] = props[key];
+        }
+      }
+    }
+    return filteredObject;
+  };
+
+  // ../element/dist/esm/create.js
+  var EXCLUDED_ATTRS = /* @__PURE__ */ new Set(["class", "style"]);
+  var applyPropsAsAttrs = (element) => {
+    const { tag, props, context } = element;
+    if (!tag || !props) return;
+    const autoAttrs = filterAttributesByTagName(tag, props, context?.cssPropsRegistry);
+    const filtered = {};
+    for (const key in autoAttrs) {
+      if (!EXCLUDED_ATTRS.has(key)) filtered[key] = autoAttrs[key];
+    }
+    let hasFiltered = false;
+    for (const _k in filtered) {
+      hasFiltered = true;
+      break;
+    }
+    if (!hasFiltered) return;
+    if (!element.attr) {
+      element.attr = filtered;
+    } else if (typeof element.attr === "object") {
+      element.attr = { ...filtered, ...element.attr };
+    }
+  };
+  var ENV6 = process.env.NODE_ENV;
+  var create = (props, parentEl, passedKey, options = OPTIONS.create || {}, attachOptions) => {
+    cacheOptions(options);
+    const element = createElement(props, parentEl, passedKey, options, ROOT);
+    if (!element) return;
+    const { key, parent, __ref: ref } = element;
+    createRoot(element, parent);
+    applyExtends(element, parent, options);
+    if (options.onlyResolveExtends) {
+      return onlyResolveExtends(element, parent, key, options);
+    }
+    propertizeElement.call(element, element);
+    triggerEventOn("start", element, options);
+    resetOptions(element, parent, options);
+    addMethods(element, parent, options);
+    createScope(element, parent);
+    createState(element, parent);
+    if (element.scope === "state") element.scope = element.state;
+    createIfConditionFlag(element, parent);
+    initProps(element, parent, options);
+    pickupElementFromProps.call(element, element, { cachedKeys: [] });
+    applyPropsAsAttrs(element);
+    if (element.scope === "props" || element.scope === true) {
+      element.scope = element.props;
+    }
+    createIfConditionFlag(element, parent);
+    if (element.node) {
+      if (ref.__if) return assignNode(element, parent, key, attachOptions);
+    }
+    const onInit = triggerEventOn("init", element, options);
+    if (onInit === false) return element;
+    triggerEventOn("beforeClassAssign", element, options);
+    assignKeyAsClassname(element);
+    renderElement(element, parent, options, attachOptions);
+    addElementIntoParentChildren(element, parent);
+    triggerEventOn("complete", element, options);
+    return element;
+  };
+  var cacheOptions = (options) => {
+    if (options && !OPTIONS.create) {
+      OPTIONS.create = options;
+      OPTIONS.create.context = options.context;
+    }
+  };
+  var resetOptions = (element, parent, options) => {
+    let hasKeys = false;
+    for (const _k in options) {
+      hasKeys = true;
+      break;
+    }
+    if (hasKeys) {
+      OPTIONS.defaultOptions = options;
+      if (options.ignoreChildExtends) delete options.ignoreChildExtends;
+    }
+  };
+  var addElementIntoParentChildren = (element, parent) => {
+    if (parent.__ref && parent.__ref.__children) {
+      parent.__ref.__children.push(element.key);
+    }
+  };
+  var _uniqIdCounter = 1;
+  var visitedElements = /* @__PURE__ */ new WeakMap();
+  var renderElement = (element, parent, options, attachOptions) => {
+    if (visitedElements.has(element)) {
+      if (ENV6 === "test" || ENV6 === "development") {
+        console.warn("Cyclic rendering detected:", element.__ref.path);
+      }
+    }
+    visitedElements.set(element, true);
+    const { __ref: ref, key } = element;
+    const createNestedChild = () => {
+      const isInfiniteLoopDetected = detectInfiniteLoop(ref.path);
+      if (ref.__uniqId || isInfiniteLoopDetected) return;
+      createNode(element, options);
+      ref.__uniqId = _uniqIdCounter++;
+    };
+    if (ENV6 === "test" || ENV6 === "development") {
+      createNestedChild();
+    } else {
+      try {
+        createNestedChild();
+      } catch (e) {
+        const path = ref.path;
+        if (path.includes("ComponentsGrid")) {
+          path.splice(0, path.indexOf("ComponentsGrid") + 2);
+        }
+        if (path.includes("demoComponent")) {
+          path.splice(0, path.indexOf("demoComponent") + 1);
+        }
+        const isDemoComponent = element.lookup((el) => el.state.key)?.state?.key;
+        element.warn(
+          "Error happened in:",
+          isDemoComponent ? isDemoComponent + " " : "" + path.join(".")
+        );
+        element.verbose();
+        element.error(e, options);
+        if (element.on?.error) {
+          element.on.error(e, element, element.state, element.context, options);
+        }
+      }
+    }
+    if (!ref.__if) {
+      parent[key || element.key] = element;
+      return element;
+    }
+    assignNode(element, parent, key, attachOptions);
+    applyAnimationFrame(element, options);
+    triggerEventOn("render", element, options);
+    triggerEventOn("renderRouter", element, options);
+    triggerEventOn("done", element, options);
+    triggerEventOn("create", element, options);
+  };
+  var onlyResolveExtends = (element, parent, key, options) => {
+    const { __ref: ref } = element;
+    addMethods(element, parent, options);
+    createScope(element, parent);
+    createState(element, parent);
+    if (element.scope === "state") element.scope = element.state;
+    createIfConditionFlag(element, parent);
+    initProps(element, parent, options);
+    pickupElementFromProps.call(element, element, { cachedKeys: [] });
+    if (element.scope === "props" || element.scope === true) {
+      element.scope = element.props;
+    }
+    if (element.node && ref.__if) {
+      parent[key || element.key] = element;
+    }
+    if (!element.props) element.props = {};
+    addElementIntoParentChildren(element, parent);
+    if (element.tag !== "string" && element.tag !== "fragment") {
+      throughInitialDefine(element);
+      throughInitialExec(element);
+      for (const k in element) {
+        if (isUndefined(element[k]) || isMethod(k, element) || isObject(REGISTRY[k])) {
+          continue;
+        }
+        const hasDefine = element.define?.[k];
+        const contextHasDefine = element.context?.define?.[k];
+        const optionsHasDefine = options.define?.[k];
+        if (!ref.__skipCreate && REGISTRY[k] && !optionsHasDefine) {
+          continue;
+        } else if (element[k] && !hasDefine && !optionsHasDefine && !contextHasDefine) {
+          create(exec(element[k], element), element, k, options);
+        }
+      }
+    }
+    parent[key || element.key] = element;
+    delete element.update;
+    delete element.__element;
+    if (element.props) {
+      delete element.props.update;
+      delete element.props.__element;
+    }
+    return element;
+  };
+  var create_default = create;
+
+  // index.js
+  var create2 = (element, parent, key, options) => {
+    const domqlElement = (create_default.default || create_default)(
+      element,
+      parent,
+      key,
+      options
+    );
+    const complete = domqlElement.on?.complete;
+    if (complete) {
+      domqlElement.on.complete(element, element.state, element.context, options);
+    }
+    const onComplete = domqlElement.props?.onComplete;
+    if (onComplete) {
+      domqlElement.props?.onComplete(
+        element,
+        element.state,
+        element.context,
+        options
+      );
+    }
+    const initInspect = domqlElement.on?.initInspect;
+    if (initInspect) {
+      domqlElement.on.initInspect(
+        element,
+        element.state,
+        element.context,
+        options
+      );
+    }
+    const initSync = domqlElement.on?.initSync;
+    if (initSync) {
+      domqlElement.on.initSync(element, element.state, element.context, options);
+    }
+    return domqlElement;
+  };
+  var index_default = {
+    TREE,
+    create: create2
+  };
+  return __toCommonJS(index_exports);
+})();
+// @preserve-env