@rs-x/core 0.4.4

package/dist/index.js

@@ -0,0 +1,2222 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// lib/deep-clone/deep-clone-value-getter.ts
+import { Observable } from "rxjs";
+
+// lib/dependency-injection.ts
+import "reflect-metadata";
+import { Container, ContainerModule, inject, injectable, multiInject, preDestroy, unmanaged } from "inversify";
+var InjectionContainer = new Container();
+function registerMultiInjectService(container, target, options) {
+  container.bind(target).to(target).inSingletonScope();
+  if (options.serviceToken) {
+    container.bind(options.serviceToken).toService(target);
+  }
+  container.bind(options.multiInjectToken).toService(target);
+}
+__name(registerMultiInjectService, "registerMultiInjectService");
+function registerMultiInjectServices(container, multiInjectToken, services) {
+  services.forEach((service) => registerMultiInjectService(container, service.target, {
+    multiInjectToken,
+    serviceToken: service.token
+  }));
+}
+__name(registerMultiInjectServices, "registerMultiInjectServices");
+function overrideMultiInjectServices(container, multiInjectToken, services) {
+  if (container.isBound(multiInjectToken)) {
+    container.unbind(multiInjectToken);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  services.forEach((service) => {
+    if (seen.has(service.target)) {
+      return;
+    }
+    seen.add(service.target);
+    if (!container.isBound(service.target)) {
+      container.bind(service.target).to(service.target).inSingletonScope();
+    }
+    if (service.token && !container.isBound(service.token)) {
+      container.bind(service.token).toService(service.target);
+    }
+    container.bind(multiInjectToken).toService(service.target);
+  });
+}
+__name(overrideMultiInjectServices, "overrideMultiInjectServices");
+
+// lib/rs-x-core.injection-tokens.ts
+var RsXCoreInjectionTokens = {
+  IInjectionContainer: Symbol("IInjectionContainer"),
+  IErrorLog: Symbol("IErrorLog"),
+  IIndexValueAccessor: Symbol("IIndexValueAccessor"),
+  IMapKeyAccessor: Symbol("IMapKeyAccessor"),
+  ISetKeyAccessor: Symbol("ISetKeyAccessor"),
+  IArrayIndexAccessor: Symbol("IArrayIndexAccessor"),
+  IPropertyValueAccessor: Symbol("IPropertyValueAccessor"),
+  IMethodAccessor: Symbol("IPropertyValueAccessor"),
+  IDatePropertyAccessor: Symbol("IDatePropertyAccessor"),
+  IDeepClone: Symbol("IDeepClone"),
+  IEqualityService: Symbol("IEqualityService"),
+  IObservableAccessor: Symbol("IObservableAccessor"),
+  IPromiseAccessor: Symbol("IPromiseAccessor"),
+  IIndexValueAccessorList: Symbol("IIndexValueAccessorList"),
+  ISequenceIdFactory: Symbol("ISequenceIdFactory"),
+  IFunctionCallIndexFactory: Symbol("IFunctionCallIndexFactory"),
+  IFunctionCallResultCacheFactory: Symbol("IFunctionCallResultCacheFactory"),
+  IGuidFactory: Symbol("IGuidFactory"),
+  IStructuredDeepClone: Symbol("IStructuredDeepClone"),
+  ILodashDeepClone: Symbol("ILodashDeepClone"),
+  IDeepCloneList: Symbol("IDeepCloneList"),
+  IResolvedValueCache: Symbol("IResolvedValueCache"),
+  IDeepCloneValueGetter: Symbol("IDeepCloneValueGetter"),
+  DefaultDeepCloneValueGetter: Symbol("DefaultDeepCloneValueGetter")
+};
+
+// lib/deep-clone/deep-clone-value-getter.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var DeepCloneValueGetter = class {
+  static {
+    __name(this, "DeepCloneValueGetter");
+  }
+  _resolvedValueCache;
+  constructor(_resolvedValueCache) {
+    this._resolvedValueCache = _resolvedValueCache;
+  }
+  get(source) {
+    if (source instanceof Promise || source instanceof Observable) {
+      return this._resolvedValueCache.get(source);
+    }
+    return source;
+  }
+};
+DeepCloneValueGetter = _ts_decorate([
+  injectable(),
+  _ts_param(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
+  ])
+], DeepCloneValueGetter);
+
+// lib/deep-clone/deep-clone.decorator.ts
+function DeepClone(serviceToken) {
+  return function(target) {
+    registerMultiInjectService(InjectionContainer, target, {
+      serviceToken,
+      multiInjectToken: RsXCoreInjectionTokens.IDeepCloneList
+    });
+  };
+}
+__name(DeepClone, "DeepClone");
+
+// lib/deep-clone/default-deep-clone.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");
+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 {
+  static {
+    __name(this, "DefaultDeepClone");
+  }
+  _deepCloneList;
+  _deepCloneValueGetter;
+  priority = 0;
+  constructor(_deepCloneList, _deepCloneValueGetter) {
+    this._deepCloneList = _deepCloneList;
+    this._deepCloneValueGetter = _deepCloneValueGetter;
+  }
+  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;
+  }
+};
+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");
+
+// lib/exceptions/argument-exception.ts
+var ArgumentException = class extends Error {
+  static {
+    __name(this, "ArgumentException");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+
+// lib/types/property-descriptor-type.enum.ts
+var PropertyDescriptorType = /* @__PURE__ */ (function(PropertyDescriptorType2) {
+  PropertyDescriptorType2["Function"] = "Function";
+  PropertyDescriptorType2["ReadonlyProperty"] = "ReadonlyProperty";
+  PropertyDescriptorType2["Property"] = "Property";
+  PropertyDescriptorType2["Field"] = "Field";
+  return PropertyDescriptorType2;
+})({});
+
+// lib/types/type.ts
+var emptyValue = Symbol("empty");
+var emptyFunction = /* @__PURE__ */ __name(() => {
+}, "emptyFunction");
+var truePredicate = /* @__PURE__ */ __name(() => true, "truePredicate");
+var echo = /* @__PURE__ */ __name((value) => value, "echo");
+var Type = class _Type {
+  static {
+    __name(this, "Type");
+  }
+  static isPositiveIntegerString(value) {
+    if (typeof value !== "string" || value.length === 0) {
+      return false;
+    }
+    if (value === "0") {
+      return true;
+    }
+    if (value[0] === "0") {
+      return false;
+    }
+    for (let i = 0; i < value.length; i++) {
+      const code = value.charCodeAt(i);
+      if (code < 48 || code > 57) {
+        return false;
+      }
+    }
+    return true;
+  }
+  static isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 || _Type.isPositiveIntegerString(value);
+  }
+  static walkObjectTopToBottom(object, visit, recursive) {
+    if (typeof object !== "object" || object === null) {
+      return;
+    }
+    for (const [key, value] of Object.entries(object)) {
+      visit(object, key, value);
+      if (recursive && typeof value === "object" && value !== null) {
+        _Type.walkObjectTopToBottom(value, visit, recursive);
+      }
+    }
+  }
+  static walkObjectBottomToTop(object, visit, recursive) {
+    if (typeof object !== "object" || object === null) {
+      return;
+    }
+    for (const [key, value] of Object.entries(object)) {
+      if (recursive && typeof value === "object" && value !== null) {
+        _Type.walkObjectBottomToTop(value, visit, recursive);
+      }
+      visit(object, key, value);
+    }
+  }
+  static cast(instance) {
+    return instance;
+  }
+  static isFunction(value) {
+    return typeof value === "function";
+  }
+  static isMethod(value) {
+    return typeof value === "function" && !("prototype" in value);
+  }
+  static isArrowFunction(object) {
+    return _Type.isFunction(object) && !Object.prototype.hasOwnProperty.call(object, "prototype");
+  }
+  static isString(value) {
+    return typeof value === "string" || value instanceof String;
+  }
+  static isNullOrUndefined(value) {
+    return value === null || value === void 0;
+  }
+  static isEmpty(value) {
+    return _Type.isNullOrUndefined(value) || _Type.isString(value) && value.length === 0 || Array.isArray(value) && value.length === 0;
+  }
+  static isPlainObject(object) {
+    if (object !== null && typeof object === "object") {
+      const prototype = Object.getPrototypeOf(object);
+      return prototype === Object.prototype || prototype === null;
+    }
+    return false;
+  }
+  static hasProperty(root, name) {
+    for (let current = root; current && current !== Object.prototype; current = Object.getPrototypeOf(current)) {
+      if (Object.prototype.hasOwnProperty.call(current, name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  static hasOwnPropertyInPrototypeChain(target, key) {
+    if (target == null) {
+      return false;
+    }
+    let proto = typeof target === "function" ? target.prototype : Object.getPrototypeOf(target);
+    while (proto) {
+      if (Object.prototype.hasOwnProperty.call(proto, key)) {
+        return true;
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+  }
+  static getPropertyDescriptorType(propertyDescriptor) {
+    if (propertyDescriptor.set) {
+      return PropertyDescriptorType.Property;
+    }
+    if (propertyDescriptor.get) {
+      return PropertyDescriptorType.ReadonlyProperty;
+    }
+    if (_Type.isMethod(propertyDescriptor.value)) {
+      return PropertyDescriptorType.Function;
+    }
+    return PropertyDescriptorType.Field;
+  }
+  static getPropertyDescriptor(root, name) {
+    if (!root || typeof root !== "object") {
+      throw new ArgumentException(`Cannot get property '${String(name)}' from non-object root: ${String(root)}`);
+    }
+    let current = root;
+    while (current && current !== Object.prototype) {
+      const propertyDescriptor = Object.getOwnPropertyDescriptor(current, name);
+      if (propertyDescriptor) {
+        return {
+          type: _Type.getPropertyDescriptorType(propertyDescriptor),
+          descriptor: propertyDescriptor
+        };
+      }
+      current = Object.getPrototypeOf(current);
+    }
+    const constructorName = root.constructor?.name || "UnknownObject";
+    throw new ArgumentException(`${constructorName} does not have a property, method or field with name '${String(name)}'`);
+  }
+  static toObject(context) {
+    if (context && (typeof context === "object" || typeof context === "function")) {
+      return context;
+    }
+    return void 0;
+  }
+  static getConstructorName(value) {
+    if (typeof value === "object" && value !== null) {
+      return value.constructor.name;
+    }
+    return "unknown";
+  }
+};
+
+// lib/exceptions/invalid-cast-exception.ts
+var InvalidCastException = class extends Error {
+  static {
+    __name(this, "InvalidCastException");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+
+// lib/exceptions/null-or-empty-exception.ts
+var NullOrEmptyException = class extends Error {
+  static {
+    __name(this, "NullOrEmptyException");
+  }
+  constructor(argumentName) {
+    super(`'${argumentName}' cannot be null or empty`);
+  }
+};
+
+// lib/exceptions/null-or-undefined-exception.ts
+var NullOrUndefinedException = class extends Error {
+  static {
+    __name(this, "NullOrUndefinedException");
+  }
+  constructor(argumentName) {
+    super(`'${argumentName}' cannot be null or undefined`);
+  }
+};
+
+// lib/exceptions/assertion.ts
+var Assertion = class {
+  static {
+    __name(this, "Assertion");
+  }
+  constructor() {
+  }
+  static assertIsFunction(value, name) {
+    if (!Type.isFunction(value)) {
+      const typeName = value && typeof value === "object" ? value.constructor?.name : typeof value;
+      throw new InvalidCastException(`${typeName}[${name}] is not a function`);
+    }
+  }
+  static assertNotNullOrUndefined(value, argumentName) {
+    if (Type.isNullOrUndefined(value)) {
+      throw new NullOrUndefinedException(argumentName);
+    }
+  }
+  static assertNotNullOrEmpty(value, argumentName) {
+    if (Type.isEmpty(value)) {
+      throw new NullOrEmptyException(argumentName);
+    }
+  }
+};
+
+// lib/exceptions/invalid-operation-exception.ts
+var InvalidOperationException = class extends Error {
+  static {
+    __name(this, "InvalidOperationException");
+  }
+  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/exceptions/unsupported-exception.ts
+var UnsupportedException = class extends Error {
+  static {
+    __name(this, "UnsupportedException");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+
+// lib/singleton-factory/singleton.factory.ts
+function _ts_decorate7(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate7, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var SingletonFactory = class {
+  static {
+    __name(this, "SingletonFactory");
+  }
+  _instances = /* @__PURE__ */ new Map();
+  _referenceCounts = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  exists(target) {
+    for (const instance of this._instances.values()) {
+      if (target === instance) {
+        return true;
+      }
+    }
+    return false;
+  }
+  toLines(indent = 4, level = 0) {
+    const lines = [];
+    const spaces = " ".repeat(indent * level);
+    const spacesNext = " ".repeat(indent * (level + 1));
+    const prettyPrinter = new PrettyPrinter();
+    lines.push(spaces + "___________________________________________________________");
+    lines.push(spaces + `${this.constructor.name}`);
+    for (const [key, instance] of this._instances.entries()) {
+      lines.push(spacesNext + "___________________________________________________________");
+      lines.push(spacesNext + `key (ref. count = ${this._referenceCounts.get(key)}):`);
+      const keyLines = prettyPrinter.toLines(key, level + 2, false);
+      lines.push(...keyLines);
+      lines.push(spacesNext + "instance:");
+      const instanceLines = prettyPrinter.toLines(instance, level + 2, false);
+      lines.push(...instanceLines);
+    }
+    return lines;
+  }
+  toString(indent = 4, level = 0) {
+    return this.toLines(indent, level).map((l) => " ".repeat(indent * level) + l).join("\n");
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return `${this.constructor.name}`;
+  }
+  get isEmpty() {
+    return this._instances.size === 0;
+  }
+  ids() {
+    return this._instances.keys();
+  }
+  getFromId(id) {
+    return this._instances.get(id);
+  }
+  has(id) {
+    return this._instances.has(id);
+  }
+  getFromData(data) {
+    const id = this.getId(data);
+    return id !== void 0 ? this.getFromId(id) : void 0;
+  }
+  dispose() {
+    for (const id of this._instances.keys()) {
+      this.release(id, true);
+    }
+    this._instances.clear();
+    this._referenceCounts.clear();
+    this.onDipose();
+  }
+  getOrCreate(data) {
+    let instance = this.getFromId(this.getOrCreateId(data));
+    if (instance === void 0) {
+      instance = this.create(data).instance;
+    }
+    return instance;
+  }
+  create(data) {
+    const id = this.getOrCreateId(data);
+    const instance = this.getOrCreateInstance(id, data);
+    const result = {
+      id,
+      instance,
+      referenceCount: this.updateReferenceCount(id, 1, instance)
+    };
+    if (result.referenceCount === 1) {
+      this.onInstanceCreated(result.instance, data);
+    }
+    return result;
+  }
+  release(id, force) {
+    const instance = this._instances.get(id);
+    if (!instance) {
+      return {
+        instance: null,
+        referenceCount: 0
+      };
+    }
+    return {
+      referenceCount: this.updateReferenceCount(id, -1, instance, force),
+      instance
+    };
+  }
+  get keys() {
+    return Array.from(this._instances.keys());
+  }
+  onDisposeInstance = /* @__PURE__ */ __name((id, dispose) => {
+    const { referenceCount } = this.release(id);
+    if (referenceCount === 0) {
+      dispose();
+    }
+    return referenceCount === 0;
+  }, "onDisposeInstance");
+  onDipose() {
+  }
+  onReleased() {
+  }
+  releaseInstance(_instance, _id) {
+  }
+  onInstanceCreated(_instance, _data) {
+  }
+  getOrCreateId(data) {
+    return this.getId(data) ?? this.createId(data);
+  }
+  getReferenceCount(id) {
+    return this._referenceCounts.get(id) ?? 0;
+  }
+  updateReferenceCount(id, change, instance, forceRelease) {
+    const referenceCount = this.getReferenceCount(id) + change;
+    if (change === -1 && (forceRelease || referenceCount === 0)) {
+      this._instances.delete(id);
+      this._referenceCounts.delete(id);
+      this.releaseInstance(instance, id);
+      this.onReleased();
+    } else if (referenceCount > 0) {
+      this._referenceCounts.set(id, referenceCount);
+    }
+    return referenceCount;
+  }
+  getOrCreateInstance(id, data) {
+    let instance = this._instances.get(id);
+    if (instance !== void 0) {
+      return instance;
+    }
+    instance = this.createInstance(data, id);
+    this._instances.set(id, instance);
+    return instance;
+  }
+};
+_ts_decorate7([
+  preDestroy(),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", []),
+  _ts_metadata4("design:returntype", void 0)
+], SingletonFactory.prototype, "dispose", null);
+
+// lib/function-call-index/function-call-index.ts
+var FunctionCallIndex = class {
+  static {
+    __name(this, "FunctionCallIndex");
+  }
+  context;
+  functionName;
+  _sequenceWithId;
+  _owner;
+  _isDisposed = false;
+  _id;
+  constructor(context, functionName, _sequenceWithId, _owner) {
+    this.context = context;
+    this.functionName = functionName;
+    this._sequenceWithId = _sequenceWithId;
+    this._owner = _owner;
+  }
+  get id() {
+    if (!this._id) {
+      this._id = `${this.functionName}${this._sequenceWithId.id}`;
+    }
+    return this._id;
+  }
+  get argumentsId() {
+    return this._sequenceWithId;
+  }
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    if (this._owner.canDispose?.()) {
+      this._isDisposed = true;
+      this._sequenceWithId.dispose();
+    }
+    this._owner.release();
+  }
+};
+
+// lib/function-call-index/function-call-index.factory.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");
+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) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param3, "_ts_param");
+var FunctionCallIndexFactory = class extends SingletonFactory {
+  static {
+    __name(this, "FunctionCallIndexFactory");
+  }
+  _sequenceIdFactory;
+  constructor(_sequenceIdFactory) {
+    super(), this._sequenceIdFactory = _sequenceIdFactory;
+  }
+  getId(data) {
+    return this._sequenceIdFactory.get(data.context, data.arguments);
+  }
+  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")
+    });
+  }
+  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);
+  }
+  releaseInstance(_, id) {
+    id.dispose();
+  }
+};
+FunctionCallIndexFactory = _ts_decorate8([
+  injectable(),
+  _ts_param3(0, inject(RsXCoreInjectionTokens.ISequenceIdFactory)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof ISequenceIdFactory === "undefined" ? Object : ISequenceIdFactory
+  ])
+], FunctionCallIndexFactory);
+
+// lib/function-call-result-cache/function-call-result-cache.factory.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");
+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) {
+  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 {
+  static {
+    __name(this, "FunctionCallResultCacheManager");
+  }
+  _functionCallIndexFactory;
+  constructor(_functionCallIndexFactory) {
+    super(), this._functionCallIndexFactory = _functionCallIndexFactory;
+  }
+  getId(contex) {
+    return this.createId(contex);
+  }
+  createInstance(context, id) {
+    return new FunctionCallResultCacheForContextManager(context, this._functionCallIndexFactory, () => this.release(id));
+  }
+  createId(contex) {
+    return contex;
+  }
+};
+var FunctionCallResultCacheFactory = 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;
+  }
+  has(context, index) {
+    return this._functionCallResultCacheManager.getFromId(context)?.has(index) ?? false;
+  }
+  get(context, index) {
+    return this._functionCallResultCacheManager.getFromId(context)?.getFromId(index);
+  }
+};
+FunctionCallResultCacheFactory = _ts_decorate9([
+  injectable(),
+  _ts_param4(0, inject(RsXCoreInjectionTokens.IFunctionCallIndexFactory)),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [
+    typeof IFunctionCallIndexFactory === "undefined" ? Object : IFunctionCallIndexFactory
+  ])
+], FunctionCallResultCacheFactory);
+
+// lib/guid/guid.factory.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_decorate10, "_ts_decorate");
+var GuidFactory = class {
+  static {
+    __name(this, "GuidFactory");
+  }
+  create() {
+    return crypto.randomUUID();
+  }
+};
+GuidFactory = _ts_decorate10([
+  injectable()
+], GuidFactory);
+
+// lib/index-value-accessor/array-index-accessor.ts
+function _ts_decorate11(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate11, "_ts_decorate");
+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_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/index-value-accessor/date-property-accessor.ts
+function _ts_decorate12(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate12, "_ts_decorate");
+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_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");
+  }
+  priority = 0;
+  _accessors;
+  constructor(accessors) {
+    this._accessors = [
+      ...accessors
+    ].sort((a, b) => b.priority - a.priority);
+  }
+  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 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");
+  }
+  priority = 4;
+  getIndexes(map) {
+    return map.keys();
+  }
+  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;
+  }
+};
+MapKeyAccessor = _ts_decorate14([
+  injectable()
+], MapKeyAccessor);
+
+// lib/index-value-accessor/method-accessor.ts
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+function _ts_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 {
+  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_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) {
+  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) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var ObservableAccessor = class {
+  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);
+  }
+  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");
+  }
+  applies(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return isObservable3(val);
+  }
+  setLastValue(observable, value) {
+    this._resolvedValueCache.set(observable, value);
+  }
+  clearLastValue(observable) {
+    this._resolvedValueCache.delete(observable);
+  }
+  getIndexedValue(context, index) {
+    return (Type.toObject(context) ?? {})[index];
+  }
+};
+ObservableAccessor = _ts_decorate16([
+  injectable(),
+  _ts_param7(0, inject(RsXCoreInjectionTokens.IResolvedValueCache)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
+    typeof IResolvedValueCache === "undefined" ? Object : IResolvedValueCache
+  ])
+], ObservableAccessor);
+
+// lib/index-value-accessor/promise-accessor.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_decorate17, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param8, "_ts_param");
+var PromiseAccessor = class {
+  static {
+    __name(this, "PromiseAccessor");
+  }
+  _resolvedValueCache;
+  priority = 1;
+  constructor(_resolvedValueCache) {
+    this._resolvedValueCache = _resolvedValueCache;
+  }
+  getIndexes() {
+    return [].values();
+  }
+  isAsync() {
+    return true;
+  }
+  hasValue(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return this.isCacheable(val) && this._resolvedValueCache.get(val) !== PENDING;
+  }
+  getResolvedValue(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return this.isCacheable(val) ? this._resolvedValueCache.get(val) ?? PENDING : PENDING;
+  }
+  getValue(context, index) {
+    return this.getIndexedValue(context, index);
+  }
+  setValue() {
+    throw new UnsupportedException("Cannot set value for a Promise");
+  }
+  applies(context, index) {
+    const val = this.getIndexedValue(context, index);
+    return val instanceof Promise;
+  }
+  setLastValue(promise, value) {
+    this._resolvedValueCache.set(promise, value);
+  }
+  clearLastValue(promise) {
+    this._resolvedValueCache.delete(promise);
+  }
+  getIndexedValue(context, index) {
+    return (Type.toObject(context) ?? {})[index];
+  }
+  isCacheable(value) {
+    return value !== null && (typeof value === "object" || typeof value === "function");
+  }
+};
+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 {
+  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;
+  }
+  getResolvedValue(context, index) {
+    return this.getValue(context, index);
+  }
+  getValue(context, index) {
+    const obj = Type.toObject(context);
+    return obj ? obj[index] : void 0;
+  }
+  setValue(context, index, value) {
+    const obj = Type.toObject(context);
+    if (obj) {
+      obj[index] = value;
+    }
+  }
+  applies(context, index) {
+    const obj = Type.toObject(context);
+    if (!obj) {
+      return false;
+    }
+    return Type.hasProperty(obj, index) && !(obj instanceof Date) && !isObservable4(obj[index]) && !(obj[index] instanceof Promise);
+  }
+};
+
+// 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 {
+  static {
+    __name(this, "ResolvedValueCache");
+  }
+  _resolvedValues = /* @__PURE__ */ new WeakMap();
+  set(source, value) {
+    this._resolvedValues.set(source, value);
+  }
+  get(source) {
+    return this._resolvedValues.get(source);
+  }
+  delete(source) {
+    this._resolvedValues.delete(source);
+  }
+};
+ResolvedValueCache = _ts_decorate18([
+  injectable()
+], ResolvedValueCache);
+
+// lib/index-value-accessor/set-key-accessor.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);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate19, "_ts_decorate");
+var SetKeyAccessor = 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);
+  }
+  applies(map) {
+    return map instanceof Set;
+  }
+};
+SetKeyAccessor = _ts_decorate19([
+  injectable()
+], SetKeyAccessor);
+
+// lib/singleton-factory/singleton-factory-with-id-generation.ts
+var SingletonFactoryWithIdGeneration = class extends SingletonFactory {
+  static {
+    __name(this, "SingletonFactoryWithIdGeneration");
+  }
+  _groupedData = /* @__PURE__ */ new Map();
+  getId(data) {
+    const groupId = this.getGroupId(data);
+    const groupMemberId = this.getGroupMemberId(data);
+    return this._groupedData.get(groupId)?.get(groupMemberId);
+  }
+  isGroupRegistered(groupId) {
+    return this._groupedData.has(groupId);
+  }
+  createId(data) {
+    const groupId = this.getGroupId(data);
+    let dataGroup = this._groupedData.get(groupId);
+    if (!dataGroup) {
+      dataGroup = /* @__PURE__ */ new Map();
+      this._groupedData.set(groupId, dataGroup);
+    }
+    let groupMemberId = this.getGroupMemberId(data);
+    let groupMember = dataGroup.get(groupMemberId);
+    if (groupMember) {
+      throw new InvalidOperationException("id allready exists");
+    }
+    const id = this.createUniqueId(data);
+    dataGroup.set(groupMemberId, id);
+    return id;
+  }
+  releaseInstance(_instance, id) {
+    const { groupId, groupMemberId } = this.findGroupMemberId(id);
+    let dataGroup = this._groupedData.get(groupId);
+    if (!dataGroup) {
+      return;
+    }
+    dataGroup.delete(groupMemberId);
+    if (dataGroup.size === 0) {
+      this._groupedData.delete(groupId);
+    }
+  }
+  findGroupMemberId(idToFind) {
+    for (const [groupId, groupData] of this._groupedData) {
+      for (const [groupMemberId, id] of groupData.entries()) {
+        if (idToFind === id) {
+          return {
+            groupId,
+            groupMemberId
+          };
+        }
+      }
+    }
+    return {
+      groupId: null,
+      groupMemberId: null
+    };
+  }
+};
+var SingletonFactoryWithGuid = class extends SingletonFactoryWithIdGeneration {
+  static {
+    __name(this, "SingletonFactoryWithGuid");
+  }
+  _guidFactory;
+  constructor(_guidFactory) {
+    super(), this._guidFactory = _guidFactory;
+  }
+  createUniqueId(_data) {
+    return this._guidFactory.create();
+  }
+};
+
+// lib/sequence-id/sequence-id.factory.ts
+function _ts_decorate20(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate20, "_ts_decorate");
+function _ts_metadata11(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) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param9, "_ts_param");
+var RegistryNode = class RegistryNode2 {
+  static {
+    __name(this, "RegistryNode");
+  }
+  children = /* @__PURE__ */ new Map();
+  id;
+};
+var SequenceWithId = class {
+  static {
+    __name(this, "SequenceWithId");
+  }
+  id;
+  sequence;
+  _owner;
+  _isDisposed = false;
+  constructor(id, sequence, _owner) {
+    this.id = id;
+    this.sequence = sequence;
+    this._owner = _owner;
+  }
+  dispose() {
+    if (this._isDisposed) {
+      return;
+    }
+    if (this._owner.canDispose?.()) {
+      this._isDisposed = true;
+    }
+    this._owner.release();
+  }
+};
+var ValueSequenceIdRegistry = class ValueSequenceIdRegistry2 {
+  static {
+    __name(this, "ValueSequenceIdRegistry");
+  }
+  _guidFactory;
+  _root = new RegistryNode();
+  _idToSequence = /* @__PURE__ */ new Map();
+  constructor(_guidFactory) {
+    this._guidFactory = _guidFactory;
+  }
+  getId(sequence) {
+    let node = this._root;
+    for (const value of sequence) {
+      let next = node.children.get(value);
+      if (!next) {
+        next = new RegistryNode();
+        node.children.set(value, next);
+      }
+      node = next;
+    }
+    let isNew = !node.id;
+    if (isNew) {
+      node.id = this._guidFactory.create();
+      this._idToSequence.set(node.id, [
+        ...sequence
+      ]);
+    }
+    return {
+      isNew,
+      id: node.id
+    };
+  }
+  deleteId(id) {
+    const sequence = this.getSequence(id);
+    if (!sequence) {
+      return;
+    }
+    const stack = [];
+    let node = this._root;
+    for (const value of sequence) {
+      const next = node.children.get(value);
+      if (!next) {
+        this._idToSequence.delete(id);
+        return;
+      }
+      stack.push({
+        node,
+        value
+      });
+      node = next;
+    }
+    delete node.id;
+    for (let i = stack.length - 1; i >= 0; i--) {
+      const { node: parent, value } = stack[i];
+      const child = parent.children.get(value);
+      if (child.children.size === 0 && !child.id) {
+        parent.children.delete(value);
+      } else {
+        break;
+      }
+    }
+    this._idToSequence.delete(id);
+  }
+  getSequence(id) {
+    return this._idToSequence.get(id);
+  }
+  hasSequence(id) {
+    return this._idToSequence.has(id);
+  }
+};
+var ValueSequenceIdsForContext = class ValueSequenceIdsForContext2 extends SingletonFactory {
+  static {
+    __name(this, "ValueSequenceIdsForContext");
+  }
+  context;
+  _guidFactory;
+  releaseContext;
+  _valueSequenceIdRegistry;
+  constructor(context, _guidFactory, releaseContext) {
+    super(), this.context = context, this._guidFactory = _guidFactory, this.releaseContext = releaseContext;
+    this._valueSequenceIdRegistry = new ValueSequenceIdRegistry(this._guidFactory);
+  }
+  getId(sequence) {
+    return this.createId(sequence);
+  }
+  createInstance(sequence, id) {
+    return new SequenceWithId(id, sequence, {
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => this.release(id), "release")
+    });
+  }
+  createId(sequence) {
+    return this._valueSequenceIdRegistry.getId(sequence).id;
+  }
+  releaseInstance(_, id) {
+    this._valueSequenceIdRegistry.deleteId(id);
+  }
+  onReleased() {
+    this.releaseContext();
+  }
+};
+var ValueSequenceIdRegistryManager = class ValueSequenceIdRegistryManager2 extends SingletonFactory {
+  static {
+    __name(this, "ValueSequenceIdRegistryManager");
+  }
+  _guidFactory;
+  constructor(_guidFactory) {
+    super(), this._guidFactory = _guidFactory;
+  }
+  getId(context) {
+    return context;
+  }
+  createInstance(context, id) {
+    return new ValueSequenceIdsForContext(context, this._guidFactory, () => this.release(id));
+  }
+  releaseInstance(instance, _id) {
+    instance.dispose();
+  }
+  createId(context) {
+    return context;
+  }
+};
+var SequenceIdFactory = class {
+  static {
+    __name(this, "SequenceIdFactory");
+  }
+  _valueSequenceIdRegistryManager;
+  constructor(guidFactory) {
+    this._valueSequenceIdRegistryManager = new ValueSequenceIdRegistryManager(guidFactory);
+  }
+  dispose() {
+    this._valueSequenceIdRegistryManager.dispose();
+  }
+  create(context, sequence) {
+    return this._valueSequenceIdRegistryManager.create(context).instance.create(sequence).instance;
+  }
+  release(context, id) {
+    this._valueSequenceIdRegistryManager.getFromId(context)?.release(id);
+  }
+  get(context, sequence) {
+    return this._valueSequenceIdRegistryManager.getFromId(context)?.getFromData(sequence);
+  }
+  has(context, id) {
+    return !!this._valueSequenceIdRegistryManager.getFromId(context)?.has(id);
+  }
+};
+_ts_decorate20([
+  preDestroy(),
+  _ts_metadata11("design:type", Function),
+  _ts_metadata11("design:paramtypes", []),
+  _ts_metadata11("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", [
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory
+  ])
+], SequenceIdFactory);
+
+// lib/rs-x-core.module.ts
+var defaultIndexValueAccessorList = [
+  {
+    target: PropertyValueAccessor,
+    token: RsXCoreInjectionTokens.IPropertyValueAccessor
+  },
+  {
+    target: MethodAccessor,
+    token: RsXCoreInjectionTokens.IMethodAccessor
+  },
+  {
+    target: ArrayIndexAccessor,
+    token: RsXCoreInjectionTokens.IArrayIndexAccessor
+  },
+  {
+    target: MapKeyAccessor,
+    token: RsXCoreInjectionTokens.IMapKeyAccessor
+  },
+  {
+    target: SetKeyAccessor,
+    token: RsXCoreInjectionTokens.ISetKeyAccessor
+  },
+  {
+    target: ObservableAccessor,
+    token: RsXCoreInjectionTokens.IObservableAccessor
+  },
+  {
+    target: PromiseAccessor,
+    token: RsXCoreInjectionTokens.IPromiseAccessor
+  },
+  {
+    target: DatePropertyAccessor,
+    token: RsXCoreInjectionTokens.IDatePropertyAccessor
+  }
+];
+var defaultDeeoCloneList = [
+  {
+    target: StructuredDeepClone,
+    token: RsXCoreInjectionTokens.IStructuredDeepClone
+  },
+  {
+    target: LodashDeepClone,
+    token: RsXCoreInjectionTokens.ILodashDeepClone
+  }
+];
+var RsXCoreModule = new ContainerModule((options) => {
+  options.bind(RsXCoreInjectionTokens.IInjectionContainer).toConstantValue(InjectionContainer);
+  options.bind(RsXCoreInjectionTokens.IErrorLog).to(ErrorLog).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.IIndexValueAccessor).to(IndexValueAccessor).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.IDeepClone).to(DefaultDeepClone).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.IEqualityService).to(EqualityService).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.ISequenceIdFactory).to(SequenceIdFactory).inSingletonScope();
+  options.bind(RsXCoreInjectionTokens.IFunctionCallIndexFactory).to(FunctionCallIndexFactory).inSingletonScope();
+  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();
+  registerMultiInjectServices(options, RsXCoreInjectionTokens.IIndexValueAccessorList, defaultIndexValueAccessorList);
+  registerMultiInjectServices(options, RsXCoreInjectionTokens.IDeepCloneList, defaultDeeoCloneList);
+});
+
+// lib/wait-for-event.ts
+import { firstValueFrom, Observable as Observable2 } from "rxjs";
+var WaitForEvent = class {
+  static {
+    __name(this, "WaitForEvent");
+  }
+  _target;
+  _eventName;
+  _options;
+  constructor(_target, _eventName, options) {
+    this._target = _target;
+    this._eventName = _eventName;
+    this._options = {
+      count: options?.count ?? 1,
+      timeout: options?.timeout ?? 100,
+      ignoreInitialValue: options?.ignoreInitialValue ?? false
+    };
+  }
+  wait(trigger) {
+    const state = {
+      results: [],
+      pending: this._options.ignoreInitialValue,
+      subscription: null,
+      timerId: 0
+    };
+    return new Promise((resolve, reject) => {
+      state.timerId = window.setTimeout(() => {
+        this.unsubscribeEvent(state);
+        resolve(null);
+      }, this._options.timeout);
+      state.subscription = this.subscribeToEvent(state, resolve, reject);
+      this.runTrigger(trigger, state, reject);
+    });
+  }
+  subscribeToEvent(state, resolve, reject) {
+    return this._target[this._eventName].subscribe({
+      next: /* @__PURE__ */ __name((value) => {
+        if (state.pending || state.results.length >= (this._options.count ?? 1)) {
+          state.pending = false;
+          return;
+        }
+        state.results.push(value);
+        if (state.results.length === this._options.count) {
+          this.finish(state, resolve);
+        }
+      }, "next"),
+      error: /* @__PURE__ */ __name((error) => {
+        this.cleanup(state);
+        reject(error);
+      }, "error")
+    });
+  }
+  async runTrigger(trigger, state, reject) {
+    try {
+      const result = trigger();
+      if (result instanceof Promise) {
+        await result;
+      } else if (result instanceof Observable2) {
+        await firstValueFrom(result);
+      }
+    } catch (error) {
+      this.cleanup(state);
+      reject(error);
+    }
+  }
+  finish(state, resolve) {
+    this.cleanup(state);
+    resolve(state.results.length > 1 ? state.results : state.results[0]);
+  }
+  cleanup(state) {
+    window.clearTimeout(state.timerId);
+    this.unsubscribeEvent(state);
+  }
+  unsubscribeEvent(state) {
+    if (state.subscription) {
+      state.subscription.unsubscribe();
+    }
+  }
+};
+export {
+  ArgumentException,
+  ArrayIndexAccessor,
+  Assertion,
+  Container,
+  ContainerModule,
+  DatePropertyAccessor,
+  DeepClone,
+  DeepCloneValueGetter,
+  DefaultDeepClone,
+  EqualityService,
+  ErrorLog,
+  FunctionCallIndex,
+  FunctionCallIndexFactory,
+  FunctionCallResultCacheFactory,
+  GuidFactory,
+  IndexValueAccessor,
+  inject as Inject,
+  injectable as Injectable,
+  InjectionContainer,
+  InvalidCastException,
+  InvalidOperationException,
+  LodashDeepClone,
+  MapKeyAccessor,
+  MethodAccessor,
+  multiInject as MultiInject,
+  NullOrEmptyException,
+  NullOrUndefinedException,
+  ObservableAccessor,
+  PENDING,
+  ParserException,
+  preDestroy as PreDestroy,
+  PrettyPrinter,
+  PromiseAccessor,
+  PropertyDescriptorType,
+  PropertyValueAccessor,
+  ResolvedValueCache,
+  RsXCoreInjectionTokens,
+  RsXCoreModule,
+  SequenceIdFactory,
+  SequenceWithId,
+  SetKeyAccessor,
+  SingletonFactory,
+  SingletonFactoryWithGuid,
+  SingletonFactoryWithIdGeneration,
+  StructuredDeepClone,
+  Type,
+  UnexpectedException,
+  unmanaged as Unmanaged,
+  UnsupportedException,
+  WaitForEvent,
+  dataProperties,
+  defaultDeeoCloneList,
+  defaultIndexValueAccessorList,
+  echo,
+  emptyFunction,
+  emptyValue,
+  overrideMultiInjectServices,
+  printValue,
+  registerMultiInjectService,
+  registerMultiInjectServices,
+  replaceSetItemAt,
+  truePredicate,
+  utCDate
+};