@lexriver/dome 2.0.2 → 2.0.4

package/out/index.mjs

@@ -0,0 +1,2164 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// node_modules/@lexriver/async/out/src/Async.mjs
+var Async;
+(function(Async2) {
+  async function waitMsAsync(millisecondsToWait) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, millisecondsToWait);
+    });
+  }
+  Async2.waitMsAsync = waitMsAsync;
+  async function waitForFunctionToReturnTrueAsync(functionToReturnTrue, msStep = 50, maxMsToWait = 0) {
+    if (msStep <= 0)
+      throw new Error(`msStep=${msStep}<=0`);
+    if (maxMsToWait < 0)
+      throw new Error(`maxMsToWait=${maxMsToWait}`);
+    let maxSteps = 0;
+    if (maxMsToWait) {
+      maxSteps = maxMsToWait / msStep;
+      if (maxSteps < 1) {
+        maxSteps = 1;
+      }
+    }
+    let currentStep = 0;
+    while (true) {
+      if (functionToReturnTrue()) {
+        return;
+      }
+      if (maxSteps > 0 && currentStep > maxSteps) {
+        throw new Error(`waitForFunctionToReturnTrue failed after timeout ${maxMsToWait}ms`);
+      }
+      await waitMsAsync(msStep);
+      currentStep++;
+    }
+  }
+  Async2.waitForFunctionToReturnTrueAsync = waitForFunctionToReturnTrueAsync;
+})(Async || (Async = {}));
+
+// node_modules/@lexriver/async/out/src/Lock.mjs
+var Lock = class {
+  constructor() {
+    __publicField(this, "isLocked", false);
+  }
+  async waitForUnlockAndLockAsync(msStep = 50, maxMsToWait = 0) {
+    if (this.isLocked) {
+      try {
+        await Async.waitForFunctionToReturnTrueAsync(() => this.isLocked === false, msStep, maxMsToWait);
+      } catch (x) {
+        throw new Error(`Unable to unlock the lock. Timeout ${maxMsToWait} ms`);
+      }
+    }
+    if (this.isLocked)
+      throw new Error("unable to unlock");
+    this.isLocked = true;
+  }
+  async unlockAsync() {
+    if (!this.isLocked)
+      throw new Error("unlock failed, not locked");
+    this.isLocked = false;
+  }
+  async lockAndExecuteAsync(action, msStep = 50, maxMsToWait = 0) {
+    await this.waitForUnlockAndLockAsync(msStep, maxMsToWait);
+    await action();
+    await this.unlockAsync();
+  }
+};
+
+// node_modules/@lexriver/data-types/out/src/DataTypes.mjs
+var DataTypes;
+(function(DataTypes2) {
+  function isFunction(x) {
+    return typeof x === "function";
+  }
+  DataTypes2.isFunction = isFunction;
+  function isClass(x) {
+    return typeof x === "function" && /^\s*class\s+/.test(x.toString());
+  }
+  DataTypes2.isClass = isClass;
+  function isClassInstance(classInstance, className) {
+    return classInstance instanceof className;
+  }
+  DataTypes2.isClassInstance = isClassInstance;
+  function isDate(date) {
+    return Object.prototype.toString.call(date) === "[object Date]";
+  }
+  DataTypes2.isDate = isDate;
+  function isObject(o) {
+    return o === Object(o) && Object.prototype.toString.call(o) === "[object Object]";
+  }
+  DataTypes2.isObject = isObject;
+  function isObjectWithKeys(o) {
+    return isObject(o) && Object.keys(o).length > 0;
+  }
+  DataTypes2.isObjectWithKeys = isObjectWithKeys;
+  function isIterableObject(o) {
+    return Object.prototype.toString.call(o) === "[object Object]";
+  }
+  function isString(x) {
+    return typeof x === "string";
+  }
+  DataTypes2.isString = isString;
+  function isNumber(x) {
+    return typeof x === "number";
+  }
+  DataTypes2.isNumber = isNumber;
+  function isNullOrUndefined(x) {
+    return x == null;
+  }
+  DataTypes2.isNullOrUndefined = isNullOrUndefined;
+  function isBoolean(x) {
+    return typeof x === "boolean";
+  }
+  DataTypes2.isBoolean = isBoolean;
+  function isArray(x) {
+    return Array.isArray(x);
+  }
+  DataTypes2.isArray = isArray;
+  function isPrimitive(x) {
+    return x === null || typeof x === "boolean" || typeof x === "number" || typeof x === "string" || typeof x === "symbol" || // ES6 symbol
+    typeof x === "undefined";
+  }
+  DataTypes2.isPrimitive = isPrimitive;
+  function isEqual(x, y, options) {
+    if (x === y)
+      return true;
+    if (isPrimitive(x)) {
+      if (isPrimitive(y)) {
+        if (typeof x === "string" && typeof y === "string" && (options == null ? void 0 : options.ignoreCaseInStrings)) {
+          return x.toLocaleLowerCase() === y.toLocaleLowerCase();
+        }
+        return x === y;
+      }
+      return false;
+    }
+    if (isPrimitive(y))
+      return false;
+    if (typeof x !== typeof y)
+      return false;
+    if (isDate(x) && isDate(y)) {
+      return x.getTime() == y.getTime();
+    }
+    if (isArray(x) && isArray(y) && x.length == y.length) {
+      for (let i = 0; i < x.length; i++) {
+        if (isEqual(x[i], y[i]) == false)
+          return false;
+      }
+      return true;
+    }
+    if (isIterableObject(x) && isIterableObject(y)) {
+      if (Object.keys(x).length !== Object.keys(y).length)
+        return false;
+      for (let [k, v] of Object.entries(x)) {
+        if (isEqual(v, y[k], options) == false)
+          return false;
+      }
+      return true;
+    }
+    return false;
+  }
+  DataTypes2.isEqual = isEqual;
+  function isObjectContainsObject(p) {
+    var _a;
+    if (isIterableObject(p.smallObject) && isIterableObject(p.bigObject)) {
+    } else
+      return false;
+    if (Object.entries(p.smallObject).length == 0) {
+      if (p.ignoreEmptySmallObject) {
+        return false;
+      }
+      return true;
+    }
+    for (let [smallKey, smallValue] of Object.entries(p.smallObject)) {
+      if (p.bigObject.hasOwnProperty(smallKey) == false)
+        return false;
+      if (isIterableObject(smallValue)) {
+        if (isObjectContainsObject({
+          bigObject: p.bigObject[smallKey],
+          smallObject: smallValue,
+          ignoreCaseInStringValues: p.ignoreCaseInStringValues,
+          ignoreEmptySmallObject: p.ignoreEmptySmallObject
+        }) === false)
+          return false;
+      } else {
+        if (isEqual(smallValue, p.bigObject[smallKey], { ignoreCaseInStrings: (_a = p.ignoreCaseInStringValues) != null ? _a : false }) === false)
+          return false;
+      }
+    }
+    return true;
+  }
+  DataTypes2.isObjectContainsObject = isObjectContainsObject;
+  function filterObjectByKeys(o, keysToCopy, recursive) {
+    if (!o)
+      throw new Error(`filterObjectByKeys failed, o=${o}`);
+    if (isValidJsonObject(o) == false) {
+      console.warn("filterObjectByKeys is trying to filter not a valid json object", "o=", o);
+    }
+    try {
+      if (isArray(o)) {
+        return o.map((x) => filterObjectByKeys(x, keysToCopy, recursive));
+      }
+      if (isDate(o)) {
+        return o;
+      }
+      if (isObject(o)) {
+        let result = {};
+        Object.entries(o).forEach(([key, value]) => {
+          if (keysToCopy(key)) {
+            if (recursive && value) {
+              value = filterObjectByKeys(value, keysToCopy, recursive);
+            }
+            result[key] = value;
+          }
+        });
+        return result;
+      }
+      return o;
+    } catch (x) {
+      console.error("filterObjectByKeys failed", "o=", o);
+      throw x;
+    }
+  }
+  DataTypes2.filterObjectByKeys = filterObjectByKeys;
+  function isValidJsonObject(json) {
+    if (json === null || json === void 0)
+      return true;
+    const typeName = json.constructor.name;
+    switch (typeName) {
+      case "Boolean":
+      case "Number":
+      case "String":
+      case "Date":
+        return true;
+      case "Object":
+        for (let [k, v] of Object.entries(json)) {
+          if (isValidJsonObject(v) == false)
+            return false;
+        }
+        return true;
+      case "Array":
+        for (let v of json) {
+          if (isValidJsonObject(v) == false)
+            return false;
+        }
+        return true;
+      default:
+        return false;
+    }
+  }
+  DataTypes2.isValidJsonObject = isValidJsonObject;
+  function toJson(o) {
+    return JSON.parse(JSON.stringify(o));
+  }
+  DataTypes2.toJson = toJson;
+  function isValueExistsInEnum(value, EnumType) {
+    for (let enumValue in EnumType) {
+      if (value == EnumType[enumValue])
+        return true;
+    }
+    return false;
+  }
+  DataTypes2.isValueExistsInEnum = isValueExistsInEnum;
+})(DataTypes || (DataTypes = {}));
+
+// node_modules/@lexriver/type-event/out/src/TypeEvent.mjs
+var TypeEvent = class {
+  //protected _maxCountOfSubscribers:number|undefined = undefined
+  //public maxSubscribers:number = 100
+  constructor(maxCountOfSubscribers = void 0) {
+    __publicField(this, "maxCountOfSubscribers");
+    __publicField(this, "_actions", []);
+    __publicField(this, "_onceActions", []);
+    this.maxCountOfSubscribers = maxCountOfSubscribers;
+  }
+  subscribe(action) {
+    if (this.maxCountOfSubscribers && this.maxCountOfSubscribers > 0 && this._actions.length > this.maxCountOfSubscribers)
+      throw new Error(`too much susbcribers: limit is ${this.maxCountOfSubscribers}`);
+    this._actions.push(action);
+  }
+  /**
+   * subscribe to event and delete this subscriber after first execution
+   * @param onceAction
+   */
+  once(onceAction) {
+    this._onceActions.push(onceAction);
+  }
+  unsubscribe(action) {
+    this._actions = this._actions.filter((x) => x !== action);
+    this._onceActions = this._onceActions.filter((x) => x !== action);
+  }
+  unsubscribeAll() {
+    this._actions = [];
+    this._onceActions = [];
+  }
+  async triggerAsync(...p) {
+    const actionsToDelete = [];
+    for (let action of this._actions) {
+      let result = await action(...p);
+      if (result && result.unsubscribe) {
+        actionsToDelete.push(action);
+      }
+    }
+    for (let onceAction of this._onceActions) {
+      onceAction(...p);
+    }
+    this._onceActions = [];
+    if (actionsToDelete.length > 0) {
+      this._actions = this._actions.filter((x) => actionsToDelete.indexOf(x) < 0);
+    }
+  }
+  get countOfSubscribers() {
+    return this._actions.length;
+  }
+  get countOfOnceSubscribers() {
+    return this._onceActions.length;
+  }
+};
+
+// node_modules/@lexriver/observable/out/src/ObservableArray.mjs
+var ObservableArray = class {
+  constructor(initialArray) {
+    __publicField(this, "eventOnChange", new TypeEvent());
+    //eventOnAdd:TypeEvent<(item:T, index:number)=>void> = new TypeEvent()
+    //eventOnRemove:TypeEvent<(item:T, index:number)=>void> = new TypeEvent()
+    __publicField(this, "items", []);
+    //#region iterator
+    // *[Symbol.iterator]() {
+    //     for(let i of this.items) {
+    //         yield i;
+    //     }
+    // }    
+    __publicField(this, "iteratorIndex", 0);
+    if (initialArray) {
+      this.items = initialArray;
+    }
+    let proxySettings = {
+      get: (target, prop, receiver) => {
+        let propNumber = parseInt(prop);
+        if (propNumber >= 0) {
+          return this.items[propNumber];
+        }
+        const result = Reflect.get(target, prop, receiver);
+        return result;
+      },
+      set: (target, prop, value, receiver) => {
+        if (prop === "items") {
+          this.items = value;
+          return true;
+        }
+        let propNumber = parseInt(prop);
+        if (propNumber >= 0) {
+          this.items[propNumber] = value;
+          this.eventOnChange.triggerAsync(value);
+        }
+        return true;
+      }
+    };
+    return new Proxy(this, proxySettings);
+  }
+  getItemsCopy() {
+    return this.items.slice(0);
+  }
+  get length() {
+    return this.items.length;
+  }
+  getInternalArray() {
+    return this.items;
+  }
+  getAsArray() {
+    return this.getItemsCopy();
+  }
+  toArray() {
+    return this.getAsArray();
+  }
+  set(items) {
+    this.items = items;
+    this.eventOnChange.triggerAsync();
+  }
+  setByPrevious(setter) {
+    const prevItems = this.items;
+    const nextItems = setter(prevItems);
+    this.items = nextItems;
+    this.eventOnChange.triggerAsync();
+  }
+  appendArray(arrayToAppend) {
+    this.items = this.items.concat(arrayToAppend);
+    this.eventOnChange.triggerAsync();
+  }
+  /**
+   * The every() method tests whether all elements in the array pass the test implemented by the provided function. It returns a Boolean value.
+   */
+  every(conditionToCheck) {
+    return this.items.every(conditionToCheck);
+  }
+  /**
+   * The fill() method changes all elements in an array to a static value, from a start index (default 0) to an end index (default array.length). It returns the modified array.
+   */
+  fill(value, start, end) {
+    const result = this.items.fill(value, start, end);
+    this.eventOnChange.triggerAsync();
+    return result;
+  }
+  /**
+   * The filter() method creates a new array with all elements that pass the test implemented by the provided function.
+   */
+  filter(action) {
+    return this.items.filter(action);
+  }
+  /**
+   * The find() method returns the value of the first element in the provided array that satisfies the provided testing function.
+   */
+  find(predicate) {
+    return this.items.find(predicate);
+  }
+  /**
+   * The findIndex() method returns the index of the first element in the array that satisfies the provided testing function. Otherwise, it returns -1, indicating that no element passed the test.
+   */
+  findIndex(predicate) {
+    return this.items.findIndex(predicate);
+  }
+  // /**
+  //  * The flat() method creates a new array with all sub-array elements concatenated into it recursively up to the specified depth.
+  //  */
+  // flat(){
+  //     this.items.flat()
+  // }
+  /**
+   * The forEach() method executes a provided function once for each array element.
+   */
+  forEach(action, thisArg) {
+    return this.items.forEach(action, thisArg);
+  }
+  /**
+   * The includes() method determines whether an array includes a certain value among its entries, returning true or false as appropriate.
+   */
+  includes(searchElement, fromIndex) {
+    return this.items.includes(searchElement, fromIndex);
+  }
+  /**
+   * The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.
+   */
+  indexOf(searchElement, fromIndex) {
+    return this.items.indexOf(searchElement, fromIndex);
+  }
+  /**
+   * The join() method creates and returns a new string by concatenating all of the elements in an array, separated by commas or a specified separator string. If the array has only one item, then that item will be returned without using the separator.
+   */
+  join(separator) {
+    return this.items.join(separator);
+  }
+  /**
+   * The keys() method returns a new Array Iterator object that contains the keys for each index in the array
+   */
+  keys() {
+    return this.items.keys();
+  }
+  /**
+   * The lastIndexOf() method returns the last index at which a given element can be found in the array, or -1 if it is not present. The array is searched backwards, starting at fromIndex.
+   */
+  lastIndexOf(searchElement, fromIndex) {
+    return this.items.lastIndexOf(searchElement, fromIndex);
+  }
+  /**
+   * The map() method creates a new array populated with the results of calling a provided function on every element in the calling array.
+   * @param action
+   */
+  map(action, thisArg) {
+    return this.items.map(action, thisArg);
+  }
+  /**
+   * The pop() method removes the last element from an array and returns that element. This method changes the length of the array.
+   */
+  pop() {
+    const result = this.items.pop();
+    this.eventOnChange.triggerAsync();
+    return result;
+  }
+  /**
+   * The push() method adds zero or more elements to the end of an array and returns the new length of the array.
+   * @param item
+   */
+  push(item) {
+    this.items.push(item);
+    this.eventOnChange.triggerAsync(item);
+    return this.items.length;
+  }
+  /**
+   * The reduce() method executes a reducer function (that you provide) on each element of the array, resulting in single output value.
+   */
+  reduce(action, initValue) {
+    return this.items.reduce(action, initValue);
+  }
+  /**
+   * The reduceRight() method applies a function against an accumulator and each value of the array (from right-to-left) to reduce it to a single value.
+   */
+  reduceRight(action, initValue) {
+    return this.items.reduceRight(action, initValue);
+  }
+  /**
+   * The reverse() method reverses an array in place. The first array element becomes the last, and the last array element becomes the first.
+   */
+  reverse() {
+    this.items.reverse();
+    this.eventOnChange.triggerAsync();
+  }
+  /**
+   * Removes the first element from an array and returns it.
+   */
+  shift() {
+    const result = this.items.shift();
+    this.eventOnChange.triggerAsync(result);
+    return result;
+  }
+  /**
+   * Returns a section of an array.
+   * @param start The beginning of the specified portion of the array.
+   * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'.
+   */
+  slice(start, end) {
+    return this.items.slice(start, end);
+  }
+  /**
+   * Determines whether the specified callback function returns true for any element of an array.
+   * @param callbackfn A function that accepts up to three arguments. The some method calls
+   * the callbackfn function for each element in the array until the callbackfn returns a value
+   * which is coercible to the Boolean value true, or until the end of the array.
+   * @param thisArg An object to which the this keyword can refer in the callbackfn function.
+   * If thisArg is omitted, undefined is used as the this value.
+   */
+  some(predicate, thisArg) {
+    return this.items.some(predicate, thisArg);
+  }
+  /**
+   * Sorts an array.
+   * @param compareFn Function used to determine the order of the elements. It is expected to return
+   * a negative value if first argument is less than second argument, zero if they're equal and a positive
+   * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+   * ```ts
+   * [11,2,22,1].sort((a, b) => a - b)
+   * ```
+   */
+  sort(compareFn) {
+    const result = this.items.sort(compareFn);
+    this.eventOnChange.triggerAsync();
+    return result;
+  }
+  splice(start, deleteCount, ...items) {
+    const result = typeof deleteCount === "number" ? this.items.splice(start, deleteCount, ...items) : this.items.splice(start, deleteCount);
+    this.eventOnChange.triggerAsync();
+    return result;
+  }
+  // /**
+  //  * The toLocaleString() method returns a string representing the elements of the array. The elements are converted to Strings using their toLocaleString methods and these Strings are separated by a locale-specific String (such as a comma “,”).
+  //  */
+  // toLocaleString(locales?:string, options?:any){
+  //     //return this.items.toLocaleString(locales, options)
+  // }
+  /**
+   * A string representing the elements of the array.
+   */
+  toString() {
+    return `ObservableArray:` + this.items.toString();
+  }
+  /**
+   * Inserts new elements at the start of an array.
+   * @param items  Elements to insert at the start of the Array.
+   */
+  unshift(...items) {
+    const result = this.items.unshift(...items);
+    this.eventOnChange.triggerAsync();
+    return result;
+  }
+  /**
+   * Returns an iterable of values in the array
+   */
+  values() {
+    return this.items.values();
+  }
+  getByIndex(index) {
+    return this.items[index];
+  }
+  setByIndex(index, value) {
+    this.items[index] = value;
+    this.eventOnChange.triggerAsync(value);
+  }
+  removeItemByIndex(index) {
+    const itemToBeRemoved = this.items[index];
+    this.items.splice(index, 1);
+    this.eventOnChange.triggerAsync(itemToBeRemoved);
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    if (this.iteratorIndex < this.items.length) {
+      return { value: this.items[this.iteratorIndex], done: false };
+    }
+    return { value: null, done: true };
+  }
+};
+
+// node_modules/@lexriver/observable/out/src/ObservableMap.mjs
+var ObservableMap = class {
+  constructor(mapEntries) {
+    __publicField(this, "eventOnChange", new TypeEvent());
+    __publicField(this, "eventOnChangeKey", new TypeEvent());
+    __publicField(this, "eventOnDeleteKey", new TypeEvent());
+    __publicField(this, "eventOnClear", new TypeEvent());
+    __publicField(this, "internalMap", /* @__PURE__ */ new Map());
+    if (mapEntries) {
+      this.internalMap = new Map(mapEntries);
+    }
+  }
+  /**
+   * The entries() method returns a new Iterator object that contains the [key, value] pairs for each element in the Map object in insertion order.
+   */
+  entries() {
+    return this.internalMap.entries();
+  }
+  /**
+   * The has() method returns a boolean indicating whether an element with the specified key exists or not.
+   */
+  has(key) {
+    return this.internalMap.has(key);
+  }
+  /**
+   * The forEach() method executes a provided function once per each key/value pair in the Map object, in insertion order.
+   * @param callbackfn
+   * @param thisArg
+   */
+  forEach(callbackfn, thisArg) {
+    return this.internalMap.forEach(callbackfn, thisArg);
+  }
+  set(key, value) {
+    this.internalMap.set(key, value);
+    this.eventOnChangeKey.triggerAsync(key, value);
+    this.eventOnChange.triggerAsync(key, value);
+  }
+  get(key) {
+    return this.internalMap.get(key);
+  }
+  toArray() {
+    return Array.from(this.internalMap.entries());
+  }
+  initFromArray(mapEntries) {
+    this.internalMap = new Map(mapEntries);
+    this.eventOnChange.triggerAsync();
+  }
+  delete(key) {
+    const result = this.internalMap.delete(key);
+    if (result) {
+      this.eventOnDeleteKey.triggerAsync(key);
+      this.eventOnChange.triggerAsync(key);
+    }
+    return result;
+  }
+  clear() {
+    this.internalMap.clear();
+    this.eventOnClear.triggerAsync();
+    this.eventOnChange.triggerAsync();
+  }
+  /**
+   * The keys() method returns a new Iterator object that contains the keys for each element in the Map object in insertion order.
+   */
+  keys() {
+    return this.internalMap.keys();
+  }
+  /**
+   * The values() method returns a new Iterator object that contains the values for each element in the Map object in insertion order.
+   */
+  values() {
+    return this.internalMap.values();
+  }
+  isEmpty() {
+    return this.internalMap.size == 0;
+  }
+  get size() {
+    return this.internalMap.size;
+  }
+};
+
+// node_modules/@lexriver/observable/out/src/ObservableVariable.mjs
+var ObservableVariable = class {
+  constructor(value) {
+    __publicField(this, "value");
+    __publicField(this, "eventOnChange", new TypeEvent());
+    this.value = value;
+  }
+  set(value) {
+    const prevValue = this.value;
+    this.value = value;
+    this.eventOnChange.triggerAsync(this.value, prevValue);
+  }
+  setByPrevious(setter) {
+    const prevValue = this.value;
+    const newValue = setter(this.value);
+    this.value = newValue;
+    this.eventOnChange.triggerAsync(this.value, prevValue);
+  }
+  get() {
+    return this.value;
+  }
+};
+
+// node_modules/@lexriver/observable/out/src/Functions.mjs
+function createObservable(x) {
+  if (typeof x === "string") {
+    return new ObservableVariable(x);
+  }
+  if (typeof x === "number") {
+    return new ObservableVariable(x);
+  }
+  if (typeof x === "boolean") {
+    return new ObservableVariable(x);
+  }
+  if (Array.isArray(x)) {
+    return new ObservableArray(x);
+  }
+  if (x instanceof Map) {
+    return new ObservableMap(x);
+  }
+  console.error("argument=", x, typeof x);
+  throw new Error("unable to create Observable from this argument type");
+}
+function checkIfObservable(o) {
+  return o instanceof ObservableVariable || o instanceof ObservableArray || o instanceof ObservableMap;
+}
+
+// node_modules/@lexriver/observable/out/src/ObservableLocalStorageArray.mjs
+var ObservableLocalStorageArray = class {
+  constructor(p) {
+    __publicField(this, "p");
+    //protected observableVariable:Observable<T|undefined>
+    //protected localStorageKey:string
+    __publicField(this, "items", []);
+    __publicField(this, "eventOnChange", new TypeEvent());
+    //#region iterator
+    // *[Symbol.iterator]() {
+    //     for(let i of this.items) {
+    //         yield i;
+    //     }
+    // }    
+    __publicField(this, "iteratorIndex", 0);
+    this.p = p;
+    this.assignCurrentValue(false);
+    this.subscribeToWindowEvent();
+  }
+  subscribeToWindowEvent() {
+    window.addEventListener("storage", (e) => {
+      if (e.key != this.p.localStorageKey)
+        return;
+      this.assignCurrentValue(true);
+    });
+  }
+  getInternalArray() {
+    return this.items;
+  }
+  getAsCopy() {
+    return this.items.slice(0);
+  }
+  toArray() {
+    return this.getAsCopy();
+  }
+  get length() {
+    return this.items.length;
+  }
+  appendArray(arrayToAppend) {
+    this.items = this.items.concat(arrayToAppend);
+    this.set(this.items);
+  }
+  /**
+   * The every() method tests whether all elements in the array pass the test implemented by the provided function. It returns a Boolean value.
+   */
+  every(conditionToCheck) {
+    return this.items.every(conditionToCheck);
+  }
+  /**
+   * The fill() method changes all elements in an array to a static value, from a start index (default 0) to an end index (default array.length). It returns the modified array.
+   */
+  fill(value, start, end) {
+    const result = this.items.fill(value, start, end);
+    this.set(result);
+    return result;
+  }
+  /**
+   * The filter() method creates a new array with all elements that pass the test implemented by the provided function.
+   */
+  filter(action) {
+    return this.items.filter(action);
+  }
+  /**
+   * The find() method returns the value of the first element in the provided array that satisfies the provided testing function.
+   */
+  find(predicate) {
+    return this.items.find(predicate);
+  }
+  /**
+   * The findIndex() method returns the index of the first element in the array that satisfies the provided testing function. Otherwise, it returns -1, indicating that no element passed the test.
+   */
+  findIndex(predicate) {
+    return this.items.findIndex(predicate);
+  }
+  /**
+   * The forEach() method executes a provided function once for each array element.
+   */
+  forEach(action, thisArg) {
+    return this.items.forEach(action, thisArg);
+  }
+  /**
+   * The includes() method determines whether an array includes a certain value among its entries, returning true or false as appropriate.
+   */
+  includes(searchElement, fromIndex) {
+    return this.items.includes(searchElement, fromIndex);
+  }
+  /**
+   * The indexOf() method returns the first index at which a given element can be found in the array, or -1 if it is not present.
+   */
+  indexOf(searchElement, fromIndex) {
+    return this.items.indexOf(searchElement, fromIndex);
+  }
+  /**
+   * The join() method creates and returns a new string by concatenating all of the elements in an array, separated by commas or a specified separator string. If the array has only one item, then that item will be returned without using the separator.
+   */
+  join(separator) {
+    return this.items.join(separator);
+  }
+  /**
+   * The keys() method returns a new Array Iterator object that contains the keys for each index in the array
+   */
+  keys() {
+    return this.items.keys();
+  }
+  /**
+   * The lastIndexOf() method returns the last index at which a given element can be found in the array, or -1 if it is not present. The array is searched backwards, starting at fromIndex.
+   */
+  lastIndexOf(searchElement, fromIndex) {
+    return this.items.lastIndexOf(searchElement, fromIndex);
+  }
+  /**
+   * The map() method creates a new array populated with the results of calling a provided function on every element in the calling array.
+   * @param action
+   */
+  map(action, thisArg) {
+    return this.items.map(action, thisArg);
+  }
+  /**
+   * The pop() method removes the last element from an array and returns that element. This method changes the length of the array.
+   */
+  pop() {
+    const result = this.items.pop();
+    this.set(this.items);
+    return result;
+  }
+  /**
+   * The push() method adds zero or more elements to the end of an array and returns the new length of the array.
+   * @param item
+   */
+  push(item) {
+    this.items.push(item);
+    this.set(this.items);
+    return this.items.length;
+  }
+  /**
+   * The reduce() method executes a reducer function (that you provide) on each element of the array, resulting in single output value.
+   */
+  reduce(action, initValue) {
+    return this.items.reduce(action, initValue);
+  }
+  /**
+   * The reduceRight() method applies a function against an accumulator and each value of the array (from right-to-left) to reduce it to a single value.
+   */
+  reduceRight(action, initValue) {
+    return this.items.reduceRight(action, initValue);
+  }
+  /**
+   * The reverse() method reverses an array in place. The first array element becomes the last, and the last array element becomes the first.
+   */
+  reverse() {
+    this.items.reverse();
+    this.set(this.items);
+  }
+  /**
+   * Removes the first element from an array and returns it.
+   */
+  shift() {
+    const result = this.items.shift();
+    this.set(this.items);
+    return result;
+  }
+  /**
+   * Returns a section of an array.
+   * @param start The beginning of the specified portion of the array.
+   * @param end The end of the specified portion of the array. This is exclusive of the element at the index 'end'.
+   */
+  slice(start, end) {
+    return this.items.slice(start, end);
+  }
+  /**
+   * Determines whether the specified callback function returns true for any element of an array.
+   * @param callbackfn A function that accepts up to three arguments. The some method calls
+   * the callbackfn function for each element in the array until the callbackfn returns a value
+   * which is coercible to the Boolean value true, or until the end of the array.
+   * @param thisArg An object to which the this keyword can refer in the callbackfn function.
+   * If thisArg is omitted, undefined is used as the this value.
+   */
+  some(predicate, thisArg) {
+    return this.items.some(predicate, thisArg);
+  }
+  /**
+   * Sorts an array.
+   * @param compareFn Function used to determine the order of the elements. It is expected to return
+   * a negative value if first argument is less than second argument, zero if they're equal and a positive
+   * value otherwise. If omitted, the elements are sorted in ascending, ASCII character order.
+   * ```ts
+   * [11,2,22,1].sort((a, b) => a - b)
+   * ```
+   */
+  sort(compareFn) {
+    const result = this.items.sort(compareFn);
+    this.set(this.items);
+    return result;
+  }
+  splice(start, deleteCount, ...items) {
+    const result = typeof deleteCount === "number" ? this.items.splice(start, deleteCount, ...items) : this.items.splice(start, deleteCount);
+    this.set(this.items);
+    return result;
+  }
+  /**
+   * A string representing the elements of the array.
+   */
+  toString() {
+    return `ObservableLocalStorageArray:` + this.items.toString();
+  }
+  /**
+   * Inserts new elements at the start of an array.
+   * @param items  Elements to insert at the start of the Array.
+   */
+  unshift(...items) {
+    const result = this.items.unshift(...items);
+    this.set(this.items);
+    return result;
+  }
+  /**
+   * Returns an iterable of values in the array
+   */
+  values() {
+    return this.items.values();
+  }
+  getByIndex(index) {
+    return this.items[index];
+  }
+  setByIndex(index, value) {
+    this.items[index] = value;
+    this.set(this.items);
+  }
+  removeItemByIndex(index) {
+    this.items.splice(index, 1);
+    this.set(this.items);
+  }
+  /**
+   * Removes first item in array.
+   * Returns true if successful.
+   * @param item
+   * @returns
+   */
+  removeFirst(item) {
+    const index = this.items.indexOf(item);
+    if (index >= 0) {
+      this.removeItemByIndex(index);
+      return true;
+    }
+    return false;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    if (this.iteratorIndex < this.items.length) {
+      return { value: this.items[this.iteratorIndex], done: false };
+    }
+    return { value: null, done: true };
+  }
+  //#endregion iterator
+  set(items) {
+    const valueToPut = JSON.stringify(items);
+    const valueInLocalStorageAsString = window.localStorage.getItem(this.p.localStorageKey);
+    if (valueToPut !== valueInLocalStorageAsString) {
+      window.localStorage.setItem(this.p.localStorageKey, valueToPut);
+      this.assignCurrentValue(true);
+    }
+  }
+  getValueFromLocalStorage() {
+    const valueInLocalStorageAsString = window.localStorage.getItem(this.p.localStorageKey);
+    if (valueInLocalStorageAsString == null || valueInLocalStorageAsString === "undefined") {
+      window.localStorage.removeItem(this.p.localStorageKey);
+      return void 0;
+    }
+    return valueInLocalStorageAsString;
+  }
+  assignCurrentValue(triggerEventIfNew) {
+    const previousItemsAsString = JSON.stringify(this.items);
+    const newItemsAsString = this.getValueFromLocalStorage();
+    if (newItemsAsString === previousItemsAsString)
+      return;
+    this.items = this.p.defaultValueIfNotInLocalStorage || [];
+    if (newItemsAsString) {
+      try {
+        this.items = JSON.parse(newItemsAsString);
+        if (triggerEventIfNew) {
+          this.eventOnChange.triggerAsync(this.items);
+        }
+      } catch (x) {
+        console.warn("unable to parse", newItemsAsString);
+      }
+    }
+  }
+};
+
+// node_modules/@lexriver/observable/out/src/ObservableLocalStorageVariable.mjs
+var ObservableLocalStorageVariable = class {
+  constructor(p) {
+    __publicField(this, "p");
+    //protected observableVariable:Observable<T|undefined>
+    //protected localStorageKey:string
+    __publicField(this, "currentValue");
+    __publicField(this, "eventOnChange", new TypeEvent());
+    this.p = p;
+    this.assignCurrentValue();
+    this.subscribeToWindowEvent();
+  }
+  subscribeToWindowEvent() {
+    window.addEventListener("storage", (e) => {
+      if (e.key != this.p.localStorageKey)
+        return;
+      const oldValue = this.currentValue;
+      this.assignCurrentValue();
+      this.eventOnChange.triggerAsync(this.currentValue, oldValue);
+    });
+  }
+  get() {
+    return this.currentValue;
+  }
+  set(value) {
+    const valueToPut = JSON.stringify(value);
+    const valueInLocalStorageAsString = window.localStorage.getItem(this.p.localStorageKey);
+    if (valueToPut !== valueInLocalStorageAsString) {
+      const prevValue = this.currentValue;
+      window.localStorage.setItem(this.p.localStorageKey, valueToPut);
+      this.assignCurrentValue();
+      this.eventOnChange.triggerAsync(value, prevValue);
+    }
+  }
+  getValueFromLocalStorage() {
+    const valueInLocalStorageAsString = window.localStorage.getItem(this.p.localStorageKey);
+    if (valueInLocalStorageAsString == null || valueInLocalStorageAsString === "undefined") {
+      window.localStorage.removeItem(this.p.localStorageKey);
+      return void 0;
+    }
+    return valueInLocalStorageAsString;
+  }
+  assignCurrentValue() {
+    this.currentValue = this.p.defaultValueIfNotInLocalStorage || void 0;
+    let stringValue = this.getValueFromLocalStorage();
+    if (stringValue) {
+      try {
+        this.currentValue = JSON.parse(stringValue);
+      } catch (x) {
+        console.warn("unable to parse", stringValue);
+      }
+    }
+  }
+};
+
+// src/DomeManipulator.mts
+var replacementPromiseByElement = /* @__PURE__ */ new WeakMap();
+var DomeManipulator;
+((DomeManipulator2) => {
+  async function hideElementAsync(element, animation) {
+    if (!element) throw new Error("hideElementAsync failed, no element");
+    if (element.hidden) return;
+    if (animation) {
+      await addCssClassAsync(element, animation.cssClassName, animation.timeMs);
+    }
+    element.style.display = "none";
+    element.hidden = true;
+  }
+  DomeManipulator2.hideElementAsync = hideElementAsync;
+  async function unhideElementAsync(element, animation) {
+    if (!element) throw new Error("unhideElementAsync failed, no element");
+    if (!element.hidden) return;
+    element.style.display = "";
+    element.hidden = false;
+    if (animation) {
+      await addCssClassAsync(element, animation.cssClassName, animation.timeMs);
+    }
+  }
+  DomeManipulator2.unhideElementAsync = unhideElementAsync;
+  async function insertAsFirstChildAsync(elementToInsert, parentElement, animation) {
+    parentElement.insertBefore(elementToInsert, parentElement.firstChild);
+    if (animation) {
+      await addCssClassAsync(elementToInsert, animation.cssClassName, animation.timeMs);
+    }
+  }
+  DomeManipulator2.insertAsFirstChildAsync = insertAsFirstChildAsync;
+  async function insertBeforeAsync(elementToInsert, refElement, parentElement, animation) {
+    parentElement.insertBefore(elementToInsert, refElement);
+    if (animation) {
+      await addCssClassAsync(elementToInsert, animation.cssClassName, animation.timeMs);
+    }
+  }
+  DomeManipulator2.insertBeforeAsync = insertBeforeAsync;
+  async function insertAfterAsync(elementToInsert, refElement, parentElement, animation) {
+    if (refElement) {
+      parentElement.insertBefore(elementToInsert, refElement.nextSibling);
+    } else {
+      parentElement.appendChild(elementToInsert);
+    }
+    if (animation) {
+      await addCssClassAsync(elementToInsert, animation.cssClassName, animation.timeMs);
+    }
+  }
+  DomeManipulator2.insertAfterAsync = insertAfterAsync;
+  async function insertByIndexAsync(elementToInsert, index, parentElement, animation) {
+    if (index == 0) {
+      parentElement.appendChild(elementToInsert);
+      if (animation) {
+        await addCssClassAsync(elementToInsert, animation.cssClassName, animation.timeMs);
+      }
+      return;
+    }
+    await insertAfterAsync(elementToInsert, parentElement.children[index], parentElement, animation);
+  }
+  DomeManipulator2.insertByIndexAsync = insertByIndexAsync;
+  async function replaceAsync(oldElement, newElement, animationHide, animationShow) {
+    if (!oldElement.parentNode) {
+      console.error("replaceAsync() failed, no parentNode.", "oldElement=", oldElement);
+      throw new Error("no parent node for replaceAsync");
+    }
+    if (animationHide) {
+      await addCssClassAsync(oldElement, animationHide.cssClassName, animationHide.timeMs);
+    }
+    const parent = oldElement.parentNode;
+    if (!parent) {
+      console.error("replaceAsync() failed, no parent. Probably node was deleted while hide animation.", "oldElement=", oldElement, "type=", typeof oldElement, "parent=", oldElement.parentElement, oldElement.parentNode);
+      throw new Error("no parent for replaceAsync()");
+    }
+    parent.replaceChild(newElement, oldElement);
+    if (animationShow) {
+      await addCssClassAsync(newElement, animationShow.cssClassName, animationShow.timeMs);
+    }
+    return newElement;
+  }
+  DomeManipulator2.replaceAsync = replaceAsync;
+  async function removeElementAsync(element, animation) {
+    if (animation) {
+      await addCssClassAsync(element, animation.cssClassName, animation.timeMs);
+    }
+    element.remove();
+  }
+  DomeManipulator2.removeElementAsync = removeElementAsync;
+  function forEachChildrenOf(element, action) {
+    for (let i = 0; i < element.childNodes.length; i++) {
+      action(element.childNodes[i]);
+    }
+  }
+  DomeManipulator2.forEachChildrenOf = forEachChildrenOf;
+  async function removeAllChildrenAsync(element, animation) {
+    if (!animation) {
+      while (element.firstChild) {
+        element.firstChild.remove();
+      }
+    } else {
+      forEachChildrenOf(element, (child) => child.nodeType == Node.ELEMENT_NODE && child.classList.add(animation.cssClassName));
+      await Async.waitMsAsync(animation.timeMs);
+      Array.from(element.childNodes).forEach((child) => child.remove());
+    }
+  }
+  DomeManipulator2.removeAllChildrenAsync = removeAllChildrenAsync;
+  async function appendChildAsync(containerElement, child, animation) {
+    containerElement.appendChild(child);
+    if (animation) {
+      await addCssClassAsync(child, animation.cssClassName, animation.timeMs);
+    }
+  }
+  DomeManipulator2.appendChildAsync = appendChildAsync;
+  async function appendChildrenAsync(containerElement, children, animation) {
+    if (DataTypes.isString(children)) {
+      containerElement.appendChild(document.createTextNode(children));
+    } else if (DataTypes.isArray(children)) {
+      await Promise.all(
+        children.map((child) => appendChildAsync(containerElement, child, animation))
+      );
+    } else if (children) {
+      await appendChildAsync(containerElement, children, animation);
+    }
+  }
+  DomeManipulator2.appendChildrenAsync = appendChildrenAsync;
+  async function replaceAllChildrenAsync(containerElement, childrenToInsert, animationForHide, animationForShow) {
+    const previousReplacement = replacementPromiseByElement.get(containerElement);
+    const replacement = (previousReplacement != null ? previousReplacement : Promise.resolve()).catch(() => void 0).then(async () => {
+      if (containerElement.childNodes.length > 0) {
+        await removeAllChildrenAsync(containerElement, animationForHide);
+      }
+      await appendChildrenAsync(containerElement, childrenToInsert, animationForShow);
+    });
+    replacementPromiseByElement.set(containerElement, replacement);
+    try {
+      await replacement;
+    } finally {
+      if (replacementPromiseByElement.get(containerElement) === replacement) {
+        replacementPromiseByElement.delete(containerElement);
+      }
+    }
+  }
+  DomeManipulator2.replaceAllChildrenAsync = replaceAllChildrenAsync;
+  function isInDom(el) {
+    if (!el) return false;
+    return document.body.contains(el);
+  }
+  DomeManipulator2.isInDom = isInDom;
+  function isOnScreen(el) {
+    if (!el) return false;
+    var rect = el.getBoundingClientRect();
+    var viewHeight = Math.max(document.documentElement.clientHeight, window.innerHeight);
+    return !(rect.bottom < 0 || rect.top - viewHeight >= 0);
+  }
+  DomeManipulator2.isOnScreen = isOnScreen;
+  async function addCssClassAsync(element, cssClassName, removeAfterMs) {
+    if (element.nodeType !== Node.ELEMENT_NODE) return;
+    element.classList.add(cssClassName);
+    if (removeAfterMs && removeAfterMs > 0) {
+      await Async.waitMsAsync(removeAfterMs);
+      element.classList.remove(cssClassName);
+    }
+  }
+  DomeManipulator2.addCssClassAsync = addCssClassAsync;
+  async function addCssClassesAsync(element, cssClassNames, removeAfterMs) {
+    await Promise.all(cssClassNames.map((cssClassName) => addCssClassAsync(element, cssClassName, removeAfterMs)));
+  }
+  DomeManipulator2.addCssClassesAsync = addCssClassesAsync;
+  function removeCssClass(element, cssClassName) {
+    element.classList.remove(cssClassName);
+  }
+  DomeManipulator2.removeCssClass = removeCssClass;
+  function removeCssClasses(element, cssClassNames) {
+    for (let cssClassName of cssClassNames) {
+      element.classList.remove(cssClassName);
+    }
+  }
+  DomeManipulator2.removeCssClasses = removeCssClasses;
+  function setCssClasses(element, value) {
+    if (!value) return;
+    if (DataTypes.isArray(value)) {
+      setAttribute(element, "class", value.join(" "));
+    } else if (DataTypes.isObjectWithKeys(value)) {
+      let classNameArray = [];
+      for (let [k, v] of Object.entries(value)) {
+        if (checkIfObservable(v)) {
+          if (v.get()) {
+            classNameArray.push(k);
+          }
+        } else if (v) {
+          classNameArray.push(k);
+        }
+      }
+      setAttribute(element, "class", classNameArray.join(" "));
+    } else {
+      setAttribute(element, "class", value);
+    }
+  }
+  DomeManipulator2.setCssClasses = setCssClasses;
+  function setAttribute(element, name, value) {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (/^xlink[AHRST]/.test(name)) {
+      element.setAttributeNS("http://www.w3.org/1999/xlink", name.replace("xlink", "xlink:").toLowerCase(), value);
+    } else {
+      element.setAttribute(name, value);
+    }
+  }
+  DomeManipulator2.setAttribute = setAttribute;
+  function hasFocus(el) {
+    return document.activeElement == el;
+  }
+  DomeManipulator2.hasFocus = hasFocus;
+  function scrollIntoView(element, paddingFromTop = 100) {
+    if (isOnScreen(element)) {
+      return;
+    }
+    let expectedPosition = element.getBoundingClientRect().top + window.pageYOffset;
+    expectedPosition -= paddingFromTop;
+    window.scrollTo({ top: expectedPosition, behavior: "smooth" });
+  }
+  DomeManipulator2.scrollIntoView = scrollIntoView;
+  DomeManipulator2.scrollToTop = () => {
+    let position = getCurrentScrollPosition();
+    if (position > 0) {
+      window.requestAnimationFrame(DomeManipulator2.scrollToTop);
+      if (position < 20) {
+        window.scrollTo(0, 0);
+      } else {
+        window.scrollTo(0, position - position / 9);
+      }
+    }
+  };
+  function getCurrentScrollPosition() {
+    return document.documentElement.scrollTop || document.body.scrollTop;
+  }
+  DomeManipulator2.getCurrentScrollPosition = getCurrentScrollPosition;
+  async function scrollToAsync(p) {
+    var _a, _b;
+    const msStep = (_a = p.msStep) != null ? _a : 50;
+    const maxMsToWait = (_b = p.maxMsToWait) != null ? _b : 5e3;
+    let scrollOptions = {};
+    if (p.pxFromTop) {
+      scrollOptions.top = p.pxFromTop;
+    }
+    if (p.pxFromLeft) {
+      scrollOptions.left = p.pxFromLeft;
+    }
+    if (p.smooth) {
+      scrollOptions.behavior = "smooth";
+    }
+    try {
+      if (p.pxFromLeft || p.pxFromTop) {
+        await Async.waitForFunctionToReturnTrueAsync(() => {
+          if (p.pxFromTop) {
+            return document.body.scrollHeight >= p.pxFromTop;
+          }
+          if (p.pxFromLeft) {
+            return document.body.scrollWidth >= p.pxFromLeft;
+          }
+          return false;
+        }, msStep, maxMsToWait);
+      }
+    } catch (error) {
+    }
+    window.scrollTo(scrollOptions);
+  }
+  DomeManipulator2.scrollToAsync = scrollToAsync;
+})(DomeManipulator || (DomeManipulator = {}));
+
+// src/LongestCommonSubsequence.mts
+var LongestCommonSubsequence;
+((LongestCommonSubsequence2) => {
+  function getLongestCommonSubsequence(set1, set2) {
+    const lcsMatrix = Array(set2.length + 1).fill(null).map(() => Array(set1.length + 1).fill(null));
+    for (let columnIndex2 = 0; columnIndex2 <= set1.length; columnIndex2 += 1) {
+      lcsMatrix[0][columnIndex2] = 0;
+    }
+    for (let rowIndex2 = 0; rowIndex2 <= set2.length; rowIndex2 += 1) {
+      lcsMatrix[rowIndex2][0] = 0;
+    }
+    for (let rowIndex2 = 1; rowIndex2 <= set2.length; rowIndex2 += 1) {
+      for (let columnIndex2 = 1; columnIndex2 <= set1.length; columnIndex2 += 1) {
+        if (set1[columnIndex2 - 1] === set2[rowIndex2 - 1]) {
+          lcsMatrix[rowIndex2][columnIndex2] = lcsMatrix[rowIndex2 - 1][columnIndex2 - 1] + 1;
+        } else {
+          lcsMatrix[rowIndex2][columnIndex2] = Math.max(
+            lcsMatrix[rowIndex2 - 1][columnIndex2],
+            lcsMatrix[rowIndex2][columnIndex2 - 1]
+          );
+        }
+      }
+    }
+    if (!lcsMatrix[set2.length][set1.length]) {
+      return [""];
+    }
+    const longestSequence = [];
+    let columnIndex = set1.length;
+    let rowIndex = set2.length;
+    while (columnIndex > 0 || rowIndex > 0) {
+      if (set1[columnIndex - 1] === set2[rowIndex - 1]) {
+        longestSequence.unshift(set1[columnIndex - 1]);
+        columnIndex -= 1;
+        rowIndex -= 1;
+      } else if (lcsMatrix[rowIndex][columnIndex] === lcsMatrix[rowIndex][columnIndex - 1]) {
+        columnIndex -= 1;
+      } else {
+        rowIndex -= 1;
+      }
+    }
+    return longestSequence;
+  }
+  LongestCommonSubsequence2.getLongestCommonSubsequence = getLongestCommonSubsequence;
+  function getPatch({ oldArray, newArray, onRemove, onAdd }) {
+    const lcsArray = getLongestCommonSubsequence(oldArray, newArray);
+    let countOfOperations = 0;
+    let lcsIndex = 0;
+    for (let oldIndex = 0; oldIndex < oldArray.length; oldIndex++) {
+      let oldItem = oldArray[oldIndex];
+      let oldItemInLcs = lcsArray[lcsIndex] == oldItem;
+      if (oldItemInLcs) {
+        lcsIndex++;
+      } else {
+        onRemove(oldIndex - countOfOperations, oldItem);
+        countOfOperations++;
+      }
+    }
+    lcsIndex = 0;
+    for (let newIndex = 0; newIndex < newArray.length; newIndex++) {
+      let newItem = newArray[newIndex];
+      let newItemInLcs = lcsArray[lcsIndex] == newItem;
+      if (newItemInLcs) {
+        lcsIndex++;
+      } else {
+        onAdd(newIndex, newItem);
+        countOfOperations++;
+      }
+    }
+    return countOfOperations;
+  }
+  LongestCommonSubsequence2.getPatch = getPatch;
+  function getPatchOrdered({ oldArray, newArray, onRemove, onAdd }) {
+    const lcsArray = getLongestCommonSubsequence(oldArray, newArray);
+    let lcsIndexForOld = 0;
+    let lcsIndexForNew = 0;
+    let oldIndex = 0;
+    let newIndex = 0;
+    let countOfRemoveOperations = 0;
+    let countOfAddOperations = 0;
+    let indexForOperation = 0;
+    while (oldIndex < oldArray.length || newIndex < newArray.length) {
+      while (oldIndex < oldArray.length) {
+        let oldItem = oldArray[oldIndex];
+        let oldItemInLcs = lcsArray[lcsIndexForOld] == oldItem;
+        if (oldItemInLcs) {
+          lcsIndexForOld++;
+          oldIndex++;
+          break;
+        } else {
+          onRemove(indexForOperation, oldItem);
+          countOfRemoveOperations++;
+          oldIndex++;
+        }
+      }
+      while (newIndex < newArray.length) {
+        let newItem = newArray[newIndex];
+        let newItemInLcs = lcsArray[lcsIndexForNew] == newItem;
+        if (newItemInLcs) {
+          lcsIndexForNew++;
+          indexForOperation++;
+          newIndex++;
+          break;
+        } else {
+          onAdd(indexForOperation, newItem);
+          indexForOperation++;
+          countOfAddOperations++;
+          newIndex++;
+        }
+      }
+    }
+    return countOfAddOperations + countOfRemoveOperations;
+  }
+  LongestCommonSubsequence2.getPatchOrdered = getPatchOrdered;
+})(LongestCommonSubsequence || (LongestCommonSubsequence = {}));
+
+// src/AnimatedArray.mts
+var AnimatedArray = class {
+  constructor(params) {
+    this.params = params;
+    __publicField(this, "arrayOfKeyToElement", []);
+    if (params.array && params.parentElement) {
+      this.update(params.array);
+    }
+  }
+  get size() {
+    return this.arrayOfKeyToElement.length;
+  }
+  update(array, parentElement) {
+    parentElement = parentElement || this.params.parentElement;
+    if (!parentElement) {
+      console.warn("AnimatedArray unable to update, no parentElement");
+      return;
+    }
+    if (array.length == 0 && this.params.emptyList) {
+      DomeManipulator.replaceAllChildrenAsync(parentElement, this.params.emptyList);
+      return;
+    }
+    if (array.length > 0 && this.params.emptyList) {
+      DomeManipulator.removeElementAsync(this.params.emptyList, this.params.animationHide);
+    }
+    let newArrayOfKeys = array.map((item) => this.params.getKey(item));
+    let oldArrayOfKeys = this.arrayOfKeyToElement.map((x) => x.key);
+    LongestCommonSubsequence.getPatchOrdered({
+      oldArray: oldArrayOfKeys,
+      newArray: newArrayOfKeys,
+      onAdd: (index, key) => {
+        if (!parentElement) throw new Error("no parent element");
+        let itemIndex = newArrayOfKeys.indexOf(key);
+        if (itemIndex == -1) throw new Error("no itemIndex");
+        let item = array[itemIndex];
+        let element = this.params.getHtmlElement(item);
+        this.arrayOfKeyToElement.splice(index, 0, { key, element });
+        DomeManipulator.insertByIndexAsync(element, index, parentElement, this.params.animationShow);
+      },
+      onRemove: (index, key) => {
+        DomeManipulator.removeElementAsync(this.arrayOfKeyToElement[index].element, this.params.animationHide);
+        this.arrayOfKeyToElement.splice(index, 1);
+      }
+    });
+  }
+};
+
+// node_modules/ts-debounce/dist/src/index.esm.js
+function r(r2, e, n) {
+  var i, t, o;
+  void 0 === e && (e = 50), void 0 === n && (n = {});
+  var a = null != (i = n.isImmediate) && i, u = null != (t = n.callback) && t, c = n.maxWait, v = Date.now(), l = [];
+  function f() {
+    if (void 0 !== c) {
+      var r3 = Date.now() - v;
+      if (r3 + e >= c) return c - r3;
+    }
+    return e;
+  }
+  var d = function() {
+    var e2 = [].slice.call(arguments), n2 = this;
+    return new Promise(function(i2, t2) {
+      var c2 = a && void 0 === o;
+      if (void 0 !== o && clearTimeout(o), o = setTimeout(function() {
+        if (o = void 0, v = Date.now(), !a) {
+          var i3 = r2.apply(n2, e2);
+          u && u(i3), l.forEach(function(r3) {
+            return (0, r3.resolve)(i3);
+          }), l = [];
+        }
+      }, f()), c2) {
+        var d2 = r2.apply(n2, e2);
+        return u && u(d2), i2(d2);
+      }
+      l.push({ resolve: i2, reject: t2 });
+    });
+  };
+  return d.cancel = function(r3) {
+    void 0 !== o && clearTimeout(o), l.forEach(function(e2) {
+      return (0, e2.reject)(r3);
+    }), l = [];
+  }, d;
+}
+
+// src/DomeComponent.mts
+var DomeComponent = class {
+  constructor(attrs, children) {
+    this.attrs = attrs;
+    this.children = children;
+    __publicField(this, "rootElement");
+    __publicField(this, "updateInProgress", false);
+    __publicField(this, "updateRequested", false);
+    __publicField(this, "scheduleUpdate", r(() => this.runScheduledUpdateAsync(), 5));
+  }
+  //abstract render(attrs:Attrs, children:any):HTMLElement
+  init() {
+  }
+  afterRender() {
+  }
+  // protected onMount(){
+  // }
+  async updateAsync() {
+    if (!this.rootElement) {
+      console.error("DomeComponent: unable to update, no rootElement", "this=", this);
+      return;
+    }
+    if (!this.rootElement.parentNode) {
+      console.error("DomeComponent: unable to update, no parent for rootElement, not mounted?", "this=", this);
+      return;
+    }
+    const newEl = this.render();
+    await DomeManipulator.replaceAsync(this.rootElement, newEl, this.attrs.onHideAnimation, this.attrs.onShowAnimation);
+    this.rootElement = newEl;
+    this.afterUpdate();
+  }
+  async runScheduledUpdateAsync() {
+    if (this.updateInProgress) {
+      this.updateRequested = true;
+      return;
+    }
+    this.updateInProgress = true;
+    try {
+      do {
+        this.updateRequested = false;
+        try {
+          await this.updateAsync();
+        } catch (error) {
+          console.error("DomeComponent: scheduled update failed", error);
+        }
+      } while (this.updateRequested);
+    } finally {
+      this.updateInProgress = false;
+    }
+  }
+  afterUpdate() {
+  }
+};
+DomeComponent.prototype["__DomeComponent"] = true;
+
+// src/AnimatedTable.mts
+var AnimatedTable = class extends DomeComponent {
+  constructor() {
+    super(...arguments);
+    // rootElement
+    //   table
+    //     thead
+    //     tbody
+    //     tfooter
+    //   emptyList
+    __publicField(this, "refRoot", this.attrs.rootElement || document.createElement("div"));
+    __publicField(this, "refTable", this.attrs.tableElement || document.createElement("table"));
+    __publicField(this, "refTableHead", this.attrs.renderTableHead ? this.attrs.renderTableHead(this.attrs.itemsO.get()) : document.createElement("thead"));
+    __publicField(this, "refTableBody", this.attrs.tableBody || document.createElement("tbody"));
+    __publicField(this, "refTableFooter", this.attrs.renderTableFooter ? this.attrs.renderTableFooter(this.attrs.itemsO.get()) : document.createElement("tfoot"));
+    __publicField(this, "refEmptyList", this.attrs.renderEmptyList ? this.attrs.renderEmptyList() : document.createElement("div"));
+    __publicField(this, "refLoading", this.attrs.renderLoading ? this.attrs.renderLoading() : document.createElement("div"));
+    __publicField(this, "animatedArray", new AnimatedArray({
+      animationHide: this.attrs.animationHideRow,
+      animationShow: this.attrs.animationShowRow,
+      array: [],
+      getKey: this.attrs.getKey,
+      getHtmlElement: this.attrs.renderTableRow
+    }));
+  }
+  render() {
+    this.refRoot.appendChild(this.refTable);
+    this.refRoot.appendChild(this.refEmptyList);
+    this.refRoot.appendChild(this.refLoading);
+    if (this.refTableHead) this.refTable.appendChild(this.refTableHead);
+    if (this.refTableBody) this.refTable.appendChild(this.refTableBody);
+    if (this.refTableFooter) this.refTable.appendChild(this.refTableFooter);
+    console.log("AnimatedTable render()", "refRoot=", this.refRoot);
+    return this.refRoot;
+  }
+  afterRender() {
+    this.updateAsync();
+  }
+  async updateAsync() {
+    try {
+      if (this.attrs.renderLoading) {
+        this.refLoading = await DomeManipulator.replaceAsync(this.refLoading, this.attrs.renderLoading());
+      }
+      if (this.attrs.isLoadingO && this.attrs.isLoadingO.get()) {
+        await DomeManipulator.unhideElementAsync(this.refLoading, this.attrs.animationShowLoading);
+      } else {
+        await DomeManipulator.hideElementAsync(this.refLoading, this.attrs.animationHideLoading);
+      }
+      const items = this.attrs.itemsO.get();
+      const currentCount = items.length;
+      if (currentCount == 0) {
+        await DomeManipulator.hideElementAsync(this.refTable, this.attrs.animationHideTable);
+        if (this.attrs.renderEmptyList) {
+          this.refEmptyList = await DomeManipulator.replaceAsync(this.refEmptyList, this.attrs.renderEmptyList());
+        }
+        await DomeManipulator.unhideElementAsync(this.refEmptyList, this.attrs.animationShowEmptyList);
+      } else {
+        await DomeManipulator.hideElementAsync(this.refEmptyList, this.attrs.animationHideEmptyList);
+        if (this.attrs.renderTableHead) {
+          this.refTableHead = await DomeManipulator.replaceAsync(this.refTableHead, this.attrs.renderTableHead(items));
+        }
+        if (this.attrs.renderTableFooter) {
+          this.refTableFooter = await DomeManipulator.replaceAsync(this.refTableFooter, this.attrs.renderTableFooter(items));
+        }
+        await DomeManipulator.unhideElementAsync(this.refTable, this.attrs.animationShowTable);
+        this.animatedArray.update(items, this.refTableBody);
+      }
+    } catch (x) {
+      console.error("AnimatedTable update failed", x);
+    }
+  }
+};
+
+// src/AnimatedText.mts
+var AnimatedText = class extends DomeComponent {
+  render() {
+    const result = document.createElement(this.attrs.tag || "span");
+    if (this.attrs.class) {
+      DomeManipulator.setCssClasses(result, this.attrs.class);
+    }
+    result.append(this.attrs.textO.get());
+    return result;
+  }
+  async updateAsync() {
+    if (!this.rootElement) return;
+    try {
+      this.rootElement = await DomeManipulator.replaceAsync(this.rootElement, this.render(), this.attrs.onHideAnimation, this.attrs.onShowAnimation);
+    } catch (x) {
+      console.error("AnimatedText update failed", x);
+    }
+  }
+};
+
+// node_modules/svg-tag-names/index.js
+var svgTagNames = [
+  "a",
+  "altGlyph",
+  "altGlyphDef",
+  "altGlyphItem",
+  "animate",
+  "animateColor",
+  "animateMotion",
+  "animateTransform",
+  "animation",
+  "audio",
+  "canvas",
+  "circle",
+  "clipPath",
+  "color-profile",
+  "cursor",
+  "defs",
+  "desc",
+  "discard",
+  "ellipse",
+  "feBlend",
+  "feColorMatrix",
+  "feComponentTransfer",
+  "feComposite",
+  "feConvolveMatrix",
+  "feDiffuseLighting",
+  "feDisplacementMap",
+  "feDistantLight",
+  "feDropShadow",
+  "feFlood",
+  "feFuncA",
+  "feFuncB",
+  "feFuncG",
+  "feFuncR",
+  "feGaussianBlur",
+  "feImage",
+  "feMerge",
+  "feMergeNode",
+  "feMorphology",
+  "feOffset",
+  "fePointLight",
+  "feSpecularLighting",
+  "feSpotLight",
+  "feTile",
+  "feTurbulence",
+  "filter",
+  "font",
+  "font-face",
+  "font-face-format",
+  "font-face-name",
+  "font-face-src",
+  "font-face-uri",
+  "foreignObject",
+  "g",
+  "glyph",
+  "glyphRef",
+  "handler",
+  "hkern",
+  "iframe",
+  "image",
+  "line",
+  "linearGradient",
+  "listener",
+  "marker",
+  "mask",
+  "metadata",
+  "missing-glyph",
+  "mpath",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "prefetch",
+  "radialGradient",
+  "rect",
+  "script",
+  "set",
+  "solidColor",
+  "stop",
+  "style",
+  "svg",
+  "switch",
+  "symbol",
+  "tbreak",
+  "text",
+  "textArea",
+  "textPath",
+  "title",
+  "tref",
+  "tspan",
+  "unknown",
+  "use",
+  "video",
+  "view",
+  "vkern"
+];
+
+// src/Dome.mts
+function flattenArray(arr, res = []) {
+  var i = 0, cur;
+  var len = arr.length;
+  for (; i < len; i++) {
+    cur = arr[i];
+    Array.isArray(cur) ? flattenArray(cur, res) : res.push(cur);
+  }
+  return res;
+}
+function checkIfNonDimensionalCssName(name) {
+  const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i;
+  return IS_NON_DIMENSIONAL.test(name);
+}
+var excludeSvgTags = [
+  "a",
+  "audio",
+  "canvas",
+  "iframe",
+  "script",
+  "video"
+];
+var svgTags = svgTagNames.filter((name) => !excludeSvgTags.includes(name));
+var isSVG = (tagName) => svgTags.includes(tagName);
+var setCSSProps = (el, style) => {
+  if (DataTypes.isString(style)) {
+    el.style = style;
+  } else if (DataTypes.isObjectWithKeys(style)) {
+    Object.keys(style).forEach((name) => {
+      let value = style[name];
+      if (typeof value === "number" && !checkIfNonDimensionalCssName(name)) {
+        value = `${value}px`;
+      }
+      el.style[name] = value;
+    });
+  }
+};
+var createElement = (tagName) => {
+  if (isSVG(tagName)) {
+    return document.createElementNS("http://www.w3.org/2000/svg", tagName);
+  }
+  if (tagName === DocumentFragment) {
+    return document.createDocumentFragment();
+  }
+  return document.createElement(tagName);
+};
+var build = (tagName, attrs, children) => {
+  if (!tagName) {
+    console.trace();
+    throw new Error("tagName=" + tagName);
+  }
+  if (tagName == DocumentFragment) {
+    const el = createElement(tagName);
+    el.appendChild(children);
+    return el;
+  }
+  if (tagName.prototype && tagName.prototype["__DomeComponent"]) {
+    try {
+      const instance = new tagName(attrs, children);
+      if (instance["render"] && DataTypes.isFunction(instance["render"])) {
+        if (attrs.ref && DataTypes.isFunction(attrs.ref)) {
+          attrs.ref(instance);
+        }
+        instance["init"]();
+        instance.rootElement = instance["render"]();
+        for (let attribute of Object.values(attrs)) {
+          if (checkIfObservable(attribute)) {
+            attribute.eventOnChange.subscribe(() => {
+              instance.scheduleUpdate();
+            });
+          }
+        }
+        instance["afterRender"]();
+        return instance.rootElement;
+      }
+    } catch (error) {
+      console.error("error while creating DomeComponent class", error);
+    }
+    return;
+  }
+  if (DataTypes.isFunction(tagName)) {
+    return tagName(attrs, children);
+  } else if (DataTypes.isString(tagName)) {
+    const el = createElement(tagName);
+    Object.keys(attrs).forEach((name) => {
+      const value = attrs[name];
+      if (name === "class" || name === "className" || name === "cssClasses") {
+        assignDynamicCssClasses(name, value, el);
+      } else if (name === "style") {
+        setCSSProps(el, value);
+      } else if (["disabled", "autocomplete", "selected", "checked"].indexOf(name) >= 0) {
+        if (attrs[name]) {
+          DomeManipulator.setAttribute(el, name, name);
+        }
+      } else if (name === "onCreate" || name === "ref") {
+        if (DataTypes.isFunction(value) == false) throw new Error(`Please provide function <${tagName} ${name}={ref => myRef=ref} />`);
+        value(el);
+      } else if (name == "visibleIf") {
+        if (checkIfObservable(value) == false) {
+          console.error("value=", value);
+          throw new Error("Please provide Observable<boolean> as argument for visibleIf");
+        }
+        let obs = value;
+        obs.eventOnChange.subscribe((isVisible) => {
+          if (isVisible) {
+            DomeManipulator.unhideElementAsync(el);
+          } else {
+            DomeManipulator.hideElementAsync(el);
+          }
+        });
+        setTimeout(() => {
+          obs.eventOnChange.triggerAsync(obs.get());
+        }, 1);
+      } else if (name.indexOf("on") === 0 && value) {
+        const eventName = name.slice(2).toLowerCase();
+        if (DataTypes.isFunction(value) == false) {
+          console.error("unable to subscribe for event", eventName, "listener is not a function", "element=", el, "listener=", value);
+          return;
+        }
+        el.addEventListener(eventName, value);
+      } else if (name === "innerHtml") {
+        el.innerHTML = value;
+      } else if (name !== "key" && value !== false) {
+        DomeManipulator.setAttribute(el, name, value === true ? "" : value);
+      }
+    });
+    if (!attrs.innerHtml) {
+      el.appendChild(children);
+    }
+    return el;
+  } else throw new Error("not implemented");
+};
+function assignDynamicCssClasses(name, value, element) {
+  if (DataTypes.isObjectWithKeys(value) == false) {
+    DomeManipulator.setCssClasses(element, value);
+    return;
+  }
+  let resultArray = [];
+  for (let [k, v] of Object.entries(value)) {
+    if (v === void 0) {
+    } else if (DataTypes.isBoolean(v)) {
+      if (v) {
+        resultArray.push(k);
+      }
+    } else if (checkIfObservable(v)) {
+      let o = v;
+      o.eventOnChange.subscribe((showThiCssClass) => {
+        if (!DomeManipulator.isInDom(element)) return { unsubscribe: true };
+        DomeManipulator.setCssClasses(element, value);
+      });
+      if (o.get()) {
+        resultArray.push(k);
+      }
+    } else {
+      console.error(`Please provide classNames as a keys and boolean or Observable<boolean> for values., ex: {class1:true, class2:myVarO}`, "name=", name, "value=", value, "typeof value =", typeof value);
+      throw new Error("Wrong value for `class` attribute");
+    }
+  }
+  DomeManipulator.setCssClasses(element, resultArray);
+}
+function h(tagName, attrs, ...childrenArgs) {
+  const children = document.createDocumentFragment();
+  flattenArray(childrenArgs).forEach((child) => {
+    if (child instanceof Node) {
+      children.appendChild(child);
+    } else if (typeof child !== "boolean" && typeof child !== "undefined" && child !== null) {
+      children.appendChild(document.createTextNode(child));
+    }
+  });
+  return build(tagName, attrs || {}, children);
+}
+var React = {
+  createElement: h,
+  Fragment: typeof DocumentFragment === "function" ? DocumentFragment : () => {
+  }
+};
+
+// src/DomeRouter.mts
+var DomeRouter;
+((DomeRouter2) => {
+  const historyUrls = [];
+  const scrollPositionByUrl = /* @__PURE__ */ new Map();
+  DomeRouter2.maxHistoryUrlsCount = 20;
+  const allRoutes = [];
+  let onNotFoundAction = void 0;
+  window.addEventListener("popstate", async (e) => {
+    const url = window.location.pathname;
+    await executeAsync(url, getScrollPositionForUrl(url));
+    await DomeManipulator.scrollToAsync({
+      pxFromTop: getScrollPositionForUrl(window.location.pathname)
+    });
+  });
+  function getScrollPositionForUrl(url) {
+    var _a;
+    return (_a = scrollPositionByUrl.get(url)) != null ? _a : 0;
+  }
+  function saveScrollPositionForUrl(url) {
+    scrollPositionByUrl.set(url, DomeManipulator.getCurrentScrollPosition());
+  }
+  function saveScrollPositionForCurrentUrl() {
+    scrollPositionByUrl.set(getCurrentUrl(), DomeManipulator.getCurrentScrollPosition());
+  }
+  function navigate(url) {
+    addUrlToHistory(getCurrentUrl());
+    saveScrollPositionForCurrentUrl();
+    window.history.pushState(null, "", url);
+    executeAsync(url, 0);
+    DomeManipulator.scrollToTop();
+  }
+  DomeRouter2.navigate = navigate;
+  function goBack() {
+    window.history.go(-1);
+  }
+  DomeRouter2.goBack = goBack;
+  function goForward() {
+    window.history.go(1);
+  }
+  DomeRouter2.goForward = goForward;
+  function changeUrl(url) {
+    window.history.replaceState(null, "", url);
+  }
+  DomeRouter2.changeUrl = changeUrl;
+  function addUrlToHistory(url) {
+    historyUrls.push({ url, scroll: 0 });
+    while (historyUrls.length > DomeRouter2.maxHistoryUrlsCount) {
+      historyUrls.shift();
+    }
+    if (historyUrls.length > 1) {
+      historyUrls[historyUrls.length - 2].scroll = DomeManipulator.getCurrentScrollPosition();
+    }
+  }
+  function getCurrentUrl() {
+    return window.location.pathname;
+  }
+  DomeRouter2.getCurrentUrl = getCurrentUrl;
+  function getPreviousPageUrl(previousPageIndex = 0) {
+    let index = historyUrls.length - 2 - previousPageIndex;
+    if (index >= 0 && index < historyUrls.length) return historyUrls[index].url;
+    return void 0;
+  }
+  DomeRouter2.getPreviousPageUrl = getPreviousPageUrl;
+  function resolveUrl(url = window.location.pathname, addToHistory = true) {
+    if (addToHistory) addUrlToHistory(window.location.pathname);
+    executeAsync(url, getScrollPositionForUrl(url));
+  }
+  DomeRouter2.resolveUrl = resolveUrl;
+  function onRoute(route, exactMatch, action) {
+    if (route[0] !== "/") throw new Error("Please provide correct route. route=" + route);
+    let routeSlices = getRouteSlices(route);
+    allRoutes.push({ routeSlices, exactMatch, action });
+  }
+  DomeRouter2.onRoute = onRoute;
+  function getRouteSlices(route) {
+    return route.split("/").map((x) => decodeURIComponent(x));
+  }
+  function onNotFound(action) {
+    onNotFoundAction = action;
+  }
+  DomeRouter2.onNotFound = onNotFound;
+  function checkUrlMatchRouteAndGetParameters(url, route, exactMatch = true) {
+    const urlSlices = getRouteSlices(url);
+    const routeSlices = getRouteSlices(route);
+    if (exactMatch && routeSlices.length !== urlSlices.length) return void 0;
+    const extractedParameters = {};
+    for (let i = 0; i < routeSlices.length; i++) {
+      let cRouteSlice = routeSlices[i];
+      let cUrlSlice = urlSlices[i];
+      if (cRouteSlice.startsWith(":")) {
+        if (cUrlSlice === void 0) {
+          return void 0;
+        }
+        const [name, value] = parseToNameAndValue(cRouteSlice, cUrlSlice);
+        extractedParameters[name] = value;
+      } else {
+        if (cRouteSlice !== cUrlSlice) {
+          return void 0;
+        }
+      }
+    }
+    return extractedParameters;
+  }
+  DomeRouter2.checkUrlMatchRouteAndGetParameters = checkUrlMatchRouteAndGetParameters;
+  function parseToNameAndValue(name, value) {
+    if (!name) throw new Error("no name");
+    const haveMatch = name.match(/:(.+)<(.+)>/);
+    if (haveMatch) {
+      const paramName = haveMatch[1];
+      const paramType = haveMatch[2].toLowerCase();
+      if (paramType == "int") {
+        return [paramName, parseInt(value)];
+      } else if (paramType == "float") {
+        return [paramName, parseFloat(value)];
+      } else if (paramType == "number") {
+        return [paramName, Number(value)];
+      } else {
+        return [paramName, value];
+      }
+    } else {
+      return [name.substring(1), value];
+    }
+  }
+  function parseQueryString(search) {
+    const query = {};
+    if (!search || search[0] !== "?") return query;
+    const params = new URLSearchParams(search.substring(1));
+    for (const [key, value] of params.entries()) {
+      query[key] = value;
+    }
+    return query;
+  }
+  async function executeAsync(url = window.location.pathname, scrollToPosition) {
+    const queryString = window.location.search;
+    const query = parseQueryString(queryString);
+    url = url.split("?")[0];
+    const urlSlices = getRouteSlices(url);
+    let countOfFoundRoutes = 0;
+    for (let route of allRoutes) {
+      if (route.exactMatch && route.routeSlices.length != urlSlices.length) continue;
+      let matched = true;
+      const extractedParameters = {};
+      for (let i = 0; i < route.routeSlices.length; i++) {
+        let cRouteSlice = route.routeSlices[i];
+        let cUrlSlice = urlSlices[i];
+        if (cRouteSlice && typeof cRouteSlice === "string" && cRouteSlice.startsWith(":")) {
+          if (cUrlSlice === void 0) {
+            matched = false;
+            continue;
+          }
+          const [name, value] = parseToNameAndValue(cRouteSlice, cUrlSlice);
+          extractedParameters[name] = value;
+        } else {
+          if (cRouteSlice !== cUrlSlice) {
+            matched = false;
+            continue;
+          }
+        }
+      }
+      if (matched) {
+        countOfFoundRoutes++;
+        await route.action(extractedParameters, url, async () => {
+          await DomeManipulator.scrollToAsync({
+            pxFromTop: scrollToPosition
+          });
+        }, query);
+      }
+    }
+    if (countOfFoundRoutes == 0 && onNotFoundAction) {
+      onNotFoundAction();
+    }
+  }
+})(DomeRouter || (DomeRouter = {}));
+export {
+  AnimatedArray,
+  AnimatedTable,
+  AnimatedText,
+  Async,
+  DataTypes,
+  DomeComponent,
+  DomeManipulator,
+  DomeRouter,
+  Lock,
+  ObservableArray,
+  ObservableLocalStorageArray,
+  ObservableLocalStorageVariable,
+  ObservableMap,
+  ObservableVariable as ObservableValue,
+  ObservableVariable,
+  React,
+  TypeEvent,
+  checkIfObservable,
+  createObservable,
+  h
+};