@rs-x/state-manager 0.4.4

package/dist/index.js

@@ -0,0 +1,3219 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// lib/abstract-observer.ts
+import { Type } from "@rs-x/core";
+import { Subject } from "rxjs";
+var AbstractObserver = class {
+  static {
+    __name(this, "AbstractObserver");
+  }
+  _owner;
+  _target;
+  _value;
+  id;
+  _isDisposed = false;
+  _changed;
+  constructor(_owner, _target, _value, changed, id) {
+    this._owner = _owner;
+    this._target = _target;
+    this._value = _value;
+    this.id = id;
+    this._changed = changed ?? new Subject();
+  }
+  get value() {
+    return this._value;
+  }
+  set value(value) {
+    this._value = value;
+  }
+  get target() {
+    return this._target;
+  }
+  set target(value) {
+    this._target = value;
+  }
+  get changed() {
+    return this._changed;
+  }
+  init() {
+  }
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    if (!this._owner?.canDispose || this._owner.canDispose()) {
+      this.disposeInternal();
+      this._target = Type.cast(void 0);
+      this._value = Type.cast(void 0);
+      this._isDisposed = true;
+    }
+    this._owner?.release?.();
+  }
+  get isDisposed() {
+    return this._isDisposed;
+  }
+  disposeInternal() {
+  }
+  emitChange(change) {
+    this._changed.next(change);
+  }
+};
+
+// lib/grouped-change-subscriptions-for-context-manager.ts
+import { SingletonFactoryWithGuid } from "@rs-x/core";
+var GroupedChangeSubscriptionsForContextManager = class extends SingletonFactoryWithGuid {
+  static {
+    __name(this, "GroupedChangeSubscriptionsForContextManager");
+  }
+  _context;
+  releaseContext;
+  _errorLog;
+  _subscriptions = /* @__PURE__ */ new Map();
+  constructor(_context, releaseContext, _errorLog, guidFactory) {
+    super(guidFactory), this._context = _context, this.releaseContext = releaseContext, this._errorLog = _errorLog;
+  }
+  getSubsriptionData(id) {
+    return this._subscriptions.get(id)?.data;
+  }
+  createInstance(data, id) {
+    const { observer, subscriptionData } = this.createObserver(this._context, data, id);
+    this._subscriptions.set(id, {
+      subscription: observer.changed.subscribe({
+        next: data.onChanged,
+        error: /* @__PURE__ */ __name((e) => this._errorLog.add({
+          message: `Failed to handle change emitted ${id}`,
+          exception: e,
+          context: this._context,
+          fatal: true,
+          data
+        }), "error")
+      }),
+      data: subscriptionData
+    });
+    return observer;
+  }
+  onInstanceCreated(observer, data) {
+    const init = data.init ? data.init : (observer2) => observer2.init();
+    init(observer);
+  }
+  releaseInstance(observer, id) {
+    super.releaseInstance(observer, id);
+    this._subscriptions.get(id)?.subscription.unsubscribe();
+    this._subscriptions.delete(id);
+  }
+  onReleased() {
+    this.releaseContext();
+  }
+};
+
+// lib/object-observer/factories/abstract-object-observer-proxy-pair.factory.ts
+import { truePredicate } from "@rs-x/core";
+
+// lib/observer-group.ts
+import { Type as Type2 } from "@rs-x/core";
+import { ReplaySubject } from "rxjs";
+var ObserverGroup = class _ObserverGroup extends AbstractObserver {
+  static {
+    __name(this, "ObserverGroup");
+  }
+  _errorLog;
+  getRootObserver;
+  _observeRootObserver;
+  _subscriptions = /* @__PURE__ */ new Map();
+  _rootChangeSubscription;
+  _observers = [];
+  mustHandleChange;
+  _rootObserver;
+  _isInitialized = false;
+  _parent;
+  constructor(owner, target, initialValue, mustHandleChange, _errorLog, id, getRootObserver, _observeRootObserver) {
+    super(owner, target, initialValue, new ReplaySubject(1), id), this._errorLog = _errorLog, this.getRootObserver = getRootObserver, this._observeRootObserver = _observeRootObserver;
+    this.mustHandleChange = mustHandleChange ?? (() => true);
+  }
+  get rootObserver() {
+    if (!this._rootObserver && this.getRootObserver) {
+      this._rootObserver = this.getRootObserver();
+    }
+    return this._rootObserver;
+  }
+  init() {
+    if (this._isInitialized) {
+      return;
+    }
+    this._isInitialized = true;
+    this.rootObserver?.init();
+    this._observers.forEach((observer) => observer.init());
+    if (this._observeRootObserver && this._rootObserver) {
+      this._rootChangeSubscription = this._rootObserver.changed.subscribe({
+        next: this.emitChange,
+        error: /* @__PURE__ */ __name((e) => {
+          const target = this._rootObserver.target;
+          this._errorLog.add({
+            message: `Failed to handle change for ${Type2.getConstructorName(target)}[${this._rootObserver.id}]`,
+            exception: e,
+            context: target,
+            fatal: true
+          });
+        }, "error")
+      });
+    }
+  }
+  addObservers(observers) {
+    this._observers.push(...observers);
+    observers.filter((observer) => observer instanceof _ObserverGroup).forEach((observer) => observer._parent = this);
+    observers.forEach((observer) => this._subscriptions.set(observer, observer.changed.subscribe({
+      next: this.emitChange,
+      error: /* @__PURE__ */ __name((e) => this._errorLog.add({
+        message: "Failed to handle change emitted",
+        exception: e,
+        context: this,
+        fatal: true
+      }), "error")
+    })));
+    return this;
+  }
+  replaceObservers(observers) {
+    this.unsubscribeToObservers();
+    this.addObservers(observers);
+    this._observers.forEach((observer) => observer.init());
+  }
+  emitValue(newValue) {
+    this.emitChange({
+      arguments: [],
+      target: this.target,
+      chain: [
+        {
+          object: this.target,
+          id: this.id
+        }
+      ],
+      id: this.id,
+      newValue
+    });
+  }
+  removeObserver(target, id) {
+    const index = this._observers.findIndex((observer) => observer.target === target && observer.id === id);
+    if (index === -1) {
+      return;
+    }
+    const subscription = this._subscriptions.get(this._observers[index]);
+    if (subscription) {
+      subscription.unsubscribe();
+      this._subscriptions.delete(this._observers[index]);
+    }
+    this._observers.splice(index, 1);
+  }
+  disposeInternal() {
+    this.rootObserver?.dispose();
+    this.unsubscribeToObservers();
+  }
+  emitChange = /* @__PURE__ */ __name((change) => {
+    if (!change || !this.mustHandleChange(change)) {
+      return;
+    }
+    const isThisTarget = change.target === this.target;
+    const chain = isThisTarget || Type2.isNullOrUndefined(this.id) ? change.chain : [
+      {
+        object: this.target,
+        id: this.id
+      },
+      ...change.chain ?? []
+    ];
+    super.emitChange({
+      ...change,
+      chain
+    });
+  }, "emitChange");
+  unsubscribeToObservers() {
+    this._subscriptions.forEach((subscription) => subscription.unsubscribe());
+    this._subscriptions.clear();
+    this._observers.forEach((observer) => observer.dispose());
+    this._observers.length = 0;
+    this._rootChangeSubscription?.unsubscribe();
+  }
+};
+
+// lib/object-observer/factories/abstract-object-observer-proxy-pair.factory.ts
+var AbstractObjectObserverProxyPairFactory = class {
+  static {
+    __name(this, "AbstractObjectObserverProxyPairFactory");
+  }
+  priority;
+  _observerRootObserver;
+  _errorLog;
+  _indexAccessor;
+  _objectPropertyObserverProxyPairManager;
+  constructor(priority, _observerRootObserver, _errorLog, _indexAccessor, _objectPropertyObserverProxyPairManager) {
+    this.priority = priority;
+    this._observerRootObserver = _observerRootObserver;
+    this._errorLog = _errorLog;
+    this._indexAccessor = _indexAccessor;
+    this._objectPropertyObserverProxyPairManager = _objectPropertyObserverProxyPairManager;
+  }
+  create(owner, data) {
+    const observerGroup = new ObserverGroup(this.createDisposableOwner(owner, data), data.target, data.target, truePredicate, this._errorLog, void 0, () => rootObserver?.observer, this._observerRootObserver);
+    this.onObserverGroupCreate(data.target, observerGroup, data.mustProxify);
+    const rootObserver = this.createRootObserver(data);
+    if (!data.initializeManually) {
+      observerGroup.init();
+    }
+    return {
+      observer: observerGroup,
+      proxy: rootObserver?.proxy,
+      proxyTarget: rootObserver?.proxyTarget
+    };
+  }
+  createDisposableOwner(owner, _data) {
+    return owner;
+  }
+  onObserverGroupCreate(target, observerGroup, mustProxify) {
+    if (!mustProxify) {
+      return;
+    }
+    const observers = [];
+    const indexes = this._indexAccessor.getIndexes(target);
+    for (const index of indexes) {
+      if (!mustProxify(index, target)) {
+        continue;
+      }
+      const { observer } = this._objectPropertyObserverProxyPairManager.create(target).instance.create({
+        key: index,
+        mustProxify
+      }).instance;
+      observers.push(observer);
+    }
+    observerGroup.replaceObservers(observers);
+  }
+};
+
+// lib/object-observer/factories/array-observer-proxy-pair.factory.ts
+import { Inject, Injectable, RsXCoreInjectionTokens } from "@rs-x/core";
+
+// lib/rs-x-state-manager-injection-tokes.ts
+var RsXStateManagerInjectionTokens = {
+  IArrayProxyFactory: Symbol("IArrayProxyFactory"),
+  IMapProxyFactory: Symbol("IMapProxyFactory"),
+  ISetProxyFactory: Symbol("ISetProxyFactory"),
+  IDateProxyFactory: Symbol("IDateProxyFactory"),
+  IProxyRegistry: Symbol("IProxyRegistry"),
+  IPromiseProxyFactory: Symbol("IPromiseProxyFactory"),
+  IObservableProxyFactory: Symbol("IObservableProxyFactory"),
+  IObjectPropertyObserverProxyPairManager: Symbol("IObjectPropertyObserverProxyPairManager"),
+  IPlainObjectObserverProxyPairFactory: Symbol("IPlainObjectObserverProxyPairFactory"),
+  IDateObserverProxyPairFactory: Symbol("IDateObserverProxyPairFactory"),
+  IArrayObserverProxyPairFactory: Symbol("IArrayObserverProxyPairFactory"),
+  PromiseObserverProxyPairFactory: Symbol("PromiseObserverProxyPairFactory"),
+  ObservableObserverProxyPairFactory: Symbol("ObservableObserverProxyPairFactory"),
+  IMapObserverProxyPairFactory: Symbol("IMapObserverProxyPairFactory"),
+  ISetObserverProxyPairFactory: Symbol("ISetObserverProxyPairFactory"),
+  IDatePropertyObserverProxyPairFactory: Symbol("IDatePropertyObserverProxyPairFactory"),
+  IObjectObserverProxyPairFactoryList: Symbol("IObjectObserverProxyPairFactoryList"),
+  IObjectObserverProxyPairFactoryProvider: Symbol("IObjectObserverProxyPairFactoryProvider"),
+  IObjectObserverProxyPairManager: Symbol("IObjectObserverProxyPairManager"),
+  IObjectPropertyObserverManager: Symbol("IObjectPropertyObserverManager"),
+  ICollectionItemObserverManager: Symbol("ICollectionItemObserverManager"),
+  ISetItemObserverManager: Symbol("ISetItemObserverManager"),
+  IDatePropertyObserverManager: Symbol("IDatePropertyObserverManager"),
+  IPropertyObserverProxyPairFactoryList: Symbol("IPropertyObserverProxyPairFactoryList"),
+  NonIterableObjectPropertyObserverProxyPairFactory: Symbol("NonIterableObjectPropertyObserverProxyPairFactory"),
+  ICollectionItemObserverProxyPairFactory: Symbol("ICollectionItemObserverProxyPairFactory"),
+  IMustProxifyItemHandlerFactory: Symbol("IMustProxifyItemHandlerFactory"),
+  IObjectStateManager: Symbol("IObjectStateManager"),
+  IPropertyObserverProxyPairFactoryProvider: Symbol("IPropertyObserverProxyPairFactoryProvider"),
+  IPropertyObserverProxyPairFactoryProviderFactory: Symbol("IPropertyObserverProxyPairFactoryProviderFactory"),
+  IObjectObserverProxyPairFactoryProviderFactory: Symbol("IObjectObserverProxyPairFactoryProviderFactory"),
+  IStateManager: Symbol("IStateManager")
+};
+
+// lib/object-observer/factories/array-observer-proxy-pair.factory.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var ArrayObserverProxyPairFactory = class extends AbstractObjectObserverProxyPairFactory {
+  static {
+    __name(this, "ArrayObserverProxyPairFactory");
+  }
+  _arrayProxyFactory;
+  constructor(_arrayProxyFactory, errorLog, arrayIndexAccessor, objectPropertyObserverProxyPairManager) {
+    super(5, true, errorLog, arrayIndexAccessor, objectPropertyObserverProxyPairManager), this._arrayProxyFactory = _arrayProxyFactory;
+  }
+  applies(object) {
+    return Array.isArray(object);
+  }
+  createRootObserver(data) {
+    return this._arrayProxyFactory.create({
+      array: data.target
+    }).instance;
+  }
+};
+ArrayObserverProxyPairFactory = _ts_decorate([
+  Injectable(),
+  _ts_param(0, Inject(RsXStateManagerInjectionTokens.IArrayProxyFactory)),
+  _ts_param(1, Inject(RsXCoreInjectionTokens.IErrorLog)),
+  _ts_param(2, Inject(RsXCoreInjectionTokens.IArrayIndexAccessor)),
+  _ts_param(3, Inject(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof IArrayProxyFactory === "undefined" ? Object : IArrayProxyFactory,
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IArrayIndexAccessor === "undefined" ? Object : IArrayIndexAccessor,
+    typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager
+  ])
+], ArrayObserverProxyPairFactory);
+
+// lib/object-observer/factories/date-observer-proxy-pair.factory.ts
+import { Inject as Inject2, Injectable as Injectable2 } from "@rs-x/core";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var DateObserverProxyPairFactory = class {
+  static {
+    __name(this, "DateObserverProxyPairFactory");
+  }
+  _dateProxyFactory;
+  priority = 6;
+  constructor(_dateProxyFactory) {
+    this._dateProxyFactory = _dateProxyFactory;
+  }
+  create(owner, proxyTarget) {
+    return this._dateProxyFactory.create({
+      owner,
+      date: proxyTarget.target
+    }).instance;
+  }
+  applies(object) {
+    return object instanceof Date;
+  }
+};
+DateObserverProxyPairFactory = _ts_decorate2([
+  Injectable2(),
+  _ts_param2(0, Inject2(RsXStateManagerInjectionTokens.IDateProxyFactory)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof IDateProxyFactory === "undefined" ? Object : IDateProxyFactory
+  ])
+], DateObserverProxyPairFactory);
+
+// lib/object-observer/factories/map-observer-proxy-pair.factory.ts
+import { Inject as Inject3, Injectable as Injectable3, RsXCoreInjectionTokens as RsXCoreInjectionTokens2 } from "@rs-x/core";
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var MapObserverProxyPairFactory = class extends AbstractObjectObserverProxyPairFactory {
+  static {
+    __name(this, "MapObserverProxyPairFactory");
+  }
+  _mapProxyFactory;
+  constructor(_mapProxyFactory, errorLog, mapKeyAccessor, objectPropertyObserverProxyPairManager) {
+    super(2, true, errorLog, mapKeyAccessor, objectPropertyObserverProxyPairManager), this._mapProxyFactory = _mapProxyFactory;
+  }
+  applies(object) {
+    return object instanceof Map;
+  }
+  createRootObserver(data) {
+    return this._mapProxyFactory.create({
+      map: data.target
+    }).instance;
+  }
+};
+MapObserverProxyPairFactory = _ts_decorate3([
+  Injectable3(),
+  _ts_param3(0, Inject3(RsXStateManagerInjectionTokens.IMapProxyFactory)),
+  _ts_param3(1, Inject3(RsXCoreInjectionTokens2.IErrorLog)),
+  _ts_param3(2, Inject3(RsXCoreInjectionTokens2.IMapKeyAccessor)),
+  _ts_param3(3, Inject3(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof IMapProxyFactory === "undefined" ? Object : IMapProxyFactory,
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IMapKeyAccessor === "undefined" ? Object : IMapKeyAccessor,
+    typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager
+  ])
+], MapObserverProxyPairFactory);
+
+// lib/object-observer/factories/observable-observer-proxy-pair.factory.ts
+import { Inject as Inject4, Injectable as Injectable4 } from "@rs-x/core";
+import { isObservable } from "rxjs";
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var ObservableObserverProxyPairFactory = class {
+  static {
+    __name(this, "ObservableObserverProxyPairFactory");
+  }
+  _observableProxyFactory;
+  priority = 3;
+  constructor(_observableProxyFactory) {
+    this._observableProxyFactory = _observableProxyFactory;
+  }
+  create(owner, objectObserverInfo) {
+    return this._observableProxyFactory.create({
+      observable: objectObserverInfo.target,
+      owner
+    }).instance;
+  }
+  applies(object) {
+    return isObservable(object);
+  }
+};
+ObservableObserverProxyPairFactory = _ts_decorate4([
+  Injectable4(),
+  _ts_param4(0, Inject4(RsXStateManagerInjectionTokens.IObservableProxyFactory)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof IObservableProxyFactory === "undefined" ? Object : IObservableProxyFactory
+  ])
+], ObservableObserverProxyPairFactory);
+
+// lib/object-observer/factories/plain-object-observer-proxy-pair.factory.ts
+import { Inject as Inject5, Injectable as Injectable5, RsXCoreInjectionTokens as RsXCoreInjectionTokens3, truePredicate as truePredicate2, Type as Type3 } from "@rs-x/core";
+function _ts_decorate5(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var PlainObjectObserverProxyPairFactory = class extends AbstractObjectObserverProxyPairFactory {
+  static {
+    __name(this, "PlainObjectObserverProxyPairFactory");
+  }
+  constructor(errorLog, propertyValueAccessor, objectPropertyObserverProxyPairManager) {
+    super(7, true, errorLog, propertyValueAccessor, objectPropertyObserverProxyPairManager);
+  }
+  applies(object) {
+    return Type3.isPlainObject(object);
+  }
+  createRootObserver(data) {
+    if (data.mustProxify) {
+      return void 0;
+    }
+    const target = data.target;
+    const observers = [];
+    for (const index of this._indexAccessor.getIndexes(target)) {
+      const { observer } = this._objectPropertyObserverProxyPairManager.create(target).instance.create({
+        key: index
+      }).instance;
+      observers.push(observer);
+    }
+    if (observers.length === 0) {
+      return void 0;
+    }
+    const observerGroup = new ObserverGroup(void 0, data.target, data.target, truePredicate2, this._errorLog);
+    observerGroup.replaceObservers(observers);
+    return {
+      observer: observerGroup
+    };
+  }
+};
+PlainObjectObserverProxyPairFactory = _ts_decorate5([
+  Injectable5(),
+  _ts_param5(0, Inject5(RsXCoreInjectionTokens3.IErrorLog)),
+  _ts_param5(1, Inject5(RsXCoreInjectionTokens3.IPropertyValueAccessor)),
+  _ts_param5(2, Inject5(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IPropertyValueAccessor === "undefined" ? Object : IPropertyValueAccessor,
+    typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager
+  ])
+], PlainObjectObserverProxyPairFactory);
+
+// lib/object-observer/factories/promise-observer-proxy-pair.factory.ts
+import { Inject as Inject6, Injectable as Injectable6 } from "@rs-x/core";
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+var PromiseObserverProxyPairFactory = class {
+  static {
+    __name(this, "PromiseObserverProxyPairFactory");
+  }
+  _promiseProxyFactory;
+  priority = 4;
+  constructor(_promiseProxyFactory) {
+    this._promiseProxyFactory = _promiseProxyFactory;
+  }
+  create(owner, proxyTarget) {
+    return this._promiseProxyFactory.create({
+      promise: proxyTarget.target,
+      owner
+    }).instance;
+  }
+  applies(object) {
+    return object instanceof Promise;
+  }
+};
+PromiseObserverProxyPairFactory = _ts_decorate6([
+  Injectable6(),
+  _ts_param6(0, Inject6(RsXStateManagerInjectionTokens.IPromiseProxyFactory)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof IPromiseProxyFactory === "undefined" ? Object : IPromiseProxyFactory
+  ])
+], PromiseObserverProxyPairFactory);
+
+// lib/object-observer/factories/set-observer-proxy-pair.factory.ts
+import { Inject as Inject7, Injectable as Injectable7, RsXCoreInjectionTokens as RsXCoreInjectionTokens4 } from "@rs-x/core";
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var SetObserverProxyPairFactory = class extends AbstractObjectObserverProxyPairFactory {
+  static {
+    __name(this, "SetObserverProxyPairFactory");
+  }
+  _setProxyFactory;
+  constructor(_setProxyFactory, errorLog, setKeyAccessor, objectPropertyObserverProxyPairManager) {
+    super(1, true, errorLog, setKeyAccessor, objectPropertyObserverProxyPairManager), this._setProxyFactory = _setProxyFactory;
+  }
+  applies(object) {
+    return object instanceof Set;
+  }
+  createRootObserver(data) {
+    return this._setProxyFactory.create({
+      set: data.target
+    }).instance;
+  }
+};
+SetObserverProxyPairFactory = _ts_decorate7([
+  Injectable7(),
+  _ts_param7(0, Inject7(RsXStateManagerInjectionTokens.ISetProxyFactory)),
+  _ts_param7(1, Inject7(RsXCoreInjectionTokens4.IErrorLog)),
+  _ts_param7(2, Inject7(RsXCoreInjectionTokens4.ISetKeyAccessor)),
+  _ts_param7(3, Inject7(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof ISetProxyFactory === "undefined" ? Object : ISetProxyFactory,
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof ISetKeyAccessor === "undefined" ? Object : ISetKeyAccessor,
+    typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager
+  ])
+], SetObserverProxyPairFactory);
+
+// lib/object-observer/object-observer-proxy-pair-factory.provider.ts
+import { Injectable as Injectable8, MultiInject } from "@rs-x/core";
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param8, "_ts_param");
+var ObjectObserverProxyPairFactoryProvider = class {
+  static {
+    __name(this, "ObjectObserverProxyPairFactoryProvider");
+  }
+  factories;
+  constructor(factories) {
+    this.factories = [
+      ...factories
+    ].sort((a, b) => b.priority - a.priority);
+  }
+};
+ObjectObserverProxyPairFactoryProvider = _ts_decorate8([
+  Injectable8(),
+  _ts_param8(0, MultiInject(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryList)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    Object
+  ])
+], ObjectObserverProxyPairFactoryProvider);
+
+// lib/object-observer/object-observer-proxy-pair-manager.ts
+import { Inject as Inject8, Injectable as Injectable9, InvalidOperationException, RsXCoreInjectionTokens as RsXCoreInjectionTokens5, SingletonFactoryWithGuid as SingletonFactoryWithGuid2, Type as Type4 } from "@rs-x/core";
+function _ts_decorate9(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate9, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param9, "_ts_param");
+var ObjectObserverProxyPairManager = class extends SingletonFactoryWithGuid2 {
+  static {
+    __name(this, "ObjectObserverProxyPairManager");
+  }
+  getObserverFactoryProvider;
+  _proxyRegistry;
+  constructor(getObserverFactoryProvider, _proxyRegistry, guidFactory) {
+    super(guidFactory), this.getObserverFactoryProvider = getObserverFactoryProvider, this._proxyRegistry = _proxyRegistry;
+  }
+  getGroupId(data) {
+    return data.target;
+  }
+  getGroupMemberId(data) {
+    return data.mustProxify;
+  }
+  create(data) {
+    if (this._proxyRegistry.isProxy(data.target)) {
+      throw new InvalidOperationException("Cannot create a proxy for a proxy");
+    }
+    return super.create(data);
+  }
+  createInstance(objectObserverInfo, id) {
+    const factory = this.getObserverFactoryProvider().factories.find((factory2) => factory2.applies(objectObserverInfo.target));
+    return factory ? factory.create({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    }, objectObserverInfo) : Type4.cast(null);
+  }
+  releaseInstance(observerProxyPair) {
+    observerProxyPair.observer.dispose();
+  }
+};
+ObjectObserverProxyPairManager = _ts_decorate9([
+  Injectable9(),
+  _ts_param9(0, Inject8(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProviderFactory)),
+  _ts_param9(1, Inject8(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_param9(2, Inject8(RsXCoreInjectionTokens5.IGuidFactory)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    Function,
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry,
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory
+  ])
+], ObjectObserverProxyPairManager);
+
+// lib/object-property-observer-proxy-pair-manager.ts
+import { Inject as Inject9, Injectable as Injectable10, MultiInject as MultiInject2, RsXCoreInjectionTokens as RsXCoreInjectionTokens6, SingletonFactory, SingletonFactoryWithGuid as SingletonFactoryWithGuid3, Type as Type5, UnsupportedException } from "@rs-x/core";
+function _ts_decorate10(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate10, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param10, "_ts_param");
+var PropertyObserverProxyPairManager = class PropertyObserverProxyPairManager2 extends SingletonFactoryWithGuid3 {
+  static {
+    __name(this, "PropertyObserverProxyPairManager");
+  }
+  _object;
+  _observerFactories;
+  releaseContext;
+  constructor(guidFactory, _object, _observerFactories, releaseContext) {
+    super(guidFactory), this._object = _object, this._observerFactories = _observerFactories, this.releaseContext = releaseContext;
+  }
+  getGroupId(data) {
+    return data.key;
+  }
+  getGroupMemberId(data) {
+    return data.mustProxify;
+  }
+  createInstance(propertyInfo, id) {
+    return this.getObserverFactory(propertyInfo).create({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => {
+        propertyInfo.owner?.release();
+        this.release(id);
+      }, "release")
+    }, this._object, propertyInfo);
+  }
+  releaseInstance(observerProxyPair) {
+    observerProxyPair.observer.dispose();
+  }
+  onReleased() {
+    this.releaseContext();
+  }
+  getObserverFactory(propertyInfo) {
+    const observerFactory = this._observerFactories.find((observerFactory2) => observerFactory2.applies(this._object, propertyInfo));
+    if (!observerFactory) {
+      throw new UnsupportedException(`No observer factory found for given object of type ${Type5.getConstructorName(this._object)} for given id ${propertyInfo.key}`);
+    }
+    return observerFactory;
+  }
+};
+var ObjectPropertyObserverProxyPairManager = class extends SingletonFactory {
+  static {
+    __name(this, "ObjectPropertyObserverProxyPairManager");
+  }
+  _factories;
+  _guidFactory;
+  constructor(_factories, _guidFactory) {
+    super(), this._factories = _factories, this._guidFactory = _guidFactory;
+  }
+  getId(context) {
+    return context;
+  }
+  createId(context) {
+    return context;
+  }
+  createInstance(context) {
+    return new PropertyObserverProxyPairManager(this._guidFactory, context, this._factories, () => this.release(context));
+  }
+};
+ObjectPropertyObserverProxyPairManager = _ts_decorate10([
+  Injectable10(),
+  _ts_param10(0, MultiInject2(RsXStateManagerInjectionTokens.IPropertyObserverProxyPairFactoryList)),
+  _ts_param10(1, Inject9(RsXCoreInjectionTokens6.IGuidFactory)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    Array,
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory
+  ])
+], ObjectPropertyObserverProxyPairManager);
+
+// lib/property-observer/factories/collection-item/collection-item-observer-manager.ts
+import { Inject as Inject10, Injectable as Injectable11, RsXCoreInjectionTokens as RsXCoreInjectionTokens7, SingletonFactory as SingletonFactory2 } from "@rs-x/core";
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+function _ts_param11(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param11, "_ts_param");
+var CollectionIndexObserver = class CollectionIndexObserver2 extends AbstractObserver {
+  static {
+    __name(this, "CollectionIndexObserver");
+  }
+  _equalityService;
+  _indexValueAccessor;
+  _objectObserverProxyPairManager;
+  _changeSubscription;
+  _collectionObserver;
+  constructor(owner, collection, index, _equalityService, _indexValueAccessor, _objectObserverProxyPairManager, errorLog) {
+    super(owner, collection, _indexValueAccessor.getValue(collection, index), void 0, index), this._equalityService = _equalityService, this._indexValueAccessor = _indexValueAccessor, this._objectObserverProxyPairManager = _objectObserverProxyPairManager;
+    this._collectionObserver = this._objectObserverProxyPairManager.create({
+      target: collection
+    }).instance.observer;
+    this._changeSubscription = this._collectionObserver.changed.subscribe({
+      next: this.onChanged,
+      error: /* @__PURE__ */ __name((e) => errorLog.add({
+        message: `Failed to handle change for ${collection.constructor.name} item for index '${index}'`,
+        exception: e,
+        context: collection,
+        fatal: true
+      }), "error")
+    });
+  }
+  disposeInternal() {
+    super.disposeInternal();
+    this._changeSubscription?.unsubscribe();
+    this._collectionObserver.dispose();
+  }
+  onChanged = /* @__PURE__ */ __name((change) => {
+    if (change.id !== this.id) {
+      return;
+    }
+    if (!this._indexValueAccessor.hasValue(this.target, this.id)) {
+      this.value = void 0;
+      this.emitChange(change);
+      return;
+    }
+    if (!this._equalityService.isEqual(this.value, change.newValue)) {
+      this.value = change.newValue;
+      this.emitChange(change);
+    }
+  }, "onChanged");
+};
+var CollectionIndexObserverManager = class CollectionIndexObserverManager2 extends SingletonFactory2 {
+  static {
+    __name(this, "CollectionIndexObserverManager");
+  }
+  _collection;
+  _errorLog;
+  _equalityService;
+  _indexValueAccessor;
+  _objectObserverProxyPairManager;
+  releaseObject;
+  constructor(_collection, _errorLog, _equalityService, _indexValueAccessor, _objectObserverProxyPairManager, releaseObject) {
+    super(), this._collection = _collection, this._errorLog = _errorLog, this._equalityService = _equalityService, this._indexValueAccessor = _indexValueAccessor, this._objectObserverProxyPairManager = _objectObserverProxyPairManager, this.releaseObject = releaseObject;
+  }
+  getId(data) {
+    return data.index;
+  }
+  createId(data) {
+    return data.index;
+  }
+  createInstance(data, id) {
+    return new CollectionIndexObserver({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    }, this._collection, data.index, this._equalityService, this._indexValueAccessor, this._objectObserverProxyPairManager, this._errorLog);
+  }
+  releaseInstance(observer) {
+    observer.dispose();
+  }
+  onReleased() {
+    this.releaseObject();
+  }
+};
+var CollectionItemObserverManager = class extends SingletonFactory2 {
+  static {
+    __name(this, "CollectionItemObserverManager");
+  }
+  _errorLog;
+  _equalityService;
+  _indexValueAccessor;
+  _objectObserverProxyPairManager;
+  constructor(_errorLog, _equalityService, _indexValueAccessor, _objectObserverProxyPairManager) {
+    super(), this._errorLog = _errorLog, this._equalityService = _equalityService, this._indexValueAccessor = _indexValueAccessor, this._objectObserverProxyPairManager = _objectObserverProxyPairManager;
+  }
+  getId(collection) {
+    return collection;
+  }
+  createId(collection) {
+    return collection;
+  }
+  createInstance(collection) {
+    return new CollectionIndexObserverManager(collection, this._errorLog, this._equalityService, this._indexValueAccessor, this._objectObserverProxyPairManager, () => this.release(collection));
+  }
+  releaseInstance(collectionIndexObserverManager) {
+    collectionIndexObserverManager.dispose();
+  }
+};
+CollectionItemObserverManager = _ts_decorate11([
+  Injectable11(),
+  _ts_param11(0, Inject10(RsXCoreInjectionTokens7.IErrorLog)),
+  _ts_param11(1, Inject10(RsXCoreInjectionTokens7.IEqualityService)),
+  _ts_param11(2, Inject10(RsXCoreInjectionTokens7.IIndexValueAccessor)),
+  _ts_param11(3, Inject10(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IEqualityService === "undefined" ? Object : IEqualityService,
+    typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
+    typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager
+  ])
+], CollectionItemObserverManager);
+
+// lib/property-observer/factories/collection-item/collection-item-observer-proxy-pair.factory.ts
+import { Inject as Inject11, Injectable as Injectable12, RsXCoreInjectionTokens as RsXCoreInjectionTokens8, truePredicate as truePredicate4 } from "@rs-x/core";
+
+// lib/property-observer/factories/indexed-value-observer-proxy-pair/indexed-value-observer-proxy-pair.factory.ts
+import { truePredicate as truePredicate3, Type as Type6, UnexpectedException } from "@rs-x/core";
+
+// lib/property-observer/factories/indexed-value-observer-proxy-pair/index-change-subscription-manager.ts
+import { SingletonFactory as SingletonFactory3 } from "@rs-x/core";
+var IndexChangeSubscriptionsForContextManager = class IndexChangeSubscriptionsForContextManager2 extends GroupedChangeSubscriptionsForContextManager {
+  static {
+    __name(this, "IndexChangeSubscriptionsForContextManager");
+  }
+  _indexSetObserverManager;
+  constructor(context, releaseContext, _indexSetObserverManager, errorLog, guidFactory) {
+    super(context, releaseContext, errorLog, guidFactory), this._indexSetObserverManager = _indexSetObserverManager;
+  }
+  getGroupId(data) {
+    return data.index;
+  }
+  getGroupMemberId(data) {
+    return data.mustProxify;
+  }
+  createObserver(context, data, id) {
+    const indexSetObserver = this._indexSetObserverManager.create(context).instance.create({
+      index: data.index,
+      initialValue: data.initialValue
+    }).instance;
+    const group = this.createGroupObserver(data, indexSetObserver, id);
+    return {
+      subscriptionData: group,
+      observer: indexSetObserver
+    };
+  }
+  createGroupObserver(data, indexSetObserver, id) {
+    const observer = new ObserverGroup({
+      ...data.owner,
+      release: /* @__PURE__ */ __name(() => {
+        data.owner.release();
+        this.release(id);
+      }, "release")
+    }, this._context, data.initialValue, data.mustHandleChange, this._errorLog, data.index, () => indexSetObserver).addObservers(data.indexValueObserver ? [
+      data.indexValueObserver
+    ] : []);
+    if (!data.initializeManually) {
+      observer.init();
+    }
+    return observer;
+  }
+};
+var IndexChangeSubscriptionManager = class extends SingletonFactory3 {
+  static {
+    __name(this, "IndexChangeSubscriptionManager");
+  }
+  _indexSetObserverManager;
+  _errorLog;
+  _guidFactory;
+  constructor(_indexSetObserverManager, _errorLog, _guidFactory) {
+    super(), this._indexSetObserverManager = _indexSetObserverManager, this._errorLog = _errorLog, this._guidFactory = _guidFactory;
+  }
+  getId(context) {
+    return context;
+  }
+  createId(context) {
+    return context;
+  }
+  createInstance(context) {
+    return new IndexChangeSubscriptionsForContextManager(context, () => this.release(context), this._indexSetObserverManager, this._errorLog, this._guidFactory);
+  }
+  releaseInstance(instance, id) {
+    super.releaseInstance(instance, id);
+    instance.dispose();
+  }
+};
+
+// lib/property-observer/factories/indexed-value-observer-proxy-pair/indexed-value-observer-proxy-pair.factory.ts
+var IndexObserverProxyPairFactory = class {
+  static {
+    __name(this, "IndexObserverProxyPairFactory");
+  }
+  _objectObserveryManager;
+  _indexValueAccessor;
+  _proxyRegister;
+  mustHandleChange;
+  _indexChangeSubscriptionManager;
+  constructor(_objectObserveryManager, indexSetObserverManager, errorLog, guidFactory, _indexValueAccessor, _proxyRegister, mustHandleChange) {
+    this._objectObserveryManager = _objectObserveryManager;
+    this._indexValueAccessor = _indexValueAccessor;
+    this._proxyRegister = _proxyRegister;
+    this.mustHandleChange = mustHandleChange;
+    this._indexChangeSubscriptionManager = new IndexChangeSubscriptionManager(indexSetObserverManager, errorLog, guidFactory);
+  }
+  dispose() {
+    this._indexChangeSubscriptionManager.dispose();
+  }
+  create(owner, object, propertyInfo) {
+    const index = propertyInfo.key;
+    const valueAtIndex = this._indexValueAccessor.getValue(object, index);
+    const mustProxify = this.getMustProxifyHandler(propertyInfo.mustProxify, object, index);
+    const indexValueObserverProxyPair = mustProxify ? this.createIndexValueProxy(propertyInfo, object, index, valueAtIndex, mustProxify) : void 0;
+    const initialValue = indexValueObserverProxyPair ? indexValueObserverProxyPair.observer.value : valueAtIndex;
+    ;
+    const groupObserver = this.createGroupObserver(owner, object, index, initialValue, propertyInfo.initializeManually, indexValueObserverProxyPair?.observer, mustProxify);
+    return {
+      observer: groupObserver,
+      proxy: indexValueObserverProxyPair?.proxy,
+      proxyTarget: valueAtIndex
+    };
+  }
+  getMustProxifyHandler(mustProxify, context, index) {
+    if (mustProxify) {
+      return mustProxify;
+    }
+    return this._indexValueAccessor.isAsync(context, index) ? truePredicate3 : void 0;
+  }
+  createIndexValueProxy(propertyInfo, object, index, value, mustProxify) {
+    const setValue = propertyInfo.setValue ?? ((v) => this._indexValueAccessor.setValue(object, index, v));
+    return this.proxifyIndexValue(value, mustProxify, propertyInfo.initializeManually, setValue);
+  }
+  createGroupObserver(owner, object, index, initialValue, initializeManually, indexValueObserver, mustProxify) {
+    const indexChangeSubscriptionsForContextManager = this._indexChangeSubscriptionManager.create(object).instance;
+    const { id } = indexChangeSubscriptionsForContextManager.create({
+      index,
+      initialValue,
+      indexValueObserver,
+      mustProxify,
+      initializeManually,
+      mustHandleChange: this.mustHandleChange,
+      onChanged: /* @__PURE__ */ __name((change) => this.onIndexSet(change, id, mustProxify), "onChanged"),
+      owner
+    });
+    return Type6.cast(indexChangeSubscriptionsForContextManager.getSubsriptionData(id));
+  }
+  onIndexSet(change, subsriptionId, mustProxify) {
+    const emitValue = Type6.isNullOrUndefined(change.newValue) || !this._indexValueAccessor.isAsync(change.target, change.id);
+    const observerGroup = this._indexChangeSubscriptionManager.getFromId(change.target)?.getSubsriptionData(subsriptionId);
+    if (!observerGroup) {
+      throw new UnexpectedException(`Observer group not found for subscription id ${subsriptionId}`);
+    }
+    if (emitValue) {
+      observerGroup.emitValue(change.newValue);
+    }
+    const observers = this.getNestedObservers(change, mustProxify);
+    observerGroup.replaceObservers(observers);
+  }
+  getNestedObservers(change, mustProxify) {
+    const mustProxifyHandler = this.getMustProxifyHandler(mustProxify, change.target, change.id);
+    let observers = [];
+    if (mustProxifyHandler) {
+      const observerProxyPair = this.proxifyIndexValue(change.newValue, mustProxifyHandler, true, change.setValue ?? ((value) => {
+        const obj = Type6.toObject(change.target);
+        if (obj) {
+          obj[change.id] = value;
+        }
+      }));
+      if (observerProxyPair) {
+        observers.push(observerProxyPair.observer);
+      }
+    }
+    return observers;
+  }
+  proxifyIndexValue(value, mustProxify, initializeManually, setValue) {
+    const target = this._proxyRegister.getProxyTarget(value) ?? value;
+    const observerProxyPair = this._objectObserveryManager.create({
+      target,
+      mustProxify,
+      initializeManually
+    }).instance;
+    if (!observerProxyPair) {
+      return void 0;
+    }
+    if (observerProxyPair.proxy !== void 0) {
+      setValue(observerProxyPair.proxy);
+    }
+    return observerProxyPair;
+  }
+};
+
+// lib/property-observer/factories/collection-item/collection-item-observer-proxy-pair.factory.ts
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param12(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param12, "_ts_param");
+var CollectionItemObserverProxyPairFactory = class extends IndexObserverProxyPairFactory {
+  static {
+    __name(this, "CollectionItemObserverProxyPairFactory");
+  }
+  constructor(objectObserverManager, collectionItemObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister) {
+    super(objectObserverManager, collectionItemObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister, truePredicate4);
+  }
+  applies(object) {
+    return object instanceof Map || object instanceof Array || object instanceof Set;
+  }
+};
+CollectionItemObserverProxyPairFactory = _ts_decorate12([
+  Injectable12(),
+  _ts_param12(0, Inject11(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
+  _ts_param12(1, Inject11(RsXStateManagerInjectionTokens.ICollectionItemObserverManager)),
+  _ts_param12(2, Inject11(RsXCoreInjectionTokens8.IErrorLog)),
+  _ts_param12(3, Inject11(RsXCoreInjectionTokens8.IGuidFactory)),
+  _ts_param12(4, Inject11(RsXCoreInjectionTokens8.IIndexValueAccessor)),
+  _ts_param12(5, Inject11(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
+    typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
+    typeof ICollectionItemObserverManager === "undefined" ? Object : ICollectionItemObserverManager,
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
+    typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+  ])
+], CollectionItemObserverProxyPairFactory);
+
+// lib/property-observer/factories/date-property/data-property-observer-manager.ts
+import { Inject as Inject12, Injectable as Injectable13, RsXCoreInjectionTokens as RsXCoreInjectionTokens9, SingletonFactory as SingletonFactory4 } from "@rs-x/core";
+function _ts_decorate13(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate13, "_ts_decorate");
+function _ts_metadata13(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata13, "_ts_metadata");
+function _ts_param13(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param13, "_ts_param");
+var DatePropertybserver = class DatePropertybserver2 extends AbstractObserver {
+  static {
+    __name(this, "DatePropertybserver");
+  }
+  _dateObserver;
+  _errorLog;
+  _oldValue;
+  _dateChangeSubscription;
+  constructor(owner, target, propertyName, datePropertyAccessor, _dateObserver, _errorLog) {
+    super(owner, target, datePropertyAccessor.getValue(target, propertyName), void 0, propertyName), this._dateObserver = _dateObserver, this._errorLog = _errorLog;
+    this._oldValue = this.value;
+    this._dateChangeSubscription = this._dateObserver.changed.subscribe({
+      next: this.onDateChanged,
+      error: /* @__PURE__ */ __name((e) => this._errorLog.add({
+        message: `Failed to handle change for Date  property '${propertyName}'`,
+        exception: e,
+        context: target,
+        fatal: true
+      }), "error")
+    });
+  }
+  disposeInternal() {
+    this._dateObserver.dispose();
+    this._dateChangeSubscription.unsubscribe();
+  }
+  onDateChanged = /* @__PURE__ */ __name((change) => {
+    if (change.id !== this.id || change.newValue === this._oldValue) {
+      return;
+    }
+    this.emitChange(change);
+    this._oldValue = change.newValue;
+  }, "onDateChanged");
+};
+var ProperForDataObserverManager = class ProperForDataObserverManager2 extends SingletonFactory4 {
+  static {
+    __name(this, "ProperForDataObserverManager");
+  }
+  _date;
+  _dateProxyFactory;
+  _datePropertyAccessor;
+  _errorLog;
+  _mustProxifyItemHandlerFactory;
+  releaseObject;
+  constructor(_date, _dateProxyFactory, _datePropertyAccessor, _errorLog, _mustProxifyItemHandlerFactory, releaseObject) {
+    super(), this._date = _date, this._dateProxyFactory = _dateProxyFactory, this._datePropertyAccessor = _datePropertyAccessor, this._errorLog = _errorLog, this._mustProxifyItemHandlerFactory = _mustProxifyItemHandlerFactory, this.releaseObject = releaseObject;
+  }
+  getId(data) {
+    return data.index;
+  }
+  createId(data) {
+    return data.index;
+  }
+  createInstance(data, id) {
+    const dateObserver = this._dateProxyFactory.create({
+      date: this._date,
+      mustProxify: this._mustProxifyItemHandlerFactory.create(id).instance
+    }).instance.observer;
+    return new DatePropertybserver({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    }, this._date, data.index, this._datePropertyAccessor, dateObserver, this._errorLog);
+  }
+  releaseInstance(observer) {
+    observer.dispose();
+  }
+  onReleased() {
+    this.releaseObject();
+  }
+};
+var DatePropertyObserverManager = class extends SingletonFactory4 {
+  static {
+    __name(this, "DatePropertyObserverManager");
+  }
+  _dateProxyFactory;
+  _errorLog;
+  _datePropertyAccessor;
+  _mustProxifyItemHandlerFactory;
+  constructor(_dateProxyFactory, _errorLog, _datePropertyAccessor, _mustProxifyItemHandlerFactory) {
+    super(), this._dateProxyFactory = _dateProxyFactory, this._errorLog = _errorLog, this._datePropertyAccessor = _datePropertyAccessor, this._mustProxifyItemHandlerFactory = _mustProxifyItemHandlerFactory;
+  }
+  getId(date) {
+    return date;
+  }
+  createId(date) {
+    return date;
+  }
+  createInstance(date) {
+    return new ProperForDataObserverManager(date, this._dateProxyFactory, this._datePropertyAccessor, this._errorLog, this._mustProxifyItemHandlerFactory, () => this.release(date));
+  }
+  releaseInstance(properForDataObserverManager) {
+    properForDataObserverManager.dispose();
+  }
+};
+DatePropertyObserverManager = _ts_decorate13([
+  Injectable13(),
+  _ts_param13(0, Inject12(RsXStateManagerInjectionTokens.IDateProxyFactory)),
+  _ts_param13(1, Inject12(RsXCoreInjectionTokens9.IErrorLog)),
+  _ts_param13(2, Inject12(RsXCoreInjectionTokens9.IDatePropertyAccessor)),
+  _ts_param13(3, Inject12(RsXStateManagerInjectionTokens.IMustProxifyItemHandlerFactory)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    typeof IDateProxyFactory === "undefined" ? Object : IDateProxyFactory,
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IDatePropertyAccessor === "undefined" ? Object : IDatePropertyAccessor,
+    typeof IMustProxifyItemHandlerFactory === "undefined" ? Object : IMustProxifyItemHandlerFactory
+  ])
+], DatePropertyObserverManager);
+
+// lib/property-observer/factories/date-property/date-property-observer-proxy-pair.factory.ts
+import { Inject as Inject13, Injectable as Injectable14, RsXCoreInjectionTokens as RsXCoreInjectionTokens10, truePredicate as truePredicate5 } from "@rs-x/core";
+function _ts_decorate14(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata14(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata14, "_ts_metadata");
+function _ts_param14(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param14, "_ts_param");
+var DatePropertyObserverProxyPairFactory = class extends IndexObserverProxyPairFactory {
+  static {
+    __name(this, "DatePropertyObserverProxyPairFactory");
+  }
+  constructor(objectObserverManager, datePropertyObserverManager, errorLog, guidFactory, datePropertyAccessor, proxyRegister) {
+    super(objectObserverManager, datePropertyObserverManager, errorLog, guidFactory, datePropertyAccessor, proxyRegister, truePredicate5);
+  }
+  applies(object) {
+    return object instanceof Date;
+  }
+};
+DatePropertyObserverProxyPairFactory = _ts_decorate14([
+  Injectable14(),
+  _ts_param14(0, Inject13(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
+  _ts_param14(1, Inject13(RsXStateManagerInjectionTokens.IDatePropertyObserverManager)),
+  _ts_param14(2, Inject13(RsXCoreInjectionTokens10.IErrorLog)),
+  _ts_param14(3, Inject13(RsXCoreInjectionTokens10.IGuidFactory)),
+  _ts_param14(4, Inject13(RsXCoreInjectionTokens10.IIndexValueAccessor)),
+  _ts_param14(5, Inject13(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_metadata14("design:type", Function),
+  _ts_metadata14("design:paramtypes", [
+    typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
+    typeof IDatePropertyObserverManager === "undefined" ? Object : IDatePropertyObserverManager,
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
+    typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+  ])
+], DatePropertyObserverProxyPairFactory);
+
+// lib/property-observer/factories/non-iterable-object-property/non-iterable-object-property-observer-proxy-pair.factory.ts
+import { Inject as Inject14, Injectable as Injectable15, RsXCoreInjectionTokens as RsXCoreInjectionTokens11, Type as Type7 } from "@rs-x/core";
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_metadata15(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata15, "_ts_metadata");
+function _ts_param15(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param15, "_ts_param");
+var NonIterableObjectPropertyObserverProxyPairFactory = class extends IndexObserverProxyPairFactory {
+  static {
+    __name(this, "NonIterableObjectPropertyObserverProxyPairFactory");
+  }
+  constructor(objectObserveryManager, objectPropertyObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister) {
+    super(objectObserveryManager, objectPropertyObserverManager, errorLog, guidFactory, indexValueAccessor, proxyRegister);
+  }
+  applies(object, propertyInfo) {
+    return !(Array.isArray(object) || object instanceof Date || object instanceof Map || object instanceof Set) && Type7.isString(propertyInfo.key) && !Type7.isMethod((Type7.toObject(object) ?? {})[propertyInfo.key]);
+  }
+  setIndexValue(object, key, value) {
+    object[key] = value;
+  }
+};
+NonIterableObjectPropertyObserverProxyPairFactory = _ts_decorate15([
+  Injectable15(),
+  _ts_param15(0, Inject14(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager)),
+  _ts_param15(1, Inject14(RsXStateManagerInjectionTokens.IObjectPropertyObserverManager)),
+  _ts_param15(2, Inject14(RsXCoreInjectionTokens11.IErrorLog)),
+  _ts_param15(3, Inject14(RsXCoreInjectionTokens11.IGuidFactory)),
+  _ts_param15(4, Inject14(RsXCoreInjectionTokens11.IIndexValueAccessor)),
+  _ts_param15(5, Inject14(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_metadata15("design:type", Function),
+  _ts_metadata15("design:paramtypes", [
+    typeof IObjectObserverProxyPairManager === "undefined" ? Object : IObjectObserverProxyPairManager,
+    typeof IObjectPropertyObserverManager === "undefined" ? Object : IObjectPropertyObserverManager,
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
+    typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+  ])
+], NonIterableObjectPropertyObserverProxyPairFactory);
+
+// lib/property-observer/factories/non-iterable-object-property/object-property-observer-manager.ts
+import { Inject as Inject15, Injectable as Injectable16, InvalidOperationException as InvalidOperationException2, PropertyDescriptorType, SingletonFactory as SingletonFactory5, Type as Type8 } from "@rs-x/core";
+import { Subject as Subject2 } from "rxjs";
+function _ts_decorate16(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata16(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata16, "_ts_metadata");
+function _ts_param16(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param16, "_ts_param");
+var PropertObserver = class PropertObserver2 extends AbstractObserver {
+  static {
+    __name(this, "PropertObserver");
+  }
+  _proxyRegister;
+  _emitingChange = false;
+  _propertyDescriptorWithTarget;
+  constructor(owner, target, propertyName, initialValue, _proxyRegister) {
+    super(owner, target, initialValue, new Subject2(), propertyName), this._proxyRegister = _proxyRegister;
+    this.patch(propertyName);
+  }
+  disposeInternal() {
+    const propertyName = this.id;
+    const object = Type8.toObject(this.target) ?? {};
+    const value = object[propertyName];
+    delete object[propertyName];
+    Object.defineProperty(this.target, propertyName, Type8.cast(this._propertyDescriptorWithTarget?.descriptor));
+    if (this._propertyDescriptorWithTarget?.type !== PropertyDescriptorType.Function) {
+      object[propertyName] = this._proxyRegister.getProxyTarget(value) ?? value;
+    }
+    this.value = void 0;
+    this._propertyDescriptorWithTarget = void 0;
+  }
+  patch(propertyName) {
+    const descriptorWithTarget = Type8.getPropertyDescriptor(this.target, propertyName);
+    const descriptor = descriptorWithTarget.descriptor;
+    let newDescriptor;
+    if (descriptorWithTarget.type === PropertyDescriptorType.Function) {
+      newDescriptor = this.createFunctionPropertyDescriptor(descriptorWithTarget);
+    } else if (!descriptor.get && !descriptor.set) {
+      newDescriptor = this.createFieldPropertyDescriptor(descriptorWithTarget);
+    } else if (descriptor.set) {
+      newDescriptor = this.createWritablePropertyDescriptor(descriptorWithTarget);
+    } else {
+      throw new InvalidOperationException2(`Property '${propertyName}' can not be watched because it is readonly`);
+    }
+    Object.defineProperty(this.target, propertyName, newDescriptor);
+    this._propertyDescriptorWithTarget = descriptorWithTarget;
+  }
+  createFunctionPropertyDescriptor(descriptorWithTarget) {
+    const newDescriptor = {
+      ...descriptorWithTarget.descriptor
+    };
+    newDescriptor.value = (...args) => {
+      const newValue = descriptorWithTarget.descriptor.value.call(this.target, ...args);
+      if (newValue === void 0 || this.value !== newValue) {
+        this.internalEmitChange({
+          newValue,
+          arguments: args
+        }, this.id);
+      }
+      return newValue;
+    };
+    this.value = void 0;
+    return newDescriptor;
+  }
+  setValue = /* @__PURE__ */ __name((value) => {
+    this.value = value;
+  }, "setValue");
+  internalEmitChange(change, id) {
+    this.value = change.newValue;
+    if (!this._emitingChange) {
+      this._emitingChange = true;
+      super.emitChange({
+        arguments: [],
+        ...change,
+        chain: [
+          {
+            object: this.target,
+            id: this.id
+          }
+        ],
+        target: this.target,
+        id,
+        setValue: this.setValue
+      });
+      this._emitingChange = false;
+    }
+  }
+  createFieldPropertyDescriptor(descriptorWithTarget) {
+    const newDescriptor = {
+      ...descriptorWithTarget.descriptor
+    };
+    newDescriptor.get = () => this.value;
+    delete newDescriptor.writable;
+    delete newDescriptor.value;
+    newDescriptor.set = (value) => {
+      if (value !== this.value) {
+        this.internalEmitChange({
+          newValue: value
+        }, this.id);
+      }
+    };
+    this.value = (Type8.toObject(this.target) ?? {})[this.id];
+    return newDescriptor;
+  }
+  createWritablePropertyDescriptor(descriptorWithTarget) {
+    const newDescriptor = {
+      ...descriptorWithTarget.descriptor
+    };
+    const oldSetter = descriptorWithTarget.descriptor.set;
+    newDescriptor.set = (value) => {
+      const oldValue = (Type8.toObject(this.target) ?? {})[this.id];
+      if (value !== oldValue) {
+        oldSetter.call(this.target, value);
+        this.internalEmitChange({
+          newValue: value
+        }, this.id);
+      }
+    };
+    this.value = (Type8.toObject(this.target) ?? {})[this.id];
+    return newDescriptor;
+  }
+};
+var PropertyObserverManager = class PropertyObserverManager2 extends SingletonFactory5 {
+  static {
+    __name(this, "PropertyObserverManager");
+  }
+  _object;
+  _proxyRegister;
+  releaseObject;
+  constructor(_object, _proxyRegister, releaseObject) {
+    super(), this._object = _object, this._proxyRegister = _proxyRegister, this.releaseObject = releaseObject;
+  }
+  getId(data) {
+    return data.index;
+  }
+  createId(data) {
+    return data.index;
+  }
+  createInstance(data, id) {
+    return new PropertObserver({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    }, this._object, data.index, data.initialValue, this._proxyRegister);
+  }
+  onReleased() {
+    this.releaseObject();
+  }
+  releaseInstance(observer) {
+    observer.dispose();
+  }
+};
+var ObjectPropertyObserverManager = class extends SingletonFactory5 {
+  static {
+    __name(this, "ObjectPropertyObserverManager");
+  }
+  _proxyRegister;
+  constructor(_proxyRegister) {
+    super(), this._proxyRegister = _proxyRegister;
+  }
+  getId(context) {
+    return context;
+  }
+  createId(context) {
+    return context;
+  }
+  createInstance(context) {
+    return new PropertyObserverManager(context, this._proxyRegister, () => this.release(context));
+  }
+  releaseInstance(propertyObserverManager) {
+    propertyObserverManager.dispose();
+  }
+};
+ObjectPropertyObserverManager = _ts_decorate16([
+  Injectable16(),
+  _ts_param16(0, Inject15(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_metadata16("design:type", Function),
+  _ts_metadata16("design:paramtypes", [
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+  ])
+], ObjectPropertyObserverManager);
+
+// lib/property-observer/must-proxify-item-handler.factory.ts
+import { Injectable as Injectable17, SingletonFactory as SingletonFactory6 } from "@rs-x/core";
+function _ts_decorate17(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata17(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata17, "_ts_metadata");
+var MustProxifyItemHandlerFactory = class extends SingletonFactory6 {
+  static {
+    __name(this, "MustProxifyItemHandlerFactory");
+  }
+  constructor() {
+    super();
+  }
+  getId(index) {
+    return index;
+  }
+  createInstance(_, id) {
+    return (index) => index === id;
+  }
+  createId(index) {
+    return index;
+  }
+};
+MustProxifyItemHandlerFactory = _ts_decorate17([
+  Injectable17(),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [])
+], MustProxifyItemHandlerFactory);
+
+// lib/proxies/array-proxy/array-proxy.factory.ts
+import { Inject as Inject16, Injectable as Injectable18, SingletonFactory as SingletonFactory7, Type as Type9 } from "@rs-x/core";
+import { Subject as Subject3 } from "rxjs";
+function _ts_decorate18(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate18, "_ts_decorate");
+function _ts_metadata18(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata18, "_ts_metadata");
+function _ts_param17(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param17, "_ts_param");
+var ArrayProxy = class ArrayProxy2 extends AbstractObserver {
+  static {
+    __name(this, "ArrayProxy");
+  }
+  _proxyRegistry;
+  _patching = false;
+  updateArray;
+  constructor(owner, initialValue, _proxyRegistry) {
+    super(owner, Type9.cast(void 0), initialValue, new Subject3(), void 0), this._proxyRegistry = _proxyRegistry;
+    this.updateArray = {
+      push: this.pushArray,
+      splice: this.spliceArray,
+      pop: this.popArray,
+      shift: this.shiftArray,
+      unshift: this.unshiftArray,
+      reverse: this.reverseArray,
+      sort: this.sortArray,
+      fill: this.fillArray
+    };
+    this.target = new Proxy(initialValue, this);
+    this._proxyRegistry.register(initialValue, this.target);
+  }
+  get(originalArray, property, receiver) {
+    if (this.isUpdateArrayKey(property)) {
+      return (...args) => {
+        return this.updateArray[property](originalArray, ...args);
+      };
+    }
+    return Reflect.get(originalArray, property, receiver);
+  }
+  set(originalArray, property, value, receiver) {
+    if (!this._patching) {
+      if (property === "length") {
+        this.setLength(originalArray, value);
+      } else if (Type9.isPositiveInteger(property)) {
+        const index = Number(property);
+        originalArray[index] = value;
+        this.emitSet(originalArray, index, value);
+      } else {
+        Reflect.set(originalArray, property, value, receiver);
+      }
+    }
+    return true;
+  }
+  disposeInternal() {
+    this._proxyRegistry.unregister(this.value);
+    this.target = Type9.cast(void 0);
+  }
+  isUpdateArrayKey(property) {
+    return typeof property === "string" && property in this.updateArray;
+  }
+  pushArray = /* @__PURE__ */ __name((orginalArray, ...args) => {
+    const startIndex = orginalArray.length;
+    orginalArray.push(...args);
+    this.emitSetForRange(orginalArray, startIndex, args.length);
+    return orginalArray.length;
+  }, "pushArray");
+  spliceArray = /* @__PURE__ */ __name((originalArray, ...args) => {
+    const startIndex = args[0];
+    const itemsToAdd = args.length > 2 ? args.slice(2) : [];
+    const deleteCount = args[1];
+    const before = originalArray.slice();
+    const removed = originalArray.splice(startIndex, deleteCount, ...itemsToAdd);
+    const after = originalArray;
+    const maxLength = Math.max(before.length, after.length);
+    for (let i = startIndex; i < maxLength; i++) {
+      if (before[i] !== after[i]) {
+        this.emitSet(originalArray, i, after[i]);
+      }
+    }
+    return removed;
+  }, "spliceArray");
+  popArray = /* @__PURE__ */ __name((orginalArray) => {
+    const index = orginalArray.length - 1;
+    const removedItem = orginalArray.pop();
+    this.emitSet(orginalArray, index);
+    return removedItem;
+  }, "popArray");
+  shiftArray = /* @__PURE__ */ __name((orginalArray) => {
+    const oldLength = orginalArray.length;
+    const result = orginalArray.shift();
+    this.emitSetForRange(orginalArray, 0, orginalArray.length);
+    this.emitSet(orginalArray, oldLength - 1);
+    return result;
+  }, "shiftArray");
+  unshiftArray = /* @__PURE__ */ __name((orginalArray, ...args) => {
+    orginalArray.unshift(...args);
+    this.emitSetForRange(orginalArray, 0, orginalArray.length);
+    return orginalArray.length;
+  }, "unshiftArray");
+  reverseArray = /* @__PURE__ */ __name((orginalArray) => {
+    const result = orginalArray.reverse();
+    this.emitSetForRange(orginalArray, 0, orginalArray.length);
+    return result;
+  }, "reverseArray");
+  sortArray = /* @__PURE__ */ __name((orginalArray, ...args) => {
+    const result = orginalArray.sort(args[0]);
+    this.emitSetForRange(orginalArray, 0, orginalArray.length);
+    return result;
+  }, "sortArray");
+  fillArray = /* @__PURE__ */ __name((orginalArray, ...args) => {
+    const start = args[1] ?? 0;
+    const end = args[2] ?? orginalArray.length;
+    for (let i = start; i < end; i++) {
+      orginalArray[i] = structuredClone(args[0]);
+      this.emitSet(orginalArray, i, orginalArray[i]);
+    }
+    return orginalArray;
+  }, "fillArray");
+  setLength(array, length) {
+    if (length < array.length) {
+      this.updateArray.splice(array, length, array.length - length);
+    } else {
+      array.length = length;
+    }
+  }
+  emitSet(originaArray, index, value) {
+    this.emitChange({
+      arguments: [],
+      chain: [
+        {
+          object: originaArray,
+          id: index
+        }
+      ],
+      id: index,
+      target: originaArray,
+      newValue: value
+    });
+  }
+  emitSetForRange(originaArray, startIndex, length) {
+    const endIndex = startIndex + length;
+    for (let i = startIndex; i < endIndex; i++) {
+      this.emitSet(originaArray, i, originaArray[i]);
+    }
+  }
+};
+var ArrayProxyFactory = class extends SingletonFactory7 {
+  static {
+    __name(this, "ArrayProxyFactory");
+  }
+  _proxyRegistry;
+  constructor(_proxyRegistry) {
+    super(), this._proxyRegistry = _proxyRegistry;
+  }
+  getId(data) {
+    return data.array;
+  }
+  createId(data) {
+    return data.array;
+  }
+  createInstance(data, id) {
+    const observer = new ArrayProxy({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => {
+        this.release(id);
+        data.owner?.release();
+      }, "release")
+    }, data.array, this._proxyRegistry);
+    return {
+      observer,
+      proxy: observer.target,
+      proxyTarget: data.array
+    };
+  }
+  releaseInstance(arrayObserverWithProxy, id) {
+    super.releaseInstance(arrayObserverWithProxy, id);
+    arrayObserverWithProxy.observer.dispose();
+  }
+};
+ArrayProxyFactory = _ts_decorate18([
+  Injectable18(),
+  _ts_param17(0, Inject16(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_metadata18("design:type", Function),
+  _ts_metadata18("design:paramtypes", [
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+  ])
+], ArrayProxyFactory);
+
+// lib/proxies/date-proxy/date-proxy.factory.ts
+import { Inject as Inject17, Injectable as Injectable19, RsXCoreInjectionTokens as RsXCoreInjectionTokens12, SingletonFactoryWithGuid as SingletonFactoryWithGuid4, Type as Type10 } from "@rs-x/core";
+import { Subject as Subject4 } from "rxjs";
+function _ts_decorate19(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate19, "_ts_decorate");
+function _ts_metadata19(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata19, "_ts_metadata");
+function _ts_param18(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param18, "_ts_param");
+var DateProxy = class DateProxy2 extends AbstractObserver {
+  static {
+    __name(this, "DateProxy");
+  }
+  _proxyRegistry;
+  _filter;
+  _dateSetterMetadata = /* @__PURE__ */ new Map([
+    [
+      "setFullYear",
+      {
+        name: "year",
+        getterName: "getFullYear",
+        setterName: "setFullYear"
+      }
+    ],
+    [
+      "setUTCFullYear",
+      {
+        name: "utcYear",
+        getterName: "getUTCFullYear",
+        setterName: "setUTCFullYear"
+      }
+    ],
+    [
+      "setMonth",
+      {
+        name: "month",
+        getterName: "getMonth",
+        setterName: "setMonth"
+      }
+    ],
+    [
+      "setUTCMonth",
+      {
+        name: "utcMonth",
+        getterName: "getUTCMonth",
+        setterName: "setUTCMonth"
+      }
+    ],
+    [
+      "setDate",
+      {
+        name: "date",
+        getterName: "getDate",
+        setterName: "setDate"
+      }
+    ],
+    [
+      "setUTCDate",
+      {
+        name: "utcDate",
+        getterName: "getUTCDate",
+        setterName: "setUTCDate"
+      }
+    ],
+    [
+      "setHours",
+      {
+        name: "hours",
+        getterName: "getHours",
+        setterName: "setHours"
+      }
+    ],
+    [
+      "setUTCHours",
+      {
+        name: "utcHours",
+        getterName: "getUTCHours",
+        setterName: "setUTCHours"
+      }
+    ],
+    [
+      "setMinutes",
+      {
+        name: "minutes",
+        getterName: "getMinutes",
+        setterName: "setMinutes"
+      }
+    ],
+    [
+      "setUTCMinutes",
+      {
+        name: "utcMinutes",
+        getterName: "getUTCMinutes",
+        setterName: "setUTCMinutes"
+      }
+    ],
+    [
+      "setSeconds",
+      {
+        name: "seconds",
+        getterName: "getSeconds",
+        setterName: "setSeconds"
+      }
+    ],
+    [
+      "setUTCSeconds",
+      {
+        name: "utcSeconds",
+        getterName: "getUTCSeconds",
+        setterName: "setUTCSeconds"
+      }
+    ],
+    [
+      "setMilliseconds",
+      {
+        name: "milliseconds",
+        getterName: "getMilliseconds",
+        setterName: "setMilliseconds"
+      }
+    ],
+    [
+      "setUTCMilliseconds",
+      {
+        name: "utcMilliseconds",
+        getterName: "getUTCMilliseconds",
+        setterName: "setUTCMilliseconds"
+      }
+    ],
+    [
+      "setTime",
+      {
+        name: "time",
+        getterName: "getTime",
+        setterName: "setTime"
+      }
+    ]
+  ]);
+  constructor(owner, initialValue, _proxyRegistry, _filter) {
+    super(owner, Type10.cast(void 0), initialValue, new Subject4(), void 0), this._proxyRegistry = _proxyRegistry, this._filter = _filter;
+    this.target = new Proxy(initialValue, this);
+    this._proxyRegistry.register(initialValue, this.target);
+  }
+  get(target, property, receiver) {
+    const value = Reflect.get(target, property, receiver);
+    if (typeof property === "string") {
+      const setterMetadata = this._dateSetterMetadata.get(property);
+      if (!setterMetadata) {
+        return typeof value === "function" ? value.bind(target) : value;
+      }
+      return (...args) => {
+        const oldTimeStamp = target.getTime();
+        const setter = value;
+        const result = setter.apply(target, args);
+        if (oldTimeStamp !== target.getTime()) {
+          this.emitChanges(oldTimeStamp, target, setterMetadata.name);
+        }
+        return result;
+      };
+    }
+    return value;
+  }
+  emitChanges(oldTimestamp, newDate, propertyName) {
+    const oldDate = new Date(oldTimestamp);
+    if (!this._filter) {
+      this.emitChange({
+        arguments: [],
+        chain: [
+          {
+            object: newDate,
+            id: propertyName
+          }
+        ],
+        id: propertyName,
+        target: newDate,
+        newValue: newDate
+      });
+      return;
+    }
+    for (const setterMetaData of this._dateSetterMetadata.values()) {
+      if (!this._filter(setterMetaData.name)) {
+        continue;
+      }
+      const oldValue = oldDate[setterMetaData.getterName].call(oldDate);
+      const newValue = newDate[setterMetaData.getterName].call(newDate);
+      if (oldValue !== newValue) {
+        this.emitChange({
+          arguments: [],
+          chain: [
+            {
+              object: newDate,
+              id: setterMetaData.name
+            }
+          ],
+          id: setterMetaData.name,
+          target: newDate,
+          newValue
+        });
+      }
+    }
+  }
+  set(target, property, value, receiver) {
+    const oldTimeStamp = target.getTime();
+    const result = Reflect.set(target, property, value, receiver);
+    if (oldTimeStamp !== target.getTime()) {
+      this.emitChange({
+        arguments: [
+          value
+        ],
+        chain: [
+          {
+            object: target,
+            id: 0
+          }
+        ],
+        id: 0,
+        target,
+        newValue: target
+      });
+    }
+    return result;
+  }
+  disposeInternal() {
+    this._proxyRegistry.unregister(this.value);
+    this.target = Type10.cast(void 0);
+  }
+};
+var DateProxyFactory = class extends SingletonFactoryWithGuid4 {
+  static {
+    __name(this, "DateProxyFactory");
+  }
+  _proxyRegistry;
+  constructor(guidFactory, _proxyRegistry) {
+    super(guidFactory), this._proxyRegistry = _proxyRegistry;
+  }
+  getGroupId(data) {
+    return data.date;
+  }
+  getGroupMemberId(data) {
+    return data.mustProxify;
+  }
+  createInstance(dateProxyData, id) {
+    const observer = new DateProxy({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => {
+        this.release(id);
+        dateProxyData.owner?.release();
+      }, "release")
+    }, dateProxyData.date, this._proxyRegistry, dateProxyData.mustProxify);
+    return {
+      observer,
+      proxy: observer.target,
+      proxyTarget: dateProxyData.date
+    };
+  }
+};
+DateProxyFactory = _ts_decorate19([
+  Injectable19(),
+  _ts_param18(0, Inject17(RsXCoreInjectionTokens12.IGuidFactory)),
+  _ts_param18(1, Inject17(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_metadata19("design:type", Function),
+  _ts_metadata19("design:paramtypes", [
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+  ])
+], DateProxyFactory);
+
+// lib/proxies/map-proxy/map-proxy.factory.ts
+import { Inject as Inject18, Injectable as Injectable20, SingletonFactory as SingletonFactory8, Type as Type11 } from "@rs-x/core";
+function _ts_decorate20(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate20, "_ts_decorate");
+function _ts_metadata20(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata20, "_ts_metadata");
+function _ts_param19(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param19, "_ts_param");
+var MapProxy = class extends AbstractObserver {
+  static {
+    __name(this, "MapProxy");
+  }
+  _proxyRegistry;
+  updateMap;
+  constructor(owner, map, _proxyRegistry) {
+    super(owner, Type11.cast(void 0), map), this._proxyRegistry = _proxyRegistry;
+    this.updateMap = {
+      clear: this.clearMap,
+      set: this.setMap,
+      delete: this.deleteMap
+    };
+    this.target = new Proxy(map, this);
+    this._proxyRegistry.register(map, this.target);
+  }
+  get(originalMap, property) {
+    if (this.isUpdateMapKey(property)) {
+      return (...args) => {
+        return this.updateMap[property](originalMap, ...args);
+      };
+    }
+    if (property === "get") {
+      return (key) => originalMap.get(key);
+    }
+    const mapAny = originalMap;
+    return typeof mapAny[property] === "function" ? mapAny[property].bind(originalMap) : mapAny[property];
+  }
+  disposeInternal() {
+    this._proxyRegistry.unregister(this.value);
+    ;
+  }
+  isUpdateMapKey(property) {
+    return typeof property === "string" && property in this.updateMap;
+  }
+  clearMap = /* @__PURE__ */ __name((originalMap) => {
+    for (const key of originalMap.keys()) {
+      this.deleteItem(originalMap, key);
+    }
+  }, "clearMap");
+  setMap = /* @__PURE__ */ __name((originalMap, ...args) => {
+    const key = args[0];
+    const value = args[1];
+    originalMap.set(key, value);
+    this.emitSet(originalMap, key, value);
+    return this.target;
+  }, "setMap");
+  deleteMap = /* @__PURE__ */ __name((originalMap, ...args) => {
+    return this.deleteItem(originalMap, args[0]);
+  }, "deleteMap");
+  deleteItem(originalMap, key) {
+    const item = originalMap.get(key);
+    if (item === void 0) {
+      return false;
+    }
+    originalMap.delete(key);
+    this.emitSet(originalMap, key);
+    return true;
+  }
+  emitSet(originalMap, key, value) {
+    this.emitChange({
+      arguments: [],
+      chain: [
+        {
+          object: originalMap,
+          id: key
+        }
+      ],
+      id: key,
+      target: originalMap,
+      newValue: value
+    });
+  }
+};
+var MapProxyFactory = class extends SingletonFactory8 {
+  static {
+    __name(this, "MapProxyFactory");
+  }
+  _proxyRegistry;
+  constructor(_proxyRegistry) {
+    super(), this._proxyRegistry = _proxyRegistry;
+  }
+  getId(data) {
+    return data.map;
+  }
+  createId(data) {
+    return data.map;
+  }
+  createInstance(data, id) {
+    const observer = new MapProxy({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => {
+        this.release(id);
+        data.owner?.release();
+      }, "release")
+    }, data.map, this._proxyRegistry);
+    return {
+      observer,
+      proxy: observer.target,
+      proxyTarget: data.map
+    };
+  }
+  releaseInstance(mapObserverWithProxy) {
+    mapObserverWithProxy.observer.dispose();
+  }
+};
+MapProxyFactory = _ts_decorate20([
+  Injectable20(),
+  _ts_param19(0, Inject18(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+  ])
+], MapProxyFactory);
+
+// lib/proxies/observable-proxy/observable-proxy.factory.ts
+import { Inject as Inject19, Injectable as Injectable21, RsXCoreInjectionTokens as RsXCoreInjectionTokens13, SingletonFactory as SingletonFactory9 } from "@rs-x/core";
+import { ReplaySubject as ReplaySubject2 } from "rxjs";
+function _ts_decorate21(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate21, "_ts_decorate");
+function _ts_metadata21(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata21, "_ts_metadata");
+function _ts_param20(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param20, "_ts_param");
+var ObservableProxy = class ObservableProxy2 extends AbstractObserver {
+  static {
+    __name(this, "ObservableProxy");
+  }
+  _observableAccessor;
+  _observableSubscription;
+  _oldValue;
+  constructor(owner, target, _observableAccessor) {
+    super(owner, target, void 0, new ReplaySubject2(1)), this._observableAccessor = _observableAccessor;
+  }
+  init() {
+    if (this._observableSubscription) {
+      return;
+    }
+    this._observableSubscription = this.target.subscribe(this.emitObservableChange);
+  }
+  disposeInternal() {
+    this._observableSubscription?.unsubscribe();
+    this._observableAccessor.clearLastValue(this.target);
+    this._observableSubscription = void 0;
+    this._oldValue = null;
+  }
+  emitObservableChange = /* @__PURE__ */ __name((newValue) => {
+    if (newValue === this._oldValue || this.isDisposed) {
+      return;
+    }
+    this._oldValue = newValue;
+    this._observableAccessor.setLastValue(this.target, newValue);
+    this.emitChange({
+      arguments: [],
+      chain: [],
+      target: this.target,
+      id: this.id,
+      newValue
+    });
+  }, "emitObservableChange");
+};
+var ObservableProxyFactory = class extends SingletonFactory9 {
+  static {
+    __name(this, "ObservableProxyFactory");
+  }
+  _observableAccessor;
+  constructor(_observableAccessor) {
+    super(), this._observableAccessor = _observableAccessor;
+  }
+  getId(data) {
+    return data.observable;
+  }
+  createId(data) {
+    return data.observable;
+  }
+  createInstance(data, id) {
+    const observer = new ObservableProxy({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => {
+        this.release(id);
+        data.owner?.release();
+      }, "release")
+    }, data.observable, this._observableAccessor);
+    return {
+      observer,
+      proxy: void 0,
+      proxyTarget: data.observable
+    };
+  }
+  releaseInstance(observableObserverWithProxy) {
+    observableObserverWithProxy.observer.dispose();
+  }
+};
+ObservableProxyFactory = _ts_decorate21([
+  Injectable21(),
+  _ts_param20(0, Inject19(RsXCoreInjectionTokens13.IObservableAccessor)),
+  _ts_metadata21("design:type", Function),
+  _ts_metadata21("design:paramtypes", [
+    typeof IObservableAccessor === "undefined" ? Object : IObservableAccessor
+  ])
+], ObservableProxyFactory);
+
+// lib/proxies/promise-proxy/promise-proxy.factory.ts
+import { Inject as Inject20, Injectable as Injectable22, RsXCoreInjectionTokens as RsXCoreInjectionTokens14, SingletonFactory as SingletonFactory10 } from "@rs-x/core";
+import { ReplaySubject as ReplaySubject3 } from "rxjs";
+function _ts_decorate22(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate22, "_ts_decorate");
+function _ts_metadata22(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata22, "_ts_metadata");
+function _ts_param21(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param21, "_ts_param");
+var PromiseObserver = class PromiseObserver2 extends AbstractObserver {
+  static {
+    __name(this, "PromiseObserver");
+  }
+  _promiseAccessor;
+  constructor(owner, target, _promiseAccessor) {
+    super(owner, target, void 0, new ReplaySubject3(1)), this._promiseAccessor = _promiseAccessor;
+    target.then(this.onValueResolved);
+  }
+  disposeInternal() {
+    this._promiseAccessor.clearLastValue(this.target);
+  }
+  onValueResolved = /* @__PURE__ */ __name((newValue) => {
+    if (this.isDisposed) {
+      return;
+    }
+    this._promiseAccessor.setLastValue(this.target, newValue);
+    this.emitChange({
+      arguments: [],
+      chain: [],
+      target: this.target,
+      newValue
+    });
+  }, "onValueResolved");
+};
+var PromiseProxyFactory = class extends SingletonFactory10 {
+  static {
+    __name(this, "PromiseProxyFactory");
+  }
+  _promiseAccessor;
+  constructor(_promiseAccessor) {
+    super(), this._promiseAccessor = _promiseAccessor;
+  }
+  getId(data) {
+    return data.promise;
+  }
+  createId(data) {
+    return data.promise;
+  }
+  createInstance(data, id) {
+    const observer = new PromiseObserver({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => {
+        this.release(id);
+        data.owner?.release();
+      }, "release")
+    }, data.promise, this._promiseAccessor);
+    return {
+      observer,
+      proxy: void 0,
+      proxyTarget: data.promise
+    };
+  }
+  releaseInstance(promiseObserverWithProxy) {
+    promiseObserverWithProxy.observer.dispose();
+  }
+};
+PromiseProxyFactory = _ts_decorate22([
+  Injectable22(),
+  _ts_param21(0, Inject20(RsXCoreInjectionTokens14.IPromiseAccessor)),
+  _ts_metadata22("design:type", Function),
+  _ts_metadata22("design:paramtypes", [
+    typeof IPromiseAccessor === "undefined" ? Object : IPromiseAccessor
+  ])
+], PromiseProxyFactory);
+
+// lib/proxies/proxy-registry/proxy-registry.ts
+import { Injectable as Injectable23 } from "@rs-x/core";
+function _ts_decorate23(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate23, "_ts_decorate");
+var ProxyRegistry = class {
+  static {
+    __name(this, "ProxyRegistry");
+  }
+  _proxies = /* @__PURE__ */ new Map();
+  getProxyTarget(proxyToFind) {
+    return Array.from(this._proxies.entries()).find(([_, proxy]) => proxy === proxyToFind)?.[0];
+  }
+  getProxy(proxyTarget) {
+    return this._proxies.get(proxyTarget);
+  }
+  register(proxyTarget, proxy) {
+    this._proxies.set(proxyTarget, proxy);
+  }
+  unregister(proxyTarget) {
+    this._proxies.delete(proxyTarget);
+  }
+  isProxy(object) {
+    return !!this.getProxyTarget(object);
+  }
+};
+ProxyRegistry = _ts_decorate23([
+  Injectable23()
+], ProxyRegistry);
+
+// lib/proxies/set-proxy/set-proxy.factory.ts
+import { Inject as Inject21, Injectable as Injectable24, SingletonFactory as SingletonFactory11, Type as Type12 } from "@rs-x/core";
+function _ts_decorate24(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate24, "_ts_decorate");
+function _ts_metadata23(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata23, "_ts_metadata");
+function _ts_param22(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param22, "_ts_param");
+var SetProxy = class extends AbstractObserver {
+  static {
+    __name(this, "SetProxy");
+  }
+  _proxyRegistry;
+  updateSet;
+  constructor(owner, initialValue, _proxyRegistry) {
+    super(owner, Type12.cast(void 0), initialValue), this._proxyRegistry = _proxyRegistry;
+    this.updateSet = {
+      clear: this.clearSet,
+      add: this.addSet,
+      delete: this.deleteSet,
+      has: this.hasSet
+    };
+    this.target = new Proxy(initialValue, this);
+    this._proxyRegistry.register(initialValue, this.target);
+  }
+  get(originalSet, property) {
+    const target = originalSet;
+    if (property !== "constructor" && property in this.updateSet) {
+      return (...args) => this.updateSet[property](originalSet, ...args);
+    }
+    const value = target[property];
+    return typeof value === "function" ? value.bind(originalSet) : value;
+  }
+  disposeInternal() {
+    this._proxyRegistry.unregister(this.value);
+  }
+  clearSet = /* @__PURE__ */ __name((originalSet) => {
+    for (const value of originalSet.values()) {
+      this.deleteSet(originalSet, value);
+    }
+  }, "clearSet");
+  addSet = /* @__PURE__ */ __name((originalSet, ...args) => {
+    originalSet.add(args[0]);
+    this.emitValueChange(originalSet, args[0], args[0]);
+    return this.target;
+  }, "addSet");
+  deleteSet = /* @__PURE__ */ __name((originalSet, ...args) => {
+    const result = originalSet.delete(args[0]);
+    this.emitValueChange(originalSet, args[0], void 0);
+    return result;
+  }, "deleteSet");
+  hasSet = /* @__PURE__ */ __name((originalSet, ...args) => {
+    return originalSet.has(args[0]);
+  }, "hasSet");
+  emitValueChange(originalSet, id, value) {
+    this.emitChange({
+      arguments: [],
+      chain: [
+        {
+          object: originalSet,
+          id
+        }
+      ],
+      id,
+      target: originalSet,
+      newValue: value
+    });
+  }
+};
+var SetProxyFactory = class extends SingletonFactory11 {
+  static {
+    __name(this, "SetProxyFactory");
+  }
+  _proxyRegistry;
+  constructor(_proxyRegistry) {
+    super(), this._proxyRegistry = _proxyRegistry;
+  }
+  getId(data) {
+    return data.set;
+  }
+  createId(data) {
+    return data.set;
+  }
+  createInstance(data, id) {
+    const observer = new SetProxy({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => {
+        this.release(id);
+        data.owner?.release();
+      }, "release")
+    }, data.set, this._proxyRegistry);
+    return {
+      observer,
+      proxy: observer.target,
+      proxyTarget: data.set
+    };
+  }
+  releaseInstance(setObserverWithProxy) {
+    setObserverWithProxy.observer.dispose();
+  }
+};
+SetProxyFactory = _ts_decorate24([
+  Injectable24(),
+  _ts_param22(0, Inject21(RsXStateManagerInjectionTokens.IProxyRegistry)),
+  _ts_metadata23("design:type", Function),
+  _ts_metadata23("design:paramtypes", [
+    typeof IProxyRegistry === "undefined" ? Object : IProxyRegistry
+  ])
+], SetProxyFactory);
+
+// lib/rs-x-state-manager.module.ts
+import { ContainerModule, InjectionContainer, registerMultiInjectServices, RsXCoreModule } from "@rs-x/core";
+
+// lib/state-manager/object-state-manager.ts
+import { Inject as Inject22, Injectable as Injectable25, RsXCoreInjectionTokens as RsXCoreInjectionTokens15, SingletonFactory as SingletonFactory12, UnsupportedException as UnsupportedException2 } from "@rs-x/core";
+function _ts_decorate25(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate25, "_ts_decorate");
+function _ts_metadata24(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata24, "_ts_metadata");
+function _ts_param23(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param23, "_ts_param");
+var StateForObjectManager = class extends SingletonFactory12 {
+  static {
+    __name(this, "StateForObjectManager");
+  }
+  _deepClone;
+  releaseContext;
+  constructor(_deepClone, releaseContext) {
+    super(), this._deepClone = _deepClone, this.releaseContext = releaseContext;
+  }
+  getId(data) {
+    return data.key;
+  }
+  set(key, value, watched) {
+    const state = this.getFromId(key);
+    if (state) {
+      state.valueCopy = this.deepClone(key, value);
+      state.value = value;
+    } else {
+      this.create({
+        key,
+        value,
+        watched
+      });
+    }
+  }
+  createId(data) {
+    return data.key;
+  }
+  deepClone(key, data) {
+    try {
+      return this._deepClone.clone(data);
+    } catch (e) {
+      throw new UnsupportedException2(`Failed to clone state for key '${key}'. Error: ${e}. If the object type is not supported, you can provide your own implementation of IDeepClone.`);
+    }
+  }
+  createInstance(data) {
+    return {
+      value: data.value,
+      valueCopy: this.deepClone(data.key, data.value),
+      watched: data.watched
+    };
+  }
+  onReleased() {
+    this.releaseContext();
+  }
+};
+var ObjectStateManager = class extends SingletonFactory12 {
+  static {
+    __name(this, "ObjectStateManager");
+  }
+  _deepClone;
+  constructor(_deepClone) {
+    super(), this._deepClone = _deepClone;
+  }
+  getId(object) {
+    return object;
+  }
+  isRegistered(context, key) {
+    return !!this.getFromId(context)?.has(key);
+  }
+  replaceState(key, newContext, newValue, oldContext, watched) {
+    let stateForObjectManagerForNewContext;
+    const stateForObjectManagerForOldContext = this.getFromId(oldContext);
+    if (newValue === void 0) {
+      stateForObjectManagerForOldContext?.release(key);
+      return;
+    }
+    if (newContext !== oldContext) {
+      stateForObjectManagerForOldContext?.release(key);
+      stateForObjectManagerForNewContext = this.getFromId(newContext);
+    } else {
+      stateForObjectManagerForNewContext = stateForObjectManagerForOldContext;
+    }
+    if (stateForObjectManagerForNewContext) {
+      stateForObjectManagerForNewContext.set(key, newValue, watched);
+    } else if (newValue !== void 0) {
+      this.create(newContext).instance.create({
+        key,
+        value: newValue,
+        watched
+      });
+    }
+  }
+  createId(object) {
+    return object;
+  }
+  createInstance(context) {
+    return new StateForObjectManager(this._deepClone, () => this.release(context));
+  }
+};
+ObjectStateManager = _ts_decorate25([
+  Injectable25(),
+  _ts_param23(0, Inject22(RsXCoreInjectionTokens15.IDeepClone)),
+  _ts_metadata24("design:type", Function),
+  _ts_metadata24("design:paramtypes", [
+    typeof IDeepClone === "undefined" ? Object : IDeepClone
+  ])
+], ObjectStateManager);
+
+// lib/state-manager/state-manager.ts
+import { Inject as Inject23, Injectable as Injectable26, PENDING, RsXCoreInjectionTokens as RsXCoreInjectionTokens16 } from "@rs-x/core";
+import { Subject as Subject5 } from "rxjs";
+
+// lib/state-manager/state-change-subscription-manager/state-change-subsription-manager.ts
+import { SingletonFactory as SingletonFactory13 } from "@rs-x/core";
+var StateChangeSubscriptionsForContextManager = class StateChangeSubscriptionsForContextManager2 extends GroupedChangeSubscriptionsForContextManager {
+  static {
+    __name(this, "StateChangeSubscriptionsForContextManager");
+  }
+  _objectObserverManager;
+  constructor(context, releaseContext, _objectObserverManager, errorLog, guidFactory) {
+    super(context, releaseContext, errorLog, guidFactory), this._objectObserverManager = _objectObserverManager;
+  }
+  getGroupId(data) {
+    return data.key;
+  }
+  getGroupMemberId(data) {
+    return data.mustProxify;
+  }
+  createObserver(context, data, id) {
+    const objectObserver = this._objectObserverManager.create(context).instance;
+    const observer = objectObserver.create({
+      key: data.key,
+      initializeManually: true,
+      mustProxify: data.mustProxify,
+      owner: {
+        release: /* @__PURE__ */ __name(() => this.release(id), "release")
+      }
+    }).instance.observer;
+    return {
+      observer,
+      subscriptionData: void 0
+    };
+  }
+};
+var StateChangeSubscriptionManager = class extends SingletonFactory13 {
+  static {
+    __name(this, "StateChangeSubscriptionManager");
+  }
+  _objectObserverManager;
+  _errorLog;
+  _guidFactory;
+  constructor(_objectObserverManager, _errorLog, _guidFactory) {
+    super(), this._objectObserverManager = _objectObserverManager, this._errorLog = _errorLog, this._guidFactory = _guidFactory;
+  }
+  getId(context) {
+    return context;
+  }
+  isRegistered(context, key) {
+    const stateChangeSubscriptionsForContextManager = this.getFromId(context);
+    if (!stateChangeSubscriptionsForContextManager) {
+      return false;
+    }
+    return stateChangeSubscriptionsForContextManager.isGroupRegistered(key);
+  }
+  createId(context) {
+    return context;
+  }
+  createInstance(context, id) {
+    return new StateChangeSubscriptionsForContextManager(context, () => this.release(id), this._objectObserverManager, this._errorLog, this._guidFactory);
+  }
+  releaseInstance(instance, id) {
+    super.releaseInstance(instance, id);
+    instance.dispose();
+  }
+};
+
+// lib/state-manager/state-manager.ts
+function _ts_decorate26(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate26, "_ts_decorate");
+function _ts_metadata25(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata25, "_ts_metadata");
+function _ts_param24(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param24, "_ts_param");
+var StateManager = class {
+  static {
+    __name(this, "StateManager");
+  }
+  _objectStateManager;
+  _indexValueAccessor;
+  _equalityService;
+  _changed = new Subject5();
+  _contextChanged = new Subject5();
+  _startChangeCycle = new Subject5();
+  _endChangeCycle = new Subject5();
+  _stateChangeSubscriptionManager;
+  _pending = /* @__PURE__ */ new Map();
+  constructor(objectObserverManager, _objectStateManager, errorLog, guidFactory, _indexValueAccessor, _equalityService) {
+    this._objectStateManager = _objectStateManager;
+    this._indexValueAccessor = _indexValueAccessor;
+    this._equalityService = _equalityService;
+    this._stateChangeSubscriptionManager = new StateChangeSubscriptionManager(objectObserverManager, errorLog, guidFactory);
+  }
+  get changed() {
+    return this._changed;
+  }
+  get contextChanged() {
+    return this._contextChanged;
+  }
+  get startChangeCycle() {
+    return this._startChangeCycle;
+  }
+  get endChangeCycle() {
+    return this._endChangeCycle;
+  }
+  toString() {
+    return this._objectStateManager.toString();
+  }
+  isWatched(context, index, mustProxify) {
+    const stateChangeSubscriptionsForContextManager = this._stateChangeSubscriptionManager.getFromId(context);
+    if (!stateChangeSubscriptionsForContextManager) {
+      return false;
+    }
+    const id = stateChangeSubscriptionsForContextManager.getId({
+      key: index,
+      mustProxify
+    });
+    return id ? stateChangeSubscriptionsForContextManager.has(id) : false;
+  }
+  watchState(context, index, mustProxify) {
+    if (!this.isWatched(context, index, mustProxify)) {
+      const value = this.getState(context, index);
+      this.tryToSubscribeToChange(context, index, mustProxify);
+      return value;
+    } else {
+      return this.increaseStateReferenceCount(context, index, true);
+    }
+  }
+  releaseState(context, index, mustProxify) {
+    if (!this._objectStateManager.getFromId(context)?.has(index)) {
+      return;
+    }
+    this.internalUnregister(context, index, mustProxify);
+  }
+  clear() {
+    this._stateChangeSubscriptionManager.dispose();
+    this._objectStateManager.dispose();
+  }
+  getState(context, index) {
+    return this._objectStateManager.getFromId(context)?.getFromId(index)?.value;
+  }
+  setState(context, index, value) {
+    this.internalSetState(context, index, value, {
+      context,
+      value: this.getState(context, index)
+    });
+  }
+  internalSetState(context, index, value, transferValue) {
+    this.tryRebindingNestedState(value, transferValue.value);
+    this._objectStateManager.replaceState(index, context, value, transferValue.context, false);
+    this.emitChange(context, index, value, transferValue.value, transferValue.context);
+  }
+  getOldValue(context, index) {
+    return this._objectStateManager.getFromId(context)?.getFromId(index)?.valueCopy;
+  }
+  unnsubscribeToObserverEvents(context, index, mustProxify) {
+    const subscriptionsForKey = this._stateChangeSubscriptionManager.getFromId(context);
+    const observer = subscriptionsForKey?.getFromData({
+      key: index,
+      mustProxify
+    });
+    if (!observer) {
+      return;
+    }
+    observer.dispose();
+  }
+  internalUnregister(context, index, mustProxify) {
+    if (this.canReleaseState(context, index)) {
+      this.unnsubscribeToObserverEvents(context, index, mustProxify);
+    }
+  }
+  emitChange(context, index, newValue, oldValue, oldContext) {
+    if (this._equalityService.isEqual(newValue, oldValue)) {
+      return;
+    }
+    this._changed.next({
+      oldContext: oldContext ?? context,
+      context,
+      key: index,
+      oldValue,
+      newValue
+    });
+  }
+  updateState(newContext, oldContext, index, newValue, watched) {
+    this._objectStateManager.replaceState(index, newContext, newValue, oldContext, watched);
+  }
+  canReleaseState(context, key) {
+    return this._objectStateManager.getFromId(context)?.release(key).referenceCount === 0;
+  }
+  increaseStateReferenceCount(context, index, watched) {
+    const state = this.getState(context, index);
+    this._objectStateManager.create(context).instance.create({
+      value: state,
+      key: index,
+      watched
+    });
+    return state;
+  }
+  tryToSubscribeToChange(context, index, mustProxify, transferedValue) {
+    this._stateChangeSubscriptionManager.create(context).instance.create({
+      key: index,
+      mustProxify,
+      onChanged: /* @__PURE__ */ __name((change) => this.onChange(change, mustProxify, true), "onChanged"),
+      init: /* @__PURE__ */ __name((observer) => {
+        if (observer.value !== void 0) {
+          this.setInitialValue(context, index, observer.value, transferedValue, true);
+        }
+        observer.init();
+      }, "init")
+    });
+  }
+  getValue(context, key) {
+    try {
+      return this._indexValueAccessor.getResolvedValue(context, key);
+    } catch {
+      return this.getState(context, key);
+    }
+  }
+  getStateChanges(oldContext, newContext) {
+    const oldState = this._objectStateManager.getFromId(oldContext);
+    if (!oldState) {
+      return [];
+    }
+    return Array.from(oldState.ids()).map((id) => {
+      const { value: oldValue, watched } = oldState.getFromId(id) ?? {};
+      const newValue = this.getValue(newContext, id);
+      if (oldContext === newContext && this._equalityService.isEqual(oldValue, newValue)) {
+        return [];
+      }
+      let pendingId = null;
+      if (newValue === PENDING) {
+        this._pending.set(newContext, oldValue);
+      }
+      const stateInfo = {
+        oldContext,
+        context: newContext,
+        key: id,
+        oldValue,
+        newValue: pendingId ?? newValue,
+        watched
+      };
+      return newValue === PENDING ? [
+        stateInfo
+      ] : [
+        stateInfo,
+        ...this.getStateChanges(oldValue, newValue)
+      ];
+    }).reduce((a, b) => a.concat(b), []);
+  }
+  tryRebindingNestedState(newValue, oldValue, mustProxify) {
+    const stateChanges = this.getStateChanges(oldValue, newValue);
+    stateChanges.forEach((stateChange) => {
+      this.internalUnregister(stateChange.oldContext, stateChange.key, mustProxify);
+    });
+    stateChanges.filter((stateChange) => stateChange.context !== stateChange.oldContext).forEach((stateChange) => this._contextChanged.next({
+      context: stateChange.context,
+      oldContext: stateChange.oldContext,
+      key: stateChange.key
+    }));
+    stateChanges.filter((stateChange) => stateChange.watched).forEach((stateChange) => this.tryToSubscribeToChange(stateChange.context, stateChange.key, mustProxify, {
+      context: stateChange.oldContext,
+      value: stateChange.oldValue
+    }));
+    stateChanges.filter((stateChange) => !stateChange.watched).forEach((stateChange) => this.internalSetState(stateChange.context, stateChange.key, stateChange.newValue, {
+      context: stateChange.oldContext,
+      value: stateChange.oldValue
+    }));
+  }
+  setInitialValue(context, index, initialValue, transferedValue, watched) {
+    this.updateState(context, transferedValue?.context ?? context, index, initialValue, watched);
+    this.emitChange(context, index, initialValue, transferedValue?.value, transferedValue?.context);
+  }
+  getChainChanges(chain) {
+    if (!chain) {
+      return [];
+    }
+    const registeredChainParts = chain.filter((chainPart) => this._stateChangeSubscriptionManager.isRegistered(chainPart.object, chainPart.id));
+    return registeredChainParts.map((chainPart) => ({
+      ...chainPart,
+      oldValue: this.getOldValue(chainPart.object, chainPart.id),
+      value: this.getValue(chainPart.object, chainPart.id)
+    }));
+  }
+  getCurrentValue(context, id) {
+    const value = this._pending.get(context);
+    if (value !== void 0) {
+      this._pending.delete(context);
+      return value;
+    }
+    return this.getState(context, id);
+  }
+  onChange(change, mustProxify, watched) {
+    const chainChanges = this.getChainChanges(change.chain);
+    if (chainChanges.length === 0) {
+      return;
+    }
+    this._startChangeCycle.next();
+    try {
+      const chainLeaf = chainChanges[chainChanges.length - 1];
+      const currentValue = this.getCurrentValue(chainLeaf.object, chainLeaf.id);
+      this.tryRebindingNestedState(change.newValue, currentValue, mustProxify);
+      this.updateState(chainLeaf.object, chainLeaf.object, chainLeaf.id, chainLeaf.value, watched);
+      chainChanges.forEach((chainChange) => this.emitChange(chainChange.object, chainChange.id, chainChange.value, chainChange.oldValue));
+    } finally {
+      this._endChangeCycle.next();
+    }
+  }
+};
+StateManager = _ts_decorate26([
+  Injectable26(),
+  _ts_param24(0, Inject23(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager)),
+  _ts_param24(1, Inject23(RsXStateManagerInjectionTokens.IObjectStateManager)),
+  _ts_param24(2, Inject23(RsXCoreInjectionTokens16.IErrorLog)),
+  _ts_param24(3, Inject23(RsXCoreInjectionTokens16.IGuidFactory)),
+  _ts_param24(4, Inject23(RsXCoreInjectionTokens16.IIndexValueAccessor)),
+  _ts_param24(5, Inject23(RsXCoreInjectionTokens16.IEqualityService)),
+  _ts_metadata25("design:type", Function),
+  _ts_metadata25("design:paramtypes", [
+    typeof IObjectPropertyObserverProxyPairManager === "undefined" ? Object : IObjectPropertyObserverProxyPairManager,
+    typeof IObjectStateManager === "undefined" ? Object : IObjectStateManager,
+    typeof IErrorLog === "undefined" ? Object : IErrorLog,
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
+    typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
+    typeof IEqualityService === "undefined" ? Object : IEqualityService
+  ])
+], StateManager);
+
+// lib/rs-x-state-manager.module.ts
+var defaultObjectObserverProxyPairFactoryList = [
+  {
+    target: PlainObjectObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.IPlainObjectObserverProxyPairFactory
+  },
+  {
+    target: DateObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.IDateObserverProxyPairFactory
+  },
+  {
+    target: ArrayObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.IArrayObserverProxyPairFactory
+  },
+  {
+    target: PromiseObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.PromiseObserverProxyPairFactory
+  },
+  {
+    target: ObservableObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.ObservableObserverProxyPairFactory
+  },
+  {
+    target: MapObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.IMapObserverProxyPairFactory
+  },
+  {
+    target: SetObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.ISetObserverProxyPairFactory
+  }
+];
+var defaultPropertyObserverProxyPairFactoryList = [
+  {
+    target: NonIterableObjectPropertyObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.NonIterableObjectPropertyObserverProxyPairFactory
+  },
+  {
+    target: CollectionItemObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.ICollectionItemObserverProxyPairFactory
+  },
+  {
+    target: DatePropertyObserverProxyPairFactory,
+    token: RsXStateManagerInjectionTokens.IDatePropertyObserverProxyPairFactory
+  }
+];
+InjectionContainer.load(RsXCoreModule);
+var RsXStateManagerModule = new ContainerModule((options) => {
+  options.bind(RsXStateManagerInjectionTokens.IArrayProxyFactory).to(ArrayProxyFactory).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IMapProxyFactory).to(MapProxyFactory).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.ISetProxyFactory).to(SetProxyFactory).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IDateProxyFactory).to(DateProxyFactory).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IPromiseProxyFactory).to(PromiseProxyFactory).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IObservableProxyFactory).to(ObservableProxyFactory).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IProxyRegistry).to(ProxyRegistry).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IObjectPropertyObserverProxyPairManager).to(ObjectPropertyObserverProxyPairManager).inSingletonScope();
+  registerMultiInjectServices(options, RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryList, defaultObjectObserverProxyPairFactoryList);
+  registerMultiInjectServices(options, RsXStateManagerInjectionTokens.IPropertyObserverProxyPairFactoryList, defaultPropertyObserverProxyPairFactoryList);
+  options.bind(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProvider).to(ObjectObserverProxyPairFactoryProvider).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IObjectObserverProxyPairManager).to(ObjectObserverProxyPairManager).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IObjectPropertyObserverManager).to(ObjectPropertyObserverManager).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.ICollectionItemObserverManager).to(CollectionItemObserverManager).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IDatePropertyObserverManager).to(DatePropertyObserverManager).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IMustProxifyItemHandlerFactory).to(MustProxifyItemHandlerFactory).inSingletonScope();
+  options.bind(RsXStateManagerInjectionTokens.IObjectStateManager).to(ObjectStateManager).inTransientScope();
+  options.bind(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProviderFactory).toFactory((context) => {
+    return () => context.get(RsXStateManagerInjectionTokens.IObjectObserverProxyPairFactoryProvider);
+  });
+  options.bind(RsXStateManagerInjectionTokens.IStateManager).to(StateManager).inSingletonScope();
+});
+async function unloadRsXStateManagerModule() {
+  await InjectionContainer.unload(RsXStateManagerModule);
+  await InjectionContainer.unload(RsXCoreModule);
+}
+__name(unloadRsXStateManagerModule, "unloadRsXStateManagerModule");
+export {
+  AbstractObjectObserverProxyPairFactory,
+  AbstractObserver,
+  ArrayObserverProxyPairFactory,
+  ArrayProxyFactory,
+  CollectionItemObserverManager,
+  CollectionItemObserverProxyPairFactory,
+  DateObserverProxyPairFactory,
+  DatePropertyObserverManager,
+  DatePropertyObserverProxyPairFactory,
+  DateProxyFactory,
+  GroupedChangeSubscriptionsForContextManager,
+  IndexChangeSubscriptionManager,
+  IndexObserverProxyPairFactory,
+  MapObserverProxyPairFactory,
+  MapProxy,
+  MapProxyFactory,
+  MustProxifyItemHandlerFactory,
+  NonIterableObjectPropertyObserverProxyPairFactory,
+  ObjectObserverProxyPairFactoryProvider,
+  ObjectObserverProxyPairManager,
+  ObjectPropertyObserverManager,
+  ObjectPropertyObserverProxyPairManager,
+  ObjectStateManager,
+  ObservableObserverProxyPairFactory,
+  ObservableProxyFactory,
+  ObserverGroup,
+  PlainObjectObserverProxyPairFactory,
+  PromiseObserverProxyPairFactory,
+  PromiseProxyFactory,
+  ProxyRegistry,
+  RsXStateManagerInjectionTokens,
+  RsXStateManagerModule,
+  SetObserverProxyPairFactory,
+  SetProxy,
+  SetProxyFactory,
+  StateChangeSubscriptionManager,
+  StateForObjectManager,
+  StateManager,
+  defaultObjectObserverProxyPairFactoryList,
+  defaultPropertyObserverProxyPairFactoryList,
+  unloadRsXStateManagerModule
+};