oidc-spa 8.1.10 → 8.1.11

package/esm/vendor/backend/evt.js

@@ -0,0 +1,3286 @@
+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 __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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/evt/lib/types/helper/index.js
+var require_helper = __commonJS({
+  "node_modules/evt/lib/types/helper/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/evt/node_modules/tsafe/typeGuard.js
+var require_typeGuard = __commonJS({
+  "node_modules/evt/node_modules/tsafe/typeGuard.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.typeGuard = void 0;
+    function typeGuard(_value, isMatched) {
+      return isMatched;
+    }
+    exports.typeGuard = typeGuard;
+  }
+});
+
+// node_modules/evt/lib/types/interfaces/CtxLike.js
+var require_CtxLike = __commonJS({
+  "node_modules/evt/lib/types/interfaces/CtxLike.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CtxLike = void 0;
+    var typeGuard_1 = require_typeGuard();
+    var CtxLike;
+    (function(CtxLike2) {
+      function match(o) {
+        return (0, typeGuard_1.typeGuard)(o, true) && o instanceof Object && typeof o.done === "function" && typeof o.abort === "function" && typeof o.zz__addHandler === "function" && typeof o.zz__removeHandler === "function";
+      }
+      CtxLike2.match = match;
+    })(CtxLike = exports.CtxLike || (exports.CtxLike = {}));
+  }
+});
+
+// node_modules/evt/lib/types/interfaces/index.js
+var require_interfaces = __commonJS({
+  "node_modules/evt/lib/types/interfaces/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_CtxLike(), exports);
+  }
+});
+
+// node_modules/evt/lib/types/lib.dom.js
+var require_lib_dom = __commonJS({
+  "node_modules/evt/lib/types/lib.dom.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.__hack = void 0;
+    exports.__hack = "NOT TYPE ONLY";
+  }
+});
+
+// node_modules/evt/lib/types/EventTargetLike.js
+var require_EventTargetLike = __commonJS({
+  "node_modules/evt/lib/types/EventTargetLike.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.EventTargetLike = void 0;
+    var typeGuard_1 = require_typeGuard();
+    var EventTargetLike;
+    (function(EventTargetLike2) {
+      var RxJSSubject;
+      (function(RxJSSubject2) {
+        function match(eventTarget) {
+          return (0, typeGuard_1.typeGuard)(eventTarget, true) && eventTarget instanceof Object && typeof eventTarget.subscribe === "function";
+        }
+        RxJSSubject2.match = match;
+      })(RxJSSubject = EventTargetLike2.RxJSSubject || (EventTargetLike2.RxJSSubject = {}));
+      var NodeStyleEventEmitter;
+      (function(NodeStyleEventEmitter2) {
+        ;
+        function match(eventTarget) {
+          return (0, typeGuard_1.typeGuard)(eventTarget, true) && eventTarget instanceof Object && typeof eventTarget.addListener === "function" && typeof eventTarget.removeListener === "function";
+        }
+        NodeStyleEventEmitter2.match = match;
+      })(NodeStyleEventEmitter = EventTargetLike2.NodeStyleEventEmitter || (EventTargetLike2.NodeStyleEventEmitter = {}));
+      var JQueryStyleEventEmitter;
+      (function(JQueryStyleEventEmitter2) {
+        function match(eventTarget) {
+          return (0, typeGuard_1.typeGuard)(eventTarget, true) && eventTarget instanceof Object && typeof eventTarget.on === "function" && typeof eventTarget.off === "function";
+        }
+        JQueryStyleEventEmitter2.match = match;
+      })(JQueryStyleEventEmitter = EventTargetLike2.JQueryStyleEventEmitter || (EventTargetLike2.JQueryStyleEventEmitter = {}));
+      var HasEventTargetAddRemove;
+      (function(HasEventTargetAddRemove2) {
+        function match(eventTarget) {
+          return (0, typeGuard_1.typeGuard)(eventTarget, true) && eventTarget instanceof Object && typeof eventTarget.addEventListener === "function" && typeof eventTarget.removeEventListener === "function";
+        }
+        HasEventTargetAddRemove2.match = match;
+      })(HasEventTargetAddRemove = EventTargetLike2.HasEventTargetAddRemove || (EventTargetLike2.HasEventTargetAddRemove = {}));
+      function canBe(o) {
+        try {
+          return HasEventTargetAddRemove.match(o) || NodeStyleEventEmitter.match(o) || JQueryStyleEventEmitter.match(o) || RxJSSubject.match(o);
+        } catch (_a) {
+          return false;
+        }
+      }
+      EventTargetLike2.canBe = canBe;
+    })(EventTargetLike = exports.EventTargetLike || (exports.EventTargetLike = {}));
+  }
+});
+
+// node_modules/evt/lib/types/EvtError.js
+var require_EvtError = __commonJS({
+  "node_modules/evt/lib/types/EvtError.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DetachedEvtError = exports.TimeoutEvtError = void 0;
+    var TimeoutEvtError = (
+      /** @class */
+      (function(_super) {
+        __extends(TimeoutEvtError2, _super);
+        function TimeoutEvtError2(timeout) {
+          var _newTarget = this.constructor;
+          var _this_1 = _super.call(this, "Evt timeout after ".concat(timeout, "ms")) || this;
+          _this_1.timeout = timeout;
+          Object.setPrototypeOf(_this_1, _newTarget.prototype);
+          return _this_1;
+        }
+        return TimeoutEvtError2;
+      })(Error)
+    );
+    exports.TimeoutEvtError = TimeoutEvtError;
+    var DetachedEvtError = (
+      /** @class */
+      (function(_super) {
+        __extends(DetachedEvtError2, _super);
+        function DetachedEvtError2() {
+          var _newTarget = this.constructor;
+          var _this_1 = _super.call(this, "Evt handler detached") || this;
+          Object.setPrototypeOf(_this_1, _newTarget.prototype);
+          return _this_1;
+        }
+        return DetachedEvtError2;
+      })(Error)
+    );
+    exports.DetachedEvtError = DetachedEvtError;
+  }
+});
+
+// node_modules/evt/lib/types/Operator.js
+var require_Operator = __commonJS({
+  "node_modules/evt/lib/types/Operator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// node_modules/evt/lib/types/index.js
+var require_types = __commonJS({
+  "node_modules/evt/lib/types/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dom = void 0;
+    __exportStar(require_helper(), exports);
+    __exportStar(require_interfaces(), exports);
+    exports.dom = __importStar(require_lib_dom());
+    __exportStar(require_EventTargetLike(), exports);
+    __exportStar(require_EvtError(), exports);
+    __exportStar(require_Operator(), exports);
+  }
+});
+
+// node_modules/evt/lib/util/convertOperatorToStatelessFLambda.js
+var require_convertOperatorToStatelessFLambda = __commonJS({
+  "node_modules/evt/lib/util/convertOperatorToStatelessFLambda.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.convertOperatorToStatelessF\u03BB = void 0;
+    function encapsulateOpState(statefulF\u03BBOp) {
+      var state = statefulF\u03BBOp[1];
+      return function(data, registerSideEffect) {
+        var opResult = statefulF\u03BBOp[0](data, state, registerSideEffect);
+        if (opResult !== null) {
+          registerSideEffect(function() {
+            return state = opResult[0];
+          });
+        }
+        return opResult;
+      };
+    }
+    function statelessOpToStatelessF\u03BB(op) {
+      return function(data, registerSideEffect) {
+        var opResult = op(data, registerSideEffect);
+        return opResult instanceof Object && !("input" in opResult) && //exclude String.prototype.match
+        opResult.length === 1 ? opResult : !!opResult ? [data] : null;
+      };
+    }
+    function convertOperatorToStatelessF\u03BB(op) {
+      return typeof op !== "function" ? encapsulateOpState(op) : statelessOpToStatelessF\u03BB(op);
+    }
+    exports.convertOperatorToStatelessF\u03BB = convertOperatorToStatelessF\u03BB;
+  }
+});
+
+// node_modules/evt/node_modules/tsafe/id.js
+var require_id = __commonJS({
+  "node_modules/evt/node_modules/tsafe/id.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.id = void 0;
+    var id = function(x) {
+      return x;
+    };
+    exports.id = id;
+  }
+});
+
+// node_modules/evt/lib/util/compose.js
+var require_compose = __commonJS({
+  "node_modules/evt/lib/util/compose.js"(exports) {
+    "use strict";
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.compose = void 0;
+    var convertOperatorToStatelessFLambda_1 = require_convertOperatorToStatelessFLambda();
+    var id_1 = require_id();
+    function f_o_g(op1, op2) {
+      var opAtoB = (0, convertOperatorToStatelessFLambda_1.convertOperatorToStatelessF\u03BB)(op1);
+      var opBtoC = (0, convertOperatorToStatelessFLambda_1.convertOperatorToStatelessF\u03BB)(op2);
+      return (0, id_1.id)(function(dataA, registerSideEffect) {
+        var resultB = opAtoB(dataA, registerSideEffect);
+        if (!resultB) {
+          return null;
+        }
+        var _a = __read(resultB, 1), dataB = _a[0];
+        var resultC = opBtoC(dataB, registerSideEffect);
+        if (!resultC) {
+          return resultC;
+        }
+        return [resultC[0]];
+      });
+    }
+    function compose() {
+      var ops = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        ops[_i] = arguments[_i];
+      }
+      if (ops.length === 1) {
+        var _a = __read(ops, 1), op = _a[0];
+        return (0, convertOperatorToStatelessFLambda_1.convertOperatorToStatelessF\u03BB)(op);
+      }
+      var _b = __read(ops), op1 = _b[0], op2 = _b[1], rest = _b.slice(2);
+      var op1_o_op2 = f_o_g(op1, op2);
+      if (rest.length === 0) {
+        return op1_o_op2;
+      }
+      return compose.apply(void 0, __spreadArray([op1_o_op2], __read(rest), false));
+    }
+    exports.compose = compose;
+  }
+});
+
+// node_modules/evt/lib/util/index.js
+var require_util = __commonJS({
+  "node_modules/evt/lib/util/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.compose = void 0;
+    var compose_1 = require_compose();
+    Object.defineProperty(exports, "compose", { enumerable: true, get: function() {
+      return compose_1.compose;
+    } });
+  }
+});
+
+// node_modules/minimal-polyfills/Map.js
+var require_Map = __commonJS({
+  "node_modules/minimal-polyfills/Map.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.Polyfill = exports.LightMapImpl = void 0;
+    var LightMapImpl = (
+      /** @class */
+      (function() {
+        function LightMapImpl2() {
+          this.record = [];
+        }
+        LightMapImpl2.prototype.has = function(key) {
+          return this.record.map(function(_a) {
+            var _key = _a[0];
+            return _key;
+          }).indexOf(key) >= 0;
+        };
+        LightMapImpl2.prototype.get = function(key) {
+          var entry = this.record.filter(function(_a) {
+            var _key = _a[0];
+            return _key === key;
+          })[0];
+          if (entry === void 0) {
+            return void 0;
+          }
+          return entry[1];
+        };
+        LightMapImpl2.prototype.set = function(key, value) {
+          var entry = this.record.filter(function(_a) {
+            var _key = _a[0];
+            return _key === key;
+          })[0];
+          if (entry === void 0) {
+            this.record.push([key, value]);
+          } else {
+            entry[1] = value;
+          }
+          return this;
+        };
+        LightMapImpl2.prototype["delete"] = function(key) {
+          var index = this.record.map(function(_a) {
+            var key2 = _a[0];
+            return key2;
+          }).indexOf(key);
+          if (index < 0) {
+            return false;
+          }
+          this.record.splice(index, 1);
+          return true;
+        };
+        LightMapImpl2.prototype.keys = function() {
+          return this.record.map(function(_a) {
+            var key = _a[0];
+            return key;
+          });
+        };
+        return LightMapImpl2;
+      })()
+    );
+    exports.LightMapImpl = LightMapImpl;
+    exports.Polyfill = typeof Map !== "undefined" ? Map : LightMapImpl;
+  }
+});
+
+// node_modules/minimal-polyfills/Set.js
+var require_Set = __commonJS({
+  "node_modules/minimal-polyfills/Set.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.Polyfill = exports.LightSetImpl = void 0;
+    var Map_1 = require_Map();
+    var LightSetImpl = (
+      /** @class */
+      (function() {
+        function LightSetImpl2(values) {
+          this.map = new Map_1.Polyfill();
+          if (values === void 0) {
+            return;
+          }
+          for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
+            var value = values_1[_i];
+            this.add(value);
+          }
+        }
+        LightSetImpl2.prototype.has = function(value) {
+          return this.map.has(value);
+        };
+        LightSetImpl2.prototype.add = function(value) {
+          this.map.set(value, true);
+          return this;
+        };
+        LightSetImpl2.prototype.values = function() {
+          return this.map.keys();
+        };
+        LightSetImpl2.prototype["delete"] = function(value) {
+          return this.map["delete"](value);
+        };
+        return LightSetImpl2;
+      })()
+    );
+    exports.LightSetImpl = LightSetImpl;
+    exports.Polyfill = typeof Set !== "undefined" ? Set : LightSetImpl;
+  }
+});
+
+// node_modules/minimal-polyfills/WeakMap.js
+var require_WeakMap = __commonJS({
+  "node_modules/minimal-polyfills/WeakMap.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    exports.Polyfill = void 0;
+    var Map_1 = require_Map();
+    exports.Polyfill = typeof WeakMap !== "undefined" ? WeakMap : Map_1.Polyfill;
+  }
+});
+
+// node_modules/evt/node_modules/tsafe/zz_internal/assertIsRefWrapper.js
+var require_assertIsRefWrapper = __commonJS({
+  "node_modules/evt/node_modules/tsafe/zz_internal/assertIsRefWrapper.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.assertIsRefWrapper = void 0;
+    var id_1 = require_id();
+    exports.assertIsRefWrapper = {
+      "ref": (0, id_1.id)(void 0)
+    };
+  }
+});
+
+// node_modules/evt/node_modules/tsafe/is.js
+var require_is = __commonJS({
+  "node_modules/evt/node_modules/tsafe/is.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.is = void 0;
+    var assertIsRefWrapper_1 = require_assertIsRefWrapper();
+    var errorMessage = [
+      "Wrong usage of the ".concat(is.name, " function refer to"),
+      "https://docs.tsafe.dev/".concat(is.name.toLowerCase())
+    ].join(" ");
+    function is(_value) {
+      var ref = {};
+      if (assertIsRefWrapper_1.assertIsRefWrapper.ref !== void 0) {
+        assertIsRefWrapper_1.assertIsRefWrapper.ref = void 0;
+        throw new Error(errorMessage);
+      }
+      assertIsRefWrapper_1.assertIsRefWrapper.ref = ref;
+      Promise.resolve().then(function() {
+        if (assertIsRefWrapper_1.assertIsRefWrapper.ref === ref) {
+          throw new Error(errorMessage);
+        }
+      });
+      return null;
+    }
+    exports.is = is;
+  }
+});
+
+// node_modules/evt/node_modules/tsafe/lab/overwriteReadonlyProp.js
+var require_overwriteReadonlyProp = __commonJS({
+  "node_modules/evt/node_modules/tsafe/lab/overwriteReadonlyProp.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.overwriteReadonlyProp = void 0;
+    var assert_1 = require_assert();
+    var is_1 = require_is();
+    var overwriteReadonlyProp = function(obj, propertyName, value) {
+      try {
+        obj[propertyName] = value;
+      } catch (_a) {
+      }
+      if (obj[propertyName] === value) {
+        return value;
+      }
+      var errorDefineProperty = void 0;
+      var propertyDescriptor = Object.getOwnPropertyDescriptor(obj, propertyName) || {
+        "enumerable": true,
+        "configurable": true
+      };
+      if (!!propertyDescriptor.get) {
+        throw new Error("Probably a wrong ides to overwrite ".concat(String(propertyName), " getter"));
+      }
+      try {
+        Object.defineProperty(obj, propertyName, __assign(__assign({}, propertyDescriptor), { value }));
+      } catch (error) {
+        (0, assert_1.assert)((0, is_1.is)(error));
+        errorDefineProperty = error;
+      }
+      if (obj[propertyName] !== value) {
+        throw errorDefineProperty || new Error("Can't assign");
+      }
+      return value;
+    };
+    exports.overwriteReadonlyProp = overwriteReadonlyProp;
+  }
+});
+
+// node_modules/evt/node_modules/tsafe/assert.js
+var require_assert = __commonJS({
+  "node_modules/evt/node_modules/tsafe/assert.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.assert = exports.AssertionError = void 0;
+    var overwriteReadonlyProp_1 = require_overwriteReadonlyProp();
+    var assertIsRefWrapper_1 = require_assertIsRefWrapper();
+    var AssertionError = (
+      /** @class */
+      (function(_super) {
+        __extends(AssertionError2, _super);
+        function AssertionError2(msg) {
+          var _newTarget = this.constructor;
+          var _this = _super.call(this, "Wrong assertion encountered" + (!msg ? "" : ': "'.concat(msg, '"'))) || this;
+          Object.setPrototypeOf(_this, _newTarget.prototype);
+          if (!_this.stack) {
+            return _this;
+          }
+          try {
+            (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(_this, "stack", _this.stack.split("\n").filter(function() {
+              var _a = [];
+              for (var _i = 0; _i < arguments.length; _i++) {
+                _a[_i] = arguments[_i];
+              }
+              var _b = __read(_a, 2), i = _b[1];
+              return i !== 1 && i !== 2;
+            }).join("\n"));
+          } catch (_a) {
+          }
+          return _this;
+        }
+        return AssertionError2;
+      })(Error)
+    );
+    exports.AssertionError = AssertionError;
+    function assert(condition, msg) {
+      if (arguments.length === 0) {
+        condition = true;
+      }
+      if (assertIsRefWrapper_1.assertIsRefWrapper.ref !== void 0) {
+        assertIsRefWrapper_1.assertIsRefWrapper.ref = void 0;
+        return;
+      }
+      if (!condition) {
+        throw new AssertionError(msg);
+      }
+    }
+    exports.assert = assert;
+  }
+});
+
+// node_modules/evt/lib/importProxy.js
+var require_importProxy = __commonJS({
+  "node_modules/evt/lib/importProxy.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.importProxy = void 0;
+    exports.importProxy = {};
+  }
+});
+
+// node_modules/evt/lib/LazyEvt.js
+var require_LazyEvt = __commonJS({
+  "node_modules/evt/lib/LazyEvt.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LazyEvt = void 0;
+    var overwriteReadonlyProp_1 = require_overwriteReadonlyProp();
+    var importProxy_1 = require_importProxy();
+    var LazyEvt = (
+      /** @class */
+      (function() {
+        function LazyEvt2() {
+          this.initialPostCount = 0;
+        }
+        Object.defineProperty(LazyEvt2.prototype, "evt", {
+          get: function() {
+            if (this.__evt === void 0) {
+              this.__evt = new importProxy_1.importProxy.Evt();
+              (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(this.__evt, "postCount", this.initialPostCount);
+            }
+            return this.__evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        LazyEvt2.prototype.__post = function(data, doWait) {
+          if (this.__evt === void 0) {
+            return ++this.initialPostCount;
+          }
+          return this.__evt[doWait ? "postAndWait" : "post"](data);
+        };
+        LazyEvt2.prototype.post = function(data) {
+          return this.__post(data, false);
+        };
+        LazyEvt2.prototype.postAndWait = function(data) {
+          return this.__post(data, true);
+        };
+        return LazyEvt2;
+      })()
+    );
+    exports.LazyEvt = LazyEvt;
+  }
+});
+
+// node_modules/evt/lib/Ctx.js
+var require_Ctx = __commonJS({
+  "node_modules/evt/lib/Ctx.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __values = exports && exports.__values || function(o) {
+      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+      if (m) return m.call(o);
+      if (o && typeof o.length === "number") return {
+        next: function() {
+          if (o && i >= o.length) o = void 0;
+          return { value: o && o[i++], done: !o };
+        }
+      };
+      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Ctx = void 0;
+    var Set_1 = require_Set();
+    var WeakMap_1 = require_WeakMap();
+    var assert_1 = require_assert();
+    var is_1 = require_is();
+    var LazyEvt_1 = require_LazyEvt();
+    var importProxy_1 = require_importProxy();
+    var overwriteReadonlyProp_1 = require_overwriteReadonlyProp();
+    var CtxImpl = (
+      /** @class */
+      (function() {
+        function CtxImpl2() {
+          this.lazyEvtAttach = new LazyEvt_1.LazyEvt();
+          this.lazyEvtDetach = new LazyEvt_1.LazyEvt();
+          this.lazyEvtDoneOrAborted = new LazyEvt_1.LazyEvt();
+          this.handlers = new Set_1.Polyfill();
+          this.evtByHandler = new WeakMap_1.Polyfill();
+        }
+        Object.defineProperty(CtxImpl2.prototype, "evtDoneOrAborted", {
+          get: function() {
+            return this.lazyEvtDoneOrAborted.evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(CtxImpl2.prototype, "evtAttach", {
+          get: function() {
+            return this.lazyEvtAttach.evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(CtxImpl2.prototype, "evtDetach", {
+          get: function() {
+            return this.lazyEvtDetach.evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(CtxImpl2.prototype, "completionStatus", {
+          get: function() {
+            return this.__completionStatus;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        CtxImpl2.prototype.onDoneOrAborted = function(doneOrAborted) {
+          this.__completionStatus = doneOrAborted;
+          this.lazyEvtDoneOrAborted.post(doneOrAborted);
+        };
+        CtxImpl2.prototype.waitFor = function(timeout) {
+          var _this_1 = this;
+          return this.evtDoneOrAborted.waitFor(timeout).then(function(data) {
+            if (data.type === "ABORTED") {
+              throw data.error;
+            }
+            return data.result;
+          }, function(timeoutError) {
+            _this_1.abort(timeoutError);
+            throw timeoutError;
+          });
+        };
+        CtxImpl2.prototype.abort = function(error) {
+          return this.__done(error);
+        };
+        CtxImpl2.prototype.done = function(result) {
+          return this.__done(void 0, result);
+        };
+        CtxImpl2.prototype.__done = function(error, result) {
+          var e_1, _a;
+          var handlers = [];
+          try {
+            for (var _b = __values(this.handlers.values()), _c = _b.next(); !_c.done; _c = _b.next()) {
+              var handler = _c.value;
+              var evt = this.evtByHandler.get(handler);
+              var wasStillAttached = handler.detach();
+              if (!wasStillAttached) {
+                continue;
+              }
+              handlers.push({ handler, evt });
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+          this.onDoneOrAborted(__assign(__assign({}, !!error ? { type: "ABORTED", error } : { type: "DONE", "result": result }), { handlers }));
+          return handlers;
+        };
+        CtxImpl2.prototype.getHandlers = function() {
+          var _this_1 = this;
+          return Array.from(this.handlers.values()).map(function(handler) {
+            return { handler, "evt": _this_1.evtByHandler.get(handler) };
+          });
+        };
+        CtxImpl2.prototype.zz__addHandler = function(handler, evt) {
+          (0, assert_1.assert)(handler.ctx === this);
+          (0, assert_1.assert)((0, is_1.is)(handler));
+          if (this.completionStatus !== void 0) {
+            handler.detach();
+            return;
+          }
+          this.handlers.add(handler);
+          this.evtByHandler.set(handler, evt);
+          this.lazyEvtAttach.post({ handler, evt });
+        };
+        CtxImpl2.prototype.zz__removeHandler = function(handler) {
+          (0, assert_1.assert)(handler.ctx === this);
+          (0, assert_1.assert)((0, is_1.is)(handler));
+          this.lazyEvtDetach.post({
+            handler,
+            "evt": this.evtByHandler.get(handler)
+          });
+          this.handlers.delete(handler);
+        };
+        return CtxImpl2;
+      })()
+    );
+    exports.Ctx = CtxImpl;
+    try {
+      (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(exports.Ctx, "name", "Ctx");
+    } catch (_a) {
+    }
+    importProxy_1.importProxy.Ctx = exports.Ctx;
+  }
+});
+
+// node_modules/minimal-polyfills/Array.prototype.find.js
+var require_Array_prototype_find = __commonJS({
+  "node_modules/minimal-polyfills/Array.prototype.find.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    if (!Array.prototype.find) {
+      Object.defineProperty(Array.prototype, "find", {
+        value: function(predicate) {
+          if (this == null) {
+            throw new TypeError('"this" is null or not defined');
+          }
+          var o = Object(this);
+          var len = o.length >>> 0;
+          if (typeof predicate !== "function") {
+            throw new TypeError("predicate must be a function");
+          }
+          var thisArg = arguments[1];
+          var k = 0;
+          while (k < len) {
+            var kValue = o[k];
+            if (predicate.call(thisArg, kValue, k, o)) {
+              return kValue;
+            }
+            k++;
+          }
+          return void 0;
+        },
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+});
+
+// node_modules/evt/lib/Evt.create.js
+var require_Evt_create = __commonJS({
+  "node_modules/evt/lib/Evt.create.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.create = void 0;
+    var importProxy_1 = require_importProxy();
+    function create() {
+      var args = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+      }
+      return args.length === 0 ? new importProxy_1.importProxy.Evt() : new importProxy_1.importProxy.StatefulEvt(args[0]);
+    }
+    exports.create = create;
+  }
+});
+
+// node_modules/evt/lib/Evt.getCtx.js
+var require_Evt_getCtx = __commonJS({
+  "node_modules/evt/lib/Evt.getCtx.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getCtxFactory = void 0;
+    var WeakMap_1 = require_WeakMap();
+    var importProxy_1 = require_importProxy();
+    function getCtxFactory() {
+      var ctxByObj = new WeakMap_1.Polyfill();
+      function getCtx(obj) {
+        var ctx = ctxByObj.get(obj);
+        if (ctx === void 0) {
+          ctx = new importProxy_1.importProxy.Ctx();
+          ctxByObj.set(obj, ctx);
+        }
+        return ctx;
+      }
+      return getCtx;
+    }
+    exports.getCtxFactory = getCtxFactory;
+  }
+});
+
+// node_modules/evt/lib/Evt.factorize.js
+var require_Evt_factorize = __commonJS({
+  "node_modules/evt/lib/Evt.factorize.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.factorize = void 0;
+    function factorize(evt) {
+      return evt;
+    }
+    exports.factorize = factorize;
+  }
+});
+
+// node_modules/evt/lib/Evt.merge.js
+var require_Evt_merge = __commonJS({
+  "node_modules/evt/lib/Evt.merge.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.merge = exports.mergeImpl = void 0;
+    var importProxy_1 = require_importProxy();
+    function mergeImpl(ctx, evts) {
+      var evtUnion = new importProxy_1.importProxy.Evt();
+      var callback = function(data) {
+        return evtUnion.post(data);
+      };
+      evts.forEach(function(evt) {
+        if (ctx === void 0) {
+          evt.attach(callback);
+        } else {
+          evt.attach(ctx, callback);
+        }
+      });
+      return evtUnion;
+    }
+    exports.mergeImpl = mergeImpl;
+    function merge(p1, p2) {
+      return "length" in p1 ? mergeImpl(void 0, p1) : mergeImpl(p1, p2);
+    }
+    exports.merge = merge;
+  }
+});
+
+// node_modules/evt/lib/Evt.from.js
+var require_Evt_from = __commonJS({
+  "node_modules/evt/lib/Evt.from.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.from = void 0;
+    var id_1 = require_id();
+    var assert_1 = require_assert();
+    var typeGuard_1 = require_typeGuard();
+    var Evt_merge_1 = require_Evt_merge();
+    var importProxy_1 = require_importProxy();
+    var nsEventTargetLike = __importStar(require_EventTargetLike());
+    var EventTargetLikeAsValue = nsEventTargetLike.EventTargetLike;
+    function fromImplForTargetEventLike(ctx, target, eventName, options) {
+      var matchEventTargetLike = function(target_) {
+        return EventTargetLikeAsValue.canBe(target_);
+      };
+      if (!matchEventTargetLike(target)) {
+        if ("then" in target) {
+          var evt_1 = new importProxy_1.importProxy.Evt();
+          var isCtxDone_1 = (function() {
+            var getEvtDonePostCount = function() {
+              return ctx === null || ctx === void 0 ? void 0 : ctx.evtDoneOrAborted.postCount;
+            };
+            var n = getEvtDonePostCount();
+            return function() {
+              return n !== getEvtDonePostCount();
+            };
+          })();
+          target.then(function(data) {
+            if (isCtxDone_1()) {
+              return;
+            }
+            evt_1.post(data);
+          });
+          return evt_1;
+        }
+        return (0, Evt_merge_1.mergeImpl)(ctx, Array.from(target).map(function(target2) {
+          return fromImplForTargetEventLike(ctx, target2, eventName, options);
+        }));
+      }
+      var proxy;
+      if (EventTargetLikeAsValue.HasEventTargetAddRemove.match(target)) {
+        proxy = {
+          "on": function(listener2, eventName2, options2) {
+            return target.addEventListener(eventName2, listener2, options2);
+          },
+          "off": function(listener2, eventName2, options2) {
+            return target.removeEventListener(eventName2, listener2, options2);
+          }
+        };
+      } else if (EventTargetLikeAsValue.NodeStyleEventEmitter.match(target)) {
+        proxy = {
+          "on": function(listener2, eventName2) {
+            return target.addListener(eventName2, listener2);
+          },
+          "off": function(listener2, eventName2) {
+            return target.removeListener(eventName2, listener2);
+          }
+        };
+      } else if (EventTargetLikeAsValue.JQueryStyleEventEmitter.match(target)) {
+        proxy = {
+          "on": function(listener2, eventName2) {
+            return target.on(eventName2, listener2);
+          },
+          "off": function(listener2, eventName2) {
+            return target.off(eventName2, listener2);
+          }
+        };
+      } else if (EventTargetLikeAsValue.RxJSSubject.match(target)) {
+        var subscription_1;
+        proxy = {
+          "on": function(listener2) {
+            return subscription_1 = target.subscribe(function(data) {
+              return listener2(data);
+            });
+          },
+          "off": function() {
+            return subscription_1.unsubscribe();
+          }
+        };
+      } else {
+        (0, id_1.id)(target);
+        (0, assert_1.assert)(false);
+      }
+      var evt = new importProxy_1.importProxy.Evt();
+      var listener = function(data) {
+        return evt.post(data);
+      };
+      ctx === null || ctx === void 0 ? void 0 : ctx.evtDoneOrAborted.attachOnce(function() {
+        return proxy.off(listener, eventName, options);
+      });
+      proxy.on(listener, eventName, options);
+      return evt;
+    }
+    function fromImplForObserver(ctx, ObserverConstructor, target) {
+      var evt = importProxy_1.importProxy.Evt.create();
+      var listener = function(_a) {
+        var _b = __read(_a, 1), entry = _b[0];
+        return evt.post(entry);
+      };
+      var observer = new ObserverConstructor(listener);
+      observer.observe(target);
+      ctx === null || ctx === void 0 ? void 0 : ctx.evtDoneOrAborted.attachOnce(function() {
+        return observer.disconnect();
+      });
+      return evt;
+    }
+    function from(ctxOrTargetOrObserverConstructor, targetOrEventNameOrObserverConstructorOrObserverTarget, eventNameOrOptionsOrObserverTarget, options) {
+      if ("evtDoneOrAborted" in ctxOrTargetOrObserverConstructor) {
+        (0, assert_1.assert)((0, typeGuard_1.typeGuard)(targetOrEventNameOrObserverConstructorOrObserverTarget, true) && (0, typeGuard_1.typeGuard)(eventNameOrOptionsOrObserverTarget, true) && (0, typeGuard_1.typeGuard)(options, true));
+        if (typeof targetOrEventNameOrObserverConstructorOrObserverTarget === "function") {
+          (0, assert_1.assert)((0, typeGuard_1.typeGuard)(eventNameOrOptionsOrObserverTarget, true) && (0, typeGuard_1.typeGuard)(options, true));
+          return fromImplForObserver(ctxOrTargetOrObserverConstructor, targetOrEventNameOrObserverConstructorOrObserverTarget, eventNameOrOptionsOrObserverTarget);
+        } else {
+          (0, assert_1.assert)((0, typeGuard_1.typeGuard)(eventNameOrOptionsOrObserverTarget, true));
+          return fromImplForTargetEventLike(ctxOrTargetOrObserverConstructor, targetOrEventNameOrObserverConstructorOrObserverTarget, eventNameOrOptionsOrObserverTarget, options);
+        }
+      } else {
+        (0, assert_1.assert)((0, typeGuard_1.typeGuard)(ctxOrTargetOrObserverConstructor, true) && (0, typeGuard_1.typeGuard)(targetOrEventNameOrObserverConstructorOrObserverTarget, true) && (0, typeGuard_1.typeGuard)(eventNameOrOptionsOrObserverTarget, true));
+        if (typeof ctxOrTargetOrObserverConstructor === "function") {
+          (0, assert_1.assert)((0, typeGuard_1.typeGuard)(targetOrEventNameOrObserverConstructorOrObserverTarget, true) && (0, typeGuard_1.typeGuard)(eventNameOrOptionsOrObserverTarget, true));
+          return fromImplForObserver(void 0, ctxOrTargetOrObserverConstructor, targetOrEventNameOrObserverConstructorOrObserverTarget);
+        } else {
+          (0, assert_1.assert)((0, typeGuard_1.typeGuard)(targetOrEventNameOrObserverConstructorOrObserverTarget, true));
+          return fromImplForTargetEventLike(void 0, ctxOrTargetOrObserverConstructor, targetOrEventNameOrObserverConstructorOrObserverTarget, eventNameOrOptionsOrObserverTarget);
+        }
+      }
+    }
+    exports.from = from;
+  }
+});
+
+// node_modules/evt/lib/Evt.asPostable.js
+var require_Evt_asPostable = __commonJS({
+  "node_modules/evt/lib/Evt.asPostable.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.asPostable = void 0;
+    function asPostable(evt) {
+      return evt;
+    }
+    exports.asPostable = asPostable;
+  }
+});
+
+// node_modules/evt/lib/Evt.asyncPipe.js
+var require_Evt_asyncPipe = __commonJS({
+  "node_modules/evt/lib/Evt.asyncPipe.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.asyncPipe = void 0;
+    var importProxy_1 = require_importProxy();
+    function asyncPipe(evt, asyncOp) {
+      var _this_1 = this;
+      var out = "state" in evt ? importProxy_1.importProxy.Evt.create(void 0) : importProxy_1.importProxy.Evt.create();
+      var currentCallCount = 0;
+      evt.attach(function(data) {
+        return __awaiter(_this_1, void 0, void 0, function() {
+          var thisCallCount, prOpResult, opResult;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                currentCallCount++;
+                thisCallCount = currentCallCount;
+                prOpResult = asyncOp(data);
+                if (!(prOpResult !== null && "then" in prOpResult)) return [3, 2];
+                return [4, prOpResult];
+              case 1:
+                opResult = _a.sent();
+                if ("state" in evt && thisCallCount !== currentCallCount) {
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                return [3, 3];
+              case 2:
+                opResult = prOpResult;
+                _a.label = 3;
+              case 3:
+                if (!opResult) {
+                  return [
+                    2
+                    /*return*/
+                  ];
+                }
+                out.post(opResult[0]);
+                return [
+                  2
+                  /*return*/
+                ];
+            }
+          });
+        });
+      });
+      return out;
+    }
+    exports.asyncPipe = asyncPipe;
+  }
+});
+
+// node_modules/evt/lib/Evt.asNonPostable.js
+var require_Evt_asNonPostable = __commonJS({
+  "node_modules/evt/lib/Evt.asNonPostable.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.asNonPostable = void 0;
+    function asNonPostable(evt) {
+      return evt;
+    }
+    exports.asNonPostable = asNonPostable;
+  }
+});
+
+// node_modules/evt/lib/Evt.parsePropsFromArgs.js
+var require_Evt_parsePropsFromArgs = __commonJS({
+  "node_modules/evt/lib/Evt.parsePropsFromArgs.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parsePropsFromArgs = exports.matchAll = void 0;
+    var id_1 = require_id();
+    var compose_1 = require_compose();
+    var typeGuard_1 = require_typeGuard();
+    function matchAll() {
+      return true;
+    }
+    exports.matchAll = matchAll;
+    var canBeOperator = function(p) {
+      return p !== void 0 && (0, typeGuard_1.typeGuard)(p, true) && (typeof p === "function" || typeof p[0] === "function");
+    };
+    var defaultParams = {
+      "op": matchAll,
+      "ctx": void 0,
+      "timeout": void 0,
+      "callback": void 0
+    };
+    function parsePropsFromArgs(inputs, methodName) {
+      switch (methodName) {
+        case "pipe":
+          {
+            var getOpWrap = function(ops) {
+              return ops.length === 0 ? {} : { "op": ops.length === 1 ? ops[0] : compose_1.compose.apply(void 0, __spreadArray([], __read(ops), false)) };
+            };
+            if (canBeOperator(inputs[0])) {
+              return (0, id_1.id)(__assign(__assign({}, defaultParams), getOpWrap(inputs)));
+            } else {
+              var _a = __read(inputs), ctx = _a[0], rest = _a.slice(1);
+              return (0, id_1.id)(__assign(__assign(__assign({}, defaultParams), ctx !== void 0 ? { ctx } : {}), getOpWrap(rest)));
+            }
+          }
+          break;
+        case "waitFor":
+          {
+            return parsePropsFromArgs(__spreadArray(__spreadArray([], __read(inputs.filter(function(value, index) {
+              return !(index === inputs.length - 1 && value === void 0);
+            })), false), [
+              defaultParams.callback
+            ], false), "attach*");
+          }
+          break;
+        case "attach*":
+          {
+            var n = inputs.length;
+            switch (n) {
+              case 4: {
+                var _b = __read(inputs, 4), p1 = _b[0], p2 = _b[1], p3 = _b[2], p4 = _b[3];
+                return (0, id_1.id)(__assign(__assign({}, defaultParams), { "op": p1, "ctx": p2, "timeout": p3, "callback": p4 }));
+              }
+              case 3: {
+                var _c = __read(inputs, 3), p1 = _c[0], p2 = _c[1], p3 = _c[2];
+                if (typeof p2 === "number") {
+                  var timeout = p2;
+                  var callback = p3;
+                  if (canBeOperator(p1)) {
+                    return (0, id_1.id)(__assign(__assign({}, defaultParams), { timeout, callback, "op": p1 }));
+                  } else {
+                    return (0, id_1.id)(__assign(__assign({}, defaultParams), { timeout, callback, "ctx": p1 }));
+                  }
+                } else {
+                  return (0, id_1.id)(__assign(__assign({}, defaultParams), { "op": p1, "ctx": p2, "callback": p3 }));
+                }
+              }
+              case 2: {
+                var _d = __read(inputs, 2), p1 = _d[0], p2 = _d[1];
+                if (typeof p1 === "number") {
+                  return (0, id_1.id)(__assign(__assign({}, defaultParams), { "timeout": p1, "callback": p2 }));
+                } else {
+                  var callback = p2;
+                  if (canBeOperator(p1)) {
+                    return (0, id_1.id)(__assign(__assign({}, defaultParams), { callback, "op": p1 }));
+                  } else {
+                    return (0, id_1.id)(__assign(__assign({}, defaultParams), { callback, "ctx": p1 }));
+                  }
+                }
+              }
+              case 1: {
+                var _e = __read(inputs, 1), p = _e[0];
+                return (0, id_1.id)(__assign(__assign({}, defaultParams), { "callback": p }));
+              }
+              case 0: {
+                return (0, id_1.id)(__assign({}, defaultParams));
+              }
+            }
+          }
+          break;
+      }
+    }
+    exports.parsePropsFromArgs = parsePropsFromArgs;
+  }
+});
+
+// node_modules/evt/lib/Evt.newCtx.js
+var require_Evt_newCtx = __commonJS({
+  "node_modules/evt/lib/Evt.newCtx.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.newCtx = void 0;
+    var importProxy_1 = require_importProxy();
+    function newCtx() {
+      return new importProxy_1.importProxy.Ctx();
+    }
+    exports.newCtx = newCtx;
+  }
+});
+
+// node_modules/run-exclusive/lib/runExclusive.js
+var require_runExclusive = __commonJS({
+  "node_modules/run-exclusive/lib/runExclusive.js"(exports) {
+    "use strict";
+    var __spreadArrays = exports && exports.__spreadArrays || function() {
+      for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+      for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+          r[k] = a[j];
+      return r;
+    };
+    exports.__esModule = true;
+    exports.buildMethodCb = exports.buildCb = exports.getPrComplete = exports.isRunning = exports.cancelAllQueuedCalls = exports.getQueuedCallCount = exports.buildMethod = exports.build = exports.createGroupRef = void 0;
+    var WeakMap_1 = require_WeakMap();
+    var ExecQueue = (
+      /** @class */
+      (function() {
+        function ExecQueue2() {
+          this.queuedCalls = [];
+          this.isRunning = false;
+          this.prComplete = Promise.resolve();
+        }
+        ExecQueue2.prototype.cancelAllQueuedCalls = function() {
+          var n;
+          this.queuedCalls.splice(0, n = this.queuedCalls.length);
+          return n;
+        };
+        return ExecQueue2;
+      })()
+    );
+    var globalContext = {};
+    var clusters = new WeakMap_1.Polyfill();
+    function getOrCreateExecQueue(context, groupRef) {
+      var execQueueByGroup = clusters.get(context);
+      if (!execQueueByGroup) {
+        execQueueByGroup = new WeakMap_1.Polyfill();
+        clusters.set(context, execQueueByGroup);
+      }
+      var execQueue = execQueueByGroup.get(groupRef);
+      if (!execQueue) {
+        execQueue = new ExecQueue();
+        execQueueByGroup.set(groupRef, execQueue);
+      }
+      return execQueue;
+    }
+    function createGroupRef() {
+      return new Array(0);
+    }
+    exports.createGroupRef = createGroupRef;
+    function build() {
+      var inputs = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        inputs[_i] = arguments[_i];
+      }
+      switch (inputs.length) {
+        case 1:
+          return buildFnPromise(true, createGroupRef(), inputs[0]);
+        case 2:
+          return buildFnPromise(true, inputs[0], inputs[1]);
+      }
+    }
+    exports.build = build;
+    function buildMethod() {
+      var inputs = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        inputs[_i] = arguments[_i];
+      }
+      switch (inputs.length) {
+        case 1:
+          return buildFnPromise(false, createGroupRef(), inputs[0]);
+        case 2:
+          return buildFnPromise(false, inputs[0], inputs[1]);
+      }
+    }
+    exports.buildMethod = buildMethod;
+    function getQueuedCallCount(runExclusiveFunction, classInstanceObject) {
+      var execQueue = getExecQueueByFunctionAndContext(runExclusiveFunction, classInstanceObject);
+      return execQueue ? execQueue.queuedCalls.length : 0;
+    }
+    exports.getQueuedCallCount = getQueuedCallCount;
+    function cancelAllQueuedCalls(runExclusiveFunction, classInstanceObject) {
+      var execQueue = getExecQueueByFunctionAndContext(runExclusiveFunction, classInstanceObject);
+      return execQueue ? execQueue.cancelAllQueuedCalls() : 0;
+    }
+    exports.cancelAllQueuedCalls = cancelAllQueuedCalls;
+    function isRunning(runExclusiveFunction, classInstanceObject) {
+      var execQueue = getExecQueueByFunctionAndContext(runExclusiveFunction, classInstanceObject);
+      return execQueue ? execQueue.isRunning : false;
+    }
+    exports.isRunning = isRunning;
+    function getPrComplete(runExclusiveFunction, classInstanceObject) {
+      var execQueue = getExecQueueByFunctionAndContext(runExclusiveFunction, classInstanceObject);
+      return execQueue ? execQueue.prComplete : Promise.resolve();
+    }
+    exports.getPrComplete = getPrComplete;
+    var groupByRunExclusiveFunction = new WeakMap_1.Polyfill();
+    function getExecQueueByFunctionAndContext(runExclusiveFunction, context) {
+      if (context === void 0) {
+        context = globalContext;
+      }
+      var groupRef = groupByRunExclusiveFunction.get(runExclusiveFunction);
+      if (!groupRef) {
+        throw Error("Not a run exclusiveFunction");
+      }
+      var execQueueByGroup = clusters.get(context);
+      if (!execQueueByGroup) {
+        return void 0;
+      }
+      return execQueueByGroup.get(groupRef);
+    }
+    function buildFnPromise(isGlobal, groupRef, fun) {
+      var execQueue;
+      var runExclusiveFunction = (function() {
+        var _this = this;
+        var inputs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          inputs[_i] = arguments[_i];
+        }
+        if (!isGlobal) {
+          if (!(this instanceof Object)) {
+            throw new Error("Run exclusive, <this> should be an object");
+          }
+          execQueue = getOrCreateExecQueue(this, groupRef);
+        }
+        return new Promise(function(resolve, reject) {
+          var onPrCompleteResolve;
+          execQueue.prComplete = new Promise(function(resolve2) {
+            return onPrCompleteResolve = function() {
+              return resolve2();
+            };
+          });
+          var onComplete = function(result) {
+            onPrCompleteResolve();
+            execQueue.isRunning = false;
+            if (execQueue.queuedCalls.length) {
+              execQueue.queuedCalls.shift()();
+            }
+            if ("data" in result) {
+              resolve(result.data);
+            } else {
+              reject(result.reason);
+            }
+          };
+          (function callee() {
+            var _this2 = this;
+            var inputs2 = [];
+            for (var _i2 = 0; _i2 < arguments.length; _i2++) {
+              inputs2[_i2] = arguments[_i2];
+            }
+            if (execQueue.isRunning) {
+              execQueue.queuedCalls.push(function() {
+                return callee.apply(_this2, inputs2);
+              });
+              return;
+            }
+            execQueue.isRunning = true;
+            try {
+              fun.apply(this, inputs2).then(function(data) {
+                return onComplete({ data });
+              })["catch"](function(reason) {
+                return onComplete({ reason });
+              });
+            } catch (error) {
+              onComplete({ "reason": error });
+            }
+          }).apply(_this, inputs);
+        });
+      });
+      if (isGlobal) {
+        execQueue = getOrCreateExecQueue(globalContext, groupRef);
+      }
+      groupByRunExclusiveFunction.set(runExclusiveFunction, groupRef);
+      return runExclusiveFunction;
+    }
+    function buildCb() {
+      var inputs = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        inputs[_i] = arguments[_i];
+      }
+      switch (inputs.length) {
+        case 1:
+          return buildFnCallback(true, createGroupRef(), inputs[0]);
+        case 2:
+          return buildFnCallback(true, inputs[0], inputs[1]);
+      }
+    }
+    exports.buildCb = buildCb;
+    function buildMethodCb() {
+      var inputs = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        inputs[_i] = arguments[_i];
+      }
+      switch (inputs.length) {
+        case 1:
+          return buildFnCallback(false, createGroupRef(), inputs[0]);
+        case 2:
+          return buildFnCallback(false, inputs[0], inputs[1]);
+      }
+    }
+    exports.buildMethodCb = buildMethodCb;
+    function buildFnCallback(isGlobal, groupRef, fun) {
+      var execQueue;
+      var runExclusiveFunction = (function() {
+        var _this = this;
+        var inputs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          inputs[_i] = arguments[_i];
+        }
+        if (!isGlobal) {
+          if (!(this instanceof Object)) {
+            throw new Error("Run exclusive, <this> should be an object");
+          }
+          execQueue = getOrCreateExecQueue(this, groupRef);
+        }
+        var callback = void 0;
+        if (inputs.length && typeof inputs[inputs.length - 1] === "function") {
+          callback = inputs.pop();
+        }
+        var onPrCompleteResolve;
+        execQueue.prComplete = new Promise(function(resolve) {
+          return onPrCompleteResolve = function() {
+            return resolve();
+          };
+        });
+        var onComplete = function() {
+          var inputs2 = [];
+          for (var _i2 = 0; _i2 < arguments.length; _i2++) {
+            inputs2[_i2] = arguments[_i2];
+          }
+          onPrCompleteResolve();
+          execQueue.isRunning = false;
+          if (execQueue.queuedCalls.length) {
+            execQueue.queuedCalls.shift()();
+          }
+          if (callback) {
+            callback.apply(_this, inputs2);
+          }
+        };
+        onComplete.hasCallback = !!callback;
+        (function callee() {
+          var _this2 = this;
+          var inputs2 = [];
+          for (var _i2 = 0; _i2 < arguments.length; _i2++) {
+            inputs2[_i2] = arguments[_i2];
+          }
+          if (execQueue.isRunning) {
+            execQueue.queuedCalls.push(function() {
+              return callee.apply(_this2, inputs2);
+            });
+            return;
+          }
+          execQueue.isRunning = true;
+          try {
+            fun.apply(this, __spreadArrays(inputs2, [onComplete]));
+          } catch (error) {
+            error.message += " ( This exception should not have been thrown, miss use of run-exclusive buildCb )";
+            throw error;
+          }
+        }).apply(this, inputs);
+      });
+      if (isGlobal) {
+        execQueue = getOrCreateExecQueue(globalContext, groupRef);
+      }
+      groupByRunExclusiveFunction.set(runExclusiveFunction, groupRef);
+      return runExclusiveFunction;
+    }
+  }
+});
+
+// node_modules/evt/tools/Deferred.js
+var require_Deferred = __commonJS({
+  "node_modules/evt/tools/Deferred.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.VoidDeferred = exports.Deferred = void 0;
+    var overwriteReadonlyProp_1 = require_overwriteReadonlyProp();
+    var Deferred = (
+      /** @class */
+      /* @__PURE__ */ (function() {
+        function Deferred2() {
+          var _this_1 = this;
+          this.isPending = true;
+          var resolve;
+          var reject;
+          this.pr = new Promise(function(resolve_, reject_) {
+            resolve = function(value) {
+              (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(_this_1, "isPending", false);
+              resolve_(value);
+            };
+            reject = function(error) {
+              (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(_this_1, "isPending", false);
+              reject_(error);
+            };
+          });
+          this.resolve = resolve;
+          this.reject = reject;
+        }
+        return Deferred2;
+      })()
+    );
+    exports.Deferred = Deferred;
+    var VoidDeferred = (
+      /** @class */
+      (function(_super) {
+        __extends(VoidDeferred2, _super);
+        function VoidDeferred2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return VoidDeferred2;
+      })(Deferred)
+    );
+    exports.VoidDeferred = VoidDeferred;
+  }
+});
+
+// node_modules/evt/lib/Evt.loosenType.js
+var require_Evt_loosenType = __commonJS({
+  "node_modules/evt/lib/Evt.loosenType.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loosenType = void 0;
+    function loosenType(evt) {
+      return evt;
+    }
+    exports.loosenType = loosenType;
+  }
+});
+
+// node_modules/evt/tools/safeSetTimeout.js
+var require_safeSetTimeout = __commonJS({
+  "node_modules/evt/tools/safeSetTimeout.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.safeClearTimeout = exports.safeSetTimeout = void 0;
+    var safeSetTimeout = function(callback, ms) {
+      return setTimeout(callback, ms);
+    };
+    exports.safeSetTimeout = safeSetTimeout;
+    var safeClearTimeout = function(timer) {
+      return clearTimeout(timer);
+    };
+    exports.safeClearTimeout = safeClearTimeout;
+  }
+});
+
+// node_modules/evt/node_modules/tsafe/isPromiseLike.js
+var require_isPromiseLike = __commonJS({
+  "node_modules/evt/node_modules/tsafe/isPromiseLike.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isPromiseLike = void 0;
+    function isPromiseLike(o) {
+      return typeof o === "object" && o !== null && "then" in o && typeof o.then === "function";
+    }
+    exports.isPromiseLike = isPromiseLike;
+  }
+});
+
+// node_modules/evt/lib/Evt.js
+var require_Evt = __commonJS({
+  "node_modules/evt/lib/Evt.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1) throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+          if (y = 0, t) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    var __values = exports && exports.__values || function(o) {
+      var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+      if (m) return m.call(o);
+      if (o && typeof o.length === "number") return {
+        next: function() {
+          if (o && i >= o.length) o = void 0;
+          return { value: o && o[i++], done: !o };
+        }
+      };
+      throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Evt = exports.onAddHandlerByEvt = void 0;
+    require_Array_prototype_find();
+    var Map_1 = require_Map();
+    var WeakMap_1 = require_WeakMap();
+    var importProxy_1 = require_importProxy();
+    var Evt_create_1 = require_Evt_create();
+    var Evt_getCtx_1 = require_Evt_getCtx();
+    var Evt_factorize_1 = require_Evt_factorize();
+    var Evt_merge_1 = require_Evt_merge();
+    var Evt_from_1 = require_Evt_from();
+    var Evt_asPostable_1 = require_Evt_asPostable();
+    var Evt_asyncPipe_1 = require_Evt_asyncPipe();
+    var Evt_asNonPostable_1 = require_Evt_asNonPostable();
+    var Evt_parsePropsFromArgs_1 = require_Evt_parsePropsFromArgs();
+    var Evt_newCtx_1 = require_Evt_newCtx();
+    var LazyEvt_1 = require_LazyEvt();
+    var runExclusive = __importStar(require_runExclusive());
+    var overwriteReadonlyProp_1 = require_overwriteReadonlyProp();
+    var typeGuard_1 = require_typeGuard();
+    var Deferred_1 = require_Deferred();
+    var Evt_loosenType_1 = require_Evt_loosenType();
+    var safeSetTimeout_1 = require_safeSetTimeout();
+    var isPromiseLike_1 = require_isPromiseLike();
+    var EvtError_1 = require_EvtError();
+    var nsCtxLike = __importStar(require_CtxLike());
+    var convertOperatorToStatelessFLambda_1 = require_convertOperatorToStatelessFLambda();
+    var runSideEffect = function(sideEffect) {
+      return sideEffect();
+    };
+    var CtxLikeAsValue = nsCtxLike.CtxLike;
+    var EvtImpl = (
+      /** @class */
+      (function() {
+        function EvtImpl2() {
+          this.lazyEvtAttach = new LazyEvt_1.LazyEvt();
+          this.lazyEvtDetach = new LazyEvt_1.LazyEvt();
+          this.__maxHandlers = void 0;
+          this.postCount = 0;
+          this.traceId = null;
+          this.handlers = [];
+          this.handlerTriggers = new Map_1.Polyfill();
+          this.__currentChronologyMark = 0;
+          this.asyncHandlerCount = 0;
+        }
+        EvtImpl2.setDefaultMaxHandlers = function(n) {
+          this.__defaultMaxHandlers = isFinite(n) ? n : 0;
+        };
+        EvtImpl2.prototype.toStateful = function(p1, p2) {
+          var isP1Ctx = CtxLikeAsValue.match(p1);
+          var initialValue = isP1Ctx ? void 0 : p1;
+          var ctx = p2 || (isP1Ctx ? p1 : void 0);
+          var out = new importProxy_1.importProxy.StatefulEvt(initialValue);
+          var callback = function(data) {
+            return out.post(data);
+          };
+          if (!!ctx) {
+            this.attach(ctx, callback);
+          } else {
+            this.attach(callback);
+          }
+          return out;
+        };
+        Object.defineProperty(EvtImpl2.prototype, "evtAttach", {
+          get: function() {
+            return this.lazyEvtAttach.evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(EvtImpl2.prototype, "evtDetach", {
+          get: function() {
+            return this.lazyEvtDetach.evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        EvtImpl2.prototype.setMaxHandlers = function(n) {
+          this.__maxHandlers = isFinite(n) ? n : 0;
+          return this;
+        };
+        EvtImpl2.prototype.enableTrace = function(params) {
+          var id = params.id, formatter = params.formatter, log = params.log;
+          this.traceId = id;
+          this.traceFormatter = formatter || (function(data) {
+            try {
+              return JSON.stringify(data, null, 2);
+            } catch (_a) {
+              return "".concat(data);
+            }
+          });
+          this.log = log === void 0 ? (function() {
+            var inputs = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+              inputs[_i] = arguments[_i];
+            }
+            return console.log.apply(console, __spreadArray([], __read(inputs), false));
+          }) : log === false ? void 0 : log;
+        };
+        EvtImpl2.prototype.disableTrace = function() {
+          this.traceId = null;
+          return this;
+        };
+        Object.defineProperty(EvtImpl2.prototype, "asyncHandlerChronologyMark", {
+          //NOTE: An async handler ( attached with waitFor ) is only eligible to handle a post if the post
+          //occurred after the handler was set. We don't want to waitFor event from the past.
+          //private readonly asyncHandlerChronologyMark = new WeakMap<ImplicitParams.Async, number>();
+          get: function() {
+            var _a, _b;
+            var _c, _d;
+            return (_b = (_d = (_a = (_c = this)["~internal"]) !== null && _a !== void 0 ? _a : _c["~internal"] = {})["asyncHandlerChronologyMark"]) !== null && _b !== void 0 ? _b : _d["asyncHandlerChronologyMark"] = new WeakMap_1.Polyfill();
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(EvtImpl2.prototype, "asyncHandlerChronologyExceptionRange", {
+          //NOTE: There is an exception to the above rule, we want to allow async waitFor loop 
+          //do so we have to handle the case where multiple event would be posted synchronously.
+          get: function() {
+            var _a, _b;
+            var _c, _d;
+            return (_b = (_d = (_a = (_c = this)["~internal"]) !== null && _a !== void 0 ? _a : _c["~internal"] = {})["asyncHandlerChronologyExceptionRange"]) !== null && _b !== void 0 ? _b : _d["asyncHandlerChronologyExceptionRange"] = new WeakMap_1.Polyfill();
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(EvtImpl2.prototype, "invocableOpByOp", {
+          get: function() {
+            var _a, _b;
+            var _c, _d;
+            return (_b = (_d = (_a = (_c = this)["~internal"]) !== null && _a !== void 0 ? _a : _c["~internal"] = {})["invocableOpByOp"]) !== null && _b !== void 0 ? _b : _d["invocableOpByOp"] = new WeakMap_1.Polyfill();
+          },
+          enumerable: false,
+          configurable: true
+        });
+        EvtImpl2.prototype.getInvocableOp = function(op) {
+          var invocableOp = this.invocableOpByOp.get(op);
+          if (invocableOp === void 0) {
+            throw new Error([
+              "Provided operator isn't the operator of any handler",
+              "currently attached to the Evt instance"
+            ].join(" "));
+          }
+          return invocableOp;
+        };
+        EvtImpl2.prototype.getChronologyMark = function() {
+          return this.__currentChronologyMark++;
+        };
+        EvtImpl2.prototype.detachHandler = function(handler, wTimer, rejectPr) {
+          var index = this.handlers.indexOf(handler);
+          if (index < 0) {
+            return false;
+          }
+          if ((0, typeGuard_1.typeGuard)(handler, !!handler.ctx)) {
+            handler.ctx.zz__removeHandler(handler);
+          }
+          this.handlers.splice(index, 1);
+          if (handler.async) {
+            this.asyncHandlerCount--;
+          }
+          this.handlerTriggers.delete(handler);
+          if (wTimer[0] !== void 0) {
+            (0, safeSetTimeout_1.safeClearTimeout)(wTimer[0]);
+            rejectPr(new EvtError_1.DetachedEvtError());
+          }
+          this.lazyEvtDetach.post(handler);
+          return true;
+        };
+        EvtImpl2.prototype.triggerHandler = function(handler, wTimer, resolvePr, opResult) {
+          var callback = handler.callback, once = handler.once;
+          if (wTimer[0] !== void 0) {
+            (0, safeSetTimeout_1.safeClearTimeout)(wTimer[0]);
+            wTimer[0] = void 0;
+          }
+          if (once) {
+            handler.detach();
+          }
+          var _a = __read(opResult, 1), transformedData = _a[0];
+          var prOrValue = callback === null || callback === void 0 ? void 0 : callback.call(this, transformedData);
+          resolvePr === null || resolvePr === void 0 ? void 0 : resolvePr(transformedData);
+          return (0, isPromiseLike_1.isPromiseLike)(prOrValue) ? prOrValue : void 0;
+        };
+        EvtImpl2.prototype.addHandler = function(propsFromArgs, propsFromMethodName) {
+          var _this_1 = this;
+          var _a;
+          this.invocableOpByOp.set(propsFromArgs.op, (0, convertOperatorToStatelessFLambda_1.convertOperatorToStatelessF\u03BB)(propsFromArgs.op));
+          var d = new Deferred_1.Deferred();
+          var wTimer = [void 0];
+          var handler = __assign(__assign(__assign({}, propsFromArgs), propsFromMethodName), { "detach": function() {
+            return _this_1.detachHandler(handler, wTimer, d.reject);
+          }, "promise": d.pr });
+          if (typeof handler.timeout === "number") {
+            wTimer[0] = (0, safeSetTimeout_1.safeSetTimeout)(function() {
+              wTimer[0] = void 0;
+              handler.detach();
+              d.reject(new EvtError_1.TimeoutEvtError(handler.timeout));
+            }, handler.timeout);
+          }
+          var handlerTrigger = function(opResult) {
+            return _this_1.triggerHandler(handler, wTimer, d.isPending ? d.resolve : void 0, opResult);
+          };
+          this.handlerTriggers.set(handler, handlerTrigger);
+          if (handler.async) {
+            this.asyncHandlerChronologyMark.set(handler, this.getChronologyMark());
+          }
+          if (handler.prepend) {
+            var i = void 0;
+            for (i = 0; i < this.handlers.length; i++) {
+              if (this.handlers[i].extract) {
+                continue;
+              }
+              break;
+            }
+            this.handlers.splice(i, 0, handler);
+          } else {
+            this.handlers.push(handler);
+          }
+          if (handler.async) {
+            this.asyncHandlerCount++;
+          }
+          this.checkForPotentialMemoryLeak();
+          if ((0, typeGuard_1.typeGuard)(handler, !!handler.ctx)) {
+            handler.ctx.zz__addHandler(handler, this);
+          }
+          (_a = exports.onAddHandlerByEvt.get(this)) === null || _a === void 0 ? void 0 : _a(handler, handlerTrigger);
+          if (this.handlerTriggers.has(handler)) {
+            this.lazyEvtAttach.post(handler);
+          }
+          return handler;
+        };
+        EvtImpl2.prototype.checkForPotentialMemoryLeak = function() {
+          var maxHandlers = this.__maxHandlers !== void 0 ? this.__maxHandlers : EvtImpl2.__defaultMaxHandlers;
+          if (maxHandlers === 0 || this.handlers.length % (maxHandlers + 1) !== 0) {
+            return;
+          }
+          var message = [
+            "MaxHandlersExceededWarning: Possible Evt memory leak detected.",
+            "".concat(this.handlers.length, " handlers attached").concat(this.traceId ? ' to "'.concat(this.traceId, '"') : "", ".\n"),
+            "Use Evt.prototype.setMaxHandlers(n) to increase limit on a specific Evt.\n",
+            "Use Evt.setDefaultMaxHandlers(n) to change the default limit currently set to ".concat(EvtImpl2.__defaultMaxHandlers, ".\n")
+          ].join("");
+          var map = new Map_1.Polyfill();
+          this.getHandlers().map(function(_a) {
+            var ctx = _a.ctx, async = _a.async, once = _a.once, prepend = _a.prepend, extract = _a.extract, op = _a.op, callback = _a.callback;
+            return __assign(__assign({ "hasCtx": !!ctx, once, prepend, extract, "isWaitFor": async }, op === Evt_parsePropsFromArgs_1.matchAll ? {} : { "op": op.toString() }), !callback ? {} : { "callback": callback.toString() });
+          }).map(function(obj) {
+            return "{\n" + Object.keys(obj).map(function(key) {
+              return "  ".concat(key, ": ").concat(obj[key]);
+            }).join(",\n") + "\n}";
+          }).forEach(function(str) {
+            return map.set(str, (map.has(str) ? map.get(str) : 0) + 1);
+          });
+          message += "\n" + Array.from(map.keys()).map(function(str) {
+            return "".concat(map.get(str), " handler").concat(map.get(str) === 1 ? "" : "s", " like:\n").concat(str);
+          }).join("\n") + "\n";
+          if (this.traceId === null) {
+            message += "\n" + [
+              "To validate the identify of the Evt instance that is triggering this warning you can call",
+              'Evt.prototype.enableTrace({ "id": "My evt id", "log": false }) on the Evt that you suspect.\n'
+            ].join(" ");
+          }
+          try {
+            console.warn(message);
+          } catch (_a) {
+          }
+        };
+        EvtImpl2.prototype.isHandledByOp = function(op, data) {
+          var hasSideEffect = false;
+          var invocableOp;
+          try {
+            invocableOp = this.getInvocableOp(op);
+          } catch (_a) {
+            return false;
+          }
+          var opResult = invocableOp(data, function() {
+            return hasSideEffect = true;
+          });
+          return opResult !== null || hasSideEffect;
+        };
+        EvtImpl2.prototype.trace = function(data) {
+          var _this_1 = this;
+          var _a;
+          if (this.traceId === null) {
+            return;
+          }
+          var message = "(".concat(this.traceId, ") ");
+          var isExtracted = !!this.handlers.find(function(_a2) {
+            var extract = _a2.extract, op = _a2.op;
+            return extract && _this_1.isHandledByOp(op, data);
+          });
+          if (isExtracted) {
+            message += "extracted ";
+          } else {
+            var handlerCount = this.handlers.filter(function(_a2) {
+              var extract = _a2.extract, op = _a2.op;
+              return !extract && _this_1.isHandledByOp(op, data);
+            }).length;
+            message += "".concat(handlerCount, " handler").concat(handlerCount > 1 ? "s" : "", ", ");
+          }
+          (_a = this.log) === null || _a === void 0 ? void 0 : _a.call(this, message + this.traceFormatter(data));
+        };
+        EvtImpl2.prototype.postSync = function(data) {
+          var e_1, _a;
+          var prAllHandlerCallbacksResolved = [];
+          var getReturnValue = function(isExtracted) {
+            return [
+              isExtracted,
+              Promise.all(prAllHandlerCallbacksResolved).then(function() {
+              })
+            ];
+          };
+          try {
+            for (var _b = __values(__spreadArray([], __read(this.handlers), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
+              var handler = _c.value;
+              var async = handler.async, op = handler.op, extract = handler.extract;
+              if (async) {
+                continue;
+              }
+              var handlerTrigger = this.handlerTriggers.get(handler);
+              var opResult = this.getInvocableOp(op)(data, runSideEffect);
+              if (opResult === null) {
+                continue;
+              }
+              if (!handlerTrigger) {
+                continue;
+              }
+              var prOrUndefined = handlerTrigger(opResult);
+              if (prOrUndefined !== void 0) {
+                prAllHandlerCallbacksResolved.push(prOrUndefined);
+              }
+              if (extract) {
+                return getReturnValue(true);
+              }
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+          return getReturnValue(false);
+        };
+        EvtImpl2.prototype.postAsyncFactory = function() {
+          var _this_1 = this;
+          return runExclusive.buildMethodCb(function(data, postChronologyMark, releaseLock) {
+            var e_2, _a;
+            if (_this_1.asyncHandlerCount === 0) {
+              releaseLock();
+              return;
+            }
+            var promises = [];
+            var chronologyMarkStartResolveTick;
+            Promise.resolve().then(function() {
+              return chronologyMarkStartResolveTick = _this_1.getChronologyMark();
+            });
+            var _loop_1 = function(handler2) {
+              if (!handler2.async) {
+                return "continue";
+              }
+              var opResult = _this_1.getInvocableOp(handler2.op)(data, runSideEffect);
+              if (opResult === null) {
+                return "continue";
+              }
+              var handlerTrigger = _this_1.handlerTriggers.get(handler2);
+              if (!handlerTrigger) {
+                return "continue";
+              }
+              var shouldCallHandlerTrigger = (function() {
+                var handlerMark = _this_1.asyncHandlerChronologyMark.get(handler2);
+                if (postChronologyMark > handlerMark) {
+                  return true;
+                }
+                var exceptionRange = _this_1.asyncHandlerChronologyExceptionRange.get(handler2);
+                return exceptionRange !== void 0 && exceptionRange.lowerMark < postChronologyMark && postChronologyMark < exceptionRange.upperMark && handlerMark > exceptionRange.upperMark;
+              })();
+              if (!shouldCallHandlerTrigger) {
+                return "continue";
+              }
+              promises.push(new Promise(function(resolve) {
+                return handler2.promise.then(function() {
+                  return resolve();
+                }).catch(function() {
+                  return resolve();
+                });
+              }));
+              handlerTrigger(opResult);
+            };
+            try {
+              for (var _b = __values(__spreadArray([], __read(_this_1.handlers), false)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var handler = _c.value;
+                _loop_1(handler);
+              }
+            } catch (e_2_1) {
+              e_2 = { error: e_2_1 };
+            } finally {
+              try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+              } finally {
+                if (e_2) throw e_2.error;
+              }
+            }
+            if (promises.length === 0) {
+              releaseLock();
+              return;
+            }
+            var handlersDump = __spreadArray([], __read(_this_1.handlers), false);
+            Promise.all(promises).then(function() {
+              var e_3, _a2;
+              try {
+                for (var _b2 = __values(_this_1.handlers), _c2 = _b2.next(); !_c2.done; _c2 = _b2.next()) {
+                  var handler2 = _c2.value;
+                  if (!handler2.async) {
+                    continue;
+                  }
+                  if (handlersDump.indexOf(handler2) >= 0) {
+                    continue;
+                  }
+                  _this_1.asyncHandlerChronologyExceptionRange.set(handler2, {
+                    "lowerMark": postChronologyMark,
+                    "upperMark": chronologyMarkStartResolveTick
+                  });
+                }
+              } catch (e_3_1) {
+                e_3 = { error: e_3_1 };
+              } finally {
+                try {
+                  if (_c2 && !_c2.done && (_a2 = _b2.return)) _a2.call(_b2);
+                } finally {
+                  if (e_3) throw e_3.error;
+                }
+              }
+              releaseLock();
+            });
+          });
+        };
+        EvtImpl2.prototype.isHandled = function(data) {
+          var _this_1 = this;
+          return !!this.getHandlers().find(function(_a) {
+            var op = _a.op;
+            return _this_1.isHandledByOp(op, data);
+          });
+        };
+        EvtImpl2.prototype.getHandlers = function() {
+          return __spreadArray([], __read(this.handlers), false);
+        };
+        EvtImpl2.prototype.detach = function(ctx) {
+          var e_4, _a;
+          var detachedHandlers = [];
+          try {
+            for (var _b = __values(this.getHandlers()), _c = _b.next(); !_c.done; _c = _b.next()) {
+              var handler = _c.value;
+              if (ctx !== void 0 && handler.ctx !== ctx) {
+                continue;
+              }
+              var wasStillAttached = handler.detach();
+              if (!wasStillAttached) {
+                continue;
+              }
+              detachedHandlers.push(handler);
+            }
+          } catch (e_4_1) {
+            e_4 = { error: e_4_1 };
+          } finally {
+            try {
+              if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            } finally {
+              if (e_4) throw e_4.error;
+            }
+          }
+          return detachedHandlers;
+        };
+        EvtImpl2.prototype.pipe = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var evtDelegate = new EvtImpl2();
+          this.addHandler(__assign(__assign({}, (0, Evt_parsePropsFromArgs_1.parsePropsFromArgs)(args, "pipe")), { "callback": function(transformedData) {
+            return evtDelegate.post(transformedData);
+          } }), EvtImpl2.propsFormMethodNames.attach);
+          return evtDelegate;
+        };
+        EvtImpl2.prototype.waitFor = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.addHandler((0, Evt_parsePropsFromArgs_1.parsePropsFromArgs)(args, "waitFor"), EvtImpl2.propsFormMethodNames.waitFor).promise;
+        };
+        EvtImpl2.prototype[Symbol.asyncIterator] = function() {
+          return this.iter()[Symbol.asyncIterator]();
+        };
+        EvtImpl2.prototype.iter = function() {
+          var _a;
+          var _b;
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var props = (0, Evt_parsePropsFromArgs_1.parsePropsFromArgs)(args, "waitFor");
+          var ctx = (_b = props.ctx) !== null && _b !== void 0 ? _b : (0, Evt_newCtx_1.newCtx)();
+          var self = this;
+          return _a = {
+            ctx
+          }, _a[Symbol.asyncIterator] = function() {
+            var previousDonePostCount = ctx.evtDoneOrAborted.postCount;
+            var timerWrap = (function() {
+              var timeout = props.timeout;
+              if (timeout === void 0) {
+                return void 0;
+              }
+              var setTimeoutCallback = function() {
+                var error = new EvtError_1.TimeoutEvtError(timeout);
+                ctx.abort(error);
+              };
+              var timer = setTimeout(setTimeoutCallback, timeout);
+              return { timeout, setTimeoutCallback, timer };
+            })();
+            var evtProxy = self.pipe(ctx, props.op).pipe(function(data, registerSideEffect) {
+              if (timerWrap !== void 0) {
+                registerSideEffect(function() {
+                  clearTimeout(timerWrap.timer);
+                  timerWrap.timer = setTimeout(timerWrap.setTimeoutCallback, timerWrap.timeout);
+                });
+              }
+              return [data];
+            });
+            var events = [];
+            evtProxy.attach(function(event) {
+              return events.push([event]);
+            });
+            if (timerWrap !== void 0) {
+              var timer_1 = timerWrap.timer;
+              ctx.evtDoneOrAborted.attachOnce(function(event) {
+                return event.type === "DONE";
+              }, function() {
+                return clearTimeout(timer_1);
+              });
+            }
+            return {
+              next: function() {
+                return __awaiter(this, void 0, void 0, function() {
+                  var eventWrap, dEventWrap_1, ctx2_1, out;
+                  return __generator(this, function(_a2) {
+                    switch (_a2.label) {
+                      case 0:
+                        eventWrap = events.shift();
+                        if (!(eventWrap === void 0)) return [3, 2];
+                        dEventWrap_1 = new Deferred_1.Deferred();
+                        if (previousDonePostCount < ctx.evtDoneOrAborted.postCount) {
+                          return [2, { "done": true }];
+                        }
+                        ctx2_1 = (0, Evt_newCtx_1.newCtx)();
+                        ctx.evtDoneOrAborted.attachOnce(ctx2_1, function() {
+                          return dEventWrap_1.resolve(void 0);
+                        });
+                        evtProxy.attachOnceExtract(ctx2_1, function(event) {
+                          ctx2_1.done();
+                          dEventWrap_1.resolve([event]);
+                        });
+                        return [4, dEventWrap_1.pr];
+                      case 1:
+                        eventWrap = _a2.sent();
+                        if (eventWrap === void 0) {
+                          return [2, { "done": true }];
+                        }
+                        _a2.label = 2;
+                      case 2:
+                        out = { "done": false, "value": eventWrap[0] };
+                        return [2, out];
+                    }
+                  });
+                });
+              },
+              return: function() {
+                self.detach(ctx);
+                return { "done": true };
+              }
+            };
+          }, _a;
+        };
+        EvtImpl2.prototype.$attach = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.attach.apply(this, __spreadArray([], __read(args), false));
+        };
+        EvtImpl2.prototype.attach = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.__attachX(args, "attach");
+        };
+        EvtImpl2.prototype.$attachOnce = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.attachOnce.apply(this, __spreadArray([], __read(args), false));
+        };
+        EvtImpl2.prototype.attachOnce = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.__attachX(args, "attachOnce");
+        };
+        EvtImpl2.prototype.$attachExtract = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.attachExtract.apply(this, __spreadArray([], __read(args), false));
+        };
+        EvtImpl2.prototype.attachExtract = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.__attachX(args, "attachExtract");
+        };
+        EvtImpl2.prototype.$attachPrepend = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.attachPrepend.apply(this, __spreadArray([], __read(args), false));
+        };
+        EvtImpl2.prototype.attachPrepend = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.__attachX(args, "attachPrepend");
+        };
+        EvtImpl2.prototype.$attachOncePrepend = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.attachOncePrepend.apply(this, __spreadArray([], __read(args), false));
+        };
+        EvtImpl2.prototype.attachOncePrepend = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.__attachX(args, "attachOncePrepend");
+        };
+        EvtImpl2.prototype.$attachOnceExtract = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.attachOnceExtract.apply(this, __spreadArray([], __read(args), false));
+        };
+        EvtImpl2.prototype.attachOnceExtract = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          return this.__attachX(args, "attachOnceExtract");
+        };
+        EvtImpl2.prototype.__attachX = function(args, methodName) {
+          var propsFromArgs = (0, Evt_parsePropsFromArgs_1.parsePropsFromArgs)(args, "attach*");
+          var handler = this.addHandler(propsFromArgs, EvtImpl2.propsFormMethodNames[methodName]);
+          return propsFromArgs.timeout === void 0 ? this : handler.promise;
+        };
+        EvtImpl2.prototype.postAsyncOnceHandled = function(data) {
+          var _this_1 = this;
+          if (this.isHandled(data)) {
+            return this.post(data);
+          }
+          var d = new Deferred_1.Deferred();
+          this.evtAttach.attachOnce(function(_a) {
+            var op = _a.op;
+            return _this_1.isHandledByOp(op, data);
+          }, function() {
+            return Promise.resolve().then(function() {
+              return d.resolve(_this_1.post(data));
+            });
+          });
+          return d.pr;
+        };
+        EvtImpl2.prototype.postOrPostAndWait = function(data, wait) {
+          var _this_1 = this;
+          this.trace(data);
+          (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(this, "postCount", this.postCount + 1);
+          var postChronologyMark = this.getChronologyMark();
+          var _a = __read(this.postSync(data), 2), isExtracted = _a[0], prAllHandlerCallbacksResolved = _a[1];
+          var getReturnValue = wait ? function() {
+            return prAllHandlerCallbacksResolved;
+          } : function() {
+            return _this_1.postCount;
+          };
+          if (isExtracted) {
+            return getReturnValue();
+          }
+          if (this.postAsync === void 0) {
+            if (this.asyncHandlerCount === 0) {
+              return getReturnValue();
+            }
+            this.postAsync = this.postAsyncFactory();
+          }
+          this.postAsync(data, postChronologyMark);
+          return getReturnValue();
+        };
+        EvtImpl2.prototype.post = function(data) {
+          return this.postOrPostAndWait(data, false);
+        };
+        EvtImpl2.prototype.postAndWait = function(data) {
+          return this.postOrPostAndWait(data, true);
+        };
+        EvtImpl2.create = Evt_create_1.create;
+        EvtImpl2.newCtx = Evt_newCtx_1.newCtx;
+        EvtImpl2.merge = Evt_merge_1.merge;
+        EvtImpl2.from = Evt_from_1.from;
+        EvtImpl2.getCtx = (0, Evt_getCtx_1.getCtxFactory)();
+        EvtImpl2.loosenType = Evt_loosenType_1.loosenType;
+        EvtImpl2.factorize = Evt_factorize_1.factorize;
+        EvtImpl2.asPostable = Evt_asPostable_1.asPostable;
+        EvtImpl2.asyncPipe = Evt_asyncPipe_1.asyncPipe;
+        EvtImpl2.asNonPostable = Evt_asNonPostable_1.asNonPostable;
+        EvtImpl2.__defaultMaxHandlers = 25;
+        EvtImpl2.propsFormMethodNames = {
+          "waitFor": { "async": true, "extract": false, "once": true, "prepend": false },
+          "attach": { "async": false, "extract": false, "once": false, "prepend": false },
+          "attachExtract": { "async": false, "extract": true, "once": false, "prepend": true },
+          "attachPrepend": { "async": false, "extract": false, "once": false, "prepend": true },
+          "attachOnce": { "async": false, "extract": false, "once": true, "prepend": false },
+          "attachOncePrepend": { "async": false, "extract": false, "once": true, "prepend": true },
+          "attachOnceExtract": { "async": false, "extract": true, "once": true, "prepend": true }
+        };
+        return EvtImpl2;
+      })()
+    );
+    exports.onAddHandlerByEvt = new WeakMap_1.Polyfill();
+    exports.Evt = EvtImpl;
+    try {
+      (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(exports.Evt, "name", "Evt");
+    } catch (_a) {
+    }
+    importProxy_1.importProxy.Evt = exports.Evt;
+  }
+});
+
+// node_modules/minimal-polyfills/Object.is.js
+var require_Object_is = __commonJS({
+  "node_modules/minimal-polyfills/Object.is.js"(exports) {
+    "use strict";
+    exports.__esModule = true;
+    if (!Object.is) {
+      Object.is = function(x, y) {
+        if (x === y) {
+          return x !== 0 || 1 / x === 1 / y;
+        } else {
+          return x !== x && y !== y;
+        }
+      };
+    }
+  }
+});
+
+// node_modules/evt/lib/LazyStatefulEvt.js
+var require_LazyStatefulEvt = __commonJS({
+  "node_modules/evt/lib/LazyStatefulEvt.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.LazyStatefulEvt = void 0;
+    var overwriteReadonlyProp_1 = require_overwriteReadonlyProp();
+    var importProxy_1 = require_importProxy();
+    var LazyStatefulEvt = (
+      /** @class */
+      (function() {
+        function LazyStatefulEvt2(initialState) {
+          this.initialPostCount = 0;
+          this.initialState = initialState;
+        }
+        Object.defineProperty(LazyStatefulEvt2.prototype, "evt", {
+          get: function() {
+            if (this.__evt === void 0) {
+              this.__evt = new importProxy_1.importProxy.StatefulEvt(this.initialState);
+              this.initialState = null;
+              (0, overwriteReadonlyProp_1.overwriteReadonlyProp)(this.__evt, "postCount", this.initialPostCount);
+            }
+            return this.__evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        LazyStatefulEvt2.prototype.__post = function(data, doWait) {
+          if (this.__evt === void 0) {
+            this.initialState = data;
+            return ++this.initialPostCount;
+          }
+          return this.__evt[doWait ? "postAndWait" : "post"](data);
+        };
+        LazyStatefulEvt2.prototype.post = function(data) {
+          return this.__post(data, false);
+        };
+        LazyStatefulEvt2.prototype.postAndWait = function(data) {
+          return this.__post(data, true);
+        };
+        return LazyStatefulEvt2;
+      })()
+    );
+    exports.LazyStatefulEvt = LazyStatefulEvt;
+  }
+});
+
+// node_modules/evt/lib/StatefulEvt.js
+var require_StatefulEvt = __commonJS({
+  "node_modules/evt/lib/StatefulEvt.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || /* @__PURE__ */ (function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    })();
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StatefulEvt = void 0;
+    require_Object_is();
+    var LazyEvt_1 = require_LazyEvt();
+    var LazyStatefulEvt_1 = require_LazyStatefulEvt();
+    var importProxy_1 = require_importProxy();
+    var Evt_2 = require_Evt();
+    var assert_1 = require_assert();
+    var id_1 = require_id();
+    var runSideEffect = function(sideEffect) {
+      return sideEffect();
+    };
+    var StatefulEvtImpl = (
+      /** @class */
+      (function(_super) {
+        __extends(StatefulEvtImpl2, _super);
+        function StatefulEvtImpl2(initialState) {
+          var _this_1 = _super.call(this) || this;
+          _this_1.lazyEvtDiff = new LazyEvt_1.LazyEvt();
+          _this_1.lazyEvtChangeDiff = new LazyEvt_1.LazyEvt();
+          _this_1.__state = initialState;
+          _this_1.lazyEvtChange = new LazyStatefulEvt_1.LazyStatefulEvt(_this_1.__state);
+          Evt_2.onAddHandlerByEvt.set(_this_1, function(handler, handlerTrigger) {
+            if (handler.extract) {
+              return;
+            }
+            var sideEffect = (0, id_1.id)(void 0);
+            var opResult = _this_1.getInvocableOp(handler.op)(_this_1.__state, _this_1.setOpResultForPipe !== void 0 ? (function(sideEffect_) {
+              return sideEffect = sideEffect_;
+            }) : runSideEffect);
+            if (_this_1.setOpResultForPipe !== void 0) {
+              _this_1.setOpResultForPipe(opResult);
+              if (sideEffect !== void 0) {
+                sideEffect();
+              }
+            }
+            if (!opResult) {
+              return;
+            }
+            handlerTrigger(opResult);
+          });
+          return _this_1;
+        }
+        Object.defineProperty(StatefulEvtImpl2.prototype, "state", {
+          get: function() {
+            return this.__state;
+          },
+          set: function(value) {
+            if (this.state === value)
+              return;
+            this.post(value);
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(StatefulEvtImpl2.prototype, "evtDiff", {
+          get: function() {
+            return this.lazyEvtDiff.evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(StatefulEvtImpl2.prototype, "evtChange", {
+          get: function() {
+            return this.lazyEvtChange.evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        Object.defineProperty(StatefulEvtImpl2.prototype, "evtChangeDiff", {
+          get: function() {
+            return this.lazyEvtChangeDiff.evt;
+          },
+          enumerable: false,
+          configurable: true
+        });
+        StatefulEvtImpl2.prototype.post = function(data) {
+          return this.__post(data, false, false);
+        };
+        StatefulEvtImpl2.prototype.postForceChange = function(wData) {
+          return this.__post(!!wData ? wData[0] : this.state, true, false);
+        };
+        StatefulEvtImpl2.prototype.postAndWait = function(data) {
+          return this.__post(data, false, true);
+        };
+        StatefulEvtImpl2.prototype.__post = function(data, forceChange, doWait) {
+          var prevState = this.state;
+          this.__state = data;
+          var diff = { prevState, "newState": this.state };
+          var postVariantName = doWait ? "postAndWait" : "post";
+          var prs = [];
+          var r1 = this.lazyEvtDiff[postVariantName](diff);
+          if (doWait) {
+            prs.push(r1);
+          }
+          if (forceChange || !Object.is(prevState, this.state)) {
+            var r2 = this.lazyEvtChange[postVariantName](this.state);
+            var r3 = this.lazyEvtChangeDiff[postVariantName](diff);
+            if (doWait) {
+              prs.push(r2, r3);
+            }
+          }
+          var r4 = _super.prototype[postVariantName].call(this, data);
+          return doWait ? (prs.push(r4), Promise.all(prs).then(function() {
+          })) : r4;
+        };
+        StatefulEvtImpl2.prototype.pipe = function() {
+          var args = [];
+          for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+          }
+          var opResult = void 0;
+          this.setOpResultForPipe = function(opResult_) {
+            return opResult = opResult_;
+          };
+          var evt = _super.prototype.pipe.apply(this, __spreadArray([], __read(args), false));
+          (0, assert_1.assert)(opResult !== void 0);
+          this.setOpResultForPipe = void 0;
+          if (!opResult) {
+            throw new Error([
+              "Cannot pipe StatefulEvt because the operator does not match",
+              "it's current state. You would end up with evt.state === undefined",
+              "Use evt.toStateless([ctx]).pipe(op).toStatic(initialState)",
+              "to be sure the StatefulEvt does not have an undefined state"
+            ].join(" "));
+          }
+          return evt.toStateful(opResult[0]);
+        };
+        StatefulEvtImpl2.prototype.toStateless = function(ctx) {
+          var onAddHandler = Evt_2.onAddHandlerByEvt.get(this);
+          Evt_2.onAddHandlerByEvt.delete(this);
+          var out = !!ctx ? _super.prototype.pipe.call(this, ctx) : _super.prototype.pipe.call(this);
+          Evt_2.onAddHandlerByEvt.set(this, onAddHandler);
+          return out;
+        };
+        return StatefulEvtImpl2;
+      })(Evt_2.Evt)
+    );
+    exports.StatefulEvt = StatefulEvtImpl;
+    importProxy_1.importProxy.StatefulEvt = exports.StatefulEvt;
+  }
+});
+
+// node_modules/evt/operators/to.js
+var require_to = __commonJS({
+  "node_modules/evt/operators/to.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.to = void 0;
+    var map = /* @__PURE__ */ new Map();
+    var to = function(eventName) {
+      var _a;
+      return (_a = map.get(eventName)) !== null && _a !== void 0 ? _a : (map.set(eventName, function(data) {
+        return data[0] !== eventName ? null : [data[1]];
+      }), (0, exports.to)(eventName));
+    };
+    exports.to = to;
+  }
+});
+
+// node_modules/evt/operators/throttleTime.js
+var require_throttleTime = __commonJS({
+  "node_modules/evt/operators/throttleTime.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.throttleTime = void 0;
+    var compose_1 = require_compose();
+    var throttleTime2 = function(duration) {
+      return (0, compose_1.compose)([
+        function(data, _a) {
+          var lastClick = _a.lastClick;
+          var now = Date.now();
+          return now - lastClick < duration ? null : [{ data, "lastClick": now }];
+        },
+        { "lastClick": 0, "data": null }
+      ], function(_a) {
+        var data = _a.data;
+        return [data];
+      });
+    };
+    exports.throttleTime = throttleTime2;
+  }
+});
+
+// node_modules/evt/operators/nonNullable.js
+var require_nonNullable = __commonJS({
+  "node_modules/evt/operators/nonNullable.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.nonNullable = void 0;
+    var isNonNullable = function(arg) {
+      return arg !== void 0 && arg !== null;
+    };
+    var nonNullableImpl = function(data) {
+      return !isNonNullable(data) ? null : [data];
+    };
+    var nonNullable = function() {
+      return nonNullableImpl;
+    };
+    exports.nonNullable = nonNullable;
+  }
+});
+
+// node_modules/evt/operators/distinct.js
+var require_distinct = __commonJS({
+  "node_modules/evt/operators/distinct.js"(exports) {
+    "use strict";
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m) return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+      } catch (error) {
+        e = { error };
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"])) m.call(i);
+        } finally {
+          if (e) throw e.error;
+        }
+      }
+      return ar;
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+          ar[i] = from[i];
+        }
+      }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.distinct = void 0;
+    var compose_1 = require_compose();
+    var distinct = function(keySelector, ctxFlush) {
+      var _a;
+      return (0, compose_1.compose)(function(data) {
+        var _a2, _b;
+        return [{
+          data,
+          "selectedKey": (_a2 = keySelector === null || keySelector === void 0 ? void 0 : keySelector(data)) !== null && _a2 !== void 0 ? _a2 : data,
+          "currentFlushCount": (_b = ctxFlush === null || ctxFlush === void 0 ? void 0 : ctxFlush.evtDoneOrAborted.postCount) !== null && _b !== void 0 ? _b : 0
+        }];
+      }, [
+        function(_a2, _b) {
+          var data = _a2.data, selectedKey = _a2.selectedKey, currentFlushCount = _a2.currentFlushCount;
+          var alreadyPostedData = _b.alreadyPostedData, previousFlushCount = _b.previousFlushCount;
+          return [{
+            "boxedData": currentFlushCount !== previousFlushCount || !alreadyPostedData.has(selectedKey) ? [data] : null,
+            "alreadyPostedData": new Set(__spreadArray(__spreadArray([], __read(currentFlushCount !== previousFlushCount ? [] : Array.from(alreadyPostedData)), false), [
+              selectedKey
+            ], false)),
+            "previousFlushCount": currentFlushCount
+          }];
+        },
+        {
+          "boxedData": null,
+          "alreadyPostedData": /* @__PURE__ */ new Set(),
+          "previousFlushCount": (_a = ctxFlush === null || ctxFlush === void 0 ? void 0 : ctxFlush.evtDoneOrAborted.postCount) !== null && _a !== void 0 ? _a : 0
+        }
+      ], function(_a2) {
+        var boxedData = _a2.boxedData;
+        return boxedData;
+      });
+    };
+    exports.distinct = distinct;
+  }
+});
+
+// node_modules/evt/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/evt/lib/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.distinct = exports.nonNullable = exports.throttleTime = exports.to = exports.StatefulEvt = exports.Evt = exports.Ctx = void 0;
+    __exportStar(require_types(), exports);
+    __exportStar(require_util(), exports);
+    var Ctx_1 = require_Ctx();
+    Object.defineProperty(exports, "Ctx", { enumerable: true, get: function() {
+      return Ctx_1.Ctx;
+    } });
+    var Evt_2 = require_Evt();
+    Object.defineProperty(exports, "Evt", { enumerable: true, get: function() {
+      return Evt_2.Evt;
+    } });
+    var StatefulEvt_1 = require_StatefulEvt();
+    Object.defineProperty(exports, "StatefulEvt", { enumerable: true, get: function() {
+      return StatefulEvt_1.StatefulEvt;
+    } });
+    var to_1 = require_to();
+    Object.defineProperty(exports, "to", { enumerable: true, get: function() {
+      return to_1.to;
+    } });
+    var throttleTime_1 = require_throttleTime();
+    Object.defineProperty(exports, "throttleTime", { enumerable: true, get: function() {
+      return throttleTime_1.throttleTime;
+    } });
+    var nonNullable_1 = require_nonNullable();
+    Object.defineProperty(exports, "nonNullable", { enumerable: true, get: function() {
+      return nonNullable_1.nonNullable;
+    } });
+    var distinct_1 = require_distinct();
+    Object.defineProperty(exports, "distinct", { enumerable: true, get: function() {
+      return distinct_1.distinct;
+    } });
+  }
+});
+
+// dist/esm/vendor/backend/evt.js
+var import_evt = __toESM(require_lib());
+var import_throttleTime = __toESM(require_throttleTime());
+var export_Evt = import_evt.Evt;
+var export_throttleTime = import_throttleTime.throttleTime;
+export {
+  export_Evt as Evt,
+  export_throttleTime as throttleTime
+};
+/*! Bundled license information:
+
+evt/lib/types/lib.dom.js:
+  (*! *****************************************************************************
+  Copyright (c) Microsoft Corporation. All rights reserved.
+  Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+  this file except in compliance with the License. You may obtain a copy of the
+  License at http://www.apache.org/licenses/LICENSE-2.0
+   
+  THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+  WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+  MERCHANTABLITY OR NON-INFRINGEMENT.
+   
+  See the Apache Version 2.0 License for specific language governing permissions
+  and limitations under the License.
+  ***************************************************************************** *)
+*/