domql 2.2.2 → 2.2.3

package/dist/main.js

@@ -0,0 +1,1672 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
+
+  // ../node_modules/regenerator-runtime/runtime.js
+  var require_runtime = __commonJS({
+    "../node_modules/regenerator-runtime/runtime.js"(exports, module) {
+      var runtime = function(exports2) {
+        "use strict";
+        var Op = Object.prototype;
+        var hasOwn = Op.hasOwnProperty;
+        var undefined2;
+        var $Symbol = typeof Symbol === "function" ? Symbol : {};
+        var iteratorSymbol = $Symbol.iterator || "@@iterator";
+        var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+        var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+        function define2(obj, key, value) {
+          Object.defineProperty(obj, key, {
+            value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+          return obj[key];
+        }
+        try {
+          define2({}, "");
+        } catch (err) {
+          define2 = function(obj, key, value) {
+            return obj[key] = value;
+          };
+        }
+        function wrap(innerFn, outerFn, self, tryLocsList) {
+          var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+          var generator = Object.create(protoGenerator.prototype);
+          var context = new Context(tryLocsList || []);
+          generator._invoke = makeInvokeMethod(innerFn, self, context);
+          return generator;
+        }
+        exports2.wrap = wrap;
+        function tryCatch(fn, obj, arg) {
+          try {
+            return { type: "normal", arg: fn.call(obj, arg) };
+          } catch (err) {
+            return { type: "throw", arg: err };
+          }
+        }
+        var GenStateSuspendedStart = "suspendedStart";
+        var GenStateSuspendedYield = "suspendedYield";
+        var GenStateExecuting = "executing";
+        var GenStateCompleted = "completed";
+        var ContinueSentinel = {};
+        function Generator() {
+        }
+        function GeneratorFunction() {
+        }
+        function GeneratorFunctionPrototype() {
+        }
+        var IteratorPrototype = {};
+        define2(IteratorPrototype, iteratorSymbol, function() {
+          return this;
+        });
+        var getProto = Object.getPrototypeOf;
+        var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+        if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+          IteratorPrototype = NativeIteratorPrototype;
+        }
+        var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
+        GeneratorFunction.prototype = GeneratorFunctionPrototype;
+        define2(Gp, "constructor", GeneratorFunctionPrototype);
+        define2(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
+        GeneratorFunction.displayName = define2(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction");
+        function defineIteratorMethods(prototype) {
+          ["next", "throw", "return"].forEach(function(method) {
+            define2(prototype, method, function(arg) {
+              return this._invoke(method, arg);
+            });
+          });
+        }
+        exports2.isGeneratorFunction = function(genFun) {
+          var ctor = typeof genFun === "function" && genFun.constructor;
+          return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
+        };
+        exports2.mark = function(genFun) {
+          if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+          } else {
+            genFun.__proto__ = GeneratorFunctionPrototype;
+            define2(genFun, toStringTagSymbol, "GeneratorFunction");
+          }
+          genFun.prototype = Object.create(Gp);
+          return genFun;
+        };
+        exports2.awrap = function(arg) {
+          return { __await: arg };
+        };
+        function AsyncIterator(generator, PromiseImpl) {
+          function invoke(method, arg, resolve, reject) {
+            var record = tryCatch(generator[method], generator, arg);
+            if (record.type === "throw") {
+              reject(record.arg);
+            } else {
+              var result = record.arg;
+              var value = result.value;
+              if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
+                return PromiseImpl.resolve(value.__await).then(function(value2) {
+                  invoke("next", value2, resolve, reject);
+                }, function(err) {
+                  invoke("throw", err, resolve, reject);
+                });
+              }
+              return PromiseImpl.resolve(value).then(function(unwrapped) {
+                result.value = unwrapped;
+                resolve(result);
+              }, function(error) {
+                return invoke("throw", error, resolve, reject);
+              });
+            }
+          }
+          var previousPromise;
+          function enqueue(method, arg) {
+            function callInvokeWithMethodAndArg() {
+              return new PromiseImpl(function(resolve, reject) {
+                invoke(method, arg, resolve, reject);
+              });
+            }
+            return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+          }
+          this._invoke = enqueue;
+        }
+        defineIteratorMethods(AsyncIterator.prototype);
+        define2(AsyncIterator.prototype, asyncIteratorSymbol, function() {
+          return this;
+        });
+        exports2.AsyncIterator = AsyncIterator;
+        exports2.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+          if (PromiseImpl === void 0)
+            PromiseImpl = Promise;
+          var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
+          return exports2.isGeneratorFunction(outerFn) ? iter : iter.next().then(function(result) {
+            return result.done ? result.value : iter.next();
+          });
+        };
+        function makeInvokeMethod(innerFn, self, context) {
+          var state = GenStateSuspendedStart;
+          return function invoke(method, arg) {
+            if (state === GenStateExecuting) {
+              throw new Error("Generator is already running");
+            }
+            if (state === GenStateCompleted) {
+              if (method === "throw") {
+                throw arg;
+              }
+              return doneResult();
+            }
+            context.method = method;
+            context.arg = arg;
+            while (true) {
+              var delegate = context.delegate;
+              if (delegate) {
+                var delegateResult = maybeInvokeDelegate(delegate, context);
+                if (delegateResult) {
+                  if (delegateResult === ContinueSentinel)
+                    continue;
+                  return delegateResult;
+                }
+              }
+              if (context.method === "next") {
+                context.sent = context._sent = context.arg;
+              } else if (context.method === "throw") {
+                if (state === GenStateSuspendedStart) {
+                  state = GenStateCompleted;
+                  throw context.arg;
+                }
+                context.dispatchException(context.arg);
+              } else if (context.method === "return") {
+                context.abrupt("return", context.arg);
+              }
+              state = GenStateExecuting;
+              var record = tryCatch(innerFn, self, context);
+              if (record.type === "normal") {
+                state = context.done ? GenStateCompleted : GenStateSuspendedYield;
+                if (record.arg === ContinueSentinel) {
+                  continue;
+                }
+                return {
+                  value: record.arg,
+                  done: context.done
+                };
+              } else if (record.type === "throw") {
+                state = GenStateCompleted;
+                context.method = "throw";
+                context.arg = record.arg;
+              }
+            }
+          };
+        }
+        function maybeInvokeDelegate(delegate, context) {
+          var method = delegate.iterator[context.method];
+          if (method === undefined2) {
+            context.delegate = null;
+            if (context.method === "throw") {
+              if (delegate.iterator["return"]) {
+                context.method = "return";
+                context.arg = undefined2;
+                maybeInvokeDelegate(delegate, context);
+                if (context.method === "throw") {
+                  return ContinueSentinel;
+                }
+              }
+              context.method = "throw";
+              context.arg = new TypeError("The iterator does not provide a 'throw' method");
+            }
+            return ContinueSentinel;
+          }
+          var record = tryCatch(method, delegate.iterator, context.arg);
+          if (record.type === "throw") {
+            context.method = "throw";
+            context.arg = record.arg;
+            context.delegate = null;
+            return ContinueSentinel;
+          }
+          var info = record.arg;
+          if (!info) {
+            context.method = "throw";
+            context.arg = new TypeError("iterator result is not an object");
+            context.delegate = null;
+            return ContinueSentinel;
+          }
+          if (info.done) {
+            context[delegate.resultName] = info.value;
+            context.next = delegate.nextLoc;
+            if (context.method !== "return") {
+              context.method = "next";
+              context.arg = undefined2;
+            }
+          } else {
+            return info;
+          }
+          context.delegate = null;
+          return ContinueSentinel;
+        }
+        defineIteratorMethods(Gp);
+        define2(Gp, toStringTagSymbol, "Generator");
+        define2(Gp, iteratorSymbol, function() {
+          return this;
+        });
+        define2(Gp, "toString", function() {
+          return "[object Generator]";
+        });
+        function pushTryEntry(locs) {
+          var entry = { tryLoc: locs[0] };
+          if (1 in locs) {
+            entry.catchLoc = locs[1];
+          }
+          if (2 in locs) {
+            entry.finallyLoc = locs[2];
+            entry.afterLoc = locs[3];
+          }
+          this.tryEntries.push(entry);
+        }
+        function resetTryEntry(entry) {
+          var record = entry.completion || {};
+          record.type = "normal";
+          delete record.arg;
+          entry.completion = record;
+        }
+        function Context(tryLocsList) {
+          this.tryEntries = [{ tryLoc: "root" }];
+          tryLocsList.forEach(pushTryEntry, this);
+          this.reset(true);
+        }
+        exports2.keys = function(object) {
+          var keys = [];
+          for (var key in object) {
+            keys.push(key);
+          }
+          keys.reverse();
+          return function next() {
+            while (keys.length) {
+              var key2 = keys.pop();
+              if (key2 in object) {
+                next.value = key2;
+                next.done = false;
+                return next;
+              }
+            }
+            next.done = true;
+            return next;
+          };
+        };
+        function values(iterable) {
+          if (iterable) {
+            var iteratorMethod = iterable[iteratorSymbol];
+            if (iteratorMethod) {
+              return iteratorMethod.call(iterable);
+            }
+            if (typeof iterable.next === "function") {
+              return iterable;
+            }
+            if (!isNaN(iterable.length)) {
+              var i = -1, next = function next2() {
+                while (++i < iterable.length) {
+                  if (hasOwn.call(iterable, i)) {
+                    next2.value = iterable[i];
+                    next2.done = false;
+                    return next2;
+                  }
+                }
+                next2.value = undefined2;
+                next2.done = true;
+                return next2;
+              };
+              return next.next = next;
+            }
+          }
+          return { next: doneResult };
+        }
+        exports2.values = values;
+        function doneResult() {
+          return { value: undefined2, done: true };
+        }
+        Context.prototype = {
+          constructor: Context,
+          reset: function(skipTempReset) {
+            this.prev = 0;
+            this.next = 0;
+            this.sent = this._sent = undefined2;
+            this.done = false;
+            this.delegate = null;
+            this.method = "next";
+            this.arg = undefined2;
+            this.tryEntries.forEach(resetTryEntry);
+            if (!skipTempReset) {
+              for (var name in this) {
+                if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
+                  this[name] = undefined2;
+                }
+              }
+            }
+          },
+          stop: function() {
+            this.done = true;
+            var rootEntry = this.tryEntries[0];
+            var rootRecord = rootEntry.completion;
+            if (rootRecord.type === "throw") {
+              throw rootRecord.arg;
+            }
+            return this.rval;
+          },
+          dispatchException: function(exception) {
+            if (this.done) {
+              throw exception;
+            }
+            var context = this;
+            function handle(loc, caught) {
+              record.type = "throw";
+              record.arg = exception;
+              context.next = loc;
+              if (caught) {
+                context.method = "next";
+                context.arg = undefined2;
+              }
+              return !!caught;
+            }
+            for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+              var entry = this.tryEntries[i];
+              var record = entry.completion;
+              if (entry.tryLoc === "root") {
+                return handle("end");
+              }
+              if (entry.tryLoc <= this.prev) {
+                var hasCatch = hasOwn.call(entry, "catchLoc");
+                var hasFinally = hasOwn.call(entry, "finallyLoc");
+                if (hasCatch && hasFinally) {
+                  if (this.prev < entry.catchLoc) {
+                    return handle(entry.catchLoc, true);
+                  } else if (this.prev < entry.finallyLoc) {
+                    return handle(entry.finallyLoc);
+                  }
+                } else if (hasCatch) {
+                  if (this.prev < entry.catchLoc) {
+                    return handle(entry.catchLoc, true);
+                  }
+                } else if (hasFinally) {
+                  if (this.prev < entry.finallyLoc) {
+                    return handle(entry.finallyLoc);
+                  }
+                } else {
+                  throw new Error("try statement without catch or finally");
+                }
+              }
+            }
+          },
+          abrupt: function(type, arg) {
+            for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+              var entry = this.tryEntries[i];
+              if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
+                var finallyEntry = entry;
+                break;
+              }
+            }
+            if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
+              finallyEntry = null;
+            }
+            var record = finallyEntry ? finallyEntry.completion : {};
+            record.type = type;
+            record.arg = arg;
+            if (finallyEntry) {
+              this.method = "next";
+              this.next = finallyEntry.finallyLoc;
+              return ContinueSentinel;
+            }
+            return this.complete(record);
+          },
+          complete: function(record, afterLoc) {
+            if (record.type === "throw") {
+              throw record.arg;
+            }
+            if (record.type === "break" || record.type === "continue") {
+              this.next = record.arg;
+            } else if (record.type === "return") {
+              this.rval = this.arg = record.arg;
+              this.method = "return";
+              this.next = "end";
+            } else if (record.type === "normal" && afterLoc) {
+              this.next = afterLoc;
+            }
+            return ContinueSentinel;
+          },
+          finish: function(finallyLoc) {
+            for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+              var entry = this.tryEntries[i];
+              if (entry.finallyLoc === finallyLoc) {
+                this.complete(entry.completion, entry.afterLoc);
+                resetTryEntry(entry);
+                return ContinueSentinel;
+              }
+            }
+          },
+          "catch": function(tryLoc) {
+            for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+              var entry = this.tryEntries[i];
+              if (entry.tryLoc === tryLoc) {
+                var record = entry.completion;
+                if (record.type === "throw") {
+                  var thrown = record.arg;
+                  resetTryEntry(entry);
+                }
+                return thrown;
+              }
+            }
+            throw new Error("illegal catch attempt");
+          },
+          delegateYield: function(iterable, resultName, nextLoc) {
+            this.delegate = {
+              iterator: values(iterable),
+              resultName,
+              nextLoc
+            };
+            if (this.method === "next") {
+              this.arg = undefined2;
+            }
+            return ContinueSentinel;
+          }
+        };
+        return exports2;
+      }(typeof module === "object" ? module.exports : {});
+      try {
+        regeneratorRuntime = runtime;
+      } catch (accidentalStrictMode) {
+        if (typeof globalThis === "object") {
+          globalThis.regeneratorRuntime = runtime;
+        } else {
+          Function("r", "regeneratorRuntime = r")(runtime);
+        }
+      }
+    }
+  });
+
+  // event/can.js
+  var require_can = __commonJS({
+    "event/can.js"() {
+      "use strict";
+    }
+  });
+
+  // tags/htmlTags.js
+  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"
+    ]
+  };
+
+  // utils/object.js
+  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 isArray = (arg) => Array.isArray(arg);
+  var isObjectLike = (arg) => {
+    if (arg === null)
+      return false;
+    return typeof arg === "object";
+  };
+  var isNode = (obj) => {
+    return typeof window.Node === "object" ? obj instanceof window.Node : obj && typeof obj === "object" && typeof obj.nodeType === "number" && typeof obj.nodeName === "string";
+  };
+  var isHtmlElement = (obj) => {
+    return typeof window.HTMLElement === "object" ? obj instanceof window.HTMLElement : obj && typeof obj === "object" && obj !== null && obj.nodeType === 1 && typeof obj.nodeName === "string";
+  };
+  var isDefined = (arg) => {
+    return isObject(arg) || isObjectLike(arg) || isString(arg) || isNumber(arg) || isFunction(arg) || isArray(arg) || isObjectLike(arg);
+  };
+  var exec = (param, element, state) => {
+    if (isFunction(param))
+      return param(element, state || element.state);
+    return param;
+  };
+  var map = (obj, extention, element) => {
+    for (const e in extention) {
+      obj[e] = exec(extention[e], element);
+    }
+  };
+  var merge = (element, obj) => {
+    for (const e in obj) {
+      const elementProp = element[e];
+      const objProp = obj[e];
+      if (elementProp === void 0) {
+        element[e] = objProp;
+      }
+    }
+    return element;
+  };
+  var deepMerge = (element, proto) => {
+    for (const e in proto) {
+      const elementProp = element[e];
+      const protoProp = proto[e];
+      if (e === "parent" || e === "props")
+        continue;
+      if (elementProp === void 0) {
+        element[e] = protoProp;
+      } else if (isObjectLike(elementProp) && isObject(protoProp)) {
+        deepMerge(elementProp, protoProp);
+      }
+    }
+    return element;
+  };
+  var clone = (obj) => {
+    const o = {};
+    for (const prop in obj) {
+      if (prop === "node")
+        continue;
+      o[prop] = obj[prop];
+    }
+    return o;
+  };
+  var deepClone = (obj, excluding = ["parent", "node", "__element", "__root"]) => {
+    const o = {};
+    for (const prop in obj) {
+      if (excluding.indexOf(prop) > -1)
+        continue;
+      let objProp = obj[prop];
+      if (prop === "proto" && isArray(objProp)) {
+        objProp = mergeArray(objProp);
+      }
+      if (isObjectLike(objProp)) {
+        o[prop] = deepClone(objProp);
+      } else
+        o[prop] = objProp;
+    }
+    return o;
+  };
+  var overwrite = (element, params, options) => {
+    const { ref } = element;
+    const changes = {};
+    for (const e in params) {
+      if (e === "props")
+        continue;
+      const elementProp = element[e];
+      const paramsProp = params[e];
+      if (paramsProp) {
+        ref.__cache[e] = changes[e] = elementProp;
+        ref[e] = paramsProp;
+      }
+    }
+    return changes;
+  };
+  var diff = (obj, original, cache2) => {
+    const changes = cache2 || {};
+    for (const e in obj) {
+      if (e === "ref")
+        continue;
+      const originalProp = original[e];
+      const objProp = obj[e];
+      if (isObjectLike(originalProp) && isObjectLike(objProp)) {
+        changes[e] = {};
+        diff(originalProp, objProp, changes[e]);
+      } else if (objProp !== void 0) {
+        changes[e] = objProp;
+      }
+    }
+    return changes;
+  };
+  var overwriteDeep = (params, obj) => {
+    for (const e in params) {
+      const objProp = obj[e];
+      const paramsProp = params[e];
+      if (isObjectLike(objProp) && isObjectLike(paramsProp)) {
+        overwriteDeep(objProp, paramsProp);
+      } else if (paramsProp !== void 0) {
+        obj[e] = paramsProp;
+      }
+    }
+    return obj;
+  };
+  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 = (obj) => {
+    return isArray(obj) ? mergeArray(obj) : deepClone(obj);
+  };
+  var flattenRecursive = (param, prop, stack = []) => {
+    const objectized = mergeAndCloneIfArray(param);
+    stack.push(objectized);
+    const protoOfProto = objectized[prop];
+    if (protoOfProto)
+      flattenRecursive(protoOfProto, prop, stack);
+    delete objectized[prop];
+    return stack;
+  };
+
+  // utils/node.js
+  var cleanWithNode = (proto) => delete proto.node && proto;
+  var createID = function* () {
+    let index = 1;
+    while (index < index + 1) {
+      yield index++;
+    }
+  }();
+
+  // registry/methods.js
+  var DEFAULT_METHODS = {
+    key: {},
+    tag: {},
+    if: {},
+    define: {},
+    attr: {},
+    style: {},
+    content: {},
+    class: {},
+    props: {},
+    state: {},
+    method: {},
+    transform: {},
+    on: {},
+    ref: {},
+    extends: {},
+    childExtends: {},
+    text: (element, state) => {
+      element.ref.text = {
+        tag: "text",
+        text: exec(element.text, element, state)
+      };
+    },
+    innerHTML: {},
+    set: {},
+    update: {},
+    remove: {}
+  };
+
+  // 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"
+    ]
+  };
+
+  // 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 global 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}` : "");
+  };
+
+  // tree/root.js
+  var root = {
+    key: ":root",
+    ref: {}
+  };
+
+  // tree/index.js
+  var tree = root;
+
+  // key/index.js
+  var import_runtime = __toESM(require_runtime());
+  var id = function* () {
+    let index = 1;
+    while (index < index + 1) {
+      yield index++;
+    }
+  };
+  var createKey = id();
+
+  // event/on.js
+  var on_exports = {};
+  __export(on_exports, {
+    createState: () => createState,
+    init: () => init,
+    initUpdate: () => initUpdate,
+    propsUpdated: () => propsUpdated,
+    render: () => render,
+    update: () => update,
+    updateState: () => updateState,
+    updateStateInit: () => updateStateInit
+  });
+  var init = (param, element, state) => {
+    param(element, state);
+  };
+  var render = (param, element, state) => {
+    param(element, state);
+  };
+  var initUpdate = (element) => {
+    const { ref, state, on } = element;
+    const { props } = ref;
+    if (on && isFunction(on.initUpdate)) {
+      on.initUpdate(props, state, ref);
+    }
+  };
+  var createState = (state, element) => {
+    const { on, ...el } = element;
+    if (on && isFunction(on.createState)) {
+      on.createState(state, el);
+    }
+  };
+  var updateStateInit = (changes, element) => {
+    const { state, on, ...el } = element;
+    if (on && isFunction(on.updateStateInit)) {
+      on.updateStateInit(changes, state, el);
+    }
+  };
+  var updateState = (changes, element) => {
+    const { state, on } = element;
+    if (on && isFunction(on.updateState)) {
+      on.updateState(changes, state, element);
+    }
+  };
+  var propsUpdated = (element) => {
+    const { props, state, on } = element;
+    if (on && isFunction(on.propsUpdated)) {
+      on.propsUpdated(props, state, element);
+    }
+  };
+  var update = (params, element, state) => {
+    if (element.on && isFunction(element.on.update)) {
+      element.on.update(element, state);
+    }
+    return params;
+  };
+
+  // event/index.js
+  var can = __toESM(require_can());
+
+  // event/is.js
+  var is_exports = {};
+  __export(is_exports, {
+    node: () => node
+  });
+  var node = (node2) => {
+    const { Node } = window;
+    return typeof Node === "function" ? node2 instanceof Node : node2 && typeof node2 === "object" && typeof node2.nodeType === "number" && typeof node2.tag === "string";
+  };
+
+  // state/index.js
+  var parseState = function() {
+    const state = this;
+    const parseState2 = {};
+    for (const param in state) {
+      if (param !== "__element" && param !== "update" && param !== "parse") {
+        parseState2[param] = state[param];
+      }
+    }
+    return parseState2;
+  };
+  var updateState2 = function(obj, options = {}) {
+    const state = this;
+    const element = state.__element;
+    const changes = diff(obj, state);
+    on_exports.updateStateInit(changes, element);
+    overwriteDeep(changes, state);
+    if (!options.preventUpdate)
+      element.update();
+    on_exports.updateState(changes, state, element);
+  };
+  function createState2(element, parent) {
+    let { state } = element;
+    if (!state)
+      return parent && parent.state || {};
+    if (isFunction(state))
+      state = exec(state, element);
+    state = deepClone(state, ["update", "parse", "__element"]);
+    state.__element = element;
+    state.parse = parseState;
+    state.update = updateState2;
+    on_exports.createState(state, element);
+    return state;
+  }
+
+  // props/index.js
+  var initPropsStack = (element, parent) => {
+    const propsStack = [];
+    if (element.props === "inherit") {
+      if (parent && parent.props)
+        propsStack.push(parent.props);
+    } else if (element.props === "match") {
+      if (parent && parent.props)
+        propsStack.push(parent.props[element.key]);
+    } else if (element.props)
+      propsStack.push(element.props);
+    if (isArray(element.ref.__extend)) {
+      element.ref.__extend.map((extendUnit) => {
+        if (extendUnit.props)
+          propsStack.push(extendUnit.props);
+        return extendUnit.props;
+      });
+    }
+    return propsStack;
+  };
+  var inheritProps = (element, parent) => {
+    return parent && parent.ref.props;
+  };
+  var syncProps = (propsStack, element) => {
+    const { ref } = element;
+    const mergedProps = {};
+    propsStack.forEach((prop) => {
+      ref.props = deepMerge(mergedProps, exec(prop, element));
+    });
+    return mergedProps;
+  };
+  var createProps = function(element, parent, cache2) {
+    const { ref } = element;
+    if (!ref.props)
+      ref.props = {};
+    const propsStack = cache2 || initPropsStack(element, parent);
+    if (propsStack.length) {
+      ref.__props = propsStack;
+      return syncProps(propsStack, element);
+    }
+    return inheritProps(element, parent);
+  };
+  var updateProps = (newProps, element, parent) => {
+    const { ref } = element;
+    let propsStack = ref.__props;
+    if (newProps)
+      propsStack = [].concat(newProps, propsStack);
+    if (propsStack.length) {
+      ref.__props = propsStack;
+      return syncProps(propsStack, element);
+    }
+    return inheritProps(element, parent);
+  };
+
+  // extends/protoUtils.js
+  var generateHash = () => Math.random().toString(36).substring(2);
+  var protoStackRegistry = {};
+  var protoCachedRegistry = {};
+  window.protoStackRegistry = protoStackRegistry;
+  window.protoCachedRegistry = protoCachedRegistry;
+  var getHashedProto = (proto) => {
+    return protoStackRegistry[proto.__hash];
+  };
+  var setHashedProto = (proto, stack) => {
+    const hash = generateHash();
+    proto.__hash = hash;
+    protoStackRegistry[hash] = stack;
+    return protoStackRegistry[hash];
+  };
+  var getProtoStackRegistry = (proto, stack) => {
+    if (proto.__hash) {
+      return stack.concat(getHashedProto(proto));
+    } else {
+      setHashedProto(proto, stack);
+    }
+    return stack;
+  };
+  var extractArrayProto = (proto, stack) => {
+    proto.forEach((each) => flattenProto(each, stack));
+    return stack;
+  };
+  var deepProto = (proto, stack) => {
+    const protoOflattenProto = proto.extends;
+    if (protoOflattenProto) {
+      flattenProto(protoOflattenProto, stack);
+    }
+    return stack;
+  };
+  var flattenProto = (proto, stack) => {
+    if (!proto)
+      return stack;
+    if (isArray(proto))
+      return extractArrayProto(proto, stack);
+    stack.push(proto);
+    if (proto.extends)
+      deepProto(proto, stack);
+    return stack;
+  };
+  var deepCloneProto = (obj) => {
+    const o = {};
+    for (const prop in obj) {
+      if (["ref"].indexOf(prop) > -1)
+        continue;
+      const objProp = obj[prop];
+      if (isObject(objProp)) {
+        o[prop] = deepCloneProto(objProp);
+      } else if (isArray(objProp)) {
+        o[prop] = objProp.map((x) => x);
+      } else
+        o[prop] = objProp;
+    }
+    return o;
+  };
+  var deepMergeProto = (element, proto) => {
+    for (const e in proto) {
+      if (e === "ref")
+        continue;
+      const elementProp = element[e];
+      const protoProp = proto[e];
+      if (elementProp === void 0) {
+        element[e] = protoProp;
+      } else if (isObject(elementProp) && isObject(protoProp)) {
+        deepMergeProto(elementProp, protoProp);
+      } else if (isArray(elementProp) && isArray(protoProp)) {
+        element[e] = elementProp.concat(protoProp);
+      } else if (isArray(elementProp) && isObject(protoProp)) {
+        const obj = deepMergeProto({}, elementProp);
+        element[e] = deepMergeProto(obj, protoProp);
+      } else if (elementProp === void 0 && isFunction(protoProp)) {
+        element[e] = protoProp;
+      }
+    }
+    return element;
+  };
+  var cloneAndMergeArrayProto = (stack) => {
+    return stack.reduce((a, c) => {
+      return deepMergeProto(a, deepCloneProto(c));
+    }, {});
+  };
+  var jointStacks = (protoStack, childProtoStack) => {
+    return [].concat(protoStack.slice(0, 1)).concat(childProtoStack.slice(0, 1)).concat(protoStack.slice(1)).concat(childProtoStack.slice(1));
+  };
+  var getProtoStack = (proto) => {
+    if (!proto)
+      return [];
+    if (proto.__hash)
+      return getHashedProto(proto);
+    const stack = flattenProto(proto, []);
+    return getProtoStackRegistry(proto, stack);
+  };
+
+  // extends/index.js
+  var ENV = "development";
+  var extendElement = (element, parent, options = {}) => {
+    if (isFunction(element))
+      element = exec(element, parent);
+    const { extends: ext } = element;
+    const protoStack = getProtoStack(ext);
+    if (ENV !== "development")
+      delete element.extends;
+    let childProtoStack = [];
+    if (!options.ignoreChildProto) {
+      childProtoStack = getProtoStack(parent.childExtends);
+    }
+    const protoLength = protoStack.length;
+    const childProtoLength = childProtoStack.length;
+    let stack = [];
+    if (protoLength && childProtoLength) {
+      stack = jointStacks(protoStack, childProtoStack);
+    } else if (protoLength) {
+      stack = protoStack;
+    } else if (childProtoLength) {
+      stack = childProtoStack;
+    } else
+      return element;
+    if (options.extends) {
+      const defaultOptionsProto = getProtoStack(options.extends);
+      stack = [].concat(defaultOptionsProto, stack);
+    }
+    element.ref.extends = stack;
+    const mergedProto = cloneAndMergeArrayProto(stack);
+    delete mergedProto.__hash;
+    return deepMergeProto(element, mergedProto);
+  };
+
+  // create/index.js
+  var OPTIONS = {};
+  var init2 = (element, key, options, parent) => {
+    const ref = {};
+    if (!element)
+      return { ref };
+    if (isString(element) || isNumber(element)) {
+      return {
+        key,
+        ref,
+        tag: "string",
+        text: element
+      };
+    } else if (isArray(element))
+      return Object.assign({}, element);
+    else if (isObject(element)) {
+      const { extendLibrary } = options;
+      const extendFromLibrary = isString(element.extends) && extendLibrary[element.extends];
+      if (extendFromLibrary && extendLibrary) {
+        element = {
+          props: element,
+          ref,
+          extends: extendFromLibrary
+        };
+      }
+      if (!element.ref)
+        element.ref = ref;
+      if (element.on && element.on.init)
+        element.on.init(element, element.state);
+      return element;
+    } else if (isFunction(element))
+      return { ref, ...exec(parent, parent.ref.state) };
+    return element;
+  };
+  var assignKey = (element, key) => {
+    if (element.key)
+      return element;
+    element.key = key || createKey.next().value;
+    return element;
+  };
+  var applyParent = (element, key) => {
+    const { ref } = element;
+    const { parent } = ref;
+    if (isNode(parent)) {
+      ref.parent = root.ref.parent = { node: parent };
+    }
+    if (!parent)
+      ref.parent = root;
+    return element;
+  };
+  var applyState = (element, key) => {
+    const { ref } = element;
+    ref.state = createState2(element, element.ref.parent);
+    return element;
+  };
+  var applyExtends = (element, key, options) => {
+    extendElement(element, element.ref.parent, options);
+    return element;
+  };
+  var applyTag = (element, key) => {
+    if (element.tag) {
+      element.ref.tag = element.tag;
+      return element;
+    }
+    const keyIsTag = TAGS.body.indexOf(key) > -1;
+    element.tag = element.ref.tag = keyIsTag ? key : "div";
+    return element;
+  };
+  var applyProps = (element, key) => {
+    const { ref } = element;
+    ref.props = createProps(element, ref.parent);
+    return element;
+  };
+  var applyAttr = (element, key) => {
+    if (!isObject(element.attr))
+      return element;
+    const { ref } = element;
+    if (!ref.attr)
+      ref.attr = {};
+    for (const attrKey in element.attr) {
+      ref.attr[attrKey] = exec(element.attr[attrKey], element, element.state);
+    }
+    return element;
+  };
+  var onEachAvailable = (element, key, options) => {
+    const { ref } = element;
+    const value = element[key];
+    let { children, childrenKeys } = ref;
+    if (!children)
+      children = ref.children = [];
+    if (!childrenKeys)
+      childrenKeys = ref.childrenKeys = [];
+    children.push(value);
+    childrenKeys.push(key);
+    const useOption = options[onEachAvailable];
+    if (useOption)
+      useOption(element, key);
+  };
+  var onEach = (element, key, options) => {
+    for (const key2 in element) {
+      const isMethod = DEFAULT_METHODS[key2];
+      if (isMethod && isFunction(isMethod))
+        isMethod(element, element.ref.state);
+      const hasDefine = element.define && element.define[key2];
+      if (hasDefine && isFunction(hasDefine))
+        element.ref[key2] = hasDefine(element, element.ref.state);
+      if (!isMethod && !hasDefine)
+        onEachAvailable(element, key2, options);
+    }
+    return element;
+  };
+  var applyTransform = (element, key, options) => {
+    const { ref, transform } = element;
+    if (!transform)
+      return element;
+    if (!ref.transform)
+      ref.transform = {};
+    const keys = Object.keys(transform || {});
+    keys.map((key2) => {
+      const transformer = transform[key2];
+      ref.transform[key2] = transformer(element, key2);
+      return key2;
+    });
+    return element;
+  };
+  var addChildren = (element, key, options) => {
+    const { ref } = element;
+    const { children, childrenKeys } = ref;
+    if (children && children.length) {
+      ref.children = children.map((child, key2) => {
+        return create(child, element, childrenKeys[key2], options);
+      });
+    }
+    return element;
+  };
+  var applyGlobalTransform = (element, key, options) => {
+    const { ref } = element;
+    const { transform } = options;
+    if (!transform)
+      return element;
+    if (!ref.transform)
+      ref.transform = {};
+    const keys = Object.keys(transform || {});
+    keys.map((key2) => {
+      const transformer = transform[key2];
+      ref.transform[key2] = transformer(element, key2);
+      return key2;
+    });
+    return element;
+  };
+  var create = (element, parent, key, options = OPTIONS) => [
+    init2,
+    assignKey,
+    applyParent,
+    applyState,
+    applyExtends,
+    applyTag,
+    applyProps,
+    applyAttr,
+    onEach,
+    applyTransform,
+    addChildren,
+    applyGlobalTransform
+  ].reduce((prev, current) => current(prev, key, options, parent), element);
+
+  // define/index.js
+  var define = (params, options = {}) => {
+    const { overwrite: overwrite2 } = options;
+    for (const param in params) {
+      if (DEFAULT_METHODS[param] && !overwrite2) {
+        report("OverwriteToBuiltin", param);
+      } else
+        DEFAULT_METHODS[param] = params[param];
+    }
+    return DEFAULT_METHODS;
+  };
+
+  // update/index.js
+  var DEFAULT_OPTIONS = {
+    stackChanges: false,
+    cleanExec: true,
+    preventRecursive: false
+  };
+  var applyUpdateInit = (params, element) => {
+    on_exports.initUpdate(element);
+    if (isString(params) || isNumber(params))
+      params = { text: params };
+    return params;
+  };
+  var applyChanges = (params, element) => {
+    const { ref } = element;
+    const changes = diff(params, element);
+    const hasChanges = Object.keys(changes).length;
+    if (changes && hasChanges) {
+      ref.__updates = [].concat(changes, ref.__updates);
+      overwriteDeep(changes, element);
+    }
+    return params;
+  };
+  var applyPropsUpdate = (params, element, options) => {
+    if (params && !isObject(params.props))
+      return params;
+    const { ref } = element;
+    ref.props = updateProps(params.props, element, ref.parent);
+    on_exports.propsUpdated(element);
+    return params;
+  };
+  var applyAttrUpdate = (params, element, options) => {
+    const { ref } = element;
+    if (!ref.attr)
+      ref.attr = {};
+    for (const attrKey in params.attr) {
+      ref.attr[attrKey] = exec(params.attr[attrKey], element, element.state);
+    }
+    return params;
+  };
+  var updateOnEachAvailable = (params, element, key, options) => {
+    const { ref } = element;
+    const { children, childrenKeys } = ref;
+    if (childrenKeys.indexOf(key) === -1) {
+      const value = params[key];
+      childrenKeys.push(key);
+      element[key] = value;
+      const newElement = create(value, element, key, options);
+      return children.push(newElement);
+    }
+    const useOption = options[updateOnEachAvailable];
+    if (useOption)
+      useOption(element, key);
+  };
+  var updateOnEach = (params, element, options) => {
+    for (const key in params) {
+      const isMethod = DEFAULT_METHODS[key];
+      if (isMethod && isFunction(isMethod))
+        isMethod(element, element.ref.state);
+      const hasDefine = element.define && params.define[key];
+      if (hasDefine && isFunction(hasDefine))
+        element.ref[key] = hasDefine(element, element.ref.state);
+      if (!isMethod && !hasDefine)
+        updateOnEachAvailable(params, element, key, options);
+    }
+    return params;
+  };
+  var updateTransform = (params, element, options) => {
+    applyTransform(element, element.key, options);
+    return params;
+  };
+  var updateChildren = (params, element, options) => {
+    const { ref } = element;
+    const { children } = ref;
+    if (children && children.length) {
+      children.map((child) => {
+        update2(element[child.key] || {}, child, options);
+        return child;
+      });
+    }
+    return params;
+  };
+  var triggerOnUpdate = (params, element, options) => {
+    const { ref } = element;
+    on_exports.update(params, element, element.state);
+    return ref.__updates[0];
+  };
+  var update2 = (params, element, options = DEFAULT_OPTIONS) => [
+    applyUpdateInit,
+    applyChanges,
+    applyPropsUpdate,
+    applyAttrUpdate,
+    updateOnEach,
+    updateTransform,
+    updateChildren,
+    triggerOnUpdate
+  ].reduce((prev, current) => current(prev, element, options), params);
+  DEFAULT_METHODS.update = update2;
+
+  // all/allExports.js
+  var allExports_exports = {};
+  __export(allExports_exports, {
+    DEFAULT_METHODS: () => DEFAULT_METHODS,
+    ERRORS_REGISTRY: () => ERRORS_REGISTRY,
+    TAGS: () => TAGS,
+    applyTransform: () => applyTransform,
+    cache: () => cache,
+    can: () => can,
+    cleanWithNode: () => cleanWithNode,
+    clone: () => clone,
+    create: () => create,
+    createID: () => createID,
+    createKey: () => createKey,
+    createProps: () => createProps,
+    createState: () => createState2,
+    deepClone: () => deepClone,
+    deepMerge: () => deepMerge,
+    define: () => define,
+    diff: () => diff,
+    exec: () => exec,
+    extendElement: () => extendElement,
+    flattenRecursive: () => flattenRecursive,
+    inheritProps: () => inheritProps,
+    is: () => is_exports,
+    isArray: () => isArray,
+    isDefined: () => isDefined,
+    isFunction: () => isFunction,
+    isHtmlElement: () => isHtmlElement,
+    isNode: () => isNode,
+    isNumber: () => isNumber,
+    isObject: () => isObject,
+    isObjectLike: () => isObjectLike,
+    isString: () => isString,
+    isValidHtmlTag: () => isValidHtmlTag,
+    map: () => map,
+    merge: () => merge,
+    mergeAndCloneIfArray: () => mergeAndCloneIfArray,
+    mergeArray: () => mergeArray,
+    mergeIfExisted: () => mergeIfExisted,
+    on: () => on_exports,
+    onEach: () => onEach,
+    overwrite: () => overwrite,
+    overwriteDeep: () => overwriteDeep,
+    parseState: () => parseState,
+    report: () => report,
+    root: () => root,
+    syncProps: () => syncProps,
+    tree: () => tree,
+    updateProps: () => updateProps,
+    updateState: () => updateState2
+  });
+
+  // cache/index.js
+  var cache = {};
+
+  // all/index.js
+  var all_default = {
+    create,
+    define,
+    update: update2
+  };
+})();