domql 1.5.108 → 1.5.110

package/dist/index.cjs.js

@@ -0,0 +1,2330 @@
+"use strict";
+var __create = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames2(from))
+      if (!__hasOwnProp2.call(to, key) && key !== except)
+        __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps2(
+  isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+
+// node_modules/@domql/utils/dist/index.cjs.js
+var require_index_cjs = __commonJS({
+  "node_modules/@domql/utils/dist/index.cjs.js"(exports, module) {
+    "use strict";
+    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);
+    var utils_exports = {};
+    __export(utils_exports, {
+      TYPES: () => TYPES,
+      cleanWithNode: () => cleanWithNode,
+      clone: () => clone,
+      createID: () => createID,
+      createSnapshotId: () => createSnapshotId,
+      debounce: () => debounce,
+      deepClone: () => deepClone,
+      deepCloneExclude: () => deepCloneExclude,
+      deepDestringify: () => deepDestringify,
+      deepMerge: () => deepMerge,
+      deepStringify: () => deepStringify,
+      diff: () => diff,
+      exec: () => exec,
+      flattenRecursive: () => flattenRecursive,
+      is: () => is,
+      isArray: () => isArray,
+      isBoolean: () => isBoolean,
+      isDefined: () => isDefined,
+      isEqualDeep: () => isEqualDeep,
+      isFunction: () => isFunction,
+      isHtmlElement: () => isHtmlElement,
+      isNode: () => isNode,
+      isNot: () => isNot,
+      isNull: () => isNull,
+      isNumber: () => isNumber,
+      isObject: () => isObject,
+      isObjectLike: () => isObjectLike,
+      isString: () => isString,
+      isUndefined: () => isUndefined,
+      isValidHtmlTag: () => isValidHtmlTag,
+      logGroupIf: () => logGroupIf,
+      logIf: () => logIf,
+      map: () => map,
+      memoize: () => memoize,
+      merge: () => merge,
+      mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+      mergeArray: () => mergeArray,
+      mergeArrayExclude: () => mergeArrayExclude,
+      mergeIfExisted: () => mergeIfExisted,
+      overwrite: () => overwrite,
+      overwriteDeep: () => overwriteDeep,
+      overwriteObj: () => overwriteObj
+    });
+    module.exports = __toCommonJS(utils_exports);
+    var window = globalThis;
+    var document = window.document;
+    var HTML_TAGS = {
+      root: [
+        "body",
+        "html"
+      ],
+      head: [
+        "title",
+        "base",
+        "meta",
+        "style"
+      ],
+      body: [
+        "string",
+        "fragment",
+        "a",
+        "abbr",
+        "acronym",
+        "address",
+        "applet",
+        "area",
+        "article",
+        "aside",
+        "audio",
+        "b",
+        "basefont",
+        "bdi",
+        "bdo",
+        "big",
+        "blockquote",
+        "br",
+        "button",
+        "canvas",
+        "caption",
+        "center",
+        "cite",
+        "code",
+        "col",
+        "colgroup",
+        "data",
+        "datalist",
+        "dd",
+        "del",
+        "details",
+        "dfn",
+        "dialog",
+        "dir",
+        "div",
+        "dl",
+        "dt",
+        "em",
+        "embed",
+        "fieldset",
+        "figcaption",
+        "figure",
+        "font",
+        "footer",
+        "form",
+        "frame",
+        "frameset",
+        "h1",
+        "h2",
+        "h3",
+        "h4",
+        "h5",
+        "h6",
+        "head",
+        "header",
+        "hr",
+        "i",
+        "iframe",
+        "img",
+        "input",
+        "ins",
+        "kbd",
+        "label",
+        "legend",
+        "li",
+        "link",
+        "main",
+        "map",
+        "mark",
+        "meter",
+        "nav",
+        "noframes",
+        "noscript",
+        "object",
+        "ol",
+        "optgroup",
+        "option",
+        "output",
+        "p",
+        "param",
+        "picture",
+        "pre",
+        "progress",
+        "q",
+        "rp",
+        "rt",
+        "ruby",
+        "s",
+        "samp",
+        "script",
+        "section",
+        "select",
+        "small",
+        "source",
+        "span",
+        "strike",
+        "strong",
+        "sub",
+        "summary",
+        "sup",
+        "table",
+        "tbody",
+        "td",
+        "template",
+        "textarea",
+        "tfoot",
+        "th",
+        "thead",
+        "time",
+        "tr",
+        "track",
+        "tt",
+        "u",
+        "ul",
+        "var",
+        "video",
+        "wbr",
+        "svg",
+        "path"
+      ]
+    };
+    var isValidHtmlTag = (arg) => HTML_TAGS.body.indexOf(arg);
+    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 isObjectLike = (arg) => {
+      if (arg === null)
+        return false;
+      return typeof arg === "object";
+    };
+    var isNode = (obj2) => {
+      return typeof window.Node === "object" ? obj2 instanceof window.Node : obj2 && typeof obj2 === "object" && typeof obj2.nodeType === "number" && typeof obj2.nodeName === "string";
+    };
+    var isHtmlElement = (obj2) => {
+      return typeof window.HTMLElement === "object" ? obj2 instanceof window.HTMLElement : obj2 && typeof obj2 === "object" && obj2 !== null && obj2.nodeType === 1 && typeof obj2.nodeName === "string";
+    };
+    var isDefined = (arg) => {
+      return isObject(arg) || isObjectLike(arg) || isString(arg) || isNumber(arg) || isFunction(arg) || isArray(arg) || isObjectLike(arg) || isBoolean(arg) || isNull(arg);
+    };
+    var isUndefined = (arg) => {
+      return arg === void 0;
+    };
+    var TYPES = {
+      boolean: isBoolean,
+      array: isArray,
+      object: isObject,
+      string: isString,
+      number: isNumber,
+      null: isNull,
+      function: isFunction,
+      objectLike: isObjectLike,
+      node: isNode,
+      htmlElement: isHtmlElement,
+      defined: isDefined
+    };
+    var is = (arg) => {
+      return (...args) => {
+        return args.map((val) => TYPES[val](arg)).filter((v) => v).length > 0;
+      };
+    };
+    var isNot = (arg) => {
+      return (...args) => {
+        return args.map((val) => TYPES[val](arg)).filter((v) => v).length === 0;
+      };
+    };
+    var exec = (param, element, state) => {
+      if (isFunction(param))
+        return param(element, state || element.state);
+      return param;
+    };
+    var map = (obj2, extention, element) => {
+      for (const e in extention) {
+        obj2[e] = exec(extention[e], element);
+      }
+    };
+    var merge = (element, obj2) => {
+      for (const e in obj2) {
+        const elementProp = element[e];
+        const objProp2 = obj2[e];
+        if (elementProp === void 0) {
+          element[e] = objProp2;
+        }
+      }
+      return element;
+    };
+    var deepMerge = (element, extend) => {
+      for (const e in extend) {
+        const elementProp = element[e];
+        const extendProp = extend[e];
+        if (e === "parent" || e === "props")
+          continue;
+        if (elementProp === void 0) {
+          element[e] = extendProp;
+        } else if (isObjectLike(elementProp) && isObject(extendProp)) {
+          deepMerge(elementProp, extendProp);
+        }
+      }
+      return element;
+    };
+    var clone = (obj2) => {
+      const o = {};
+      for (const prop2 in obj2) {
+        if (prop2 === "node")
+          continue;
+        o[prop2] = obj2[prop2];
+      }
+      return o;
+    };
+    var deepCloneExclude = (obj2, exclude = []) => {
+      if (isArray(obj2)) {
+        return obj2.map((x) => deepCloneExclude(x, exclude));
+      }
+      const o = {};
+      for (const k in obj2) {
+        if (exclude.indexOf(k) > -1)
+          continue;
+        let v = obj2[k];
+        if (k === "extend" && isArray(v)) {
+          v = mergeArrayExclude(v, exclude);
+        }
+        if (isArray(v)) {
+          o[k] = v.map((x) => deepCloneExclude(x, exclude));
+        } else if (isObject(v)) {
+          o[k] = deepCloneExclude(v, exclude);
+        } else
+          o[k] = v;
+      }
+      return o;
+    };
+    var mergeArrayExclude = (arr, excl = []) => {
+      return arr.reduce((acc, curr) => deepMerge(acc, deepCloneExclude(curr, excl)), {});
+    };
+    var deepClone = (obj2) => {
+      if (isArray(obj2)) {
+        return obj2.map(deepClone);
+      }
+      const o = {};
+      for (const prop2 in obj2) {
+        let objProp2 = obj2[prop2];
+        if (prop2 === "extend" && isArray(objProp2)) {
+          objProp2 = mergeArray(objProp2);
+        }
+        if (isArray(objProp2)) {
+          o[prop2] = objProp2.map((v) => isObject(v) ? deepClone(v) : v);
+        } else if (isObject(objProp2)) {
+          o[prop2] = deepClone(objProp2);
+        } else
+          o[prop2] = objProp2;
+      }
+      return o;
+    };
+    var deepStringify = (obj2, stringified2 = {}) => {
+      for (const prop2 in obj2) {
+        const objProp2 = obj2[prop2];
+        if (isFunction(objProp2)) {
+          stringified2[prop2] = objProp2.toString();
+        } else if (isObject(objProp2)) {
+          stringified2[prop2] = {};
+          deepStringify(objProp2[prop2], stringified2[prop2]);
+        } else if (isArray(objProp2)) {
+          stringified2[prop2] = [];
+          objProp2.map((v, i) => deepStringify(v, stringified2[prop2][i]));
+        } else
+          stringified2[prop2] = objProp2;
+      }
+      return stringified2;
+    };
+    var deepDestringify = (obj, stringified = {}) => {
+      for (const prop in obj) {
+        const objProp = obj[prop];
+        if (isString(objProp)) {
+          if (objProp.includes("=>") || objProp.includes("function") || objProp[0] === "(") {
+            try {
+              const evalProp = eval(objProp);
+              stringified[prop] = evalProp;
+            } catch (e) {
+              if (e)
+                stringified[prop] = objProp;
+            }
+          }
+        } else
+          stringified[prop] = objProp;
+        if (isObject(objProp))
+          deepDestringify(stringified[prop], stringified[prop]);
+      }
+      return stringified;
+    };
+    var overwrite = (element, params, options) => {
+      const { ref } = element;
+      const changes = {};
+      for (const e in params) {
+        if (e === "props")
+          continue;
+        const elementProp = element[e];
+        const paramsProp = params[e];
+        if (paramsProp) {
+          ref.__cache[e] = changes[e] = elementProp;
+          ref[e] = paramsProp;
+        }
+      }
+      return changes;
+    };
+    var diff = (obj2, original, cache) => {
+      const changes = cache || {};
+      for (const e in obj2) {
+        if (e === "ref")
+          continue;
+        const originalProp = original[e];
+        const objProp2 = obj2[e];
+        if (isObjectLike(originalProp) && isObjectLike(objProp2)) {
+          changes[e] = {};
+          diff(originalProp, objProp2, changes[e]);
+        } else if (objProp2 !== void 0) {
+          changes[e] = objProp2;
+        }
+      }
+      return changes;
+    };
+    var overwriteObj = (params, obj2) => {
+      const changes = {};
+      for (const e in params) {
+        const objProp2 = obj2[e];
+        const paramsProp = params[e];
+        if (paramsProp) {
+          obj2[e] = changes[e] = objProp2;
+        }
+      }
+      return changes;
+    };
+    var overwriteDeep = (params, obj2) => {
+      for (const e in params) {
+        const objProp2 = obj2[e];
+        const paramsProp = params[e];
+        if (isObjectLike(objProp2) && isObjectLike(paramsProp)) {
+          overwriteDeep(objProp2, paramsProp);
+        } else if (paramsProp !== void 0) {
+          obj2[e] = paramsProp;
+        }
+      }
+      return obj2;
+    };
+    var mergeIfExisted = (a, b) => {
+      if (isObjectLike(a) && isObjectLike(b))
+        return deepMerge(a, b);
+      return a || b;
+    };
+    var mergeArray = (arr) => {
+      return arr.reduce((a, c) => deepMerge(a, deepClone(c)), {});
+    };
+    var mergeAndCloneIfArray = (obj2) => {
+      return isArray(obj2) ? mergeArray(obj2) : deepClone(obj2);
+    };
+    var flattenRecursive = (param, prop2, stack = []) => {
+      const objectized = mergeAndCloneIfArray(param);
+      stack.push(objectized);
+      const extendOfExtend = objectized[prop2];
+      if (extendOfExtend)
+        flattenRecursive(extendOfExtend, prop2, stack);
+      delete objectized[prop2];
+      return stack;
+    };
+    var isEqualDeep = (param, element) => {
+      if (param === element)
+        return true;
+      if (!param || !element)
+        return false;
+      for (const prop2 in param) {
+        const paramProp = param[prop2];
+        const elementProp = element[prop2];
+        if (isObjectLike(paramProp)) {
+          const isEqual = isEqualDeep(paramProp, elementProp);
+          if (!isEqual)
+            return false;
+        } else {
+          const isEqual = paramProp === elementProp;
+          if (!isEqual)
+            return false;
+        }
+      }
+      return true;
+    };
+    var debounce = (element, func, timeout = 300) => {
+      let timer;
+      return (...args) => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+          func.apply(element, args);
+        }, timeout);
+      };
+    };
+    var memoize = (fn) => {
+      const cache = {};
+      return (...args) => {
+        const n = args[0];
+        if (n in cache) {
+          return cache[n];
+        } else {
+          const result = fn(n);
+          cache[n] = result;
+          return result;
+        }
+      };
+    };
+    var cleanWithNode = (extend) => delete extend.node && extend;
+    var createID = function() {
+      let index = 0;
+      function newId() {
+        index++;
+        return index;
+      }
+      return newId;
+    }();
+    var createSnapshotId = createID;
+    var logIf = (bool, ...arg) => {
+      if (bool)
+        arg.map((v) => console.log(v));
+    };
+    var logGroupIf = (bool, key, ...arg) => {
+      if (bool) {
+        console.group(key);
+        arg.map((v) => console.log(v));
+        console.groupEnd(key);
+      }
+    };
+  }
+});
+
+// src/index.js
+var src_exports = {};
+__export2(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS2(src_exports);
+
+// node_modules/@domql/globals/index.js
+var window2 = globalThis;
+var document2 = window2.document;
+
+// node_modules/@domql/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"
+    }
+  }
+};
+var report = (err, arg, element) => {
+  const currentLang = "en";
+  let errObj;
+  if (err && typeof err === "string")
+    errObj = ERRORS_REGISTRY[currentLang][err];
+  return new Error(
+    `"${err}", "${arg}"
+
+`,
+    `${errObj.description}`,
+    element ? `
+
+${element}` : ""
+  );
+};
+
+// src/element/root.js
+var root = {
+  key: ":root",
+  node: document2 ? document2.body : report("DocumentNotDefined", document2)
+};
+var root_default = root;
+
+// src/element/tree.js
+var tree_default = root_default;
+
+// src/element/cache.js
+var import_utils4 = __toESM(require_index_cjs());
+
+// src/event/on.js
+var on_exports = {};
+__export2(on_exports, {
+  attachNode: () => attachNode,
+  beforeClassAssign: () => beforeClassAssign,
+  init: () => init,
+  initStateUpdated: () => initStateUpdated,
+  initUpdate: () => initUpdate,
+  render: () => render,
+  stateCreated: () => stateCreated,
+  stateInit: () => stateInit,
+  stateUpdated: () => stateUpdated,
+  update: () => update
+});
+var beforeClassAssign = (param, element, state) => {
+  return param(element, state);
+};
+var init = (param, element, state) => {
+  return param(element, state);
+};
+var render = (param, element, state) => {
+  return param(element, state);
+};
+var initUpdate = (param, element, state) => {
+  return param(element, state);
+};
+var attachNode = (param, element, state) => {
+  return param(element, state);
+};
+var stateInit = (param, element, state) => {
+  return param(element, state);
+};
+var stateCreated = (param, element, state) => {
+  return param(element, state);
+};
+var initStateUpdated = (param, element, state, changes) => {
+  return param(element, state, changes);
+};
+var stateUpdated = (param, element, state, changes) => {
+  return param(element, state, changes);
+};
+var update = (param, element, state) => {
+  return param(element, state);
+};
+
+// src/event/can.js
+var can_exports = {};
+__export2(can_exports, {
+  render: () => render2
+});
+
+// node_modules/@domql/registry/methods.js
+var import_utils = __toESM(require_index_cjs());
+
+// node_modules/@domql/registry/tags.js
+var TAGS = {
+  root: [
+    "body",
+    "html"
+  ],
+  head: [
+    "title",
+    "base",
+    "meta",
+    "style"
+  ],
+  body: [
+    "string",
+    "fragment",
+    "a",
+    "abbr",
+    "acronym",
+    "address",
+    "applet",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "basefont",
+    "bdi",
+    "bdo",
+    "big",
+    "blockquote",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "center",
+    "cite",
+    "code",
+    "col",
+    "colgroup",
+    "data",
+    "datalist",
+    "dd",
+    "del",
+    "details",
+    "dfn",
+    "dialog",
+    "dir",
+    "div",
+    "dl",
+    "dt",
+    "em",
+    "embed",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "font",
+    "footer",
+    "form",
+    "frame",
+    "frameset",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hr",
+    "i",
+    "iframe",
+    "img",
+    "input",
+    "ins",
+    "kbd",
+    "label",
+    "legend",
+    "li",
+    "link",
+    "main",
+    "map",
+    "mark",
+    "meter",
+    "nav",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "picture",
+    "pre",
+    "progress",
+    "q",
+    "rp",
+    "rt",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "section",
+    "select",
+    "small",
+    "source",
+    "span",
+    "strike",
+    "strong",
+    "sub",
+    "summary",
+    "sup",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "tr",
+    "track",
+    "tt",
+    "u",
+    "ul",
+    "var",
+    "video",
+    "wbr",
+    "svg",
+    "path"
+  ]
+};
+
+// src/event/can.js
+var render2 = (element) => {
+  const tag = element.tag || "div";
+  const isValid = TAGS.body.indexOf(tag) > -1;
+  return isValid || report("HTMLInvalidTag");
+};
+
+// src/utils/object.js
+var import_utils2 = __toESM(require_index_cjs());
+var isTagRegistered = (arg) => TAGS.body.indexOf(arg);
+var merge2 = (element, obj2) => {
+  for (const e in obj2) {
+    const elementProp = element[e];
+    const objProp2 = obj2[e];
+    if (elementProp === void 0) {
+      element[e] = objProp2;
+    }
+  }
+  return element;
+};
+var deepMerge2 = (element, extend) => {
+  for (const e in extend) {
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (e === "parent" || e === "props" || e === "state")
+      continue;
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if ((0, import_utils2.isObjectLike)(elementProp) && (0, import_utils2.isObject)(extendProp)) {
+      deepMerge2(elementProp, extendProp);
+    }
+  }
+  return element;
+};
+var deepClone2 = (obj2, excluding = ["parent", "node", "__element", "state", "context", "extend", "__ref"]) => {
+  const o = (0, import_utils2.isArray)(obj2) ? [] : {};
+  for (const prop2 in obj2) {
+    if (excluding.indexOf(prop2) > -1)
+      continue;
+    let objProp2 = obj2[prop2];
+    if (prop2 === "extend" && (0, import_utils2.isArray)(objProp2)) {
+      objProp2 = mergeArray2(objProp2, excluding);
+    }
+    if ((0, import_utils2.isObjectLike)(objProp2)) {
+      o[prop2] = deepClone2(objProp2, excluding);
+    } else
+      o[prop2] = objProp2;
+  }
+  return o;
+};
+var overwrite2 = (element, params, options) => {
+  const changes = {};
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  for (const e in params) {
+    if (e === "props" || e === "state" || e === "__ref")
+      continue;
+    const elementProp = element[e];
+    const paramsProp = params[e];
+    if (paramsProp !== void 0) {
+      __cached[e] = changes[e] = elementProp;
+      element[e] = paramsProp;
+    }
+    if (options.cleanExec)
+      delete __exec[e];
+  }
+  return changes;
+};
+var overwriteShallow = (obj2, params, excluding = ["node", "__ref"]) => {
+  for (const e in params) {
+    if (excluding.indexOf(e) > -1)
+      continue;
+    obj2[e] = params[e];
+  }
+  return obj2;
+};
+var overwriteDeep2 = (obj2, params, excluding = ["node", "__ref"]) => {
+  for (const e in params) {
+    if (excluding.indexOf(e) > -1)
+      continue;
+    const objProp2 = obj2[e];
+    const paramsProp = params[e];
+    if ((0, import_utils2.isObjectLike)(objProp2) && (0, import_utils2.isObjectLike)(paramsProp)) {
+      overwriteDeep2(objProp2, paramsProp);
+    } else if (paramsProp !== void 0) {
+      obj2[e] = paramsProp;
+    }
+  }
+  return obj2;
+};
+var mergeArray2 = (arr, excluding = ["parent", "node", "__element", "state", "context", "__ref"]) => {
+  return arr.reduce((a, c) => deepMerge2(a, deepClone2(c, excluding)), {});
+};
+
+// src/utils/extendUtils.js
+var import_utils3 = __toESM(require_index_cjs());
+var generateHash = () => Math.random().toString(36).substring(2);
+var extendStackRegistry = {};
+var getHashedExtend = (extend) => {
+  return extendStackRegistry[extend.__hash];
+};
+var setHashedExtend = (extend, stack) => {
+  const hash = generateHash();
+  extend.__hash = hash;
+  extendStackRegistry[hash] = stack;
+  return stack;
+};
+var getExtendStackRegistry = (extend, stack) => {
+  if (extend.__hash) {
+    return stack.concat(getHashedExtend(extend));
+  }
+  return setHashedExtend(extend, stack);
+};
+var extractArrayExtend = (extend, stack) => {
+  extend.forEach((each) => flattenExtend(each, stack));
+  return stack;
+};
+var deepExtend = (extend, stack) => {
+  const extendOflattenExtend = extend.extend;
+  if (extendOflattenExtend) {
+    flattenExtend(extendOflattenExtend, stack);
+  }
+  return stack;
+};
+var flattenExtend = (extend, stack) => {
+  if (!extend)
+    return stack;
+  if ((0, import_utils3.isArray)(extend))
+    return extractArrayExtend(extend, stack);
+  stack.push(extend);
+  if (extend.extend)
+    deepExtend(extend, stack);
+  return stack;
+};
+var deepCloneExtend = (obj2) => {
+  const o = {};
+  for (const prop2 in obj2) {
+    if (["parent", "node", "__element"].indexOf(prop2) > -1)
+      continue;
+    const objProp2 = obj2[prop2];
+    if ((0, import_utils3.isObject)(objProp2)) {
+      o[prop2] = deepCloneExtend(objProp2);
+    } else if ((0, import_utils3.isArray)(objProp2)) {
+      o[prop2] = objProp2.map((x) => x);
+    } else
+      o[prop2] = objProp2;
+  }
+  return o;
+};
+var deepMergeExtend = (element, extend) => {
+  for (const e in extend) {
+    if (["parent", "node", "__element"].indexOf(e) > -1)
+      continue;
+    const elementProp = element[e];
+    const extendProp = extend[e];
+    if (elementProp === void 0) {
+      element[e] = extendProp;
+    } else if ((0, import_utils3.isObject)(elementProp) && (0, import_utils3.isObject)(extendProp)) {
+      deepMergeExtend(elementProp, extendProp);
+    } else if ((0, import_utils3.isArray)(elementProp) && (0, import_utils3.isArray)(extendProp)) {
+      element[e] = elementProp.concat(extendProp);
+    } else if ((0, import_utils3.isArray)(elementProp) && (0, import_utils3.isObject)(extendProp)) {
+      const obj2 = deepMergeExtend({}, elementProp);
+      element[e] = deepMergeExtend(obj2, extendProp);
+    } else if (elementProp === void 0 && (0, import_utils3.isFunction)(extendProp)) {
+      element[e] = extendProp;
+    }
+  }
+  return element;
+};
+var cloneAndMergeArrayExtend = (stack) => {
+  return stack.reduce((a, c) => {
+    return deepMergeExtend(a, deepCloneExtend(c));
+  }, {});
+};
+var jointStacks = (extendStack, childExtendStack) => {
+  return [].concat(extendStack.slice(0, 1)).concat(childExtendStack.slice(0, 1)).concat(extendStack.slice(1)).concat(childExtendStack.slice(1));
+};
+var getExtendStack = (extend) => {
+  if (!extend)
+    return [];
+  if (extend.__hash)
+    return getHashedExtend(extend) || [];
+  const stack = flattenExtend(extend, []);
+  return getExtendStackRegistry(extend, stack);
+};
+
+// src/element/cache.js
+var cachedElements = {};
+var createNode = (element) => {
+  const { tag } = element;
+  if (tag) {
+    if (tag === "string")
+      return document2.createTextNode(element.text);
+    else if (tag === "fragment") {
+      return document2.createDocumentFragment();
+    } else if (tag === "svg" || tag === "path") {
+      return document2.createElementNS("http://www.w3.org/2000/svg", tag);
+    } else
+      return document2.createElement(tag);
+  } else {
+    return document2.createElement("div");
+  }
+};
+var detectTag = (element) => {
+  let { tag, key } = element;
+  tag = (0, import_utils4.exec)(tag, element);
+  if (tag === true)
+    tag = key;
+  if ((0, import_utils4.isString)(tag)) {
+    const tagExists = isTagRegistered(tag) > -1;
+    if (tagExists)
+      return tag;
+  } else {
+    const isKeyATag = isTagRegistered(key) > -1;
+    if (isKeyATag)
+      return key;
+  }
+  return "div";
+};
+var cache_default = (element) => {
+  const tag = element.tag = detectTag(element);
+  if (!can_exports.render(element)) {
+    return report("HTMLInvalidTag");
+  }
+  let cachedTag = cachedElements[tag];
+  if (!cachedTag)
+    cachedTag = cachedElements[tag] = createNode(element);
+  const clonedNode = cachedTag.cloneNode(true);
+  if (tag === "string")
+    clonedNode.nodeValue = element.text;
+  return clonedNode;
+};
+
+// src/element/create.js
+var import_utils26 = __toESM(require_index_cjs());
+
+// src/element/node.js
+var import_utils19 = __toESM(require_index_cjs());
+
+// src/element/iterate.js
+var import_utils17 = __toESM(require_index_cjs());
+
+// src/element/methods.js
+var import_utils16 = __toESM(require_index_cjs());
+
+// src/element/mixins/attr.js
+var import_utils6 = __toESM(require_index_cjs());
+var attr_default = (params, element, node) => {
+  const { __ref } = element;
+  const { __attr } = __ref;
+  if ((0, import_utils6.isNot)("object"))
+    report("HTMLInvalidAttr", params);
+  if (params) {
+    for (const attr in params) {
+      const val = (0, import_utils6.exec)(params[attr], element);
+      if (val && node.setAttribute)
+        node.setAttribute(attr, val);
+      else if (node.removeAttribute)
+        node.removeAttribute(attr);
+      __attr[attr] = val;
+    }
+  }
+  console.groupEnd(params, __attr);
+};
+
+// src/element/mixins/classList.js
+var import_utils7 = __toESM(require_index_cjs());
+var assignClass = (element) => {
+  const { key } = element;
+  if (element.class === true)
+    element.class = key;
+  else if (!element.class && typeof key === "string" && key.charAt(0) === "_" && key.charAt(1) !== "_") {
+    element.class = key.slice(1);
+  }
+};
+var classify = (obj2, element) => {
+  let className = "";
+  for (const item in obj2) {
+    const param = obj2[item];
+    if (typeof param === "boolean" && param)
+      className += ` ${item}`;
+    else if (typeof param === "string")
+      className += ` ${param}`;
+    else if (typeof param === "function") {
+      className += ` ${(0, import_utils7.exec)(param, element)}`;
+    }
+  }
+  return className;
+};
+var classList_default = (params, element, node, live) => {
+  if (!params)
+    return;
+  const { key } = element;
+  if (params === true)
+    params = element.class = { key };
+  if ((0, import_utils7.isString)(params))
+    params = element.class = { default: params };
+  if ((0, import_utils7.isObject)(params))
+    params = classify(params, element);
+  const className = params.replace(/\s+/g, " ").trim();
+  node.classList = className;
+  return className;
+};
+
+// src/element/set.js
+var import_utils8 = __toESM(require_index_cjs());
+
+// src/element/options.js
+var options_default = {};
+
+// src/element/set.js
+var removeContentElement = function(el) {
+  const element = el || this;
+  const { __ref } = element;
+  if (element.content) {
+    if (element.content.node) {
+      if (element.content.tag === "fragment")
+        element.node.innerHTML = "";
+      else
+        element.node.removeChild(element.content.node);
+    }
+    const { __cached } = __ref;
+    if (__cached && __cached.content) {
+      if (__cached.content.tag === "fragment")
+        __cached.content.parent.node.innerHTML = "";
+      else if (__cached.content && (0, import_utils8.isFunction)(__cached.content.remove))
+        __cached.content.remove();
+    }
+    delete element.content;
+  }
+};
+var set = function(params, options = {}, el) {
+  const element = el || this;
+  const __contentRef = element.content && element.content.__ref;
+  const isEqual = (0, import_utils8.isEqualDeep)(params, element.content);
+  if (isEqual && __contentRef && __contentRef.__cached)
+    return element;
+  removeContentElement(element);
+  if (params) {
+    const { childExtend } = params;
+    if (!childExtend && element.childExtend)
+      params.childExtend = element.childExtend;
+    create_default(params, element, "content", {
+      ignoreChildExtend: true,
+      ...registry_default.defaultOptions,
+      ...options_default.create,
+      ...options
+    });
+  }
+  return element;
+};
+var set_default = set;
+
+// src/element/mixins/content.js
+var content_default = (param, element, node, options) => {
+  if (param && element) {
+    if (param.__hash === element.content.__hash && element.content.update) {
+      if (!element.content.__ref)
+        element.content.__ref = {};
+      element.content.update(param);
+    } else {
+      set_default.call(element, param, options);
+    }
+  }
+};
+
+// src/element/mixins/data.js
+var import_utils9 = __toESM(require_index_cjs());
+var data_default = (params, element, node) => {
+  if (params && params.showOnNode) {
+    if (!(0, import_utils9.isObject)(params))
+      report("HTMLInvalidData", params);
+    for (const dataset in params) {
+      if (dataset !== "showOnNode") {
+        node.dataset[dataset] = (0, import_utils9.exec)(params[dataset], element);
+      }
+    }
+  }
+};
+
+// src/element/mixins/html.js
+var import_utils10 = __toESM(require_index_cjs());
+var html_default = (param, element, node) => {
+  const prop2 = (0, import_utils10.exec)(param, element);
+  const { __ref } = element;
+  if (prop2 !== __ref.__html) {
+    if (node.nodeName === "SVG")
+      node.textContent = prop2;
+    else
+      node.innerHTML = prop2;
+    __ref.__html = prop2;
+  }
+};
+
+// src/element/mixins/style.js
+var import_utils11 = __toESM(require_index_cjs());
+var style_default = (params, element, node) => {
+  if (params) {
+    if ((0, import_utils11.isObject)(params))
+      (0, import_utils11.map)(node.style, params, element);
+    else
+      report("HTMLInvalidStyles", params);
+  }
+};
+
+// src/element/mixins/text.js
+var import_utils12 = __toESM(require_index_cjs());
+var text_default = (param, element, node) => {
+  const prop2 = (0, import_utils12.exec)(param, element);
+  if (element.tag === "string") {
+    if (element.text === prop2)
+      return;
+    node.nodeValue = prop2;
+  } else if (param !== void 0 || param !== null) {
+    if (element.__text) {
+      if (element.__text.text === prop2)
+        return;
+      element.__text.text = prop2;
+      if (element.__text.node)
+        element.__text.node.nodeValue = prop2;
+    } else
+      create_default({ tag: "string", text: prop2 }, element, "__text");
+  }
+};
+
+// src/element/mixins/state.js
+var import_utils15 = __toESM(require_index_cjs());
+
+// src/element/state.js
+var import_utils13 = __toESM(require_index_cjs());
+var IGNORE_STATE_PARAMS = [
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__root",
+  "__components",
+  "__projectSystem",
+  "__projectState",
+  "__projectComponents",
+  "__projectPages",
+  "__projectSnippets",
+  "projectStateUpdate",
+  "projectSystemUpdate"
+];
+var parseState = function() {
+  const state = this;
+  const parseState2 = {};
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param)) {
+      parseState2[param] = state[param];
+    }
+  }
+  return parseState2;
+};
+var cleanState = function() {
+  const state = this;
+  for (const param in state) {
+    if (!IGNORE_STATE_PARAMS.includes(param)) {
+      delete state[param];
+    }
+  }
+  return state;
+};
+var projectSystemUpdate = function(obj2, options = {}) {
+  const state = this;
+  if (!state)
+    return;
+  const rootState = (state.__element.__ref.__root || state.__element).state;
+  rootState.update({ PROJECT_SYSTEM: obj2 }, options);
+  return state;
+};
+var projectStateUpdate = function(obj2, options = {}) {
+  const state = this;
+  if (!state)
+    return;
+  const rootState = (state.__element.__ref.__root || state.__element).state;
+  rootState.update({ PROJECT_STATE: obj2 }, options);
+  return state;
+};
+var updateState = function(obj2, options = {}) {
+  const state = this;
+  const element = state.__element;
+  const __elementRef = element.__ref;
+  state.parent = element.parent.state;
+  if (!state.__element)
+    createState(element, element.parent);
+  if (element.on && (0, import_utils13.isFunction)(element.on.initStateUpdated)) {
+    const initReturns = on_exports.initStateUpdated(element.on.initStateUpdated, element, state, obj2);
+    if (initReturns === false)
+      return;
+  }
+  const stateKey = __elementRef.__state;
+  if (stateKey) {
+    if (state.parent && state.parent[stateKey]) {
+      const keyInParentState = state.parent[stateKey];
+      if (keyInParentState && !options.stopStatePropogation) {
+        if (__elementRef.__stateType === "string") {
+          return state.parent.update({ [stateKey]: obj2.value }, options);
+        }
+        return state.parent.update({ [stateKey]: obj2 }, options);
+      }
+    }
+  } else {
+    if (options && options.shallow) {
+      overwriteShallow(state, obj2, IGNORE_STATE_PARAMS);
+    } else {
+      overwriteDeep2(state, obj2, IGNORE_STATE_PARAMS);
+    }
+  }
+  if (!options.preventUpdate) {
+    element.update({}, options);
+  } else if (options.preventUpdate === "recursive") {
+    element.update({}, { ...options, preventUpdate: true });
+  }
+  if (state.__depends) {
+    for (const el in state.__depends) {
+      const findElement = state.__depends[el];
+      findElement.clean().update(state.parse(), options);
+    }
+  }
+  if (!options.preventUpdateListener && element.on && (0, import_utils13.isFunction)(element.on.stateUpdated)) {
+    on_exports.stateUpdated(element.on.stateUpdated, element, state, obj2);
+  }
+};
+var createState = function(element, parent, opts) {
+  const skip = opts && opts.skip ? opts.skip : false;
+  let { state, __ref: __elementRef } = element;
+  if ((0, import_utils13.isFunction)(state))
+    state = (0, import_utils13.exec)(state, element);
+  if ((0, import_utils13.is)(state)("string", "number")) {
+    __elementRef.__state = state;
+    state = {};
+  }
+  if (state === true) {
+    __elementRef.__state = element.key;
+    state = {};
+  }
+  if (!state) {
+    if (parent && parent.state)
+      return parent.state;
+    return {};
+  } else {
+    __elementRef.__hasRootState = true;
+  }
+  if (element.on && (0, import_utils13.isFunction)(element.on.stateInit)) {
+    on_exports.stateInit(element.on.stateInit, element, element.state);
+  }
+  let stateKey = __elementRef.__state;
+  if (stateKey) {
+    let parentState = parent.state;
+    const parentKeysArr = stateKey.split("../");
+    for (let i = 1; i < parentKeysArr.length; i++) {
+      stateKey = parentKeysArr[i];
+      parentState = parentState.parent;
+    }
+    const childrenKeysArr = stateKey.split(".");
+    for (let i = 0; i < childrenKeysArr.length; i++) {
+      const childKey = childrenKeysArr[i];
+      const grandChildKey = childrenKeysArr[i + 1];
+      const childInParent = parentState[childKey];
+      if (childInParent && childInParent[grandChildKey]) {
+        stateKey = grandChildKey;
+        parentState = childInParent;
+      }
+    }
+    if (parentState && parentState[stateKey]) {
+      const keyInParentState = parentState[stateKey];
+      if ((0, import_utils13.is)(keyInParentState)("object", "array")) {
+        state = deepClone2(keyInParentState);
+      } else if ((0, import_utils13.is)(keyInParentState)("string", "number")) {
+        state = { value: keyInParentState };
+        __elementRef.__stateType = "string";
+      } else if ((0, import_utils13.isUndefined)(keyInParentState)) {
+        console.warn(stateKey, "is not in present", "replacing with ", {});
+        state = {};
+      }
+    }
+  }
+  const { __ref } = state;
+  if (__ref) {
+    state = deepClone2(__ref, IGNORE_STATE_PARAMS);
+    if ((0, import_utils13.isObject)(__ref.__depends)) {
+      __ref.__depends[element.key] = state;
+    } else
+      __ref.__depends = { [element.key]: state };
+  } else {
+    state = deepClone2(state, IGNORE_STATE_PARAMS);
+  }
+  element.state = state;
+  if (skip)
+    return state;
+  state.clean = cleanState;
+  state.parse = parseState;
+  state.update = updateState;
+  state.create = createState;
+  state.parent = element.parent.state;
+  state.__element = element;
+  state.__root = __elementRef.__root ? __elementRef.__root.state : state;
+  state.projectSystemUpdate = projectSystemUpdate;
+  state.projectStateUpdate = projectStateUpdate;
+  state.__components = state.__root.COMPONENTS;
+  state.__projectSystem = state.__root.PROJECT_SYSTEM;
+  state.__projectState = state.__root.PROJECT_STATE;
+  state.__projectComponents = state.__root.PROJECT_COMPONENTS;
+  state.__projectPages = state.__root.PROJECT_PAGES;
+  state.__projectSnippets = state.__root.PROJECT_SNIPPETS;
+  if (element.on && (0, import_utils13.isFunction)(element.on.stateCreated)) {
+    on_exports.stateCreated(element.on.stateCreated, element, state);
+  }
+  return state;
+};
+var state_default = createState;
+
+// src/element/mixins/state.js
+var state_default2 = (params, element, node) => {
+  const state = (0, import_utils15.exec)(params, element);
+  if ((0, import_utils15.isObject)(state)) {
+    for (const param in state) {
+      if (IGNORE_STATE_PARAMS.includes(param))
+        continue;
+      element.state[param] = (0, import_utils15.exec)(state[param], element);
+    }
+  }
+  return element;
+};
+
+// src/element/mixins/registry.js
+var registry_default = {
+  attr: attr_default,
+  style: style_default,
+  text: text_default,
+  html: html_default,
+  content: content_default,
+  data: data_default,
+  class: classList_default,
+  state: state_default2,
+  extend: {},
+  childExtend: {},
+  childExtendRecursive: {},
+  props: {},
+  path: {},
+  if: {},
+  define: {},
+  transform: {},
+  __ref: {},
+  __hash: {},
+  __text: {},
+  nextElement: {},
+  previousElement: {},
+  key: {},
+  tag: {},
+  query: {},
+  parent: {},
+  node: {},
+  set: {},
+  update: {},
+  setProps: {},
+  remove: {},
+  removeContent: {},
+  lookup: {},
+  spotByPath: {},
+  keys: {},
+  log: {},
+  parse: {},
+  parseDeep: {},
+  on: {},
+  component: {},
+  context: {}
+};
+var parseFilters = {
+  elementKeys: [
+    "tag",
+    "text",
+    "style",
+    "attr",
+    "class",
+    "state",
+    "class",
+    "data",
+    "content",
+    "html",
+    "on"
+  ],
+  propsKeys: ["__element"],
+  stateKeys: []
+};
+
+// src/element/methods.js
+var ENV = "development";
+var lookup = function(key) {
+  const element = this;
+  let { parent } = element;
+  while (parent.key !== key) {
+    if (parent[key])
+      return parent[key];
+    parent = parent.parent;
+    if (!parent)
+      return;
+  }
+  return parent;
+};
+var spotByPath = function(path) {
+  const element = this;
+  const arr = [].concat(path);
+  let active = root_default[arr[0]];
+  if (!arr || !arr.length)
+    return console.log(arr, "on", element.key, "is undefined");
+  while (active.key === arr[0]) {
+    arr.shift();
+    if (!arr.length)
+      break;
+    active = active[arr[0]];
+    if (!active)
+      return;
+  }
+  return active;
+};
+var remove = function(params) {
+  const element = this;
+  if ((0, import_utils16.isFunction)(element.node.remove))
+    element.node.remove();
+  else if (ENV === "test" || ENV === "development") {
+    console.warn("This item cant be removed");
+    element.log();
+  }
+  delete element.parent[element.key];
+};
+var setProps = function(param, options) {
+  const element = this;
+  if (!param || !element.props)
+    return;
+  element.update({ props: param }, options);
+  return element;
+};
+var keys = function() {
+  const element = this;
+  const keys2 = [];
+  for (const param in element) {
+    if (registry_default[param] && !parseFilters.elementKeys.includes(param)) {
+      continue;
+    }
+    keys2.push(param);
+  }
+  return keys2;
+};
+var parse = function() {
+  const element = this;
+  const obj2 = {};
+  const keyList = keys.call(element);
+  keyList.forEach((v) => obj2[v] = element[v]);
+  return obj2;
+};
+var parseDeep = function() {
+  const element = this;
+  const obj2 = parse.call(element);
+  for (const k in obj2) {
+    if ((0, import_utils16.isObjectLike)(obj2[k])) {
+      obj2[k] = parseDeep.call(obj2[k]);
+    }
+  }
+  return obj2;
+};
+var log = function(...args) {
+  const element = this;
+  const { __ref } = element;
+  console.group(element.key);
+  if (args.length) {
+    args.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+  } else {
+    console.log(__ref.path);
+    const keys2 = element.keys();
+    keys2.forEach((v) => console.log(`%c${v}:
+`, "font-weight: bold", element[v]));
+  }
+  console.groupEnd(element.key);
+  return element;
+};
+var isMethod = function(param) {
+  return param === "set" || param === "update" || param === "remove" || param === "removeContent" || param === "lookup" || param === "spotByPath" || param === "keys" || param === "parse" || param === "setProps" || param === "parseDeep" || param === "if" || param === "log" || param === "nextElement" || param === "previousElement";
+};
+var nextElement = function() {
+  const element = this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  const currentIndex = __children.indexOf(key);
+  const nextChild = __children[currentIndex + 1];
+  console.log(nextChild);
+  return parent[nextChild];
+};
+var previousElement = function(el) {
+  const element = el || this;
+  const { key, parent } = element;
+  const { __children } = parent.__ref;
+  if (!__children)
+    return;
+  const currentIndex = __children.indexOf(key);
+  return parent[__children[currentIndex - 1]];
+};
+
+// src/element/iterate.js
+var applyEvents = (element) => {
+  const { node, on } = element;
+  for (const param in on) {
+    if (param === "init" || param === "render" || param === "update")
+      continue;
+    const appliedFunction = element.on[param];
+    if ((0, import_utils17.isFunction)(appliedFunction)) {
+      node.addEventListener(
+        param,
+        (event) => appliedFunction(event, element, element.state),
+        true
+      );
+    }
+  }
+};
+var throughInitialExec = (element) => {
+  const { __ref } = element;
+  const { __exec } = __ref;
+  for (const param in element) {
+    const prop2 = element[param];
+    if ((0, import_utils17.isFunction)(prop2) && !isMethod(param)) {
+      __exec[param] = prop2;
+      element[param] = prop2(element, element.state);
+    }
+  }
+};
+var throughUpdatedExec = (element, options) => {
+  const { __ref } = element;
+  const { __exec, __cached } = __ref;
+  const changes = {};
+  for (const param in __exec) {
+    const prop2 = element[param];
+    const newExec = __exec[param](element, element.state);
+    if (prop2 && prop2.node && ((0, import_utils17.isString)(newExec) || (0, import_utils17.isNumber)(newExec))) {
+      overwrite2(prop2, { text: newExec }, options);
+    } else if (newExec !== prop2) {
+      __cached[param] = changes[param] = prop2;
+      element[param] = newExec;
+    }
+  }
+  return changes;
+};
+var throughInitialDefine = (element) => {
+  const { define, context, __ref } = element;
+  const { __exec, __cached } = __ref;
+  let obj2 = {};
+  if ((0, import_utils17.isObject)(define))
+    obj2 = { ...define };
+  if (context && (0, import_utils17.isObject)(context.define))
+    obj2 = { ...obj2, ...context.define };
+  for (const param in obj2) {
+    let prop2 = element[param];
+    if ((0, import_utils17.isFunction)(prop2) && !isMethod(param)) {
+      __exec[param] = prop2;
+      element[param] = prop2 = (0, import_utils17.exec)(prop2, element);
+    }
+    __cached[param] = prop2;
+    element[param] = obj2[param](prop2, element, element.state);
+  }
+  return element;
+};
+var throughUpdatedDefine = (element) => {
+  const { context, define, __ref } = element;
+  const { __exec, __cached } = __ref;
+  const changes = {};
+  let obj2 = {};
+  if ((0, import_utils17.isObject)(define))
+    obj2 = { ...define };
+  if ((0, import_utils17.isObject)(context && context.define))
+    obj2 = { ...obj2, ...context.define };
+  for (const param in obj2) {
+    const execParam = __exec[param];
+    if (execParam)
+      __cached[param] = execParam(element, element.state);
+    const cached = (0, import_utils17.exec)(__cached[param], element);
+    element[param] = obj2[param](cached, element, element.state);
+  }
+  return changes;
+};
+
+// src/element/node.js
+var ENV2 = "development";
+var createNode2 = (element, options) => {
+  let { node, tag, context, __ref } = element;
+  let isNewNode;
+  if (!node) {
+    isNewNode = true;
+    if (!__ref.__if)
+      return element;
+    if (tag === "shadow") {
+      node = element.node = element.parent.node.attachShadow({ mode: "open" });
+    } else
+      node = element.node = cache_default(element);
+    if (element.on && (0, import_utils19.isFunction)(element.on.attachNode)) {
+      attachNode(element.on.attachNode, element, element.state);
+    }
+  }
+  if (ENV2 === "test" || ENV2 === "development") {
+    node.ref = element;
+    if ((0, import_utils19.isFunction)(node.setAttribute))
+      node.setAttribute("key", element.key);
+  }
+  if (!__ref.__if)
+    return element;
+  if (element.tag !== "string" || element.tag !== "fragment") {
+    throughInitialDefine(element);
+    throughInitialExec(element);
+    if (isNewNode && (0, import_utils19.isObject)(element.on))
+      applyEvents(element);
+    for (const param in element) {
+      const prop2 = element[param];
+      if (isMethod(param) || (0, import_utils19.isObject)(registry_default[param]) || prop2 === void 0)
+        continue;
+      const DOMQLProperty = registry_default[param];
+      const DOMQLPropertyFromContext = context && context.registry && context.registry[param];
+      const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
+      const hasDefine = element.define && element.define[param];
+      const hasContextDefine = context && context.define && context.define[param];
+      if (isGlobalTransformer && !hasContextDefine) {
+        if ((0, import_utils19.isFunction)(isGlobalTransformer))
+          isGlobalTransformer(prop2, element, node, options);
+      } else if (element[param] && !hasDefine && !hasContextDefine) {
+        create_default((0, import_utils19.exec)(prop2, element), element, param, options);
+      }
+    }
+  }
+  return element;
+};
+var node_default = createNode2;
+
+// src/element/assign.js
+var appendNode = (node, parentNode) => {
+  parentNode.appendChild(node);
+  return node;
+};
+var assignNode = (element, parent, key) => {
+  parent[key || element.key] = element;
+  if (element.tag !== "shadow") {
+    appendNode(element.node, parent.node);
+  }
+  return element;
+};
+
+// src/element/extend.js
+var import_utils20 = __toESM(require_index_cjs());
+var ENV3 = "development";
+var applyExtend = (element, parent, options = {}) => {
+  if ((0, import_utils20.isFunction)(element))
+    element = (0, import_utils20.exec)(element, parent);
+  let { extend, props, context, __ref } = element;
+  const COMPONENTS = context && context.components || options.components;
+  if ((0, import_utils20.isString)(extend))
+    extend = COMPONENTS[extend];
+  const extendStack = getExtendStack(extend);
+  if (ENV3 !== "test" || ENV3 !== "development")
+    delete element.extend;
+  let childExtendStack = [];
+  if (parent) {
+    element.parent = parent;
+    if (!options.ignoreChildExtend) {
+      if (props && props.ignoreChildExtend)
+        return;
+      childExtendStack = getExtendStack(parent.childExtend);
+      if (parent.childExtendRecursive) {
+        const childExtendRecursiveStack = getExtendStack(parent.childExtendRecursive);
+        childExtendStack = childExtendStack.concat(childExtendRecursiveStack);
+        element.childExtendRecursive = parent.childExtendRecursive;
+      }
+    }
+  }
+  const extendLength = extendStack.length;
+  const childExtendLength = childExtendStack.length;
+  let stack = [];
+  if (extendLength && childExtendLength) {
+    stack = jointStacks(extendStack, childExtendStack);
+  } else if (extendLength) {
+    stack = extendStack;
+  } else if (childExtendLength) {
+    stack = childExtendStack;
+  } else if (!options.extend)
+    return element;
+  if (options.extend) {
+    const defaultOptionsExtend = getExtendStack(options.extend);
+    stack = [].concat(stack, defaultOptionsExtend);
+  }
+  __ref.__extend = stack;
+  let mergedExtend = cloneAndMergeArrayExtend(stack);
+  const component = (0, import_utils20.exec)(element.component || mergedExtend.component, element);
+  if (component && COMPONENTS && COMPONENTS[component]) {
+    const componentExtend = cloneAndMergeArrayExtend(getExtendStack(COMPONENTS[component]));
+    mergedExtend = deepMergeExtend(componentExtend, mergedExtend);
+  }
+  return deepMergeExtend(element, mergedExtend);
+};
+
+// src/element/props.js
+var import_utils22 = __toESM(require_index_cjs());
+var createPropsStack = (element, parent) => {
+  const { props, __ref } = element;
+  const propsStack = __ref.propsStack = [];
+  const isMatch = (0, import_utils22.isString)(props) && props.indexOf("match") > -1;
+  const matchParent = parent.props && parent.props[element.key];
+  const matchParentChild = parent.props && parent.props.childProps;
+  const objectizeStringProperty = (propValue) => {
+    if ((0, import_utils22.isString)(propValue))
+      return { inheritedString: propValue };
+    return propValue;
+  };
+  if (matchParent && props !== "match")
+    propsStack.push(matchParent);
+  if (matchParentChild)
+    propsStack.push(matchParentChild);
+  if ((0, import_utils22.isObject)(props)) {
+    propsStack.push(props);
+  }
+  if (props === "inherit") {
+    if (parent.props)
+      propsStack.push(parent.props);
+  } else if (isMatch) {
+    const hasArg = props.split(" ");
+    let matchParentValue;
+    if (hasArg[1] && parent.props[hasArg[1]]) {
+      const secondArgasParentMatchProp = parent.props[hasArg[1]];
+      propsStack.push(
+        objectizeStringProperty(secondArgasParentMatchProp)
+      );
+    } else if (matchParent) {
+      propsStack.push(
+        objectizeStringProperty(matchParent)
+      );
+    }
+    propsStack.push(matchParentValue);
+  } else if (props)
+    propsStack.push(props);
+  if ((0, import_utils22.isArray)(__ref.__extend)) {
+    __ref.__extend.map((extend) => {
+      if (extend.props)
+        propsStack.push(extend.props);
+      return extend.props;
+    });
+  }
+  return propsStack;
+};
+var inheritProps = (element, parent) => {
+  element.props = parent && parent.props || { update: update2, __element: element };
+};
+var syncProps = (props, element) => {
+  element.props = {};
+  const mergedProps = { update: update2, __element: element };
+  props.forEach((v) => {
+    if (v === "update" || v === "__element")
+      return;
+    const execProps = (0, import_utils22.exec)(v, element);
+    if ((0, import_utils22.isObject)(execProps) && execProps.__element)
+      return;
+    element.props = deepMerge2(mergedProps, deepClone2(execProps));
+  });
+  element.props = mergedProps;
+  return element.props;
+};
+var createProps = function(element, parent, cached) {
+  const propsStack = cached || createPropsStack(element, parent);
+  const { __ref } = element;
+  if (propsStack.length) {
+    __ref.__props = propsStack;
+    syncProps(propsStack, element);
+    element.props.update = update2;
+  } else
+    inheritProps(element, parent);
+  return element;
+};
+var updateProps = (newProps, element, parent) => {
+  const { __ref } = element;
+  let propsStack = __ref.__props;
+  if (newProps)
+    propsStack = __ref.__props = [].concat(newProps, propsStack);
+  if (propsStack)
+    syncProps(propsStack, element);
+  else
+    inheritProps(element, parent);
+  return element;
+};
+function update2(props, options) {
+  const element = this.__element;
+  element.update({ props }, options);
+}
+var props_default = createProps;
+
+// src/element/update.js
+var import_utils24 = __toESM(require_index_cjs());
+var snapshot = {
+  snapshotId: import_utils24.createSnapshotId
+};
+var UPDATE_DEFAULT_OPTIONS = {
+  stackChanges: false,
+  cleanExec: true,
+  preventRecursive: false,
+  currentSnapshot: false,
+  calleeElement: false
+};
+var update3 = function(params = {}, options = UPDATE_DEFAULT_OPTIONS) {
+  const element = this;
+  const { parent, node, context } = element;
+  let __ref = element.__ref;
+  if (!__ref)
+    __ref = element.__ref = {};
+  const { currentSnapshot, calleeElement } = options;
+  if (!calleeElement) {
+    __ref.__currentSnapshot = snapshot.snapshotId();
+  }
+  const snapshotOnCallee = __ref.__currentSnapshot || calleeElement && calleeElement.__ref && calleeElement.__currentSnapshot;
+  if (snapshotOnCallee && currentSnapshot < snapshotOnCallee) {
+  }
+  if ((0, import_utils24.isString)(params) || (0, import_utils24.isNumber)(params)) {
+    params = { text: params };
+  }
+  if ((0, import_utils24.isFunction)(element.if)) {
+    const ifPassed = element.if(element, element.state);
+    const itWasFalse = !__ref.__if;
+    if (ifPassed)
+      __ref.__if = true;
+    if (itWasFalse && ifPassed) {
+      delete element.__hash;
+      if (!__ref.__hasRootState)
+        delete element.state;
+      if (__ref.__state)
+        element.state = __ref.__state;
+      const created = create_default(element, element.parent, element.key);
+      if (!options.preventUpdate && element.on && (0, import_utils24.isFunction)(element.on.update)) {
+        on_exports.update(element.on.update, created, created.state);
+      }
+      return created;
+    } else if (element.node && !ifPassed) {
+      element.node.remove();
+      delete __ref.__if;
+    }
+  }
+  if (__ref.__state) {
+    const keyInParentState = parent.state[__ref.__state];
+    if (keyInParentState) {
+      const newState = __ref.__stateType === "string" ? state_default(element, parent) : state_default(element, parent);
+      const changes = (0, import_utils24.diff)(newState.parse(), element.state.parse());
+      if (element.on && (0, import_utils24.isFunction)(element.on.initStateUpdated)) {
+        const initReturns = on_exports.initStateUpdated(element.on.initStateUpdated, element, element.state, changes);
+        if (initReturns === false)
+          return;
+      }
+      element.state = newState;
+      if (!options.preventUpdateListener && element.on && (0, import_utils24.isFunction)(element.on.stateUpdated)) {
+        on_exports.stateUpdated(element.on.stateUpdated, element, element.state, changes);
+      }
+    }
+  } else if (!__ref.__hasRootState)
+    element.state = parent && parent.state || {};
+  if (__ref.__if && !options.preventPropsUpdate)
+    updateProps(params.props, element, parent);
+  if (element.on && (0, import_utils24.isFunction)(element.on.initUpdate) && !options.ignoreInitUpdate) {
+    const whatinitreturns = on_exports.initUpdate(element.on.initUpdate, element, element.state);
+    if (whatinitreturns === false)
+      return;
+  }
+  const overwriteChanges = overwrite2(element, params, UPDATE_DEFAULT_OPTIONS);
+  const execChanges = throughUpdatedExec(element, UPDATE_DEFAULT_OPTIONS);
+  const definedChanges = throughUpdatedDefine(element);
+  if (options.stackChanges && element.__stackChanges) {
+    const stackChanges = merge2(definedChanges, merge2(execChanges, overwriteChanges));
+    element.__stackChanges.push(stackChanges);
+  }
+  if (!__ref.__if)
+    return false;
+  if (!node) {
+    return;
+  }
+  for (const param in element) {
+    const prop2 = element[param];
+    if (options.preventDefineUpdate === true || options.preventDefineUpdate === param || options.preventContentUpdate && param === "content" || (options.preventStateUpdate && param) === "state" || isMethod(param) || (0, import_utils24.isObject)(registry_default[param]) || prop2 === void 0)
+      continue;
+    if (options.preventStateUpdate === "once")
+      options.preventStateUpdate = false;
+    const DOMQLProperty = registry_default[param];
+    const DOMQLPropertyFromContext = context && context.registry && context.registry[param];
+    const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
+    const hasDefine = element.define && element.define[param];
+    const hasContextDefine = context && context.define && context.define[param];
+    if (isGlobalTransformer && !hasContextDefine) {
+      if ((0, import_utils24.isFunction)(isGlobalTransformer))
+        isGlobalTransformer(prop2, element, node, options);
+    } else if (prop2 && (0, import_utils24.isObject)(prop2) && !hasDefine && !hasContextDefine) {
+      if (!options.preventRecursive) {
+        const childUpdateCall = () => update3.call(prop2, params[prop2], {
+          ...options,
+          currentSnapshot: snapshotOnCallee,
+          calleeElement: element
+        });
+        if (element.props.lazyLoad || options.lazyLoad) {
+          window2.requestAnimationFrame(() => childUpdateCall());
+        } else
+          childUpdateCall();
+      }
+    }
+  }
+  if (!options.preventUpdate && element.on && (0, import_utils24.isFunction)(element.on.update)) {
+    on_exports.update(element.on.update, element, element.state);
+  }
+};
+var update_default = update3;
+
+// src/element/create.js
+var ENV4 = "development";
+var create = (element, parent, key, options = options_default.create || {}) => {
+  if (options && !options_default.create)
+    options_default.create = options;
+  if (element === void 0) {
+    if (ENV4 === "test" || ENV4 === "development") {
+      console.warn(key, "element is undefined in", parent && parent.__ref && parent.__ref.path);
+    }
+    element = {};
+  }
+  if ((0, import_utils26.isString)(key) && key.slice(0, 2 === "__")) {
+    if (ENV4 === "test" || ENV4 === "development") {
+      console.warn(key, "seems like to be in __ref");
+    }
+  }
+  if (element === null)
+    return;
+  if (element === true)
+    element = { text: true };
+  if (element.__hash) {
+    element = { extend: element };
+  }
+  if (!parent)
+    parent = root_default;
+  if ((0, import_utils26.isNode)(parent))
+    parent = root_default[`${key}_parent`] = { key: ":root", node: parent };
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent, key);
+  }
+  const assignedKey = (element.key || key || (0, import_utils26.createID)()).toString();
+  if (checkIfKeyIsComponent(assignedKey)) {
+    element = applyKeyComponentAsExtend(element, parent, assignedKey);
+  }
+  if (checkIfMedia(assignedKey)) {
+    element = applyMediaProps(element, parent, assignedKey);
+  }
+  if (element.__ref)
+    element.__ref.origin = element;
+  else
+    element.__ref = { origin: element };
+  const __ref = element.__ref;
+  applyContext(element, parent, options);
+  const { context } = element;
+  if (context && context.components)
+    applyComponentFromContext(element, parent, options);
+  applyExtend(element, parent, options);
+  element.key = assignedKey;
+  if (options.onlyResolveExtends)
+    return resolveExtends(element, parent, options);
+  if (Object.keys(options).length) {
+    registry_default.defaultOptions = options;
+    if (options.ignoreChildExtend)
+      delete options.ignoreChildExtend;
+  }
+  addCaching(element, parent);
+  addMethods(element, parent);
+  element.state = state_default(element, parent);
+  checkIf(element, parent);
+  if (element.node && __ref.__if) {
+    return assignNode(element, parent, assignedKey);
+  }
+  if (__ref.__if)
+    props_default(element, parent);
+  if (element.on && (0, import_utils26.isFunction)(element.on.init)) {
+    on_exports.init(element.on.init, element, element.state);
+  }
+  if (element.on && (0, import_utils26.isFunction)(element.on.beforeClassAssign)) {
+    on_exports.beforeClassAssign(element.on.beforeClassAssign, element, element.state);
+  }
+  assignClass(element);
+  node_default(element, options);
+  if (!__ref.__if)
+    return element;
+  assignNode(element, parent, key);
+  if (element.on && (0, import_utils26.isFunction)(element.on.render)) {
+    on_exports.render(element.on.render, element, element.state);
+  }
+  if (parent.__ref && parent.__ref.__children)
+    parent.__ref.__children.push(element.key);
+  return element;
+};
+var checkIfPrimitive = (element) => {
+  return (0, import_utils26.is)(element)("string", "number");
+};
+var applyValueAsText = (element, parent, key) => {
+  const extendTag = element.extend && element.extend.tag;
+  const childExtendTag = parent.childExtend && parent.childExtend.tag;
+  const isKeyValidHTMLTag = TAGS.body.indexOf(key) > -1 && key;
+  return {
+    text: element,
+    tag: extendTag || childExtendTag || isKeyValidHTMLTag || "string"
+  };
+};
+var addMethods = (element, parent) => {
+  element.set = set_default;
+  element.update = update_default;
+  element.remove = remove;
+  element.removeContent = removeContentElement;
+  element.setProps = setProps;
+  element.lookup = lookup;
+  element.spotByPath = spotByPath;
+  element.parse = parse;
+  element.parseDeep = parseDeep;
+  element.keys = keys;
+  element.nextElement = nextElement;
+  element.previousElement = previousElement;
+  if (ENV4 === "test" || ENV4 === "development") {
+    element.log = log;
+  }
+};
+var applyContext = (element, parent, options) => {
+  if (options.context && !root_default.context && !element.context)
+    root_default.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || root_default.context;
+};
+var checkIf = (element, parent) => {
+  const { __ref } = element;
+  if ((0, import_utils26.isFunction)(element.if)) {
+    const ifPassed = element.if(element, element.state);
+    if (!ifPassed) {
+      const ifFragment = cache_default({ tag: "fragment" });
+      __ref.__ifFragment = appendNode(ifFragment, parent.node);
+      delete __ref.__if;
+    } else
+      __ref.__if = true;
+  } else
+    __ref.__if = true;
+};
+var addCaching = (element, parent) => {
+  const { __ref } = element;
+  let { __ref: __parentRef } = parent;
+  if (!element.transform)
+    element.transform = {};
+  if (!__ref.__cached)
+    __ref.__cached = {};
+  if (!__ref.__exec)
+    __ref.__exec = {};
+  if (!__ref.__class)
+    __ref.__class = {};
+  if (!__ref.__classNames)
+    __ref.__classNames = {};
+  if (!__ref.__attr)
+    __ref.__attr = {};
+  if (!__ref.__changes)
+    __ref.__changes = [];
+  if (!__ref.__children)
+    __ref.__children = [];
+  const hasRoot = parent && parent.key === ":root";
+  if (!__ref.__root)
+    __ref.__root = hasRoot ? element : parent.__ref.__root;
+  if (ENV4 === "test" || ENV4 === "development") {
+    if (!__parentRef)
+      __parentRef = parent.__ref = {};
+    if (!__parentRef.__path)
+      __parentRef.__path = [];
+    __ref.__path = __parentRef.__path.concat(element.key);
+  }
+};
+var resolveExtends = (element, parent, options) => {
+  const { __ref } = element;
+  element.tag = detectTag(element);
+  if (!__ref.__exec)
+    __ref.__exec = {};
+  if (!__ref.__attr)
+    __ref.__attr = {};
+  element.props = props_default(element, parent);
+  element.state = state_default(element, parent, { skip: true });
+  throughInitialExec(element);
+  for (const param in element) {
+    const prop2 = element[param];
+    if (isMethod(param) || (0, import_utils26.isObject)(registry_default[param]) || prop2 === void 0)
+      continue;
+    const hasDefined = element.define && element.define[param];
+    const ourParam = registry_default[param];
+    const hasOptionsDefine = options.define && options.define[param];
+    if (ourParam && !hasOptionsDefine) {
+      continue;
+    } else if (element[param] && !hasDefined && !hasOptionsDefine) {
+      create((0, import_utils26.exec)(prop2, element), element, param, options);
+    }
+  }
+  delete element.parent;
+  delete element.update;
+  delete element.__element;
+  delete element.__props;
+  delete element.props.props;
+  delete element.state.__element;
+  delete element.state.__element;
+  delete element.__hasRootState;
+  delete element.__ref;
+  return element;
+};
+var checkIfKeyIsComponent = (key) => {
+  const isFirstKeyString = (0, import_utils26.isString)(key);
+  if (!isFirstKeyString)
+    return;
+  const firstCharKey = key.slice(0, 1);
+  return /^[A-Z]*$/.test(firstCharKey);
+};
+var extendizeByKey = (element, parent, key) => {
+  const { extend, props, state, childExtend, childProps } = element;
+  const hasComponentAttrs = extend || childExtend || props || state || element.on;
+  const componentKey = key.split("_")[0];
+  if (!hasComponentAttrs || childProps) {
+    return {
+      extend: componentKey || key,
+      props: { ...element }
+    };
+  } else if (!extend || extend === true) {
+    return {
+      ...element,
+      extend: componentKey || key
+    };
+  }
+};
+var applyKeyComponentAsExtend = (element, parent, key) => {
+  return extendizeByKey(element, parent, key) || element;
+};
+var applyComponentFromContext = (element, parent, options) => {
+  const { context } = element;
+  const { components } = context;
+  const { extend } = element;
+  const execExtend = (0, import_utils26.exec)(extend, element);
+  if ((0, import_utils26.isString)(execExtend)) {
+    if (components[execExtend])
+      element.extend = components[execExtend];
+    else {
+      if ((ENV4 === "test" || ENV4 === "development") && options.verbose) {
+        console.warn(execExtend, "is not in library", components, element);
+        console.warn("replacing with ", {});
+      }
+      element.extend = {};
+    }
+  }
+};
+var checkIfMedia = (key) => key.slice(0, 1) === "@";
+var applyMediaProps = (element, parent, key) => {
+  const { props } = element;
+  if (props) {
+    props.display = "none";
+    if (props[key])
+      props[key].display = props.display;
+    else
+      props[key] = { display: props.display || "block" };
+    return element;
+  } else {
+    return {
+      ...element,
+      props: {
+        display: "none",
+        [key]: { display: "block" }
+      }
+    };
+  }
+};
+var create_default = create;
+
+// src/element/define.js
+var define_default = (params, options = {}) => {
+  const { overwrite: overwrite3 } = options;
+  for (const param in params) {
+    if (registry_default[param] && !overwrite3) {
+      report("OverwriteToBuiltin", param);
+    } else
+      registry_default[param] = params[param];
+  }
+};
+
+// src/element/parse.js
+var parse2 = (element) => {
+  const virtualTree = {
+    node: document.createElement("div")
+  };
+  if (element && element.node)
+    assignNode(element, virtualTree);
+  else
+    create_default(element, virtualTree);
+  return virtualTree.node.innerHTML;
+};
+var parse_default = parse2;
+
+// src/index.js
+var ENV5 = "development";
+if (ENV5 === "test" || ENV5 === "development")
+  window2.tree = tree_default;
+var src_default = {
+  create: create_default,
+  parse: parse_default,
+  set: set_default,
+  define: define_default,
+  tree: tree_default
+};