@rs-x/core 0.4.10 → 0.4.12

package/dist/index.js

@@ -5,8 +5,8 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import { Observable } from "rxjs";
 
 // lib/dependency-injection.ts
-import "reflect-metadata";
 import { Container, ContainerModule, inject, injectable, multiInject, preDestroy, unmanaged } from "inversify";
+import "reflect-metadata";
 var InjectionContainer = new Container();
 function registerMultiInjectService(container, target, options) {
   container.bind(target).to(target).inSingletonScope();
@@ -44,6 +44,152 @@ function overrideMultiInjectServices(container, multiInjectToken, services) {
 }
 __name(overrideMultiInjectServices, "overrideMultiInjectServices");
 
+// lib/index-value-accessor/array-index-accessor.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");
+var ArrayIndexAccessor = class {
+  static {
+    __name(this, "ArrayIndexAccessor");
+  }
+  priority = 5;
+  getIndexes(array) {
+    return array.keys();
+  }
+  hasValue(array, index) {
+    return this.getValue(array, index) !== void 0;
+  }
+  getResolvedValue(array, index) {
+    return array[index];
+  }
+  getValue(array, index) {
+    return this.getResolvedValue(array, index);
+  }
+  setValue(array, index, value) {
+    array[index] = value;
+  }
+  applies(array) {
+    return Array.isArray(array);
+  }
+};
+ArrayIndexAccessor = _ts_decorate([
+  injectable()
+], ArrayIndexAccessor);
+
+// lib/index-value-accessor/date-property-accessor.interface.ts
+var dataProperties = [
+  "year",
+  "utcYear",
+  "month",
+  "utcMonth",
+  "date",
+  "utcDate",
+  "hours",
+  "utcHours",
+  "minutes",
+  "utcMinutes",
+  "seconds",
+  "utcSeconds",
+  "milliseconds",
+  "utcMilliseconds",
+  "time"
+];
+
+// lib/index-value-accessor/date-property-accessor.ts
+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");
+var DatePropertyAccessor = class {
+  static {
+    __name(this, "DatePropertyAccessor");
+  }
+  priority = 0;
+  _setter = {
+    year: /* @__PURE__ */ __name((date, value) => date.setFullYear(value), "year"),
+    utcYear: /* @__PURE__ */ __name((date, value) => date.setUTCFullYear(value), "utcYear"),
+    month: /* @__PURE__ */ __name((date, value) => date.setMonth(value), "month"),
+    utcMonth: /* @__PURE__ */ __name((date, value) => date.setUTCMonth(value), "utcMonth"),
+    date: /* @__PURE__ */ __name((date, value) => date.setDate(value), "date"),
+    utcDate: /* @__PURE__ */ __name((date, value) => date.setUTCDate(value), "utcDate"),
+    hours: /* @__PURE__ */ __name((date, value) => date.setHours(value), "hours"),
+    utcHours: /* @__PURE__ */ __name((date, value) => date.setUTCHours(value), "utcHours"),
+    minutes: /* @__PURE__ */ __name((date, value) => date.setMinutes(value), "minutes"),
+    utcMinutes: /* @__PURE__ */ __name((date, value) => date.setUTCMinutes(value), "utcMinutes"),
+    seconds: /* @__PURE__ */ __name((date, value) => date.setSeconds(value), "seconds"),
+    utcSeconds: /* @__PURE__ */ __name((date, value) => date.setUTCSeconds(value), "utcSeconds"),
+    milliseconds: /* @__PURE__ */ __name((date, value) => date.setMilliseconds(value), "milliseconds"),
+    utcMilliseconds: /* @__PURE__ */ __name((date, value) => date.setUTCMilliseconds(value), "utcMilliseconds"),
+    time: /* @__PURE__ */ __name((date, value) => date.setTime(value), "time")
+  };
+  _getters = {
+    year: /* @__PURE__ */ __name((date) => date.getFullYear(), "year"),
+    utcYear: /* @__PURE__ */ __name((date) => date.getUTCFullYear(), "utcYear"),
+    month: /* @__PURE__ */ __name((date) => date.getMonth(), "month"),
+    utcMonth: /* @__PURE__ */ __name((date) => date.getUTCMonth(), "utcMonth"),
+    date: /* @__PURE__ */ __name((date) => date.getDate(), "date"),
+    utcDate: /* @__PURE__ */ __name((date) => date.getUTCDate(), "utcDate"),
+    hours: /* @__PURE__ */ __name((date) => date.getHours(), "hours"),
+    utcHours: /* @__PURE__ */ __name((date) => date.getUTCHours(), "utcHours"),
+    minutes: /* @__PURE__ */ __name((date) => date.getMinutes(), "minutes"),
+    utcMinutes: /* @__PURE__ */ __name((date) => date.getUTCMinutes(), "utcMinutes"),
+    seconds: /* @__PURE__ */ __name((date) => date.getSeconds(), "seconds"),
+    utcSeconds: /* @__PURE__ */ __name((date) => date.getUTCSeconds(), "utcSeconds"),
+    milliseconds: /* @__PURE__ */ __name((date) => date.getMilliseconds(), "milliseconds"),
+    utcMilliseconds: /* @__PURE__ */ __name((date) => date.getUTCMilliseconds(), "utcMilliseconds"),
+    time: /* @__PURE__ */ __name((date) => date.getTime(), "time")
+  };
+  getIndexes() {
+    return dataProperties.values();
+  }
+  hasValue(context, index) {
+    return this.getValue(context, index) !== void 0;
+  }
+  getResolvedValue(context, index) {
+    return this.getValue(context, index);
+  }
+  getValue(date, index) {
+    return this._getters[index]?.(date);
+  }
+  setValue(date, index, value) {
+    this._setter[index]?.(date, value);
+  }
+  applies(context, index) {
+    return context instanceof Date && !!this._getters[index];
+  }
+};
+DatePropertyAccessor = _ts_decorate2([
+  injectable()
+], DatePropertyAccessor);
+
+// lib/exceptions/custome-error.ts
+var CustomError = class extends Error {
+  static {
+    __name(this, "CustomError");
+  }
+  constructor(message, name) {
+    super(message);
+    this.name = name ?? this.constructor.name;
+  }
+};
+
+// lib/exceptions/unsupported-exception.ts
+var UnsupportedException = class extends CustomError {
+  static {
+    __name(this, "UnsupportedException");
+  }
+  constructor(message) {
+    super(message, "UnsupportedException");
+  }
+};
+
 // lib/rs-x-core.injection-tokens.ts
 var RsXCoreInjectionTokens = {
   IInjectionContainer: Symbol("IInjectionContainer"),
@@ -69,17 +215,26 @@ var RsXCoreInjectionTokens = {
   IDeepCloneList: Symbol("IDeepCloneList"),
   IResolvedValueCache: Symbol("IResolvedValueCache"),
   IDeepCloneExcept: Symbol("IDeepCloneExcept"),
-  DefaultDeepCloneExcept: Symbol("DefaultDeepCloneExcept")
+  DefaultDeepCloneExcept: Symbol("DefaultDeepCloneExcept"),
+  IValueMetadataList: Symbol("IValueMetadataList"),
+  ArrayMetadata: Symbol("ArrayMetadata"),
+  DateMetadata: Symbol("DateMetadata"),
+  DummyMetadata: Symbol("DummyMetadata"),
+  MapMetadata: Symbol("MapMetadata"),
+  ObservableMetadata: Symbol("ObservableMetadata"),
+  PromiseMetadata: Symbol("PromiseMetadata"),
+  SetMetadata: Symbol("SetMetadata"),
+  IValueMetadata: Symbol("IValueMetadata")
 };
 
-// lib/deep-clone/deep-clone-except.ts
-function _ts_decorate(decorators, target, key, desc) {
+// lib/index-value-accessor/index-value-accessor.ts
+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_decorate, "_ts_decorate");
+__name(_ts_decorate3, "_ts_decorate");
 function _ts_metadata(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
@@ -90,627 +245,346 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
-var DeepCloneValueExcept = class {
+var IndexValueAccessor = class {
   static {
-    __name(this, "DeepCloneValueExcept");
+    __name(this, "IndexValueAccessor");
   }
-  _resolvedValueCache;
-  constructor(_resolvedValueCache) {
-    this._resolvedValueCache = _resolvedValueCache;
+  priority = 0;
+  _accessors;
+  constructor(accessors) {
+    this._accessors = [
+      ...accessors
+    ].sort((a, b) => b.priority - a.priority);
   }
-  except(source) {
-    if (source instanceof Promise || source instanceof Observable) {
-      return this._resolvedValueCache.get(source);
+  getIndexes(context, index) {
+    return this.getIndexAccessor(context, index).getIndexes(context, index);
+  }
+  hasValue(context, index) {
+    return this.getIndexAccessor(context, index).hasValue(context, index);
+  }
+  getResolvedValue(context, index) {
+    return this.getIndexAccessor(context, index).getResolvedValue(context, index);
+  }
+  getValue(context, index) {
+    return this.getIndexAccessor(context, index).getValue(context, index);
+  }
+  setValue(context, index, value) {
+    this.getIndexAccessor(context, index).setValue(context, index, value);
+  }
+  applies(context, index) {
+    return this.getIndexAccessor(context, index).applies(context, index);
+  }
+  getIndexAccessor(context, index) {
+    const accessor = this._accessors.find((accessor2) => accessor2.applies(context, index));
+    if (!accessor) {
+      if (typeof context === "object" && context !== null) {
+        throw new UnsupportedException(`No accessor found for ${context.constructor.name}.${String(index)}`);
+      } else {
+        throw new UnsupportedException(`No accessor found for non-object context: ${String(context)}.${String(index)}`);
+      }
     }
-    return void 0;
+    return accessor;
   }
 };
-DeepCloneValueExcept = _ts_decorate([
+IndexValueAccessor = _ts_decorate3([
   injectable(),
-  _ts_param(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_param(0, multiInject(RsXCoreInjectionTokens.IIndexValueAccessorList)),
   _ts_metadata("design:type", Function),
   _ts_metadata("design:paramtypes", [
-    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
+    Object
   ])
-], DeepCloneValueExcept);
+], IndexValueAccessor);
 
-// lib/deep-clone/default-deep-clone.ts
-function _ts_decorate2(decorators, target, key, desc) {
+// lib/index-value-accessor/map-key-accessor.ts
+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_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 DefaultDeepClone = class {
+__name(_ts_decorate4, "_ts_decorate");
+var MapKeyAccessor = class {
   static {
-    __name(this, "DefaultDeepClone");
+    __name(this, "MapKeyAccessor");
   }
-  _deepCloneList;
-  priority = 0;
-  constructor(_deepCloneList) {
-    this._deepCloneList = _deepCloneList;
+  priority = 4;
+  getIndexes(map) {
+    return map.keys();
   }
-  clone(source) {
-    let error = null;
-    for (let i = 0; i < this._deepCloneList.length; i++) {
-      try {
-        return this._deepCloneList[i].clone(source);
-      } catch (e) {
-        error = e;
-      }
-    }
-    throw error;
+  hasValue(map, key) {
+    return map.has(key);
+  }
+  getResolvedValue(map, key) {
+    return map.get(key);
+  }
+  getValue(map, key) {
+    return this.getResolvedValue(map, key);
+  }
+  setValue(map, key, value) {
+    map.set(key, value);
+  }
+  applies(map) {
+    return map instanceof Map;
   }
 };
-DefaultDeepClone = _ts_decorate2([
-  injectable(),
-  _ts_param2(0, multiInject(RsXCoreInjectionTokens.IDeepCloneList)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    Object
-  ])
-], DefaultDeepClone);
+MapKeyAccessor = _ts_decorate4([
+  injectable()
+], MapKeyAccessor);
 
-// lib/deep-clone/lodash-deep-clone.ts
-import cloneDeepWith from "lodash.clonedeepwith";
-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 LodashDeepClone = class {
+// lib/exceptions/argument-exception.ts
+var ArgumentException = class extends CustomError {
   static {
-    __name(this, "LodashDeepClone");
-  }
-  _deepCloneExcept;
-  priority = 1;
-  constructor(_deepCloneExcept) {
-    this._deepCloneExcept = _deepCloneExcept;
+    __name(this, "ArgumentException");
   }
-  clone(source) {
-    return cloneDeepWith(source, this.cloneExceptPredicate);
+  constructor(message) {
+    super(message, "ArgumentException");
   }
-  cloneExceptPredicate = /* @__PURE__ */ __name((value) => {
-    return this._deepCloneExcept.except(value);
-  }, "cloneExceptPredicate");
 };
-LodashDeepClone = _ts_decorate3([
-  injectable(),
-  _ts_param3(0, inject(RsXCoreInjectionTokens.DefaultDeepCloneExcept)),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
-    typeof IDeepCloneExcept === "undefined" ? Object : IDeepCloneExcept
-  ])
-], LodashDeepClone);
 
-// lib/deep-clone/structured-deep-clone.ts
-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");
-var StructuredDeepClone = class {
+// lib/exceptions/assert-exception.ts
+var AssertionError = class extends CustomError {
   static {
-    __name(this, "StructuredDeepClone");
+    __name(this, "AssertionError");
   }
-  priority = 2;
-  clone(source) {
-    return structuredClone(source);
+  constructor(message) {
+    super(message, "AssertionError");
   }
 };
-StructuredDeepClone = _ts_decorate4([
-  injectable()
-], StructuredDeepClone);
 
-// lib/equality-service/equality-service.ts
-import { createCustomEqual } from "fast-equals";
-import { isObservable } from "rxjs";
-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");
-var EqualityService = class {
-  static {
-    __name(this, "EqualityService");
-  }
-  isEqual = createCustomEqual({
-    createCustomConfig: /* @__PURE__ */ __name((baseConfig) => ({
-      ...baseConfig,
-      areObjectsEqual: /* @__PURE__ */ __name((a, b, equalityCheck) => {
-        if (isObservable(a) && isObservable(b)) {
-          return a === b;
-        }
-        return baseConfig.areObjectsEqual(a, b, equalityCheck);
-      }, "areObjectsEqual")
-    }), "createCustomConfig")
-  });
-};
-EqualityService = _ts_decorate5([
-  injectable()
-], EqualityService);
+// lib/types/property-descriptor-type.enum.ts
+var PropertyDescriptorType = /* @__PURE__ */ (function(PropertyDescriptorType2) {
+  PropertyDescriptorType2["Function"] = "Function";
+  PropertyDescriptorType2["ReadonlyProperty"] = "ReadonlyProperty";
+  PropertyDescriptorType2["Property"] = "Property";
+  PropertyDescriptorType2["Field"] = "Field";
+  return PropertyDescriptorType2;
+})({});
 
-// lib/error-log/error-log.ts
-import { Subject } from "rxjs";
-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_metadata4(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata4, "_ts_metadata");
-var ErrorLog = class {
+// lib/types/type.ts
+var emptyValue = Symbol("empty");
+var emptyFunction = /* @__PURE__ */ __name(() => {
+}, "emptyFunction");
+var truePredicate = /* @__PURE__ */ __name(() => true, "truePredicate");
+var echo = /* @__PURE__ */ __name((value) => value, "echo");
+var Type = class _Type {
   static {
-    __name(this, "ErrorLog");
+    __name(this, "Type");
   }
-  _error;
-  constructor() {
-    this._error = new Subject();
+  static isPositiveIntegerString(value) {
+    if (typeof value !== "string" || value.length === 0) {
+      return false;
+    }
+    if (value === "0") {
+      return true;
+    }
+    if (value[0] === "0") {
+      return false;
+    }
+    for (let i = 0; i < value.length; i++) {
+      const code = value.charCodeAt(i);
+      if (code < 48 || code > 57) {
+        return false;
+      }
+    }
+    return true;
   }
-  get error() {
-    return this._error;
+  static isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 || _Type.isPositiveIntegerString(value);
   }
-  add(error) {
-    console.error(error);
-    this._error.next(error);
+  static walkObjectTopToBottom(object, visit, recursive) {
+    if (typeof object !== "object" || object === null) {
+      return;
+    }
+    for (const [key, value] of Object.entries(object)) {
+      visit(object, key, value);
+      if (recursive && typeof value === "object" && value !== null) {
+        _Type.walkObjectTopToBottom(value, visit, recursive);
+      }
+    }
   }
-  clear() {
-    console.clear();
+  static walkObjectBottomToTop(object, visit, recursive) {
+    if (typeof object !== "object" || object === null) {
+      return;
+    }
+    for (const [key, value] of Object.entries(object)) {
+      if (recursive && typeof value === "object" && value !== null) {
+        _Type.walkObjectBottomToTop(value, visit, recursive);
+      }
+      visit(object, key, value);
+    }
+  }
+  static cast(instance) {
+    return instance;
+  }
+  static isFunction(value) {
+    return typeof value === "function";
+  }
+  static isMethod(value) {
+    return typeof value === "function" && !("prototype" in value);
+  }
+  static isArrowFunction(object) {
+    return _Type.isFunction(object) && !Object.prototype.hasOwnProperty.call(object, "prototype");
+  }
+  static isString(value) {
+    return typeof value === "string" || value instanceof String;
+  }
+  static isNullOrUndefined(value) {
+    return value === null || value === void 0;
+  }
+  static isEmpty(value) {
+    return _Type.isNullOrUndefined(value) || _Type.isString(value) && value.length === 0 || Array.isArray(value) && value.length === 0;
+  }
+  static isPlainObject(object) {
+    if (object !== null && typeof object === "object") {
+      const prototype = Object.getPrototypeOf(object);
+      return prototype === Object.prototype || prototype === null;
+    }
+    return false;
+  }
+  static hasProperty(root, name) {
+    for (let current = root; current && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
+      if (Object.prototype.hasOwnProperty.call(current, name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static hasOwnPropertyInPrototypeChain(target, key) {
+    if (target == null) {
+      return false;
+    }
+    let proto = typeof target === "function" ? target.prototype : Object.getPrototypeOf(target);
+    while (proto) {
+      if (Object.prototype.hasOwnProperty.call(proto, key)) {
+        return true;
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+  }
+  static getPropertyDescriptorType(propertyDescriptor) {
+    if (propertyDescriptor.set) {
+      return PropertyDescriptorType.Property;
+    }
+    if (propertyDescriptor.get) {
+      return PropertyDescriptorType.ReadonlyProperty;
+    }
+    if (_Type.isMethod(propertyDescriptor.value)) {
+      return PropertyDescriptorType.Function;
+    }
+    return PropertyDescriptorType.Field;
+  }
+  static getPropertyDescriptor(root, name) {
+    if (!root || typeof root !== "object") {
+      throw new ArgumentException(`Cannot get property '${String(name)}' from non-object root: ${String(root)}`);
+    }
+    let current = root;
+    while (current && current !== Object.prototype) {
+      const propertyDescriptor = Object.getOwnPropertyDescriptor(current, name);
+      if (propertyDescriptor) {
+        return {
+          type: _Type.getPropertyDescriptorType(propertyDescriptor),
+          descriptor: propertyDescriptor
+        };
+      }
+      current = Object.getPrototypeOf(current);
+    }
+    const constructorName = root.constructor?.name || "UnknownObject";
+    throw new ArgumentException(`${constructorName} does not have a property, method or field with name '${String(name)}'`);
+  }
+  static toObject(context) {
+    if (context && (typeof context === "object" || typeof context === "function")) {
+      return context;
+    }
+    return void 0;
+  }
+  static getConstructorName(value) {
+    if (typeof value === "object" && value !== null) {
+      return value.constructor.name;
+    }
+    return "unknown";
   }
 };
-ErrorLog = _ts_decorate6([
-  injectable(),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [])
-], ErrorLog);
 
-// lib/error-log/pretty-printer.ts
-function registerHandler(handler) {
-  return {
-    predicate: handler.predicate,
-    action: /* @__PURE__ */ __name((value, level, quoteStrings) => handler.action(value, level, quoteStrings), "action")
-  };
-}
-__name(registerHandler, "registerHandler");
-var PrettyPrinter = class {
+// lib/exceptions/invalid-cast-exception.ts
+var InvalidCastException = class extends CustomError {
   static {
-    __name(this, "PrettyPrinter");
-  }
-  indent;
-  handlers;
-  constructor(indent = 4) {
-    this.indent = indent;
-    this.handlers = [
-      registerHandler({
-        predicate: /* @__PURE__ */ __name((v) => v === null || [
-          "string",
-          "number",
-          "boolean",
-          "bigint",
-          "symbol",
-          "undefined"
-        ].includes(typeof v), "predicate"),
-        action: /* @__PURE__ */ __name((v, level, quoteStrings) => [
-          this.spaces(level) + this.formatPrimitive(v, quoteStrings ?? false)
-        ], "action")
-      }),
-      registerHandler({
-        predicate: /* @__PURE__ */ __name((v) => typeof v === "function", "predicate"),
-        action: /* @__PURE__ */ __name((_, level) => [
-          this.spaces(level) + "[[function]]"
-        ], "action")
-      }),
-      registerHandler({
-        predicate: Array.isArray,
-        action: /* @__PURE__ */ __name((v, level, quoteStrings) => {
-          if (v.length === 0) {
-            return [
-              this.spaces(level) + "[]"
-            ];
-          }
-          const lines = [
-            this.spaces(level) + "["
-          ];
-          for (let i = 0; i < v.length; i++) {
-            const nested = this.toLines(v[i], level + 1, quoteStrings);
-            lines.push(...nested);
-            if (i < v.length - 1) {
-              lines[lines.length - 1] += ",";
-            }
-          }
-          lines.push(this.spaces(level) + "]");
-          return lines;
-        }, "action")
-      }),
-      registerHandler({
-        predicate: /* @__PURE__ */ __name((v) => v instanceof Map, "predicate"),
-        action: /* @__PURE__ */ __name((v, level, quoteStrings) => {
-          if (v.size === 0) {
-            return [
-              this.spaces(level) + "{}"
-            ];
-          }
-          const lines = [
-            this.spaces(level) + "{"
-          ];
-          const next = this.spaces(level + 1);
-          for (const [k, val] of v.entries()) {
-            const nested = this.toLines(val, level + 1, quoteStrings);
-            lines.push(`${next}${this.formatKey(k)}: ${nested[0].trimStart()}`);
-            if (nested.length > 1) {
-              lines.push(...nested.slice(1));
-            }
-          }
-          lines.push(this.spaces(level) + "}");
-          return lines;
-        }, "action")
-      }),
-      registerHandler({
-        predicate: /* @__PURE__ */ __name((v) => v instanceof Set, "predicate"),
-        action: /* @__PURE__ */ __name((v, level, quoteStrings) => {
-          if (v.size === 0) {
-            return [
-              this.spaces(level) + "{}"
-            ];
-          }
-          const lines = [
-            this.spaces(level) + "{"
-          ];
-          for (const item of v) {
-            lines.push(...this.toLines(item, level + 1, quoteStrings));
-          }
-          lines.push(this.spaces(level) + "}");
-          return lines;
-        }, "action")
-      }),
-      registerHandler({
-        predicate: /* @__PURE__ */ __name((v) => typeof v === "object" && v !== null && "toLines" in v, "predicate"),
-        action: /* @__PURE__ */ __name((v, _level) => v.toLines(this.indent, _level), "action")
-      }),
-      registerHandler({
-        predicate: /* @__PURE__ */ __name((v) => this.isCustomToString(v), "predicate"),
-        action: /* @__PURE__ */ __name((v, level) => {
-          const raw = v.toString(this.indent, level);
-          const lines = Array.isArray(raw) ? raw : String(raw).split("\n");
-          return lines.map((l) => this.spaces(level) + l);
-        }, "action")
-      }),
-      registerHandler({
-        predicate: /* @__PURE__ */ __name((v) => typeof v === "object" && v !== null && !Array.isArray(v), "predicate"),
-        action: /* @__PURE__ */ __name((v, level, quoteStrings) => {
-          const keys = Object.keys(v);
-          if (keys.length === 0) {
-            return [
-              this.spaces(level) + "{}"
-            ];
-          }
-          const lines = [
-            this.spaces(level) + "{"
-          ];
-          const next = this.spaces(level + 1);
-          for (const key of keys) {
-            const nested = this.toLines(v[key], level + 1, quoteStrings);
-            lines.push(`${next}${key}: ${nested[0].trimStart()}`);
-            if (nested.length > 1) {
-              lines.push(...nested.slice(1));
-            }
-          }
-          lines.push(this.spaces(level) + "}");
-          return lines;
-        }, "action")
-      })
-    ];
-  }
-  toString(value, quoteStrings = true) {
-    return this.toLines(value, 0, quoteStrings).join("\n");
-  }
-  toLines(value, level = 0, quoteStrings = true) {
-    for (const handler of this.handlers) {
-      if (handler.predicate(value)) {
-        return handler.action(value, level, quoteStrings);
-      }
-    }
-    return [
-      this.spaces(level) + String(value)
-    ];
-  }
-  formatPrimitive(value, quoteStrings) {
-    if (typeof value === "string" && quoteStrings) {
-      return `'${value}'`;
-    }
-    return String(value);
+    __name(this, "InvalidCastException");
   }
-  formatKey(key) {
-    return typeof key === "string" ? key : String(key);
+  constructor(message) {
+    super(message, "InvalidCastException");
   }
-  spaces(level) {
-    return " ".repeat(this.indent * level);
+};
+
+// lib/exceptions/null-or-empty-exception.ts
+var NullOrEmptyException = class extends CustomError {
+  static {
+    __name(this, "NullOrEmptyException");
   }
-  isCustomToString(value) {
-    if (typeof value !== "object" || value === null) return false;
-    const proto = Object.getPrototypeOf(value);
-    if (!proto) return false;
-    const desc = Object.getOwnPropertyDescriptor(proto, "toString");
-    return !!desc && typeof desc.value === "function" && desc.value !== Object.prototype.toString;
+  constructor(argumentName) {
+    super(`'${argumentName}' cannot be null or empty`, "NullOrEmptyException");
   }
 };
 
-// lib/error-log/print-value.ts
-function printValue(value) {
-  console.log(new PrettyPrinter().toString(value, false));
-}
-__name(printValue, "printValue");
-
-// lib/exceptions/argument-exception.ts
-var ArgumentException = class extends Error {
+// lib/exceptions/null-or-undefined-exception.ts
+var NullOrUndefinedException = class extends CustomError {
   static {
-    __name(this, "ArgumentException");
+    __name(this, "NullOrUndefinedException");
   }
-  constructor(message) {
-    super(message);
+  constructor(argumentName) {
+    super(`'${argumentName}' cannot be null or undefined`, "NullOrEmptyException");
   }
 };
 
-// lib/types/property-descriptor-type.enum.ts
-var PropertyDescriptorType = /* @__PURE__ */ (function(PropertyDescriptorType2) {
-  PropertyDescriptorType2["Function"] = "Function";
-  PropertyDescriptorType2["ReadonlyProperty"] = "ReadonlyProperty";
-  PropertyDescriptorType2["Property"] = "Property";
-  PropertyDescriptorType2["Field"] = "Field";
-  return PropertyDescriptorType2;
-})({});
-
-// lib/types/type.ts
-var emptyValue = Symbol("empty");
-var emptyFunction = /* @__PURE__ */ __name(() => {
-}, "emptyFunction");
-var truePredicate = /* @__PURE__ */ __name(() => true, "truePredicate");
-var echo = /* @__PURE__ */ __name((value) => value, "echo");
-var Type = class _Type {
+// lib/exceptions/assertion.ts
+var Assertion = class {
   static {
-    __name(this, "Type");
-  }
-  static isPositiveIntegerString(value) {
-    if (typeof value !== "string" || value.length === 0) {
-      return false;
-    }
-    if (value === "0") {
-      return true;
-    }
-    if (value[0] === "0") {
-      return false;
-    }
-    for (let i = 0; i < value.length; i++) {
-      const code = value.charCodeAt(i);
-      if (code < 48 || code > 57) {
-        return false;
-      }
-    }
-    return true;
+    __name(this, "Assertion");
   }
-  static isPositiveInteger(value) {
-    return typeof value === "number" && Number.isInteger(value) && value >= 0 || _Type.isPositiveIntegerString(value);
+  constructor() {
   }
-  static walkObjectTopToBottom(object, visit, recursive) {
-    if (typeof object !== "object" || object === null) {
-      return;
+  static assertIsFunction(value, name) {
+    if (!Type.isFunction(value)) {
+      const typeName = value && typeof value === "object" ? value.constructor?.name : typeof value;
+      throw new InvalidCastException(`${typeName}[${name}] is not a function`);
     }
-    for (const [key, value] of Object.entries(object)) {
-      visit(object, key, value);
-      if (recursive && typeof value === "object" && value !== null) {
-        _Type.walkObjectTopToBottom(value, visit, recursive);
-      }
+  }
+  static assert(predicate, messsage) {
+    if (!predicate()) {
+      throw new AssertionError(messsage);
     }
   }
-  static walkObjectBottomToTop(object, visit, recursive) {
-    if (typeof object !== "object" || object === null) {
-      return;
+  static assertNotNullOrUndefined(value, argumentName) {
+    if (Type.isNullOrUndefined(value)) {
+      throw new NullOrUndefinedException(argumentName);
     }
-    for (const [key, value] of Object.entries(object)) {
-      if (recursive && typeof value === "object" && value !== null) {
-        _Type.walkObjectBottomToTop(value, visit, recursive);
-      }
-      visit(object, key, value);
+  }
+  static assertNotNullOrEmpty(value, argumentName) {
+    if (Type.isEmpty(value)) {
+      throw new NullOrEmptyException(argumentName);
     }
   }
-  static cast(instance) {
-    return instance;
-  }
-  static isFunction(value) {
-    return typeof value === "function";
-  }
-  static isMethod(value) {
-    return typeof value === "function" && !("prototype" in value);
-  }
-  static isArrowFunction(object) {
-    return _Type.isFunction(object) && !Object.prototype.hasOwnProperty.call(object, "prototype");
-  }
-  static isString(value) {
-    return typeof value === "string" || value instanceof String;
-  }
-  static isNullOrUndefined(value) {
-    return value === null || value === void 0;
-  }
-  static isEmpty(value) {
-    return _Type.isNullOrUndefined(value) || _Type.isString(value) && value.length === 0 || Array.isArray(value) && value.length === 0;
-  }
-  static isPlainObject(object) {
-    if (object !== null && typeof object === "object") {
-      const prototype = Object.getPrototypeOf(object);
-      return prototype === Object.prototype || prototype === null;
-    }
-    return false;
-  }
-  static hasProperty(root, name) {
-    for (let current = root; current && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
-      if (Object.prototype.hasOwnProperty.call(current, name)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  static hasOwnPropertyInPrototypeChain(target, key) {
-    if (target == null) {
-      return false;
-    }
-    let proto = typeof target === "function" ? target.prototype : Object.getPrototypeOf(target);
-    while (proto) {
-      if (Object.prototype.hasOwnProperty.call(proto, key)) {
-        return true;
-      }
-      proto = Object.getPrototypeOf(proto);
-    }
-    return false;
-  }
-  static getPropertyDescriptorType(propertyDescriptor) {
-    if (propertyDescriptor.set) {
-      return PropertyDescriptorType.Property;
-    }
-    if (propertyDescriptor.get) {
-      return PropertyDescriptorType.ReadonlyProperty;
-    }
-    if (_Type.isMethod(propertyDescriptor.value)) {
-      return PropertyDescriptorType.Function;
-    }
-    return PropertyDescriptorType.Field;
-  }
-  static getPropertyDescriptor(root, name) {
-    if (!root || typeof root !== "object") {
-      throw new ArgumentException(`Cannot get property '${String(name)}' from non-object root: ${String(root)}`);
-    }
-    let current = root;
-    while (current && current !== Object.prototype) {
-      const propertyDescriptor = Object.getOwnPropertyDescriptor(current, name);
-      if (propertyDescriptor) {
-        return {
-          type: _Type.getPropertyDescriptorType(propertyDescriptor),
-          descriptor: propertyDescriptor
-        };
-      }
-      current = Object.getPrototypeOf(current);
-    }
-    const constructorName = root.constructor?.name || "UnknownObject";
-    throw new ArgumentException(`${constructorName} does not have a property, method or field with name '${String(name)}'`);
-  }
-  static toObject(context) {
-    if (context && (typeof context === "object" || typeof context === "function")) {
-      return context;
-    }
-    return void 0;
-  }
-  static getConstructorName(value) {
-    if (typeof value === "object" && value !== null) {
-      return value.constructor.name;
-    }
-    return "unknown";
-  }
-};
-
-// lib/exceptions/invalid-cast-exception.ts
-var InvalidCastException = class extends Error {
-  static {
-    __name(this, "InvalidCastException");
-  }
-  constructor(message) {
-    super(message);
-  }
-};
-
-// lib/exceptions/null-or-empty-exception.ts
-var NullOrEmptyException = class extends Error {
-  static {
-    __name(this, "NullOrEmptyException");
-  }
-  constructor(argumentName) {
-    super(`'${argumentName}' cannot be null or empty`);
-  }
-};
-
-// lib/exceptions/null-or-undefined-exception.ts
-var NullOrUndefinedException = class extends Error {
-  static {
-    __name(this, "NullOrUndefinedException");
-  }
-  constructor(argumentName) {
-    super(`'${argumentName}' cannot be null or undefined`);
-  }
-};
-
-// lib/exceptions/assertion.ts
-var Assertion = class {
-  static {
-    __name(this, "Assertion");
-  }
-  constructor() {
-  }
-  static assertIsFunction(value, name) {
-    if (!Type.isFunction(value)) {
-      const typeName = value && typeof value === "object" ? value.constructor?.name : typeof value;
-      throw new InvalidCastException(`${typeName}[${name}] is not a function`);
-    }
-  }
-  static assertNotNullOrUndefined(value, argumentName) {
-    if (Type.isNullOrUndefined(value)) {
-      throw new NullOrUndefinedException(argumentName);
-    }
-  }
-  static assertNotNullOrEmpty(value, argumentName) {
-    if (Type.isEmpty(value)) {
-      throw new NullOrEmptyException(argumentName);
-    }
-  }
-};
-
-// lib/exceptions/invalid-operation-exception.ts
-var InvalidOperationException = class extends Error {
-  static {
-    __name(this, "InvalidOperationException");
+};
+
+// lib/exceptions/invalid-operation-exception.ts
+var InvalidOperationException = class extends CustomError {
+  static {
+    __name(this, "InvalidOperationException");
   }
   constructor(message) {
-    super(message);
+    super(message, "InvalidOperationException");
   }
 };
 
 // lib/exceptions/parser-exception.ts
-var ParserException = class extends Error {
+var ParserException = class extends CustomError {
   static {
     __name(this, "ParserException");
   }
   expression;
   position;
   constructor(expression, message, position) {
-    super(createMessage(expression, message, position ?? 0)), this.expression = expression, this.position = position;
+    super(createMessage(expression, message, position ?? 0), "ParserException"), this.expression = expression, this.position = position;
   }
 };
 function createMessage(expression, message, position) {
@@ -722,765 +596,968 @@ function createMessage(expression, message, position) {
 __name(createMessage, "createMessage");
 
 // lib/exceptions/unexpected-exception.ts
-var UnexpectedException = class extends Error {
+var UnexpectedException = class extends CustomError {
   static {
     __name(this, "UnexpectedException");
   }
   constructor(message) {
-    super(message);
-  }
-};
-
-// lib/exceptions/unsupported-exception.ts
-var UnsupportedException = class extends Error {
-  static {
-    __name(this, "UnsupportedException");
-  }
-  constructor(message) {
-    super(message);
+    super(message, "UnexpectedException");
   }
 };
 
-// lib/singleton-factory/singleton.factory.ts
-function _ts_decorate7(decorators, target, key, desc) {
+// lib/index-value-accessor/method-accessor.ts
+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_decorate7, "_ts_decorate");
-function _ts_metadata5(k, v) {
+__name(_ts_decorate5, "_ts_decorate");
+function _ts_metadata2(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata5, "_ts_metadata");
-var SingletonFactory = class {
+__name(_ts_metadata2, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var MethodAccessor = class {
   static {
-    __name(this, "SingletonFactory");
-  }
-  _instances = /* @__PURE__ */ new Map();
-  _referenceCounts = /* @__PURE__ */ new Map();
-  constructor() {
-  }
-  exists(target) {
-    for (const instance of this._instances.values()) {
-      if (target === instance) {
-        return true;
-      }
-    }
-    return false;
-  }
-  toLines(indent = 4, level = 0) {
-    const lines = [];
-    const spaces = " ".repeat(indent * level);
-    const spacesNext = " ".repeat(indent * (level + 1));
-    const prettyPrinter = new PrettyPrinter();
-    lines.push(spaces + "___________________________________________________________");
-    lines.push(spaces + `${this.constructor.name}`);
-    for (const [key, instance] of this._instances.entries()) {
-      lines.push(spacesNext + "___________________________________________________________");
-      lines.push(spacesNext + `key (ref. count = ${this._referenceCounts.get(key)}):`);
-      const keyLines = prettyPrinter.toLines(key, level + 2, false);
-      lines.push(...keyLines);
-      lines.push(spacesNext + "instance:");
-      const instanceLines = prettyPrinter.toLines(instance, level + 2, false);
-      lines.push(...instanceLines);
-    }
-    return lines;
-  }
-  toString(indent = 4, level = 0) {
-    return this.toLines(indent, level).map((l) => " ".repeat(indent * level) + l).join("\n");
-  }
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return `${this.constructor.name}`;
+    __name(this, "MethodAccessor");
   }
-  get isEmpty() {
-    return this._instances.size === 0;
+  _functionCallResultCacheFactory;
+  priority = 6;
+  constructor(_functionCallResultCacheFactory) {
+    this._functionCallResultCacheFactory = _functionCallResultCacheFactory;
   }
-  ids() {
-    return this._instances.keys();
+  getIndexes() {
+    return [].values();
   }
-  getFromId(id) {
-    return this._instances.get(id);
+  hasValue(context, index) {
+    return this._functionCallResultCacheFactory.has(context, index);
   }
-  has(id) {
-    return this._instances.has(id);
+  getResolvedValue(context, index) {
+    return this.getValue(context, index);
   }
-  getFromData(data) {
-    const id = this.getId(data);
-    return id !== void 0 ? this.getFromId(id) : void 0;
+  getValue(context, index) {
+    return this._functionCallResultCacheFactory.get(context, index)?.result;
   }
-  dispose() {
-    for (const id of this._instances.keys()) {
-      this.release(id, true);
-    }
-    this._instances.clear();
-    this._referenceCounts.clear();
-    this.onDipose();
+  setValue(_, index) {
+    throw new UnsupportedException(`Cannot set method '${index}'`);
   }
-  getOrCreate(data) {
-    let instance = this.getFromId(this.getOrCreateId(data));
-    if (instance === void 0) {
-      instance = this.create(data).instance;
+  applies(context, index) {
+    if (!index || typeof context !== "object" || context === null) {
+      return false;
     }
-    return instance;
-  }
-  create(data) {
-    const id = this.getOrCreateId(data);
-    const instance = this.getOrCreateInstance(id, data);
-    const result = {
-      id,
-      instance,
-      referenceCount: this.updateReferenceCount(id, 1, instance)
-    };
-    if (result.referenceCount === 1) {
-      this.onInstanceCreated(result.instance, data);
-    }
-    return result;
-  }
-  release(id, force) {
-    const instance = this._instances.get(id);
-    if (!instance) {
-      return {
-        instance: null,
-        referenceCount: 0
-      };
-    }
-    return {
-      referenceCount: this.updateReferenceCount(id, -1, instance, force),
-      instance
-    };
-  }
-  get keys() {
-    return Array.from(this._instances.keys());
-  }
-  onDisposeInstance = /* @__PURE__ */ __name((id, dispose) => {
-    const { referenceCount } = this.release(id);
-    if (referenceCount === 0) {
-      dispose();
-    }
-    return referenceCount === 0;
-  }, "onDisposeInstance");
-  onDipose() {
-  }
-  onReleased() {
-  }
-  releaseInstance(_instance, _id) {
-  }
-  onInstanceCreated(_instance, _data) {
-  }
-  getOrCreateId(data) {
-    return this.getId(data) ?? this.createId(data);
-  }
-  getReferenceCount(id) {
-    return this._referenceCounts.get(id) ?? 0;
-  }
-  updateReferenceCount(id, change, instance, forceRelease) {
-    const referenceCount = this.getReferenceCount(id) + change;
-    if (change === -1 && (forceRelease || referenceCount === 0)) {
-      this._instances.delete(id);
-      this._referenceCounts.delete(id);
-      this.releaseInstance(instance, id);
-      this.onReleased();
-    } else if (referenceCount > 0) {
-      this._referenceCounts.set(id, referenceCount);
-    }
-    return referenceCount;
-  }
-  getOrCreateInstance(id, data) {
-    let instance = this._instances.get(id);
-    if (instance !== void 0) {
-      return instance;
-    }
-    instance = this.createInstance(data, id);
-    this._instances.set(id, instance);
-    return instance;
+    const prop = context[index.functionName];
+    return Type.isFunction(prop) || Type.isArrowFunction(prop);
   }
 };
-_ts_decorate7([
-  preDestroy(),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", []),
-  _ts_metadata5("design:returntype", void 0)
-], SingletonFactory.prototype, "dispose", null);
+MethodAccessor = _ts_decorate5([
+  injectable(),
+  _ts_param2(0, inject(RsXCoreInjectionTokens.IFunctionCallResultCacheFactory)),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof IFunctionCallResultCacheFactory === "undefined" ? Object : IFunctionCallResultCacheFactory
+  ])
+], MethodAccessor);
 
-// lib/function-call-index/function-call-index.ts
-var FunctionCallIndex = class {
-  static {
-    __name(this, "FunctionCallIndex");
-  }
-  context;
-  functionName;
-  _sequenceWithId;
-  _owner;
-  _isDisposed = false;
-  _id;
-  constructor(context, functionName, _sequenceWithId, _owner) {
-    this.context = context;
-    this.functionName = functionName;
-    this._sequenceWithId = _sequenceWithId;
-    this._owner = _owner;
-  }
-  get id() {
-    if (!this._id) {
-      this._id = `${this.functionName}${this._sequenceWithId.id}`;
-    }
-    return this._id;
-  }
-  get argumentsId() {
-    return this._sequenceWithId;
-  }
-  dispose() {
-    if (this._isDisposed) {
-      return;
-    }
-    if (this._owner.canDispose?.()) {
-      this._isDisposed = true;
-      this._sequenceWithId.dispose();
-    }
-    this._owner.release();
+// lib/index-value-accessor/observable-accessor.ts
+import { BehaviorSubject, isObservable, Subject } from "rxjs";
+
+// lib/types/set.ts
+function replaceSetItemAt(set, oldValue, newValue) {
+  const values = Array.from(set);
+  const index = values.indexOf(oldValue);
+  if (index === -1) {
+    throw new RangeError("Index out of range");
   }
-};
+  values[index] = newValue;
+  set.clear();
+  values.forEach((value) => set.add(value));
+  return set;
+}
+__name(replaceSetItemAt, "replaceSetItemAt");
 
-// lib/function-call-index/function-call-index.factory.ts
-function _ts_decorate8(decorators, target, key, desc) {
+// lib/types/utc-date.ts
+function utCDate(year, month = 0, date = 1, hours = 0, minutes = 0, seconds = 0, millisecond = 0) {
+  return new Date(Date.UTC(year, month, date, hours, minutes, seconds, millisecond));
+}
+__name(utCDate, "utCDate");
+
+// lib/index-value-accessor/pending.ts
+var PENDING = Symbol("pending");
+
+// lib/index-value-accessor/observable-accessor.ts
+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_decorate8, "_ts_decorate");
-function _ts_metadata6(k, v) {
+__name(_ts_decorate6, "_ts_decorate");
+function _ts_metadata3(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata6, "_ts_metadata");
-function _ts_param4(paramIndex, decorator) {
+__name(_ts_metadata3, "_ts_metadata");
+function _ts_param3(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
-var FunctionCallIndexFactory = class extends SingletonFactory {
+__name(_ts_param3, "_ts_param");
+var ObservableAccessor = class {
   static {
-    __name(this, "FunctionCallIndexFactory");
+    __name(this, "ObservableAccessor");
   }
-  _sequenceIdFactory;
-  constructor(_sequenceIdFactory) {
-    super(), this._sequenceIdFactory = _sequenceIdFactory;
+  _resolvedValueCache;
+  priority = 2;
+  constructor(_resolvedValueCache) {
+    this._resolvedValueCache = _resolvedValueCache;
   }
-  getId(data) {
-    return this._sequenceIdFactory.get(data.context, data.arguments);
+  getIndexes() {
+    return [].values();
   }
-  createInstance(data, id) {
-    return new FunctionCallIndex(data.context, data.functionName, id, {
-      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
-      release: /* @__PURE__ */ __name(() => this.release(id), "release")
-    });
+  getResolvedValue(context, index) {
+    if (context instanceof BehaviorSubject) return context.value;
+    const val = this.getIndexedValue(context, index);
+    if (val && typeof val === "object" || typeof val === "function") {
+      return this._resolvedValueCache.get(val) ?? PENDING;
+    }
+    return PENDING;
   }
-  createId(data) {
-    const context = data.context;
-    if (!context || typeof context !== "object") {
-      throw new ArgumentException(`Expected context to be an object, got ${String(context)}`);
+  hasValue(context, index) {
+    return this.getResolvedValue(context, index) !== PENDING;
+  }
+  getValue(context, index) {
+    return this.getIndexedValue(context, index);
+  }
+  setValue(context, index, value) {
+    const val = this.getIndexedValue(context, index);
+    if (val instanceof Subject) {
+      val.next(value);
+      return;
     }
-    const fn = context[data.functionName];
-    return this._sequenceIdFactory.create(fn, data.arguments);
+    throw new UnsupportedException("Cannot set value for an observable");
   }
-  releaseInstance(_, id) {
-    id.dispose();
+  applies(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return isObservable(val);
+  }
+  setLastValue(observable, value) {
+    this._resolvedValueCache.set(observable, value);
+  }
+  clearLastValue(observable) {
+    this._resolvedValueCache.delete(observable);
+  }
+  getIndexedValue(context, index) {
+    return (Type.toObject(context) ?? {})[index];
   }
 };
-FunctionCallIndexFactory = _ts_decorate8([
+ObservableAccessor = _ts_decorate6([
   injectable(),
-  _ts_param4(0, inject(RsXCoreInjectionTokens.ISequenceIdFactory)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
-    typeof ISequenceIdFactory === "undefined" ? Object : ISequenceIdFactory
+  _ts_param3(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
   ])
-], FunctionCallIndexFactory);
+], ObservableAccessor);
 
-// lib/function-call-result-cache/function-call-result-cache.factory.ts
-function _ts_decorate9(decorators, target, key, desc) {
+// lib/index-value-accessor/promise-accessor.ts
+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_decorate9, "_ts_decorate");
-function _ts_metadata7(k, v) {
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata7, "_ts_metadata");
-function _ts_param5(paramIndex, decorator) {
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param5, "_ts_param");
-var FunctionCallResultCache = class FunctionCallResultCache2 {
+__name(_ts_param4, "_ts_param");
+var PromiseAccessor = class {
   static {
-    __name(this, "FunctionCallResultCache");
-  }
-  _disposeableIndex;
-  result;
-  _owner;
-  _isDisposed = false;
-  constructor(_disposeableIndex, result, _owner) {
-    this._disposeableIndex = _disposeableIndex;
-    this.result = result;
-    this._owner = _owner;
+    __name(this, "PromiseAccessor");
   }
-  get index() {
-    return this._disposeableIndex;
+  _resolvedValueCache;
+  priority = 1;
+  constructor(_resolvedValueCache) {
+    this._resolvedValueCache = _resolvedValueCache;
   }
-  dispose() {
-    if (this._isDisposed) {
-      return;
-    }
-    if (this._owner.canDispose?.()) {
-      this._disposeableIndex.dispose();
-      this._isDisposed = true;
-    }
-    this._owner.release();
+  getIndexes() {
+    return [].values();
   }
-};
-var FunctionCallResultCacheForContextManager = class FunctionCallResultCacheForContextManager2 extends SingletonFactory {
-  static {
-    __name(this, "FunctionCallResultCacheForContextManager");
-  }
-  _context;
-  _functionCallIndexFactory;
-  releaseContext;
-  constructor(_context, _functionCallIndexFactory, releaseContext) {
-    super(), this._context = _context, this._functionCallIndexFactory = _functionCallIndexFactory, this.releaseContext = releaseContext;
-  }
-  getId(data) {
-    return this._functionCallIndexFactory.getFromData({
-      functionName: data.functionName,
-      context: this._context,
-      arguments: data.arguments
-    });
-  }
-  createInstance(data, id) {
-    return new FunctionCallResultCache(id, data.result, {
-      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
-      release: /* @__PURE__ */ __name(() => this.release(id), "release")
-    });
+  hasValue(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return this.isCacheable(val) && this._resolvedValueCache.get(val) !== PENDING;
   }
-  createId(data) {
-    return this._functionCallIndexFactory.create({
-      functionName: data.functionName,
-      context: this._context,
-      arguments: data.arguments
-    }).instance;
+  getResolvedValue(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return this.isCacheable(val) ? this._resolvedValueCache.get(val) ?? PENDING : PENDING;
   }
-  releaseInstance(_, id) {
-    this._functionCallIndexFactory.release(id.argumentsId);
+  getValue(context, index) {
+    return this.getIndexedValue(context, index);
   }
-  onReleased() {
-    this.releaseContext();
+  setValue() {
+    throw new UnsupportedException("Cannot set value for a Promise");
   }
-};
-var FunctionCallResultCacheManager = class FunctionCallResultCacheManager2 extends SingletonFactory {
-  static {
-    __name(this, "FunctionCallResultCacheManager");
+  applies(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return val instanceof Promise;
   }
-  _functionCallIndexFactory;
-  constructor(_functionCallIndexFactory) {
-    super(), this._functionCallIndexFactory = _functionCallIndexFactory;
+  setLastValue(promise, value) {
+    this._resolvedValueCache.set(promise, value);
   }
-  getId(contex) {
-    return this.createId(contex);
+  clearLastValue(promise) {
+    this._resolvedValueCache.delete(promise);
   }
-  createInstance(context, id) {
-    return new FunctionCallResultCacheForContextManager(context, this._functionCallIndexFactory, () => this.release(id));
+  getIndexedValue(context, index) {
+    return (Type.toObject(context) ?? {})[index];
   }
-  createId(contex) {
-    return contex;
+  isCacheable(value) {
+    return value !== null && (typeof value === "object" || typeof value === "function");
   }
 };
-var FunctionCallResultCacheFactory = class {
+PromiseAccessor = _ts_decorate7([
+  injectable(),
+  _ts_param4(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
+  ])
+], PromiseAccessor);
+
+// lib/index-value-accessor/property-value-accessor.ts
+import { isObservable as isObservable2 } from "rxjs";
+var PropertyValueAccessor = class {
   static {
-    __name(this, "FunctionCallResultCacheFactory");
+    __name(this, "PropertyValueAccessor");
   }
-  _functionCallResultCacheManager;
-  constructor(functionCallIndexFactory) {
-    this._functionCallResultCacheManager = new FunctionCallResultCacheManager(functionCallIndexFactory);
+  priority = 7;
+  getIndexes(context) {
+    const obj = Type.toObject(context);
+    if (!obj) {
+      return [].values();
+    }
+    return Object.keys(obj).filter((key) => !Type.isMethod(obj[key])).values();
   }
-  create(context, result) {
-    return this._functionCallResultCacheManager.create(context).instance.create(result).instance;
+  hasValue(context, index) {
+    const val = this.getValue(context, index);
+    return val !== void 0;
   }
-  has(context, index) {
-    return this._functionCallResultCacheManager.getFromId(context)?.has(index) ?? false;
+  getResolvedValue(context, index) {
+    return this.getValue(context, index);
   }
-  get(context, index) {
-    return this._functionCallResultCacheManager.getFromId(context)?.getFromId(index);
+  getValue(context, index) {
+    const obj = Type.toObject(context);
+    return obj ? obj[index] : void 0;
+  }
+  setValue(context, index, value) {
+    const obj = Type.toObject(context);
+    if (obj) {
+      obj[index] = value;
+    }
+  }
+  applies(context, index) {
+    const obj = Type.toObject(context);
+    if (!obj) {
+      return false;
+    }
+    return Type.hasProperty(obj, index) && !(obj instanceof Date) && !isObservable2(obj[index]) && !(obj[index] instanceof Promise);
   }
 };
-FunctionCallResultCacheFactory = _ts_decorate9([
-  injectable(),
-  _ts_param5(0, inject(RsXCoreInjectionTokens.IFunctionCallIndexFactory)),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", [
-    typeof IFunctionCallIndexFactory === "undefined" ? Object : IFunctionCallIndexFactory
-  ])
-], FunctionCallResultCacheFactory);
 
-// lib/guid/guid.factory.ts
-function _ts_decorate10(decorators, target, key, desc) {
+// lib/index-value-accessor/resolved-value-cache.ts
+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_decorate10, "_ts_decorate");
-var GuidFactory = class {
+__name(_ts_decorate8, "_ts_decorate");
+var ResolvedValueCache = class {
   static {
-    __name(this, "GuidFactory");
+    __name(this, "ResolvedValueCache");
   }
-  create() {
-    return crypto.randomUUID();
+  _resolvedValues = /* @__PURE__ */ new WeakMap();
+  set(source, value) {
+    this._resolvedValues.set(source, value);
+  }
+  get(source) {
+    return this._resolvedValues.get(source);
+  }
+  delete(source) {
+    this._resolvedValues.delete(source);
   }
 };
-GuidFactory = _ts_decorate10([
+ResolvedValueCache = _ts_decorate8([
   injectable()
-], GuidFactory);
+], ResolvedValueCache);
 
-// lib/index-value-accessor/array-index-accessor.ts
-function _ts_decorate11(decorators, target, key, desc) {
+// lib/index-value-accessor/set-key-accessor.ts
+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_decorate11, "_ts_decorate");
-var ArrayIndexAccessor = class {
+__name(_ts_decorate9, "_ts_decorate");
+var SetKeyAccessor = class {
   static {
-    __name(this, "ArrayIndexAccessor");
-  }
-  priority = 5;
-  isAsync() {
-    return false;
+    __name(this, "SetKeyAccessor");
   }
-  getIndexes(array) {
-    return array.keys();
+  priority = 3;
+  getIndexes(set) {
+    return new Set(set).values();
   }
-  hasValue(array, index) {
-    return this.getValue(array, index) !== void 0;
+  hasValue(set, key) {
+    return set.has(key);
   }
-  getResolvedValue(array, index) {
-    return array[index];
+  getResolvedValue(set, key) {
+    return set.has(key) ? key : void 0;
   }
-  getValue(array, index) {
-    return this.getResolvedValue(array, index);
+  getValue(set, key) {
+    return this.getResolvedValue(set, key);
   }
-  setValue(array, index, value) {
-    array[index] = value;
+  setValue(set, key, value) {
+    replaceSetItemAt(set, key, value);
   }
-  applies(array) {
-    return Array.isArray(array);
+  applies(map) {
+    return map instanceof Set;
   }
 };
-ArrayIndexAccessor = _ts_decorate11([
+SetKeyAccessor = _ts_decorate9([
   injectable()
-], ArrayIndexAccessor);
-
-// lib/index-value-accessor/date-property-accessor.interface.ts
-var dataProperties = [
-  "year",
-  "utcYear",
-  "month",
-  "utcMonth",
-  "date",
-  "utcDate",
-  "hours",
-  "utcHours",
-  "minutes",
-  "utcMinutes",
-  "seconds",
-  "utcSeconds",
-  "milliseconds",
-  "utcMilliseconds",
-  "time"
-];
+], SetKeyAccessor);
 
-// lib/index-value-accessor/date-property-accessor.ts
-function _ts_decorate12(decorators, target, key, desc) {
+// lib/deep-clone/deep-clone-except.ts
+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_decorate12, "_ts_decorate");
-var DatePropertyAccessor = class {
+__name(_ts_decorate10, "_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 DeepCloneValueExcept = class {
   static {
-    __name(this, "DatePropertyAccessor");
+    __name(this, "DeepCloneValueExcept");
   }
-  priority = 0;
-  _setter = {
-    year: /* @__PURE__ */ __name((date, value) => date.setFullYear(value), "year"),
-    utcYear: /* @__PURE__ */ __name((date, value) => date.setUTCFullYear(value), "utcYear"),
-    month: /* @__PURE__ */ __name((date, value) => date.setMonth(value), "month"),
-    utcMonth: /* @__PURE__ */ __name((date, value) => date.setUTCMonth(value), "utcMonth"),
-    date: /* @__PURE__ */ __name((date, value) => date.setDate(value), "date"),
-    utcDate: /* @__PURE__ */ __name((date, value) => date.setUTCDate(value), "utcDate"),
-    hours: /* @__PURE__ */ __name((date, value) => date.setHours(value), "hours"),
-    utcHours: /* @__PURE__ */ __name((date, value) => date.setUTCHours(value), "utcHours"),
-    minutes: /* @__PURE__ */ __name((date, value) => date.setMinutes(value), "minutes"),
-    utcMinutes: /* @__PURE__ */ __name((date, value) => date.setUTCMinutes(value), "utcMinutes"),
-    seconds: /* @__PURE__ */ __name((date, value) => date.setSeconds(value), "seconds"),
-    utcSeconds: /* @__PURE__ */ __name((date, value) => date.setUTCSeconds(value), "utcSeconds"),
-    milliseconds: /* @__PURE__ */ __name((date, value) => date.setMilliseconds(value), "milliseconds"),
-    utcMilliseconds: /* @__PURE__ */ __name((date, value) => date.setUTCMilliseconds(value), "utcMilliseconds"),
-    time: /* @__PURE__ */ __name((date, value) => date.setTime(value), "time")
-  };
-  _getters = {
-    year: /* @__PURE__ */ __name((date) => date.getFullYear(), "year"),
-    utcYear: /* @__PURE__ */ __name((date) => date.getUTCFullYear(), "utcYear"),
-    month: /* @__PURE__ */ __name((date) => date.getMonth(), "month"),
-    utcMonth: /* @__PURE__ */ __name((date) => date.getUTCMonth(), "utcMonth"),
-    date: /* @__PURE__ */ __name((date) => date.getDate(), "date"),
-    utcDate: /* @__PURE__ */ __name((date) => date.getUTCDate(), "utcDate"),
-    hours: /* @__PURE__ */ __name((date) => date.getHours(), "hours"),
-    utcHours: /* @__PURE__ */ __name((date) => date.getUTCHours(), "utcHours"),
-    minutes: /* @__PURE__ */ __name((date) => date.getMinutes(), "minutes"),
-    utcMinutes: /* @__PURE__ */ __name((date) => date.getUTCMinutes(), "utcMinutes"),
-    seconds: /* @__PURE__ */ __name((date) => date.getSeconds(), "seconds"),
-    utcSeconds: /* @__PURE__ */ __name((date) => date.getUTCSeconds(), "utcSeconds"),
-    milliseconds: /* @__PURE__ */ __name((date) => date.getMilliseconds(), "milliseconds"),
-    utcMilliseconds: /* @__PURE__ */ __name((date) => date.getUTCMilliseconds(), "utcMilliseconds"),
-    time: /* @__PURE__ */ __name((date) => date.getTime(), "time")
+  _resolvedValueCache;
+  constructor(_resolvedValueCache) {
+    this._resolvedValueCache = _resolvedValueCache;
+  }
+  except(source) {
+    if (source instanceof Promise || source instanceof Observable) {
+      const value = this._resolvedValueCache.get(source);
+      return value === void 0 ? PENDING : value;
+    }
+    return void 0;
+  }
+};
+DeepCloneValueExcept = _ts_decorate10([
+  injectable(),
+  _ts_param5(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
+  ])
+], DeepCloneValueExcept);
+
+// lib/deep-clone/default-deep-clone.ts
+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_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);
   };
-  isAsync() {
-    return false;
+}
+__name(_ts_param6, "_ts_param");
+var DefaultDeepClone = class {
+  static {
+    __name(this, "DefaultDeepClone");
   }
-  getIndexes() {
-    return dataProperties.values();
+  _deepCloneList;
+  priority = 0;
+  constructor(_deepCloneList) {
+    this._deepCloneList = _deepCloneList;
   }
-  hasValue(context, index) {
-    return this.getValue(context, index) !== void 0;
+  clone(source) {
+    let error = null;
+    for (let i = 0; i < this._deepCloneList.length; i++) {
+      try {
+        return this._deepCloneList[i].clone(source);
+      } catch (e) {
+        error = e;
+      }
+    }
+    throw error;
+  }
+};
+DefaultDeepClone = _ts_decorate11([
+  injectable(),
+  _ts_param6(0, multiInject(RsXCoreInjectionTokens.IDeepCloneList)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    Object
+  ])
+], DefaultDeepClone);
+
+// lib/deep-clone/lodash-deep-clone.ts
+import cloneDeepWith from "lodash.clonedeepwith";
+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_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 LodashDeepClone = class {
+  static {
+    __name(this, "LodashDeepClone");
+  }
+  _deepCloneExcept;
+  priority = 1;
+  constructor(_deepCloneExcept) {
+    this._deepCloneExcept = _deepCloneExcept;
+  }
+  clone(source) {
+    return cloneDeepWith(source, this.cloneExceptPredicate);
+  }
+  cloneExceptPredicate = /* @__PURE__ */ __name((value) => {
+    return this._deepCloneExcept.except(value);
+  }, "cloneExceptPredicate");
+};
+LodashDeepClone = _ts_decorate12([
+  injectable(),
+  _ts_param7(0, inject(RsXCoreInjectionTokens.DefaultDeepCloneExcept)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof IDeepCloneExcept === "undefined" ? Object : IDeepCloneExcept
+  ])
+], LodashDeepClone);
+
+// lib/deep-clone/structured-deep-clone.ts
+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");
+var StructuredDeepClone = class {
+  static {
+    __name(this, "StructuredDeepClone");
+  }
+  priority = 2;
+  clone(source) {
+    return structuredClone(source);
+  }
+};
+StructuredDeepClone = _ts_decorate13([
+  injectable()
+], StructuredDeepClone);
+
+// lib/equality-service/equality-service.ts
+import { createCustomEqual } from "fast-equals";
+import { isObservable as isObservable3 } from "rxjs";
+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");
+var EqualityService = class {
+  static {
+    __name(this, "EqualityService");
+  }
+  isEqual = createCustomEqual({
+    createCustomConfig: /* @__PURE__ */ __name((baseConfig) => ({
+      ...baseConfig,
+      areObjectsEqual: /* @__PURE__ */ __name((a, b, equalityCheck) => {
+        if (isObservable3(a) && isObservable3(b)) {
+          return a === b;
+        }
+        return baseConfig.areObjectsEqual(a, b, equalityCheck);
+      }, "areObjectsEqual")
+    }), "createCustomConfig")
+  });
+};
+EqualityService = _ts_decorate14([
+  injectable()
+], EqualityService);
+
+// lib/error-log/error-log.ts
+import { Subject as Subject2 } from "rxjs";
+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_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+var ErrorLog = class {
+  static {
+    __name(this, "ErrorLog");
+  }
+  _error;
+  constructor() {
+    this._error = new Subject2();
+  }
+  get error() {
+    return this._error;
+  }
+  add(error) {
+    console.error(error);
+    this._error.next(error);
+  }
+  clear() {
+    console.clear();
+  }
+};
+ErrorLog = _ts_decorate15([
+  injectable(),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [])
+], ErrorLog);
+
+// lib/error-log/pretty-printer.ts
+function registerHandler(handler) {
+  return {
+    predicate: handler.predicate,
+    action: /* @__PURE__ */ __name((value, level, quoteStrings) => handler.action(value, level, quoteStrings), "action")
+  };
+}
+__name(registerHandler, "registerHandler");
+var PrettyPrinter = class {
+  static {
+    __name(this, "PrettyPrinter");
+  }
+  indent;
+  handlers;
+  constructor(indent = 4) {
+    this.indent = indent;
+    this.handlers = [
+      registerHandler({
+        predicate: /* @__PURE__ */ __name((v) => v === null || [
+          "string",
+          "number",
+          "boolean",
+          "bigint",
+          "symbol",
+          "undefined"
+        ].includes(typeof v), "predicate"),
+        action: /* @__PURE__ */ __name((v, level, quoteStrings) => [
+          this.spaces(level) + this.formatPrimitive(v, quoteStrings ?? false)
+        ], "action")
+      }),
+      registerHandler({
+        predicate: /* @__PURE__ */ __name((v) => typeof v === "function", "predicate"),
+        action: /* @__PURE__ */ __name((_, level) => [
+          this.spaces(level) + "[[function]]"
+        ], "action")
+      }),
+      registerHandler({
+        predicate: Array.isArray,
+        action: /* @__PURE__ */ __name((v, level, quoteStrings) => {
+          if (v.length === 0) {
+            return [
+              this.spaces(level) + "[]"
+            ];
+          }
+          const lines = [
+            this.spaces(level) + "["
+          ];
+          for (let i = 0; i < v.length; i++) {
+            const nested = this.toLines(v[i], level + 1, quoteStrings);
+            lines.push(...nested);
+            if (i < v.length - 1) {
+              lines[lines.length - 1] += ",";
+            }
+          }
+          lines.push(this.spaces(level) + "]");
+          return lines;
+        }, "action")
+      }),
+      registerHandler({
+        predicate: /* @__PURE__ */ __name((v) => v instanceof Map, "predicate"),
+        action: /* @__PURE__ */ __name((v, level, quoteStrings) => {
+          if (v.size === 0) {
+            return [
+              this.spaces(level) + "{}"
+            ];
+          }
+          const lines = [
+            this.spaces(level) + "{"
+          ];
+          const next = this.spaces(level + 1);
+          for (const [k, val] of v.entries()) {
+            const nested = this.toLines(val, level + 1, quoteStrings);
+            lines.push(`${next}${this.formatKey(k)}: ${nested[0].trimStart()}`);
+            if (nested.length > 1) {
+              lines.push(...nested.slice(1));
+            }
+          }
+          lines.push(this.spaces(level) + "}");
+          return lines;
+        }, "action")
+      }),
+      registerHandler({
+        predicate: /* @__PURE__ */ __name((v) => v instanceof Set, "predicate"),
+        action: /* @__PURE__ */ __name((v, level, quoteStrings) => {
+          if (v.size === 0) {
+            return [
+              this.spaces(level) + "{}"
+            ];
+          }
+          const lines = [
+            this.spaces(level) + "{"
+          ];
+          for (const item of v) {
+            lines.push(...this.toLines(item, level + 1, quoteStrings));
+          }
+          lines.push(this.spaces(level) + "}");
+          return lines;
+        }, "action")
+      }),
+      registerHandler({
+        predicate: /* @__PURE__ */ __name((v) => typeof v === "object" && v !== null && "toLines" in v, "predicate"),
+        action: /* @__PURE__ */ __name((v, _level) => v.toLines(this.indent, _level), "action")
+      }),
+      registerHandler({
+        predicate: /* @__PURE__ */ __name((v) => this.isCustomToString(v), "predicate"),
+        action: /* @__PURE__ */ __name((v, level) => {
+          const raw = v.toString(this.indent, level);
+          const lines = Array.isArray(raw) ? raw : String(raw).split("\n");
+          return lines.map((l) => this.spaces(level) + l);
+        }, "action")
+      }),
+      registerHandler({
+        predicate: /* @__PURE__ */ __name((v) => typeof v === "object" && v !== null && !Array.isArray(v), "predicate"),
+        action: /* @__PURE__ */ __name((v, level, quoteStrings) => {
+          const keys = Object.keys(v);
+          if (keys.length === 0) {
+            return [
+              this.spaces(level) + "{}"
+            ];
+          }
+          const lines = [
+            this.spaces(level) + "{"
+          ];
+          const next = this.spaces(level + 1);
+          for (const key of keys) {
+            const nested = this.toLines(v[key], level + 1, quoteStrings);
+            lines.push(`${next}${key}: ${nested[0].trimStart()}`);
+            if (nested.length > 1) {
+              lines.push(...nested.slice(1));
+            }
+          }
+          lines.push(this.spaces(level) + "}");
+          return lines;
+        }, "action")
+      })
+    ];
+  }
+  toString(value, quoteStrings = true) {
+    return this.toLines(value, 0, quoteStrings).join("\n");
+  }
+  toLines(value, level = 0, quoteStrings = true) {
+    for (const handler of this.handlers) {
+      if (handler.predicate(value)) {
+        return handler.action(value, level, quoteStrings);
+      }
+    }
+    return [
+      this.spaces(level) + String(value)
+    ];
+  }
+  formatPrimitive(value, quoteStrings) {
+    if (typeof value === "string" && quoteStrings) {
+      return `'${value}'`;
+    }
+    return String(value);
+  }
+  formatKey(key) {
+    return typeof key === "string" ? key : String(key);
+  }
+  spaces(level) {
+    return " ".repeat(this.indent * level);
+  }
+  isCustomToString(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const proto = Object.getPrototypeOf(value);
+    if (!proto) return false;
+    const desc = Object.getOwnPropertyDescriptor(proto, "toString");
+    return !!desc && typeof desc.value === "function" && desc.value !== Object.prototype.toString;
+  }
+};
+
+// lib/error-log/print-value.ts
+function printValue(value) {
+  console.log(new PrettyPrinter().toString(value, false));
+}
+__name(printValue, "printValue");
+
+// lib/function-call-index/function-call-index.ts
+var FunctionCallIndex = class {
+  static {
+    __name(this, "FunctionCallIndex");
   }
-  getResolvedValue(context, index) {
-    return this.getValue(context, index);
+  context;
+  functionName;
+  _sequenceWithId;
+  _owner;
+  _isDisposed = false;
+  _id;
+  constructor(context, functionName, _sequenceWithId, _owner) {
+    this.context = context;
+    this.functionName = functionName;
+    this._sequenceWithId = _sequenceWithId;
+    this._owner = _owner;
   }
-  getValue(date, index) {
-    return this._getters[index]?.(date);
+  get id() {
+    if (!this._id) {
+      this._id = `${this.functionName}${this._sequenceWithId.id}`;
+    }
+    return this._id;
   }
-  setValue(date, index, value) {
-    this._setter[index]?.(date, value);
+  get argumentsId() {
+    return this._sequenceWithId;
   }
-  applies(context, index) {
-    return context instanceof Date && !!this._getters[index];
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    if (this._owner.canDispose?.()) {
+      this._isDisposed = true;
+      this._sequenceWithId.dispose();
+    }
+    this._owner.release();
   }
 };
-DatePropertyAccessor = _ts_decorate12([
-  injectable()
-], DatePropertyAccessor);
 
-// lib/index-value-accessor/index-value-accessor.ts
-function _ts_decorate13(decorators, target, key, desc) {
+// lib/singleton-factory/singleton.factory.ts
+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_decorate13, "_ts_decorate");
-function _ts_metadata8(k, v) {
+__name(_ts_decorate16, "_ts_decorate");
+function _ts_metadata9(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata8, "_ts_metadata");
-function _ts_param6(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param6, "_ts_param");
-var IndexValueAccessor = class {
+__name(_ts_metadata9, "_ts_metadata");
+var SingletonFactory = class {
   static {
-    __name(this, "IndexValueAccessor");
-  }
-  priority = 0;
-  _accessors;
-  constructor(accessors) {
-    this._accessors = [
-      ...accessors
-    ].sort((a, b) => b.priority - a.priority);
+    __name(this, "SingletonFactory");
   }
-  getIndexes(context, index) {
-    return this.getIndexAccessor(context, index).getIndexes(context, index);
+  _instances = /* @__PURE__ */ new Map();
+  _referenceCounts = /* @__PURE__ */ new Map();
+  constructor() {
   }
-  isAsync(context, index) {
-    return this.getIndexAccessor(context, index).isAsync(context, index);
+  exists(target) {
+    for (const instance of this._instances.values()) {
+      if (target === instance) {
+        return true;
+      }
+    }
+    return false;
   }
-  hasValue(context, index) {
-    return this.getIndexAccessor(context, index).hasValue(context, index);
+  toLines(indent = 4, level = 0) {
+    const lines = [];
+    const spaces = " ".repeat(indent * level);
+    const spacesNext = " ".repeat(indent * (level + 1));
+    const prettyPrinter = new PrettyPrinter();
+    lines.push(spaces + "___________________________________________________________");
+    lines.push(spaces + `${this.constructor.name}`);
+    for (const [key, instance] of this._instances.entries()) {
+      lines.push(spacesNext + "___________________________________________________________");
+      lines.push(spacesNext + `key (ref. count = ${this._referenceCounts.get(key)}):`);
+      const keyLines = prettyPrinter.toLines(key, level + 2, false);
+      lines.push(...keyLines);
+      lines.push(spacesNext + "instance:");
+      const instanceLines = prettyPrinter.toLines(instance, level + 2, false);
+      lines.push(...instanceLines);
+    }
+    return lines;
   }
-  getResolvedValue(context, index) {
-    return this.getIndexAccessor(context, index).getResolvedValue(context, index);
+  toString(indent = 4, level = 0) {
+    return this.toLines(indent, level).map((l) => " ".repeat(indent * level) + l).join("\n");
   }
-  getValue(context, index) {
-    return this.getIndexAccessor(context, index).getValue(context, index);
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `${this.constructor.name}`;
   }
-  setValue(context, index, value) {
-    this.getIndexAccessor(context, index).setValue(context, index, value);
+  get isEmpty() {
+    return this._instances.size === 0;
   }
-  applies(context, index) {
-    return this.getIndexAccessor(context, index).applies(context, index);
+  ids() {
+    return this._instances.keys();
   }
-  getIndexAccessor(context, index) {
-    const accessor = this._accessors.find((accessor2) => accessor2.applies(context, index));
-    if (!accessor) {
-      if (typeof context === "object" && context !== null) {
-        throw new UnsupportedException(`No accessor found for ${context.constructor.name}.${String(index)}`);
-      } else {
-        throw new UnsupportedException(`No accessor found for non-object context: ${String(context)}.${String(index)}`);
-      }
-    }
-    return accessor;
+  getFromId(id) {
+    return this._instances.get(id);
   }
-};
-IndexValueAccessor = _ts_decorate13([
-  injectable(),
-  _ts_param6(0, multiInject(RsXCoreInjectionTokens.IIndexValueAccessorList)),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
-    Object
-  ])
-], IndexValueAccessor);
-
-// lib/index-value-accessor/map-key-accessor.ts
-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");
-var MapKeyAccessor = class {
-  static {
-    __name(this, "MapKeyAccessor");
+  has(id) {
+    return this._instances.has(id);
   }
-  priority = 4;
-  getIndexes(map) {
-    return map.keys();
+  getFromData(data) {
+    const id = this.getId(data);
+    return id !== void 0 ? this.getFromId(id) : void 0;
   }
-  isAsync() {
-    return false;
+  dispose() {
+    for (const id of this._instances.keys()) {
+      this.release(id, true);
+    }
+    this._instances.clear();
+    this._referenceCounts.clear();
+    this.onDipose();
   }
-  hasValue(map, key) {
-    return map.has(key);
+  getOrCreate(data) {
+    let instance = this.getFromId(this.getOrCreateId(data));
+    if (instance === void 0) {
+      instance = this.create(data).instance;
+    }
+    return instance;
   }
-  getResolvedValue(map, key) {
-    return map.get(key);
+  create(data) {
+    const id = this.getOrCreateId(data);
+    const instance = this.getOrCreateInstance(id, data);
+    const result = {
+      id,
+      instance,
+      referenceCount: this.updateReferenceCount(id, 1, instance)
+    };
+    if (result.referenceCount === 1) {
+      this.onInstanceCreated(result.instance, data);
+    }
+    return result;
   }
-  getValue(map, key) {
-    return this.getResolvedValue(map, key);
+  release(id, force) {
+    const instance = this._instances.get(id);
+    if (!instance) {
+      return {
+        instance: null,
+        referenceCount: 0
+      };
+    }
+    return {
+      referenceCount: this.updateReferenceCount(id, -1, instance, force),
+      instance
+    };
   }
-  setValue(map, key, value) {
-    map.set(key, value);
+  getReferenceCount(id) {
+    return this._referenceCounts.get(id) ?? 0;
   }
-  applies(map) {
-    return map instanceof Map;
+  get keys() {
+    return this._instances.keys();
   }
-};
-MapKeyAccessor = _ts_decorate14([
-  injectable()
-], MapKeyAccessor);
-
-// lib/index-value-accessor/method-accessor.ts
-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_metadata9(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata9, "_ts_metadata");
-function _ts_param7(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param7, "_ts_param");
-var MethodAccessor = class {
-  static {
-    __name(this, "MethodAccessor");
+  get instances() {
+    return this._instances.values();
   }
-  _functionCallResultCacheFactory;
-  priority = 6;
-  constructor(_functionCallResultCacheFactory) {
-    this._functionCallResultCacheFactory = _functionCallResultCacheFactory;
+  replaceKey(oldKey, newKey) {
+    const instance = this.getFromId(oldKey);
+    if (instance == void 0) {
+      return;
+    }
+    this._instances.delete(oldKey);
+    this._instances.set(newKey, instance);
   }
-  getIndexes() {
-    return [].values();
+  onDisposeInstance = /* @__PURE__ */ __name((id, dispose) => {
+    const { referenceCount } = this.release(id);
+    if (referenceCount === 0) {
+      dispose();
+    }
+    return referenceCount === 0;
+  }, "onDisposeInstance");
+  onDipose() {
   }
-  isAsync() {
-    return false;
+  onReleased() {
   }
-  hasValue(context, index) {
-    return this._functionCallResultCacheFactory.has(context, index);
+  releaseInstance(_instance, _id) {
   }
-  getResolvedValue(context, index) {
-    return this.getValue(context, index);
+  onInstanceCreated(_instance, _data) {
   }
-  getValue(context, index) {
-    return this._functionCallResultCacheFactory.get(context, index)?.result;
+  getOrCreateId(data) {
+    return this.getId(data) ?? this.createId(data);
   }
-  setValue(_, index) {
-    throw new UnsupportedException(`Cannot set method '${index}'`);
+  updateReferenceCount(id, change, instance, forceRelease) {
+    const referenceCount = this.getReferenceCount(id) + change;
+    if (change === -1 && (forceRelease || referenceCount === 0)) {
+      this._instances.delete(id);
+      this._referenceCounts.delete(id);
+      this.releaseInstance(instance, id);
+      this.onReleased();
+    } else if (referenceCount > 0) {
+      this._referenceCounts.set(id, referenceCount);
+    }
+    return referenceCount;
   }
-  applies(context, index) {
-    if (typeof context !== "object" || context === null) {
-      return false;
+  getOrCreateInstance(id, data) {
+    let instance = this._instances.get(id);
+    if (instance !== void 0) {
+      return instance;
     }
-    const prop = context[index.functionName];
-    return Type.isFunction(prop) || Type.isArrowFunction(prop);
+    instance = this.createInstance(data, id);
+    this._instances.set(id, instance);
+    return instance;
   }
 };
-MethodAccessor = _ts_decorate15([
-  injectable(),
-  _ts_param7(0, inject(RsXCoreInjectionTokens.IFunctionCallResultCacheFactory)),
+_ts_decorate16([
+  preDestroy(),
   _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
-    typeof IFunctionCallResultCacheFactory === "undefined" ? Object : IFunctionCallResultCacheFactory
-  ])
-], MethodAccessor);
-
-// lib/index-value-accessor/observable-accessor.ts
-import { BehaviorSubject, isObservable as isObservable2, Subject as Subject2 } from "rxjs";
-
-// lib/types/set.ts
-function replaceSetItemAt(set, oldValue, newValue) {
-  const values = Array.from(set);
-  const index = values.indexOf(oldValue);
-  if (index === -1) {
-    throw new RangeError("Index out of range");
-  }
-  values[index] = newValue;
-  set.clear();
-  values.forEach((value) => set.add(value));
-  return set;
-}
-__name(replaceSetItemAt, "replaceSetItemAt");
-
-// lib/types/utc-date.ts
-function utCDate(year, month = 0, date = 1, hours = 0, minutes = 0, seconds = 0, millisecond = 0) {
-  return new Date(Date.UTC(year, month, date, hours, minutes, seconds, millisecond));
-}
-__name(utCDate, "utCDate");
-
-// lib/index-value-accessor/pending.ts
-var PENDING = Symbol("pending");
+  _ts_metadata9("design:paramtypes", []),
+  _ts_metadata9("design:returntype", void 0)
+], SingletonFactory.prototype, "dispose", null);
 
-// lib/index-value-accessor/observable-accessor.ts
-function _ts_decorate16(decorators, target, key, desc) {
+// lib/function-call-index/function-call-index.factory.ts
+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_decorate16, "_ts_decorate");
+__name(_ts_decorate17, "_ts_decorate");
 function _ts_metadata10(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
@@ -1491,74 +1568,52 @@ function _ts_param8(paramIndex, decorator) {
   };
 }
 __name(_ts_param8, "_ts_param");
-var ObservableAccessor = class {
+var FunctionCallIndexFactory = class extends SingletonFactory {
   static {
-    __name(this, "ObservableAccessor");
-  }
-  _resolvedValueCache;
-  priority = 2;
-  constructor(_resolvedValueCache) {
-    this._resolvedValueCache = _resolvedValueCache;
-  }
-  getIndexes() {
-    return [].values();
-  }
-  isAsync() {
-    return true;
+    __name(this, "FunctionCallIndexFactory");
   }
-  getResolvedValue(context, index) {
-    if (context instanceof BehaviorSubject) return context.value;
-    const val = this.getIndexedValue(context, index);
-    if (val && typeof val === "object" || typeof val === "function") {
-      return this._resolvedValueCache.get(val) ?? PENDING;
-    }
-    return PENDING;
+  _sequenceIdFactory;
+  constructor(_sequenceIdFactory) {
+    super(), this._sequenceIdFactory = _sequenceIdFactory;
   }
-  hasValue(context, index) {
-    return this.getResolvedValue(context, index) !== PENDING;
+  getId(data) {
+    return this._sequenceIdFactory.get(data.context, data.arguments);
   }
-  getValue(context, index) {
-    return this.getIndexedValue(context, index);
+  createInstance(data, id) {
+    return new FunctionCallIndex(data.context, data.functionName, id, {
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    });
   }
-  setValue(context, index, value) {
-    const val = this.getIndexedValue(context, index);
-    if (val instanceof Subject2) {
-      val.next(value);
-      return;
+  createId(data) {
+    const context = data.context;
+    if (!context || typeof context !== "object") {
+      throw new ArgumentException(`Expected context to be an object, got ${String(context)}`);
     }
-    throw new UnsupportedException("Cannot set value for an observable");
-  }
-  applies(context, index) {
-    const val = this.getIndexedValue(context, index);
-    return isObservable2(val);
-  }
-  setLastValue(observable, value) {
-    this._resolvedValueCache.set(observable, value);
-  }
-  clearLastValue(observable) {
-    this._resolvedValueCache.delete(observable);
+    const fn = context[data.functionName];
+    return this._sequenceIdFactory.create(fn, data.arguments);
   }
-  getIndexedValue(context, index) {
-    return (Type.toObject(context) ?? {})[index];
+  releaseInstance(_, id) {
+    id.dispose();
   }
 };
-ObservableAccessor = _ts_decorate16([
+FunctionCallIndexFactory = _ts_decorate17([
   injectable(),
-  _ts_param8(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_param8(0, inject(RsXCoreInjectionTokens.ISequenceIdFactory)),
   _ts_metadata10("design:type", Function),
   _ts_metadata10("design:paramtypes", [
-    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
+    typeof ISequenceIdFactory === "undefined" ? Object : ISequenceIdFactory
   ])
-], ObservableAccessor);
+], FunctionCallIndexFactory);
 
-// lib/index-value-accessor/promise-accessor.ts
-function _ts_decorate17(decorators, target, key, desc) {
+// lib/function-call-result-cache/function-call-result-cache.factory.ts
+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_decorate17, "_ts_decorate");
+__name(_ts_decorate18, "_ts_decorate");
 function _ts_metadata11(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
@@ -1569,132 +1624,116 @@ function _ts_param9(paramIndex, decorator) {
   };
 }
 __name(_ts_param9, "_ts_param");
-var PromiseAccessor = class {
+var FunctionCallResultCache = class FunctionCallResultCache2 {
   static {
-    __name(this, "PromiseAccessor");
-  }
-  _resolvedValueCache;
-  priority = 1;
-  constructor(_resolvedValueCache) {
-    this._resolvedValueCache = _resolvedValueCache;
-  }
-  getIndexes() {
-    return [].values();
+    __name(this, "FunctionCallResultCache");
   }
-  isAsync() {
-    return true;
+  _disposeableIndex;
+  result;
+  _owner;
+  _isDisposed = false;
+  constructor(_disposeableIndex, result, _owner) {
+    this._disposeableIndex = _disposeableIndex;
+    this.result = result;
+    this._owner = _owner;
   }
-  hasValue(context, index) {
-    const val = this.getIndexedValue(context, index);
-    return this.isCacheable(val) && this._resolvedValueCache.get(val) !== PENDING;
+  get index() {
+    return this._disposeableIndex;
   }
-  getResolvedValue(context, index) {
-    const val = this.getIndexedValue(context, index);
-    return this.isCacheable(val) ? this._resolvedValueCache.get(val) ?? PENDING : PENDING;
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    if (this._owner.canDispose?.()) {
+      this._disposeableIndex.dispose();
+      this._isDisposed = true;
+    }
+    this._owner.release();
   }
-  getValue(context, index) {
-    return this.getIndexedValue(context, index);
+};
+var FunctionCallResultCacheForContextManager = class FunctionCallResultCacheForContextManager2 extends SingletonFactory {
+  static {
+    __name(this, "FunctionCallResultCacheForContextManager");
   }
-  setValue() {
-    throw new UnsupportedException("Cannot set value for a Promise");
+  _context;
+  _functionCallIndexFactory;
+  releaseContext;
+  constructor(_context, _functionCallIndexFactory, releaseContext) {
+    super(), this._context = _context, this._functionCallIndexFactory = _functionCallIndexFactory, this.releaseContext = releaseContext;
   }
-  applies(context, index) {
-    const val = this.getIndexedValue(context, index);
-    return val instanceof Promise;
+  getId(data) {
+    return this._functionCallIndexFactory.getFromData({
+      functionName: data.functionName,
+      context: this._context,
+      arguments: data.arguments
+    });
   }
-  setLastValue(promise, value) {
-    this._resolvedValueCache.set(promise, value);
+  createInstance(data, id) {
+    return new FunctionCallResultCache(id, data.result, {
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    });
   }
-  clearLastValue(promise) {
-    this._resolvedValueCache.delete(promise);
+  createId(data) {
+    return this._functionCallIndexFactory.create({
+      functionName: data.functionName,
+      context: this._context,
+      arguments: data.arguments
+    }).instance;
   }
-  getIndexedValue(context, index) {
-    return (Type.toObject(context) ?? {})[index];
+  releaseInstance(_, id) {
+    this._functionCallIndexFactory.release(id.argumentsId);
   }
-  isCacheable(value) {
-    return value !== null && (typeof value === "object" || typeof value === "function");
+  onReleased() {
+    this.releaseContext();
   }
 };
-PromiseAccessor = _ts_decorate17([
-  injectable(),
-  _ts_param9(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
-    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
-  ])
-], PromiseAccessor);
-
-// lib/index-value-accessor/property-value-accessor.ts
-import { isObservable as isObservable3 } from "rxjs";
-var PropertyValueAccessor = class {
+var FunctionCallResultCacheManager = class FunctionCallResultCacheManager2 extends SingletonFactory {
   static {
-    __name(this, "PropertyValueAccessor");
-  }
-  priority = 7;
-  isAsync() {
-    return false;
-  }
-  getIndexes(context) {
-    const obj = Type.toObject(context);
-    if (!obj) {
-      return [].values();
-    }
-    return Object.keys(obj).filter((key) => !Type.isMethod(obj[key])).values();
-  }
-  hasValue(context, index) {
-    const val = this.getValue(context, index);
-    return val !== void 0;
+    __name(this, "FunctionCallResultCacheManager");
   }
-  getResolvedValue(context, index) {
-    return this.getValue(context, index);
+  _functionCallIndexFactory;
+  constructor(_functionCallIndexFactory) {
+    super(), this._functionCallIndexFactory = _functionCallIndexFactory;
   }
-  getValue(context, index) {
-    const obj = Type.toObject(context);
-    return obj ? obj[index] : void 0;
+  getId(contex) {
+    return this.createId(contex);
   }
-  setValue(context, index, value) {
-    const obj = Type.toObject(context);
-    if (obj) {
-      obj[index] = value;
-    }
+  createInstance(context, id) {
+    return new FunctionCallResultCacheForContextManager(context, this._functionCallIndexFactory, () => this.release(id));
   }
-  applies(context, index) {
-    const obj = Type.toObject(context);
-    if (!obj) {
-      return false;
-    }
-    return Type.hasProperty(obj, index) && !(obj instanceof Date) && !isObservable3(obj[index]) && !(obj[index] instanceof Promise);
+  createId(contex) {
+    return contex;
   }
 };
-
-// lib/index-value-accessor/resolved-value-cache.ts
-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");
-var ResolvedValueCache = class {
+var FunctionCallResultCacheFactory = class {
   static {
-    __name(this, "ResolvedValueCache");
+    __name(this, "FunctionCallResultCacheFactory");
   }
-  _resolvedValues = /* @__PURE__ */ new WeakMap();
-  set(source, value) {
-    this._resolvedValues.set(source, value);
+  _functionCallResultCacheManager;
+  constructor(functionCallIndexFactory) {
+    this._functionCallResultCacheManager = new FunctionCallResultCacheManager(functionCallIndexFactory);
   }
-  get(source) {
-    return this._resolvedValues.get(source);
+  create(context, result) {
+    return this._functionCallResultCacheManager.create(context).instance.create(result).instance;
   }
-  delete(source) {
-    this._resolvedValues.delete(source);
+  has(context, index) {
+    return this._functionCallResultCacheManager.getFromId(context)?.has(index) ?? false;
+  }
+  get(context, index) {
+    return this._functionCallResultCacheManager.getFromId(context)?.getFromId(index);
   }
 };
-ResolvedValueCache = _ts_decorate18([
-  injectable()
-], ResolvedValueCache);
+FunctionCallResultCacheFactory = _ts_decorate18([
+  injectable(),
+  _ts_param9(0, inject(RsXCoreInjectionTokens.IFunctionCallIndexFactory)),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", [
+    typeof IFunctionCallIndexFactory === "undefined" ? Object : IFunctionCallIndexFactory
+  ])
+], FunctionCallResultCacheFactory);
 
-// lib/index-value-accessor/set-key-accessor.ts
+// lib/guid/guid.factory.ts
 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);
@@ -1702,36 +1741,17 @@ function _ts_decorate19(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate19, "_ts_decorate");
-var SetKeyAccessor = class {
+var GuidFactory = class {
   static {
-    __name(this, "SetKeyAccessor");
-  }
-  priority = 3;
-  getIndexes(set) {
-    return new Set(set).values();
-  }
-  isAsync() {
-    return false;
-  }
-  hasValue(set, key) {
-    return set.has(key);
-  }
-  getResolvedValue(set, key) {
-    return set.has(key) ? key : void 0;
-  }
-  getValue(set, key) {
-    return this.getResolvedValue(set, key);
-  }
-  setValue(set, key, value) {
-    replaceSetItemAt(set, key, value);
+    __name(this, "GuidFactory");
   }
-  applies(map) {
-    return map instanceof Set;
+  create() {
+    return crypto.randomUUID();
   }
 };
-SetKeyAccessor = _ts_decorate19([
+GuidFactory = _ts_decorate19([
   injectable()
-], SetKeyAccessor);
+], GuidFactory);
 
 // lib/singleton-factory/singleton-factory-with-id-generation.ts
 var SingletonFactoryWithIdGeneration = class extends SingletonFactory {
@@ -1739,6 +1759,26 @@ var SingletonFactoryWithIdGeneration = class extends SingletonFactory {
     __name(this, "SingletonFactoryWithIdGeneration");
   }
   _groupedData = /* @__PURE__ */ new Map();
+  *instanceGroupInfoEntries() {
+    for (const groupId of this.groupIds) {
+      const group = this.getGroup(groupId);
+      if (!group) {
+        continue;
+      }
+      for (const [groupMemberId, id] of group) {
+        const instance = this.getFromId(id);
+        if (!instance) {
+          continue;
+        }
+        yield {
+          groupId,
+          groupMemberId,
+          id,
+          instance
+        };
+      }
+    }
+  }
   getId(data) {
     const groupId = this.getGroupId(data);
     const groupMemberId = this.getGroupMemberId(data);
@@ -1747,6 +1787,12 @@ var SingletonFactoryWithIdGeneration = class extends SingletonFactory {
   isGroupRegistered(groupId) {
     return this._groupedData.has(groupId);
   }
+  get groupIds() {
+    return this._groupedData.keys();
+  }
+  getGroup(groupId) {
+    return this._groupedData.get(groupId);
+  }
   createId(data) {
     const groupId = this.getGroupId(data);
     let dataGroup = this._groupedData.get(groupId);
@@ -2013,6 +2059,251 @@ SequenceIdFactory = _ts_decorate20([
   ])
 ], SequenceIdFactory);
 
+// lib/value-metadata/array-metadata.ts
+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");
+var ArrayMetadata = class {
+  static {
+    __name(this, "ArrayMetadata");
+  }
+  priority = 8;
+  isAsync() {
+    return false;
+  }
+  needsProxy() {
+    return true;
+  }
+  applies(value) {
+    return Array.isArray(value);
+  }
+};
+ArrayMetadata = _ts_decorate21([
+  injectable()
+], ArrayMetadata);
+
+// lib/value-metadata/date-metadata.ts
+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");
+var DateMetadata = class {
+  static {
+    __name(this, "DateMetadata");
+  }
+  priority = 7;
+  isAsync() {
+    return false;
+  }
+  needsProxy() {
+    return true;
+  }
+  applies(value) {
+    return value instanceof Date;
+  }
+};
+DateMetadata = _ts_decorate22([
+  injectable()
+], DateMetadata);
+
+// lib/value-metadata/dummy-metadata.ts
+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 DummyMetadata = class {
+  static {
+    __name(this, "DummyMetadata");
+  }
+  priority = -1e3;
+  isAsync() {
+    return false;
+  }
+  needsProxy() {
+    return false;
+  }
+  applies() {
+    return true;
+  }
+};
+DummyMetadata = _ts_decorate23([
+  injectable()
+], DummyMetadata);
+
+// lib/value-metadata/map-metadata.ts
+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");
+var MapMetadata = class {
+  static {
+    __name(this, "MapMetadata");
+  }
+  priority = 6;
+  isAsync() {
+    return false;
+  }
+  needsProxy() {
+    return true;
+  }
+  applies(value) {
+    return value instanceof Map;
+  }
+};
+MapMetadata = _ts_decorate24([
+  injectable()
+], MapMetadata);
+
+// lib/value-metadata/observable-metadata.ts
+import { Observable as Observable2 } from "rxjs";
+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");
+var ObservableMetadata = class {
+  static {
+    __name(this, "ObservableMetadata");
+  }
+  priority = 5;
+  isAsync() {
+    return true;
+  }
+  needsProxy() {
+    return true;
+  }
+  applies(value) {
+    return value instanceof Observable2;
+  }
+};
+ObservableMetadata = _ts_decorate25([
+  injectable()
+], ObservableMetadata);
+
+// lib/value-metadata/promise-metadata.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");
+var PromiseMetadata = class {
+  static {
+    __name(this, "PromiseMetadata");
+  }
+  priority = 4;
+  isAsync() {
+    return true;
+  }
+  needsProxy() {
+    return true;
+  }
+  applies(value) {
+    return value instanceof Promise;
+  }
+};
+PromiseMetadata = _ts_decorate26([
+  injectable()
+], PromiseMetadata);
+
+// lib/value-metadata/set-metadata.ts
+function _ts_decorate27(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_decorate27, "_ts_decorate");
+var SetMetadata = class {
+  static {
+    __name(this, "SetMetadata");
+  }
+  priority = 3;
+  isAsync() {
+    return false;
+  }
+  needsProxy() {
+    return true;
+  }
+  applies(value) {
+    return value instanceof Set;
+  }
+};
+SetMetadata = _ts_decorate27([
+  injectable()
+], SetMetadata);
+
+// lib/value-metadata/value-metadata.ts
+function _ts_decorate28(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_decorate28, "_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_param11(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param11, "_ts_param");
+var ValueMetadata = class {
+  static {
+    __name(this, "ValueMetadata");
+  }
+  priority = 11;
+  _valueMetadataList;
+  constructor(valueMetadataList) {
+    this._valueMetadataList = [
+      ...valueMetadataList
+    ].sort((a, b) => b.priority - a.priority);
+  }
+  isAsync(value) {
+    return this.getValueMetadata(value).isAsync(value);
+  }
+  needsProxy(value) {
+    return this.getValueMetadata(value).needsProxy(value);
+  }
+  applies(value) {
+    return !!this.getValueMetadata(value);
+  }
+  getValueMetadata(value) {
+    const valueMetadata = this._valueMetadataList.find((valueMetadata2) => valueMetadata2.applies(value));
+    if (!valueMetadata) {
+      throw new UnsupportedException(`No accessor found for ${Type.toObject(value)?.constructor.name}}`);
+    }
+    return valueMetadata;
+  }
+};
+ValueMetadata = _ts_decorate28([
+  injectable(),
+  _ts_param11(0, multiInject(RsXCoreInjectionTokens.IValueMetadataList)),
+  _ts_metadata13("design:type", Function),
+  _ts_metadata13("design:paramtypes", [
+    Object
+  ])
+], ValueMetadata);
+
 // lib/rs-x-core.module.ts
 var defaultIndexValueAccessorList = [
   {
@@ -2058,6 +2349,36 @@ var defaultDeeoCloneList = [
     token: RsXCoreInjectionTokens.ILodashDeepClone
   }
 ];
+var defaultValueMetadataList = [
+  {
+    target: ArrayMetadata,
+    token: RsXCoreInjectionTokens.ArrayMetadata
+  },
+  {
+    target: DateMetadata,
+    token: RsXCoreInjectionTokens.DateMetadata
+  },
+  {
+    target: DummyMetadata,
+    token: RsXCoreInjectionTokens.DummyMetadata
+  },
+  {
+    target: MapMetadata,
+    token: RsXCoreInjectionTokens.MapMetadata
+  },
+  {
+    target: ObservableMetadata,
+    token: RsXCoreInjectionTokens.ObservableMetadata
+  },
+  {
+    target: PromiseMetadata,
+    token: RsXCoreInjectionTokens.PromiseMetadata
+  },
+  {
+    target: SetMetadata,
+    token: RsXCoreInjectionTokens.SetMetadata
+  }
+];
 var RsXCoreModule = new ContainerModule((options) => {
   options.bind(RsXCoreInjectionTokens.IInjectionContainer).toConstantValue(InjectionContainer);
   options.bind(RsXCoreInjectionTokens.IErrorLog).to(ErrorLog).inSingletonScope();
@@ -2071,12 +2392,14 @@ var RsXCoreModule = new ContainerModule((options) => {
   options.bind(RsXCoreInjectionTokens.IResolvedValueCache).to(ResolvedValueCache).inSingletonScope();
   options.bind(RsXCoreInjectionTokens.IDeepCloneExcept).to(DeepCloneValueExcept).inSingletonScope();
   options.bind(RsXCoreInjectionTokens.DefaultDeepCloneExcept).to(DeepCloneValueExcept).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.IValueMetadata).to(ValueMetadata).inSingletonScope();
   registerMultiInjectServices(options, RsXCoreInjectionTokens.IIndexValueAccessorList, defaultIndexValueAccessorList);
   registerMultiInjectServices(options, RsXCoreInjectionTokens.IDeepCloneList, defaultDeeoCloneList);
+  registerMultiInjectServices(options, RsXCoreInjectionTokens.IValueMetadataList, defaultValueMetadataList);
 });
 
 // lib/wait-for-event.ts
-import { firstValueFrom, Observable as Observable2 } from "rxjs";
+import { firstValueFrom, Observable as Observable3 } from "rxjs";
 var WaitForEvent = class {
   static {
     __name(this, "WaitForEvent");
@@ -2132,7 +2455,7 @@ var WaitForEvent = class {
       const result = trigger();
       if (result instanceof Promise) {
         await result;
-      } else if (result instanceof Observable2) {
+      } else if (result instanceof Observable3) {
         await firstValueFrom(result);
       }
     } catch (error) {
@@ -2157,12 +2480,17 @@ var WaitForEvent = class {
 export {
   ArgumentException,
   ArrayIndexAccessor,
+  ArrayMetadata,
   Assertion,
+  AssertionError,
   Container,
   ContainerModule,
+  CustomError,
+  DateMetadata,
   DatePropertyAccessor,
   DeepCloneValueExcept,
   DefaultDeepClone,
+  DummyMetadata,
   EqualityService,
   ErrorLog,
   FunctionCallIndex,
@@ -2177,16 +2505,19 @@ export {
   InvalidOperationException,
   LodashDeepClone,
   MapKeyAccessor,
+  MapMetadata,
   MethodAccessor,
   multiInject as MultiInject,
   NullOrEmptyException,
   NullOrUndefinedException,
   ObservableAccessor,
+  ObservableMetadata,
   PENDING,
   ParserException,
   preDestroy as PreDestroy,
   PrettyPrinter,
   PromiseAccessor,
+  PromiseMetadata,
   PropertyDescriptorType,
   PropertyValueAccessor,
   ResolvedValueCache,
@@ -2195,6 +2526,7 @@ export {
   SequenceIdFactory,
   SequenceWithId,
   SetKeyAccessor,
+  SetMetadata,
   SingletonFactory,
   SingletonFactoryWithGuid,
   SingletonFactoryWithIdGeneration,
@@ -2203,10 +2535,12 @@ export {
   UnexpectedException,
   unmanaged as Unmanaged,
   UnsupportedException,
+  ValueMetadata,
   WaitForEvent,
   dataProperties,
   defaultDeeoCloneList,
   defaultIndexValueAccessorList,
+  defaultValueMetadataList,
   echo,
   emptyFunction,
   emptyValue,