@rs-x/core 0.4.9 → 0.4.11

package/dist/index.js

@@ -1,7 +1,7 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// lib/deep-clone/deep-clone-value-getter.ts
+// lib/deep-clone/deep-clone-except.ts
 import { Observable } from "rxjs";
 
 // lib/dependency-injection.ts
@@ -44,6 +44,147 @@ 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;
+  isAsync() {
+    return false;
+  }
+  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")
+  };
+  isAsync() {
+    return false;
+  }
+  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/unsupported-exception.ts
+var UnsupportedException = class extends Error {
+  static {
+    __name(this, "UnsupportedException");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+
 // lib/rs-x-core.injection-tokens.ts
 var RsXCoreInjectionTokens = {
   IInjectionContainer: Symbol("IInjectionContainer"),
@@ -68,18 +209,18 @@ var RsXCoreInjectionTokens = {
   ILodashDeepClone: Symbol("ILodashDeepClone"),
   IDeepCloneList: Symbol("IDeepCloneList"),
   IResolvedValueCache: Symbol("IResolvedValueCache"),
-  IDeepCloneValueGetter: Symbol("IDeepCloneValueGetter"),
-  DefaultDeepCloneValueGetter: Symbol("DefaultDeepCloneValueGetter")
+  IDeepCloneExcept: Symbol("IDeepCloneExcept"),
+  DefaultDeepCloneExcept: Symbol("DefaultDeepCloneExcept")
 };
 
-// lib/deep-clone/deep-clone-value-getter.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,388 +231,97 @@ function _ts_param(paramIndex, decorator) {
   };
 }
 __name(_ts_param, "_ts_param");
-var DeepCloneValueGetter = class {
+var IndexValueAccessor = class {
   static {
-    __name(this, "DeepCloneValueGetter");
+    __name(this, "IndexValueAccessor");
   }
-  _resolvedValueCache;
-  constructor(_resolvedValueCache) {
-    this._resolvedValueCache = _resolvedValueCache;
+  priority = 0;
+  _accessors;
+  constructor(accessors) {
+    this._accessors = [
+      ...accessors
+    ].sort((a, b) => b.priority - a.priority);
   }
-  get(source) {
-    if (source instanceof Promise || source instanceof Observable) {
-      return this._resolvedValueCache.get(source);
+  getIndexes(context, index) {
+    return this.getIndexAccessor(context, index).getIndexes(context, index);
+  }
+  isAsync(context, index) {
+    return this.getIndexAccessor(context, index).isAsync(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 source;
+    return accessor;
   }
 };
-DeepCloneValueGetter = _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
   ])
-], DeepCloneValueGetter);
-
-// lib/deep-clone/deep-clone.decorator.ts
-function DeepClone(serviceToken) {
-  return function(target) {
-    registerMultiInjectService(InjectionContainer, target, {
-      serviceToken,
-      multiInjectToken: RsXCoreInjectionTokens.IDeepCloneList
-    });
-  };
-}
-__name(DeepClone, "DeepClone");
+], 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;
-  _deepCloneValueGetter;
-  priority = 0;
-  constructor(_deepCloneList, _deepCloneValueGetter) {
-    this._deepCloneList = _deepCloneList;
-    this._deepCloneValueGetter = _deepCloneValueGetter;
+  priority = 4;
+  getIndexes(map) {
+    return map.keys();
   }
-  clone(source) {
-    let error = null;
-    const value = this._deepCloneValueGetter.get(source);
-    for (let i = 0; i < this._deepCloneList.length; i++) {
-      try {
-        return this._deepCloneList[i].clone(value);
-      } catch (e) {
-        error = e;
-      }
-    }
-    throw error;
+  isAsync() {
+    return false;
+  }
+  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_param2(1, inject(RsXCoreInjectionTokens.IDeepCloneValueGetter)),
-  _ts_metadata2("design:type", Function),
-  _ts_metadata2("design:paramtypes", [
-    Object,
-    typeof IDeepCloneValueGetter === "undefined" ? Object : IDeepCloneValueGetter
-  ])
-], DefaultDeepClone);
-
-// lib/deep-clone/lodash-deep-clone.ts
-import cloneDeepWith from "lodash.clonedeepwith";
-import { isObservable } from "rxjs";
-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");
-var LodashDeepClone = class {
-  static {
-    __name(this, "LodashDeepClone");
-  }
-  priority = 1;
-  clone(source) {
-    return cloneDeepWith(source, this.cloneExceptPredicate);
-  }
-  cloneExceptPredicate = /* @__PURE__ */ __name((value) => {
-    if (value instanceof Promise || isObservable(value)) {
-      return value;
-    }
-    return void 0;
-  }, "cloneExceptPredicate");
-};
-LodashDeepClone = _ts_decorate3([
-  injectable()
-], 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 {
-  static {
-    __name(this, "StructuredDeepClone");
-  }
-  priority = 2;
-  clone(source) {
-    return structuredClone(source);
-  }
-};
-StructuredDeepClone = _ts_decorate4([
-  injectable()
-], StructuredDeepClone);
-
-// lib/equality-service/equality-service.ts
-import { createCustomEqual } from "fast-equals";
-import { isObservable as isObservable2 } 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 (isObservable2(a) && isObservable2(b)) {
-          return a === b;
-        }
-        return baseConfig.areObjectsEqual(a, b, equalityCheck);
-      }, "areObjectsEqual")
-    }), "createCustomConfig")
-  });
-};
-EqualityService = _ts_decorate5([
-  injectable()
-], EqualityService);
-
-// 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_metadata3(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata3, "_ts_metadata");
-var ErrorLog = class {
-  static {
-    __name(this, "ErrorLog");
-  }
-  _error;
-  constructor() {
-    this._error = new Subject();
-  }
-  get error() {
-    return this._error;
-  }
-  add(error) {
-    console.error(error);
-    this._error.next(error);
-  }
-  clear() {
-    console.clear();
-  }
-};
-ErrorLog = _ts_decorate6([
-  injectable(),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("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");
+MapKeyAccessor = _ts_decorate4([
+  injectable()
+], MapKeyAccessor);
 
 // lib/exceptions/argument-exception.ts
 var ArgumentException = class extends Error {
@@ -671,78 +521,234 @@ var NullOrUndefinedException = class extends Error {
 // lib/exceptions/assertion.ts
 var Assertion = class {
   static {
-    __name(this, "Assertion");
+    __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");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+
+// lib/exceptions/parser-exception.ts
+var ParserException = class extends Error {
+  static {
+    __name(this, "ParserException");
+  }
+  expression;
+  position;
+  constructor(expression, message, position) {
+    super(createMessage(expression, message, position ?? 0)), this.expression = expression, this.position = position;
+  }
+};
+function createMessage(expression, message, position) {
+  if (position >= 0) {
+    return `Invalid expression ${expression}. ${message}. Position ${position}`;
+  }
+  return `Invalid expression ${expression}. ${message}.`;
+}
+__name(createMessage, "createMessage");
+
+// lib/exceptions/unexpected-exception.ts
+var UnexpectedException = class extends Error {
+  static {
+    __name(this, "UnexpectedException");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+
+// 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_decorate5, "_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 MethodAccessor = class {
+  static {
+    __name(this, "MethodAccessor");
+  }
+  _functionCallResultCacheFactory;
+  priority = 6;
+  constructor(_functionCallResultCacheFactory) {
+    this._functionCallResultCacheFactory = _functionCallResultCacheFactory;
+  }
+  getIndexes() {
+    return [].values();
+  }
+  isAsync() {
+    return false;
+  }
+  hasValue(context, index) {
+    return this._functionCallResultCacheFactory.has(context, index);
+  }
+  getResolvedValue(context, index) {
+    return this.getValue(context, index);
+  }
+  getValue(context, index) {
+    return this._functionCallResultCacheFactory.get(context, index)?.result;
+  }
+  setValue(_, index) {
+    throw new UnsupportedException(`Cannot set method '${index}'`);
+  }
+  applies(context, index) {
+    if (typeof context !== "object" || context === null) {
+      return false;
+    }
+    const prop = context[index.functionName];
+    return Type.isFunction(prop) || Type.isArrowFunction(prop);
+  }
+};
+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/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/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_decorate6, "_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 ObservableAccessor = class {
+  static {
+    __name(this, "ObservableAccessor");
   }
-  constructor() {
+  _resolvedValueCache;
+  priority = 2;
+  constructor(_resolvedValueCache) {
+    this._resolvedValueCache = _resolvedValueCache;
   }
-  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`);
-    }
+  getIndexes() {
+    return [].values();
   }
-  static assertNotNullOrUndefined(value, argumentName) {
-    if (Type.isNullOrUndefined(value)) {
-      throw new NullOrUndefinedException(argumentName);
-    }
+  isAsync() {
+    return true;
   }
-  static assertNotNullOrEmpty(value, argumentName) {
-    if (Type.isEmpty(value)) {
-      throw new NullOrEmptyException(argumentName);
+  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;
   }
-};
-
-// lib/exceptions/invalid-operation-exception.ts
-var InvalidOperationException = class extends Error {
-  static {
-    __name(this, "InvalidOperationException");
-  }
-  constructor(message) {
-    super(message);
-  }
-};
-
-// lib/exceptions/parser-exception.ts
-var ParserException = class extends Error {
-  static {
-    __name(this, "ParserException");
+  hasValue(context, index) {
+    return this.getResolvedValue(context, index) !== PENDING;
   }
-  expression;
-  position;
-  constructor(expression, message, position) {
-    super(createMessage(expression, message, position ?? 0)), this.expression = expression, this.position = position;
+  getValue(context, index) {
+    return this.getIndexedValue(context, index);
   }
-};
-function createMessage(expression, message, position) {
-  if (position >= 0) {
-    return `Invalid expression ${expression}. ${message}. Position ${position}`;
+  setValue(context, index, value) {
+    const val = this.getIndexedValue(context, index);
+    if (val instanceof Subject) {
+      val.next(value);
+      return;
+    }
+    throw new UnsupportedException("Cannot set value for an observable");
   }
-  return `Invalid expression ${expression}. ${message}.`;
-}
-__name(createMessage, "createMessage");
-
-// lib/exceptions/unexpected-exception.ts
-var UnexpectedException = class extends Error {
-  static {
-    __name(this, "UnexpectedException");
+  applies(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return isObservable(val);
   }
-  constructor(message) {
-    super(message);
+  setLastValue(observable, value) {
+    this._resolvedValueCache.set(observable, value);
   }
-};
-
-// lib/exceptions/unsupported-exception.ts
-var UnsupportedException = class extends Error {
-  static {
-    __name(this, "UnsupportedException");
+  clearLastValue(observable) {
+    this._resolvedValueCache.delete(observable);
   }
-  constructor(message) {
-    super(message);
+  getIndexedValue(context, index) {
+    return (Type.toObject(context) ?? {})[index];
   }
 };
+ObservableAccessor = _ts_decorate6([
+  injectable(),
+  _ts_param3(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
+  ])
+], ObservableAccessor);
 
-// lib/singleton-factory/singleton.factory.ts
+// 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);
@@ -754,948 +760,961 @@ function _ts_metadata4(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata4, "_ts_metadata");
-var SingletonFactory = class {
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var PromiseAccessor = class {
   static {
-    __name(this, "SingletonFactory");
+    __name(this, "PromiseAccessor");
   }
-  _instances = /* @__PURE__ */ new Map();
-  _referenceCounts = /* @__PURE__ */ new Map();
-  constructor() {
+  _resolvedValueCache;
+  priority = 1;
+  constructor(_resolvedValueCache) {
+    this._resolvedValueCache = _resolvedValueCache;
   }
-  exists(target) {
-    for (const instance of this._instances.values()) {
-      if (target === instance) {
-        return true;
-      }
-    }
-    return false;
+  getIndexes() {
+    return [].values();
   }
-  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;
+  isAsync() {
+    return true;
   }
-  toString(indent = 4, level = 0) {
-    return this.toLines(indent, level).map((l) => " ".repeat(indent * level) + l).join("\n");
+  hasValue(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return this.isCacheable(val) && this._resolvedValueCache.get(val) !== PENDING;
   }
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return `${this.constructor.name}`;
+  getResolvedValue(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return this.isCacheable(val) ? this._resolvedValueCache.get(val) ?? PENDING : PENDING;
   }
-  get isEmpty() {
-    return this._instances.size === 0;
+  getValue(context, index) {
+    return this.getIndexedValue(context, index);
   }
-  ids() {
-    return this._instances.keys();
+  setValue() {
+    throw new UnsupportedException("Cannot set value for a Promise");
   }
-  getFromId(id) {
-    return this._instances.get(id);
+  applies(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return val instanceof Promise;
   }
-  has(id) {
-    return this._instances.has(id);
+  setLastValue(promise, value) {
+    this._resolvedValueCache.set(promise, value);
   }
-  getFromData(data) {
-    const id = this.getId(data);
-    return id !== void 0 ? this.getFromId(id) : void 0;
+  clearLastValue(promise) {
+    this._resolvedValueCache.delete(promise);
   }
-  dispose() {
-    for (const id of this._instances.keys()) {
-      this.release(id, true);
-    }
-    this._instances.clear();
-    this._referenceCounts.clear();
-    this.onDipose();
+  getIndexedValue(context, index) {
+    return (Type.toObject(context) ?? {})[index];
   }
-  getOrCreate(data) {
-    let instance = this.getFromId(this.getOrCreateId(data));
-    if (instance === void 0) {
-      instance = this.create(data).instance;
-    }
-    return instance;
+  isCacheable(value) {
+    return value !== null && (typeof value === "object" || typeof value === "function");
   }
-  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;
+};
+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, "PropertyValueAccessor");
   }
-  release(id, force) {
-    const instance = this._instances.get(id);
-    if (!instance) {
-      return {
-        instance: null,
-        referenceCount: 0
-      };
+  priority = 7;
+  isAsync() {
+    return false;
+  }
+  getIndexes(context) {
+    const obj = Type.toObject(context);
+    if (!obj) {
+      return [].values();
     }
-    return {
-      referenceCount: this.updateReferenceCount(id, -1, instance, force),
-      instance
-    };
+    return Object.keys(obj).filter((key) => !Type.isMethod(obj[key])).values();
   }
-  get keys() {
-    return Array.from(this._instances.keys());
+  hasValue(context, index) {
+    const val = this.getValue(context, index);
+    return val !== void 0;
   }
-  onDisposeInstance = /* @__PURE__ */ __name((id, dispose) => {
-    const { referenceCount } = this.release(id);
-    if (referenceCount === 0) {
-      dispose();
-    }
-    return referenceCount === 0;
-  }, "onDisposeInstance");
-  onDipose() {
+  getResolvedValue(context, index) {
+    return this.getValue(context, index);
   }
-  onReleased() {
+  getValue(context, index) {
+    const obj = Type.toObject(context);
+    return obj ? obj[index] : void 0;
   }
-  releaseInstance(_instance, _id) {
+  setValue(context, index, value) {
+    const obj = Type.toObject(context);
+    if (obj) {
+      obj[index] = value;
+    }
   }
-  onInstanceCreated(_instance, _data) {
+  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);
   }
-  getOrCreateId(data) {
-    return this.getId(data) ?? this.createId(data);
+};
+
+// 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_decorate8, "_ts_decorate");
+var ResolvedValueCache = class {
+  static {
+    __name(this, "ResolvedValueCache");
   }
-  getReferenceCount(id) {
-    return this._referenceCounts.get(id) ?? 0;
+  _resolvedValues = /* @__PURE__ */ new WeakMap();
+  set(source, value) {
+    this._resolvedValues.set(source, value);
   }
-  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;
+  get(source) {
+    return this._resolvedValues.get(source);
   }
-  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;
+  delete(source) {
+    this._resolvedValues.delete(source);
   }
 };
-_ts_decorate7([
-  preDestroy(),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", []),
-  _ts_metadata4("design:returntype", void 0)
-], SingletonFactory.prototype, "dispose", null);
+ResolvedValueCache = _ts_decorate8([
+  injectable()
+], ResolvedValueCache);
 
-// lib/function-call-index/function-call-index.ts
-var FunctionCallIndex = class {
+// 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_decorate9, "_ts_decorate");
+var SetKeyAccessor = class {
   static {
-    __name(this, "FunctionCallIndex");
+    __name(this, "SetKeyAccessor");
   }
-  context;
-  functionName;
-  _sequenceWithId;
-  _owner;
-  _isDisposed = false;
-  _id;
-  constructor(context, functionName, _sequenceWithId, _owner) {
-    this.context = context;
-    this.functionName = functionName;
-    this._sequenceWithId = _sequenceWithId;
-    this._owner = _owner;
+  priority = 3;
+  getIndexes(set) {
+    return new Set(set).values();
   }
-  get id() {
-    if (!this._id) {
-      this._id = `${this.functionName}${this._sequenceWithId.id}`;
-    }
-    return this._id;
+  isAsync() {
+    return false;
   }
-  get argumentsId() {
-    return this._sequenceWithId;
+  hasValue(set, key) {
+    return set.has(key);
   }
-  dispose() {
-    if (this._isDisposed) {
-      return;
-    }
-    if (this._owner.canDispose?.()) {
-      this._isDisposed = true;
-      this._sequenceWithId.dispose();
-    }
-    this._owner.release();
+  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);
+  }
+  applies(map) {
+    return map instanceof Set;
   }
 };
+SetKeyAccessor = _ts_decorate9([
+  injectable()
+], SetKeyAccessor);
 
-// lib/function-call-index/function-call-index.factory.ts
-function _ts_decorate8(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_decorate8, "_ts_decorate");
+__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_param3(paramIndex, decorator) {
+function _ts_param5(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param3, "_ts_param");
-var FunctionCallIndexFactory = class extends SingletonFactory {
+__name(_ts_param5, "_ts_param");
+var DeepCloneValueExcept = class {
   static {
-    __name(this, "FunctionCallIndexFactory");
-  }
-  _sequenceIdFactory;
-  constructor(_sequenceIdFactory) {
-    super(), this._sequenceIdFactory = _sequenceIdFactory;
-  }
-  getId(data) {
-    return this._sequenceIdFactory.get(data.context, data.arguments);
+    __name(this, "DeepCloneValueExcept");
   }
-  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")
-    });
+  _resolvedValueCache;
+  constructor(_resolvedValueCache) {
+    this._resolvedValueCache = _resolvedValueCache;
   }
-  createId(data) {
-    const context = data.context;
-    if (!context || typeof context !== "object") {
-      throw new ArgumentException(`Expected context to be an object, got ${String(context)}`);
+  except(source) {
+    if (source instanceof Promise || source instanceof Observable) {
+      const value = this._resolvedValueCache.get(source);
+      return value === void 0 ? PENDING : value;
     }
-    const fn = context[data.functionName];
-    return this._sequenceIdFactory.create(fn, data.arguments);
-  }
-  releaseInstance(_, id) {
-    id.dispose();
+    return void 0;
   }
 };
-FunctionCallIndexFactory = _ts_decorate8([
+DeepCloneValueExcept = _ts_decorate10([
   injectable(),
-  _ts_param3(0, inject(RsXCoreInjectionTokens.ISequenceIdFactory)),
+  _ts_param5(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
   _ts_metadata5("design:type", Function),
   _ts_metadata5("design:paramtypes", [
-    typeof ISequenceIdFactory === "undefined" ? Object : ISequenceIdFactory
+    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
   ])
-], FunctionCallIndexFactory);
+], DeepCloneValueExcept);
 
-// lib/function-call-result-cache/function-call-result-cache.factory.ts
-function _ts_decorate9(decorators, target, key, desc) {
+// 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_decorate9, "_ts_decorate");
+__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_param4(paramIndex, decorator) {
+function _ts_param6(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param4, "_ts_param");
-var FunctionCallResultCache = class FunctionCallResultCache2 {
-  static {
-    __name(this, "FunctionCallResultCache");
-  }
-  _disposeableIndex;
-  result;
-  _owner;
-  _isDisposed = false;
-  constructor(_disposeableIndex, result, _owner) {
-    this._disposeableIndex = _disposeableIndex;
-    this.result = result;
-    this._owner = _owner;
-  }
-  get index() {
-    return this._disposeableIndex;
-  }
-  dispose() {
-    if (this._isDisposed) {
-      return;
-    }
-    if (this._owner.canDispose?.()) {
-      this._disposeableIndex.dispose();
-      this._isDisposed = true;
-    }
-    this._owner.release();
-  }
-};
-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")
-    });
-  }
-  createId(data) {
-    return this._functionCallIndexFactory.create({
-      functionName: data.functionName,
-      context: this._context,
-      arguments: data.arguments
-    }).instance;
-  }
-  releaseInstance(_, id) {
-    this._functionCallIndexFactory.release(id.argumentsId);
-  }
-  onReleased() {
-    this.releaseContext();
-  }
-};
-var FunctionCallResultCacheManager = class FunctionCallResultCacheManager2 extends SingletonFactory {
+__name(_ts_param6, "_ts_param");
+var DefaultDeepClone = class {
   static {
-    __name(this, "FunctionCallResultCacheManager");
-  }
-  _functionCallIndexFactory;
-  constructor(_functionCallIndexFactory) {
-    super(), this._functionCallIndexFactory = _functionCallIndexFactory;
-  }
-  getId(contex) {
-    return this.createId(contex);
+    __name(this, "DefaultDeepClone");
   }
-  createInstance(context, id) {
-    return new FunctionCallResultCacheForContextManager(context, this._functionCallIndexFactory, () => this.release(id));
+  _deepCloneList;
+  priority = 0;
+  constructor(_deepCloneList) {
+    this._deepCloneList = _deepCloneList;
   }
-  createId(contex) {
-    return contex;
+  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;
   }
 };
-var FunctionCallResultCacheFactory = class {
+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, "FunctionCallResultCacheFactory");
-  }
-  _functionCallResultCacheManager;
-  constructor(functionCallIndexFactory) {
-    this._functionCallResultCacheManager = new FunctionCallResultCacheManager(functionCallIndexFactory);
-  }
-  create(context, result) {
-    return this._functionCallResultCacheManager.create(context).instance.create(result).instance;
+    __name(this, "LodashDeepClone");
   }
-  has(context, index) {
-    return this._functionCallResultCacheManager.getFromId(context)?.has(index) ?? false;
+  _deepCloneExcept;
+  priority = 1;
+  constructor(_deepCloneExcept) {
+    this._deepCloneExcept = _deepCloneExcept;
   }
-  get(context, index) {
-    return this._functionCallResultCacheManager.getFromId(context)?.getFromId(index);
+  clone(source) {
+    return cloneDeepWith(source, this.cloneExceptPredicate);
   }
+  cloneExceptPredicate = /* @__PURE__ */ __name((value) => {
+    return this._deepCloneExcept.except(value);
+  }, "cloneExceptPredicate");
 };
-FunctionCallResultCacheFactory = _ts_decorate9([
+LodashDeepClone = _ts_decorate12([
   injectable(),
-  _ts_param4(0, inject(RsXCoreInjectionTokens.IFunctionCallIndexFactory)),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [
-    typeof IFunctionCallIndexFactory === "undefined" ? Object : IFunctionCallIndexFactory
+  _ts_param7(0, inject(RsXCoreInjectionTokens.DefaultDeepCloneExcept)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof IDeepCloneExcept === "undefined" ? Object : IDeepCloneExcept
   ])
-], FunctionCallResultCacheFactory);
+], LodashDeepClone);
 
-// lib/guid/guid.factory.ts
-function _ts_decorate10(decorators, target, key, desc) {
+// 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_decorate10, "_ts_decorate");
-var GuidFactory = class {
+__name(_ts_decorate13, "_ts_decorate");
+var StructuredDeepClone = class {
   static {
-    __name(this, "GuidFactory");
+    __name(this, "StructuredDeepClone");
   }
-  create() {
-    return crypto.randomUUID();
+  priority = 2;
+  clone(source) {
+    return structuredClone(source);
   }
 };
-GuidFactory = _ts_decorate10([
+StructuredDeepClone = _ts_decorate13([
   injectable()
-], GuidFactory);
+], StructuredDeepClone);
 
-// lib/index-value-accessor/array-index-accessor.ts
-function _ts_decorate11(decorators, target, key, desc) {
+// 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_decorate11, "_ts_decorate");
-var ArrayIndexAccessor = class {
+__name(_ts_decorate14, "_ts_decorate");
+var EqualityService = class {
   static {
-    __name(this, "ArrayIndexAccessor");
+    __name(this, "EqualityService");
   }
-  priority = 5;
-  isAsync() {
-    return false;
+  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")
+      })
+    ];
   }
-  getIndexes(array) {
-    return array.keys();
+  toString(value, quoteStrings = true) {
+    return this.toLines(value, 0, quoteStrings).join("\n");
   }
-  hasValue(array, index) {
-    return this.getValue(array, index) !== void 0;
+  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)
+    ];
   }
-  getResolvedValue(array, index) {
-    return array[index];
+  formatPrimitive(value, quoteStrings) {
+    if (typeof value === "string" && quoteStrings) {
+      return `'${value}'`;
+    }
+    return String(value);
   }
-  getValue(array, index) {
-    return this.getResolvedValue(array, index);
+  formatKey(key) {
+    return typeof key === "string" ? key : String(key);
   }
-  setValue(array, index, value) {
-    array[index] = value;
+  spaces(level) {
+    return " ".repeat(this.indent * level);
   }
-  applies(array) {
-    return Array.isArray(array);
+  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;
   }
 };
-ArrayIndexAccessor = _ts_decorate11([
-  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/error-log/print-value.ts
+function printValue(value) {
+  console.log(new PrettyPrinter().toString(value, false));
+}
+__name(printValue, "printValue");
 
-// lib/index-value-accessor/date-property-accessor.ts
-function _ts_decorate12(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_decorate12, "_ts_decorate");
-var DatePropertyAccessor = class {
+__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_metadata9, "_ts_metadata");
+var SingletonFactory = 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")
-  };
-  isAsync() {
-    return false;
+    __name(this, "SingletonFactory");
   }
-  getIndexes() {
-    return dataProperties.values();
+  _instances = /* @__PURE__ */ new Map();
+  _referenceCounts = /* @__PURE__ */ new Map();
+  constructor() {
   }
-  hasValue(context, index) {
-    return this.getValue(context, index) !== void 0;
+  exists(target) {
+    for (const instance of this._instances.values()) {
+      if (target === instance) {
+        return true;
+      }
+    }
+    return false;
   }
-  getResolvedValue(context, index) {
-    return this.getValue(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;
   }
-  getValue(date, index) {
-    return this._getters[index]?.(date);
+  toString(indent = 4, level = 0) {
+    return this.toLines(indent, level).map((l) => " ".repeat(indent * level) + l).join("\n");
   }
-  setValue(date, index, value) {
-    this._setter[index]?.(date, value);
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `${this.constructor.name}`;
   }
-  applies(context, index) {
-    return context instanceof Date && !!this._getters[index];
+  get isEmpty() {
+    return this._instances.size === 0;
   }
-};
-DatePropertyAccessor = _ts_decorate12([
-  injectable()
-], DatePropertyAccessor);
-
-// lib/index-value-accessor/index-value-accessor.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");
-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_param5(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param5, "_ts_param");
-var IndexValueAccessor = class {
-  static {
-    __name(this, "IndexValueAccessor");
+  ids() {
+    return this._instances.keys();
   }
-  priority = 0;
-  _accessors;
-  constructor(accessors) {
-    this._accessors = [
-      ...accessors
-    ].sort((a, b) => b.priority - a.priority);
+  getFromId(id) {
+    return this._instances.get(id);
   }
-  getIndexes(context, index) {
-    return this.getIndexAccessor(context, index).getIndexes(context, index);
+  has(id) {
+    return this._instances.has(id);
   }
-  isAsync(context, index) {
-    return this.getIndexAccessor(context, index).isAsync(context, index);
+  getFromData(data) {
+    const id = this.getId(data);
+    return id !== void 0 ? this.getFromId(id) : void 0;
   }
-  hasValue(context, index) {
-    return this.getIndexAccessor(context, index).hasValue(context, index);
+  dispose() {
+    for (const id of this._instances.keys()) {
+      this.release(id, true);
+    }
+    this._instances.clear();
+    this._referenceCounts.clear();
+    this.onDipose();
   }
-  getResolvedValue(context, index) {
-    return this.getIndexAccessor(context, index).getResolvedValue(context, index);
+  getOrCreate(data) {
+    let instance = this.getFromId(this.getOrCreateId(data));
+    if (instance === void 0) {
+      instance = this.create(data).instance;
+    }
+    return instance;
   }
-  getValue(context, index) {
-    return this.getIndexAccessor(context, index).getValue(context, index);
+  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;
   }
-  setValue(context, index, value) {
-    this.getIndexAccessor(context, index).setValue(context, index, value);
+  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
+    };
   }
-  applies(context, index) {
-    return this.getIndexAccessor(context, index).applies(context, index);
+  get keys() {
+    return Array.from(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)}`);
-      }
+  onDisposeInstance = /* @__PURE__ */ __name((id, dispose) => {
+    const { referenceCount } = this.release(id);
+    if (referenceCount === 0) {
+      dispose();
     }
-    return accessor;
-  }
-};
-IndexValueAccessor = _ts_decorate13([
-  injectable(),
-  _ts_param5(0, multiInject(RsXCoreInjectionTokens.IIndexValueAccessorList)),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("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");
+    return referenceCount === 0;
+  }, "onDisposeInstance");
+  onDipose() {
   }
-  priority = 4;
-  getIndexes(map) {
-    return map.keys();
+  onReleased() {
   }
-  isAsync() {
-    return false;
+  releaseInstance(_instance, _id) {
   }
-  hasValue(map, key) {
-    return map.has(key);
+  onInstanceCreated(_instance, _data) {
   }
-  getResolvedValue(map, key) {
-    return map.get(key);
+  getOrCreateId(data) {
+    return this.getId(data) ?? this.createId(data);
   }
-  getValue(map, key) {
-    return this.getResolvedValue(map, key);
+  getReferenceCount(id) {
+    return this._referenceCounts.get(id) ?? 0;
   }
-  setValue(map, key, value) {
-    map.set(key, value);
+  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(map) {
-    return map instanceof Map;
+  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;
   }
 };
-MapKeyAccessor = _ts_decorate14([
-  injectable()
-], MapKeyAccessor);
+_ts_decorate16([
+  preDestroy(),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", []),
+  _ts_metadata9("design:returntype", void 0)
+], SingletonFactory.prototype, "dispose", null);
 
-// 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_metadata8(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 MethodAccessor = class {
+// lib/function-call-index/function-call-index.ts
+var FunctionCallIndex = class {
   static {
-    __name(this, "MethodAccessor");
-  }
-  _functionCallResultCacheFactory;
-  priority = 6;
-  constructor(_functionCallResultCacheFactory) {
-    this._functionCallResultCacheFactory = _functionCallResultCacheFactory;
-  }
-  getIndexes() {
-    return [].values();
-  }
-  isAsync() {
-    return false;
-  }
-  hasValue(context, index) {
-    return this._functionCallResultCacheFactory.has(context, index);
+    __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(context, index) {
-    return this._functionCallResultCacheFactory.get(context, index)?.result;
+  get id() {
+    if (!this._id) {
+      this._id = `${this.functionName}${this._sequenceWithId.id}`;
+    }
+    return this._id;
   }
-  setValue(_, index) {
-    throw new UnsupportedException(`Cannot set method '${index}'`);
+  get argumentsId() {
+    return this._sequenceWithId;
   }
-  applies(context, index) {
-    if (typeof context !== "object" || context === null) {
-      return false;
+  dispose() {
+    if (this._isDisposed) {
+      return;
     }
-    const prop = context[index.functionName];
-    return Type.isFunction(prop) || Type.isArrowFunction(prop);
+    if (this._owner.canDispose?.()) {
+      this._isDisposed = true;
+      this._sequenceWithId.dispose();
+    }
+    this._owner.release();
   }
 };
-MethodAccessor = _ts_decorate15([
-  injectable(),
-  _ts_param6(0, inject(RsXCoreInjectionTokens.IFunctionCallResultCacheFactory)),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
-    typeof IFunctionCallResultCacheFactory === "undefined" ? Object : IFunctionCallResultCacheFactory
-  ])
-], MethodAccessor);
-
-// lib/index-value-accessor/observable-accessor.ts
-import { BehaviorSubject, isObservable as isObservable3, 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");
 
-// 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");
-function _ts_metadata9(k, v) {
+__name(_ts_decorate17, "_ts_decorate");
+function _ts_metadata10(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) {
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param7, "_ts_param");
-var ObservableAccessor = class {
+__name(_ts_param8, "_ts_param");
+var FunctionCallIndexFactory = class extends SingletonFactory {
   static {
-    __name(this, "ObservableAccessor");
-  }
-  _resolvedValueCache;
-  priority = 2;
-  constructor(_resolvedValueCache) {
-    this._resolvedValueCache = _resolvedValueCache;
-  }
-  getIndexes() {
-    return [].values();
-  }
-  isAsync() {
-    return true;
-  }
-  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;
-  }
-  hasValue(context, index) {
-    return this.getResolvedValue(context, index) !== PENDING;
-  }
-  getValue(context, index) {
-    return this.getIndexedValue(context, index);
+    __name(this, "FunctionCallIndexFactory");
   }
-  setValue(context, index, value) {
-    const val = this.getIndexedValue(context, index);
-    if (val instanceof Subject2) {
-      val.next(value);
-      return;
-    }
-    throw new UnsupportedException("Cannot set value for an observable");
+  _sequenceIdFactory;
+  constructor(_sequenceIdFactory) {
+    super(), this._sequenceIdFactory = _sequenceIdFactory;
   }
-  applies(context, index) {
-    const val = this.getIndexedValue(context, index);
-    return isObservable3(val);
+  getId(data) {
+    return this._sequenceIdFactory.get(data.context, data.arguments);
   }
-  setLastValue(observable, value) {
-    this._resolvedValueCache.set(observable, value);
+  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")
+    });
   }
-  clearLastValue(observable) {
-    this._resolvedValueCache.delete(observable);
+  createId(data) {
+    const context = data.context;
+    if (!context || typeof context !== "object") {
+      throw new ArgumentException(`Expected context to be an object, got ${String(context)}`);
+    }
+    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_param7(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
-  _ts_metadata9("design:type", Function),
-  _ts_metadata9("design:paramtypes", [
-    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
+  _ts_param8(0, inject(RsXCoreInjectionTokens.ISequenceIdFactory)),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [
+    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");
-function _ts_metadata10(k, v) {
+__name(_ts_decorate18, "_ts_decorate");
+function _ts_metadata11(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata10, "_ts_metadata");
-function _ts_param8(paramIndex, decorator) {
+__name(_ts_metadata11, "_ts_metadata");
+function _ts_param9(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param8, "_ts_param");
-var PromiseAccessor = class {
+__name(_ts_param9, "_ts_param");
+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_param8(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
-  _ts_metadata10("design:type", Function),
-  _ts_metadata10("design:paramtypes", [
-    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
-  ])
-], PromiseAccessor);
-
-// lib/index-value-accessor/property-value-accessor.ts
-import { isObservable as isObservable4 } 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) && !isObservable4(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);
@@ -1703,36 +1722,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 {
@@ -1813,16 +1813,16 @@ function _ts_decorate20(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate20, "_ts_decorate");
-function _ts_metadata11(k, v) {
+function _ts_metadata12(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata11, "_ts_metadata");
-function _ts_param9(paramIndex, decorator) {
+__name(_ts_metadata12, "_ts_metadata");
+function _ts_param10(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param9, "_ts_param");
+__name(_ts_param10, "_ts_param");
 var RegistryNode = class RegistryNode2 {
   static {
     __name(this, "RegistryNode");
@@ -2001,15 +2001,15 @@ var SequenceIdFactory = class {
 };
 _ts_decorate20([
   preDestroy(),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", []),
-  _ts_metadata11("design:returntype", void 0)
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", []),
+  _ts_metadata12("design:returntype", void 0)
 ], SequenceIdFactory.prototype, "dispose", null);
 SequenceIdFactory = _ts_decorate20([
   injectable(),
-  _ts_param9(0, inject(RsXCoreInjectionTokens.IGuidFactory)),
-  _ts_metadata11("design:type", Function),
-  _ts_metadata11("design:paramtypes", [
+  _ts_param10(0, inject(RsXCoreInjectionTokens.IGuidFactory)),
+  _ts_metadata12("design:type", Function),
+  _ts_metadata12("design:paramtypes", [
     typeof IGuidFactory === "undefined" ? Object : IGuidFactory
   ])
 ], SequenceIdFactory);
@@ -2070,8 +2070,8 @@ var RsXCoreModule = new ContainerModule((options) => {
   options.bind(RsXCoreInjectionTokens.IFunctionCallResultCacheFactory).to(FunctionCallResultCacheFactory).inSingletonScope();
   options.bind(RsXCoreInjectionTokens.IGuidFactory).to(GuidFactory).inSingletonScope();
   options.bind(RsXCoreInjectionTokens.IResolvedValueCache).to(ResolvedValueCache).inSingletonScope();
-  options.bind(RsXCoreInjectionTokens.IDeepCloneValueGetter).to(DeepCloneValueGetter).inSingletonScope();
-  options.bind(RsXCoreInjectionTokens.DefaultDeepCloneValueGetter).to(DeepCloneValueGetter).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.IDeepCloneExcept).to(DeepCloneValueExcept).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.DefaultDeepCloneExcept).to(DeepCloneValueExcept).inSingletonScope();
   registerMultiInjectServices(options, RsXCoreInjectionTokens.IIndexValueAccessorList, defaultIndexValueAccessorList);
   registerMultiInjectServices(options, RsXCoreInjectionTokens.IDeepCloneList, defaultDeeoCloneList);
 });
@@ -2162,8 +2162,7 @@ export {
   Container,
   ContainerModule,
   DatePropertyAccessor,
-  DeepClone,
-  DeepCloneValueGetter,
+  DeepCloneValueExcept,
   DefaultDeepClone,
   EqualityService,
   ErrorLog,