@rs-x/expression-parser 0.4.10 → 0.4.12

package/dist/index.js

@@ -8213,9 +8213,9 @@ var require_estraverse = __commonJS({
 });
 
 // lib/expresion-change-transaction-manager.ts
+import { Subject } from "rxjs";
 import { Inject, Injectable, PreDestroy } from "@rs-x/core";
 import { RsXStateManagerInjectionTokens } from "@rs-x/state-manager";
-import { Subject } from "rxjs";
 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);
@@ -8319,8 +8319,8 @@ ExpressionChangeTransactionManager = _ts_decorate([
   ])
 ], ExpressionChangeTransactionManager);
 
-// lib/expression-factory/expression-factory.ts
-import { Inject as Inject2, Injectable as Injectable2 } from "@rs-x/core";
+// lib/expression-cache/expression-cache.ts
+import { Inject as Inject2, Injectable as Injectable2, SingletonFactory } from "@rs-x/core";
 
 // lib/rs-x-expression-parser-injection-tokes.ts
 var RsXExpressionParserInjectionTokens = {
@@ -8335,10 +8335,13 @@ var RsXExpressionParserInjectionTokens = {
   IExpressionFactory: Symbol("IExpressionFactory"),
   IExpressionObserverProxyPairFactory: Symbol("IExpressionObserverProxyPairFactory"),
   IExpressionIndexAccessor: Symbol("IExpressionIndexAccessor"),
-  IExpressionObserverFactory: Symbol("IExpressionObserverFactory")
+  IExpressionObserverFactory: Symbol("IExpressionObserverFactory"),
+  IExpressionCache: Symbol("IExpressionCache"),
+  IExpressionServices: Symbol("IExpressionServices"),
+  ExpressiomMetadata: Symbol("ExpressiomMetadata")
 };
 
-// lib/expression-factory/expression-factory.ts
+// lib/expression-cache/expression-cache.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);
@@ -8356,29 +8359,40 @@ function _ts_param2(paramIndex, decorator) {
   };
 }
 __name(_ts_param2, "_ts_param");
-var ExpressionFactory = class {
+var ExpressionCache = class extends SingletonFactory {
   static {
-    __name(this, "ExpressionFactory");
+    __name(this, "ExpressionCache");
   }
-  _expressionManager;
-  constructor(_expressionManager) {
-    this._expressionManager = _expressionManager;
+  _expressionParser;
+  constructor(_expressionParser) {
+    super(), this._expressionParser = _expressionParser;
+  }
+  getId(expressionString) {
+    return expressionString;
+  }
+  createId(expressionString) {
+    return expressionString;
+  }
+  create(data2) {
+    const result = super.create(data2);
+    result.instance = result.instance.clone();
+    return result;
   }
-  create(context, expression) {
-    return this._expressionManager.create(context).instance.create(expression).instance;
+  createInstance(expressionString) {
+    return this._expressionParser.parse(expressionString);
   }
 };
-ExpressionFactory = _ts_decorate2([
+ExpressionCache = _ts_decorate2([
   Injectable2(),
-  _ts_param2(0, Inject2(RsXExpressionParserInjectionTokens.IExpressionManager)),
+  _ts_param2(0, Inject2(RsXExpressionParserInjectionTokens.IExpressionParser)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof IExpressionManager === "undefined" ? Object : IExpressionManager
+    typeof IExpressionParser === "undefined" ? Object : IExpressionParser
   ])
-], ExpressionFactory);
+], ExpressionCache);
 
-// lib/expression-factory/expression-manager.ts
-import { Inject as Inject3, Injectable as Injectable3, SingletonFactory } from "@rs-x/core";
+// lib/expression-factory/expression-factory.ts
+import { Inject as Inject3, Injectable as Injectable3 } from "@rs-x/core";
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -8396,67 +8410,126 @@ function _ts_param3(paramIndex, decorator) {
   };
 }
 __name(_ts_param3, "_ts_param");
-var ExpressionForContextManager = class ExpressionForContextManager2 extends SingletonFactory {
+var ExpressionFactory = class {
   static {
-    __name(this, "ExpressionForContextManager");
+    __name(this, "ExpressionFactory");
   }
-  _expressionParser;
-  _context;
-  releaseContext;
-  constructor(_expressionParser, _context, releaseContext) {
-    super(), this._expressionParser = _expressionParser, this._context = _context, this.releaseContext = releaseContext;
+  _expressionManager;
+  constructor(_expressionManager) {
+    this._expressionManager = _expressionManager;
   }
-  getId(expression) {
-    return expression;
+  create(context, expressionString, leafIndexWatchRule) {
+    return this._expressionManager.create(context).instance.create({
+      expressionString,
+      leafIndexWatchRule
+    }).instance;
   }
-  createId(expression) {
-    return expression;
+};
+ExpressionFactory = _ts_decorate3([
+  Injectable3(),
+  _ts_param3(0, Inject3(RsXExpressionParserInjectionTokens.IExpressionManager)),
+  _ts_metadata3("design:type", Function),
+  _ts_metadata3("design:paramtypes", [
+    typeof IExpressionManager === "undefined" ? Object : IExpressionManager
+  ])
+], ExpressionFactory);
+
+// lib/expression-factory/expression-manager.ts
+import { Inject as Inject4, Injectable as Injectable4, SingletonFactory as SingletonFactory2 } from "@rs-x/core";
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+function _ts_param4(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param4, "_ts_param");
+var ExpressionForContextManager = class ExpressionForContextManager2 extends SingletonFactory2 {
+  static {
+    __name(this, "ExpressionForContextManager");
   }
-  createInstance(expression, id) {
-    return this._expressionParser.parse(this._context, expression, {
-      release: /* @__PURE__ */ __name(() => this.release(id), "release"),
-      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose")
+  _expressionCache;
+  _services;
+  _context;
+  releaseContext;
+  constructor(_expressionCache, _services, _context, releaseContext) {
+    super(), this._expressionCache = _expressionCache, this._services = _services, this._context = _context, this.releaseContext = releaseContext;
+  }
+  getId(expressionIdData) {
+    return expressionIdData.expressionString;
+  }
+  createId(expressionIdData) {
+    return expressionIdData.expressionString;
+  }
+  create(expressionData) {
+    const result = super.create(expressionData);
+    result.instance.bind({
+      rootContext: this._context,
+      services: this._services,
+      owner: {
+        release: /* @__PURE__ */ __name(() => {
+          this.release(result.id);
+          this._expressionCache.release(result.id);
+        }, "release"),
+        canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(result.id) === 1, "canDispose")
+      },
+      leafIndexWatchRule: expressionData.leafIndexWatchRule
     });
+    this._services.transactionManager.commit();
+    return result;
   }
   onReleased() {
-    if (this.isEmpty) {
-      this.releaseContext();
-    }
+    this.releaseContext();
+  }
+  createInstance(expressionData) {
+    return this._expressionCache.create(expressionData.expressionString).instance;
   }
 };
-var ExpressionManager = class extends SingletonFactory {
+var ExpressionManager = class extends SingletonFactory2 {
   static {
     __name(this, "ExpressionManager");
   }
-  _expressionParser;
+  _expressionCache;
+  _services;
   getId(context) {
     return this.createId(context);
   }
   createId(context) {
     return context;
   }
-  constructor(_expressionParser) {
-    super(), this._expressionParser = _expressionParser;
+  constructor(_expressionCache, _services) {
+    super(), this._expressionCache = _expressionCache, this._services = _services;
   }
   createInstance(context, id) {
-    return new ExpressionForContextManager(this._expressionParser, context, () => this.release(id));
+    return new ExpressionForContextManager(this._expressionCache, this._services, context, () => this.release(id));
   }
 };
-ExpressionManager = _ts_decorate3([
-  Injectable3(),
-  _ts_param3(0, Inject3(RsXExpressionParserInjectionTokens.IExpressionParser)),
-  _ts_metadata3("design:type", Function),
-  _ts_metadata3("design:paramtypes", [
-    typeof IExpressionParser === "undefined" ? Object : IExpressionParser
+ExpressionManager = _ts_decorate4([
+  Injectable4(),
+  _ts_param4(0, Inject4(RsXExpressionParserInjectionTokens.IExpressionCache)),
+  _ts_param4(1, Inject4(RsXExpressionParserInjectionTokens.IExpressionServices)),
+  _ts_metadata4("design:type", Function),
+  _ts_metadata4("design:paramtypes", [
+    typeof IExpressionCache === "undefined" ? Object : IExpressionCache,
+    typeof IExpressionServices === "undefined" ? Object : IExpressionServices
   ])
 ], ExpressionManager);
 
 // lib/expression-observer/deep-clone-except-with-expression-support.ts
-import { Inject as Inject4, Injectable as Injectable4, RsXCoreInjectionTokens } from "@rs-x/core";
+import { Inject as Inject5, Injectable as Injectable5, PENDING as PENDING2, RsXCoreInjectionTokens } from "@rs-x/core";
 
 // lib/expressions/abstract-expression.ts
-import { PENDING } from "@rs-x/core";
 import { ReplaySubject } from "rxjs";
+import { PENDING } from "@rs-x/core";
 var AbstractExpression = class {
   static {
     __name(this, "AbstractExpression");
@@ -8471,6 +8544,8 @@ var AbstractExpression = class {
   _oldValue;
   _commitedSubscription;
   _owner;
+  _services;
+  _leafIndexWatchRule;
   constructor(type, expressionString, ...childExpressions) {
     this.type = type;
     this.expressionString = expressionString;
@@ -8479,10 +8554,12 @@ var AbstractExpression = class {
     }
     this.addChildExpressions(childExpressions.filter((childExpression) => childExpression));
   }
-  initialize(settings) {
-    if (!this._parent && settings.transactionManager) {
+  bind(settings) {
+    this._services = settings.services;
+    this._leafIndexWatchRule = settings.leafIndexWatchRule;
+    if (!this._parent && this.transactionManager) {
       this._owner = settings.owner;
-      this._commitedSubscription = settings.transactionManager.commited.subscribe(this.onCommited);
+      this._commitedSubscription = this.transactionManager.commited.subscribe(this.onCommited);
     }
     return this;
   }
@@ -8513,6 +8590,27 @@ var AbstractExpression = class {
   toString() {
     return this.expressionString;
   }
+  get services() {
+    return this._services;
+  }
+  get guidFactory() {
+    return this._services?.guidFactory;
+  }
+  get leafIndexWatchRule() {
+    return this._leafIndexWatchRule;
+  }
+  get stateManager() {
+    return this._services?.stateManager;
+  }
+  get indexValueAccessor() {
+    return this._services?.indexValueAccessor;
+  }
+  get transactionManager() {
+    return this._services?.transactionManager;
+  }
+  get valueMetadata() {
+    return this._services?.valueMetadata;
+  }
   get root() {
     return this.parent ? this.parent.root : this;
   }
@@ -8566,148 +8664,410 @@ var AbstractExpression = class {
   }
 };
 
-// lib/expressions/parameterized-abstract-expression.ts
-var ParameterizedExpression = class extends AbstractExpression {
+// lib/expression-observer/deep-clone-except-with-expression-support.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_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+function _ts_param5(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param5, "_ts_param");
+var DeepCloneExceptWithExpressionSupport = class {
   static {
-    __name(this, "ParameterizedExpression");
-  }
-  constructor(type, expressionString, ...childExpressions) {
-    super(type, expressionString, ...childExpressions);
+    __name(this, "DeepCloneExceptWithExpressionSupport");
   }
-  initialize(settings) {
-    super.initialize(settings);
-    this._childExpressions.forEach((childExpression) => {
-      childExpression.initialize(settings);
-    });
-    return this;
+  _defaultDeepCloneValueGetter;
+  constructor(_defaultDeepCloneValueGetter) {
+    this._defaultDeepCloneValueGetter = _defaultDeepCloneValueGetter;
   }
-  prepareReevaluation() {
-    const args = this._childExpressions.map((childExpression) => childExpression.value);
-    if (args.some((arg) => arg === void 0)) {
-      return false;
+  except(source) {
+    if (source instanceof AbstractExpression) {
+      return source.value === void 0 ? PENDING2 : source.value;
     }
-    return true;
-  }
-  evaluate() {
-    const args = this._childExpressions.map((childExpression) => childExpression.value);
-    return this.evaluateExpression(...args);
+    return this._defaultDeepCloneValueGetter.except(source);
   }
 };
+DeepCloneExceptWithExpressionSupport = _ts_decorate5([
+  Injectable5(),
+  _ts_param5(0, Inject5(RsXCoreInjectionTokens.IDeepCloneExcept)),
+  _ts_metadata5("design:type", Function),
+  _ts_metadata5("design:paramtypes", [
+    typeof IDeepCloneExcept === "undefined" ? Object : IDeepCloneExcept
+  ])
+], DeepCloneExceptWithExpressionSupport);
 
-// lib/expressions/binary-expression.ts
-var BinaryExpression = class extends ParameterizedExpression {
+// lib/expression-observer/expression-index-accessor.ts
+import { Injectable as Injectable6, Type, UnsupportedException } from "@rs-x/core";
+function _ts_decorate6(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate6, "_ts_decorate");
+var ExpressionIndexAccessor = class {
   static {
-    __name(this, "BinaryExpression");
-  }
-  constructor(expressionType, expressionString, leftExpression, rightExpression) {
-    super(expressionType, expressionString, leftExpression, rightExpression);
+    __name(this, "ExpressionIndexAccessor");
   }
-};
-
-// lib/expressions/interfaces.ts
-var ExpressionType = /* @__PURE__ */ (function(ExpressionType2) {
-  ExpressionType2["And"] = "and";
-  ExpressionType2["Or"] = "or";
-  ExpressionType2["Not"] = "not";
-  ExpressionType2["Conditional"] = "conditional";
-  ExpressionType2["Equality"] = "equality";
-  ExpressionType2["Inequality"] = "inequality";
-  ExpressionType2["StrictEquality"] = "strict equality";
-  ExpressionType2["StrictInequality"] = "strict inequality";
-  ExpressionType2["GreaterThan"] = "greater than";
-  ExpressionType2["GreaterThanOrEqual"] = "Greater than or equal";
-  ExpressionType2["LessThan"] = "less than";
-  ExpressionType2["LessThanOrEqual"] = "less than or equal";
-  ExpressionType2["In"] = "in";
-  ExpressionType2["Instanceof"] = "instanceof";
-  ExpressionType2["Typeof"] = "typeof";
-  ExpressionType2["Remainder"] = "remain";
-  ExpressionType2["Subtraction"] = "subtraction";
-  ExpressionType2["UnaryNegation"] = "unary negation";
-  ExpressionType2["Addition"] = "addition";
-  ExpressionType2["Division"] = "division";
-  ExpressionType2["Multiplication"] = "multiplication";
-  ExpressionType2["Exponentiation"] = "exponentiation";
-  ExpressionType2["NullishCoalescing"] = "nullish coalescing";
-  ExpressionType2["String"] = "string";
-  ExpressionType2["Number"] = "number";
-  ExpressionType2["Boolean"] = "boolean";
-  ExpressionType2["Array"] = "array";
-  ExpressionType2["Identifier"] = "identifier";
-  ExpressionType2["Function"] = "function";
-  ExpressionType2["TemlateString"] = "template string";
-  ExpressionType2["Null"] = "null";
-  ExpressionType2["BigInt"] = "big int";
-  ExpressionType2["RegExp"] = "regular expression";
-  ExpressionType2["Member"] = "member";
-  ExpressionType2["Spread"] = "spread";
-  ExpressionType2["BitwiseLeftShift"] = "bitwise left shift";
-  ExpressionType2["BitwiseRightShift"] = "bitwise right shift";
-  ExpressionType2["BitwiseUnsignedRightShift"] = "bitwise unsigned right shift";
-  ExpressionType2["BitwiseNot"] = "bitwise not";
-  ExpressionType2["BitwiseAnd"] = "bitwise and";
-  ExpressionType2["BitwiseOr"] = "bitwise or";
-  ExpressionType2["BitwiseXor"] = "bitwise xor";
-  ExpressionType2["New"] = "new";
-  ExpressionType2["Sequence"] = "sequence";
-  ExpressionType2["Object"] = "object";
-  ExpressionType2["Property"] = "property";
-  ExpressionType2["PropertyContext"] = "property context";
-  ExpressionType2["Super"] = "super";
-  ExpressionType2["This"] = "this";
-  ExpressionType2["Index"] = "Index";
-  ExpressionType2["UnaryPlus"] = "unary plus";
-  return ExpressionType2;
-})({});
-
-// lib/expressions/addition-expression.ts
-var AdditionExpression = class extends BinaryExpression {
-  static {
-    __name(this, "AdditionExpression");
+  priority;
+  isAsync() {
+    return true;
   }
-  constructor(expressionString, leftExpression, rightExpression) {
-    super(ExpressionType.Addition, expressionString, leftExpression, rightExpression);
+  needsProxy() {
+    return true;
   }
-  evaluateExpression(a, b) {
-    return a + b;
+  getResolvedValue(context, index) {
+    return Type.cast((Type.toObject(context) ?? {})[index])?.value;
   }
-};
-
-// lib/expressions/collection-expression.ts
-var CollectionExpression = class extends ParameterizedExpression {
-  static {
-    __name(this, "CollectionExpression");
+  hasValue(context, index) {
+    return Type.cast((Type.toObject(context) ?? {})[index])?.value !== void 0;
   }
-  constructor(type, expressionString, expressions) {
-    super(type, expressionString, ...expressions);
+  getValue(context, index) {
+    return (Type.toObject(context) ?? {})[index];
   }
-};
-
-// lib/expressions/array-expression.ts
-var ArrayExpression = class extends CollectionExpression {
-  static {
-    __name(this, "ArrayExpression");
+  setValue() {
+    throw new UnsupportedException("Cannot set the value of an expression directly. To update it, modify the relevant properties in the expression context.");
   }
-  constructor(expressions) {
-    super(ExpressionType.Array, `[${expressions.map((expression) => expression.expressionString).join(", ")}]`, expressions);
+  getIndexes() {
+    return [].values();
   }
-  evaluateExpression(...args) {
-    const array = [];
-    args.forEach((item, i) => {
-      if (this.childExpressions[i].type === ExpressionType.Spread) {
-        array.push(...item);
-      } else {
-        array.push(item);
-      }
-    });
-    return array;
+  applies(context, index) {
+    return (Type.toObject(context) ?? {})[index] instanceof AbstractExpression;
   }
 };
+ExpressionIndexAccessor = _ts_decorate6([
+  Injectable6()
+], ExpressionIndexAccessor);
 
-// lib/expressions/bitwise-and-expression.ts
-var BitwiseAndExpression = class extends BinaryExpression {
-  static {
-    __name(this, "BitwiseAndExpression");
+// lib/expression-observer/expression-observer.factory.ts
+import { ReplaySubject as ReplaySubject2 } from "rxjs";
+import { Injectable as Injectable7, SingletonFactory as SingletonFactory3 } from "@rs-x/core";
+import { AbstractObserver } from "@rs-x/state-manager";
+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_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+var ExpressionObserver = class ExpressionObserver2 extends AbstractObserver {
+  static {
+    __name(this, "ExpressionObserver");
+  }
+  _changedSubsctiption;
+  constructor(owner, target) {
+    super(owner, target, void 0, new ReplaySubject2(1));
+    this._changedSubsctiption = target.changed.subscribe(this.onExpressionChanged);
+  }
+  disposeInternal() {
+    this._changedSubsctiption.unsubscribe();
+  }
+  onExpressionChanged = /* @__PURE__ */ __name((expression) => {
+    this.emitChange({
+      arguments: [],
+      chain: [],
+      target: this.target,
+      newValue: expression.value
+    });
+  }, "onExpressionChanged");
+};
+var ExpressionObserverFactory = class extends SingletonFactory3 {
+  static {
+    __name(this, "ExpressionObserverFactory");
+  }
+  constructor() {
+    super();
+  }
+  getId(data2) {
+    return data2.expression;
+  }
+  createId(data2) {
+    return data2.expression;
+  }
+  createInstance(data2, id) {
+    return new ExpressionObserver({
+      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
+      release: /* @__PURE__ */ __name(() => {
+        this.release(id);
+        data2.owner?.release();
+      }, "release")
+    }, data2.expression);
+  }
+  releaseInstance(observer) {
+    observer.dispose();
+  }
+};
+ExpressionObserverFactory = _ts_decorate7([
+  Injectable7(),
+  _ts_metadata6("design:type", Function),
+  _ts_metadata6("design:paramtypes", [])
+], ExpressionObserverFactory);
+
+// lib/expression-observer/expression-observer-proxy-pair.factory.ts
+import { Inject as Inject6, Injectable as Injectable8 } from "@rs-x/core";
+function _ts_decorate8(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate8, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+function _ts_param6(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param6, "_ts_param");
+var ExpressionObserverProxyPairFactory = class {
+  static {
+    __name(this, "ExpressionObserverProxyPairFactory");
+  }
+  _expressionObserverFactory;
+  priority = 100;
+  constructor(_expressionObserverFactory) {
+    this._expressionObserverFactory = _expressionObserverFactory;
+  }
+  create(owner, proxyTarget) {
+    return {
+      observer: this._expressionObserverFactory.create({
+        owner,
+        expression: proxyTarget.target
+      }).instance
+    };
+  }
+  applies(object) {
+    return object instanceof AbstractExpression;
+  }
+};
+ExpressionObserverProxyPairFactory = _ts_decorate8([
+  Injectable8(),
+  _ts_param6(0, Inject6(RsXExpressionParserInjectionTokens.IExpressionObserverFactory)),
+  _ts_metadata7("design:type", Function),
+  _ts_metadata7("design:paramtypes", [
+    typeof IExpressionObserverFactory === "undefined" ? Object : IExpressionObserverFactory
+  ])
+], ExpressionObserverProxyPairFactory);
+
+// lib/expression-services/expression-services.ts
+import { Inject as Inject7, Injectable as Injectable9, RsXCoreInjectionTokens as RsXCoreInjectionTokens2 } from "@rs-x/core";
+import { RsXStateManagerInjectionTokens as RsXStateManagerInjectionTokens2 } from "@rs-x/state-manager";
+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_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+function _ts_param7(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param7, "_ts_param");
+var ExpressionServices = class {
+  static {
+    __name(this, "ExpressionServices");
+  }
+  transactionManager;
+  stateManager;
+  indexValueAccessor;
+  guidFactory;
+  valueMetadata;
+  constructor(transactionManager, stateManager, indexValueAccessor, guidFactory, valueMetadata) {
+    this.transactionManager = transactionManager;
+    this.stateManager = stateManager;
+    this.indexValueAccessor = indexValueAccessor;
+    this.guidFactory = guidFactory;
+    this.valueMetadata = valueMetadata;
+  }
+};
+ExpressionServices = _ts_decorate9([
+  Injectable9(),
+  _ts_param7(0, Inject7(RsXExpressionParserInjectionTokens.IExpressionChangeTransactionManager)),
+  _ts_param7(1, Inject7(RsXStateManagerInjectionTokens2.IStateManager)),
+  _ts_param7(2, Inject7(RsXCoreInjectionTokens2.IIndexValueAccessor)),
+  _ts_param7(3, Inject7(RsXCoreInjectionTokens2.IGuidFactory)),
+  _ts_param7(4, Inject7(RsXCoreInjectionTokens2.IValueMetadata)),
+  _ts_metadata8("design:type", Function),
+  _ts_metadata8("design:paramtypes", [
+    typeof IExpressionChangeTransactionManager === "undefined" ? Object : IExpressionChangeTransactionManager,
+    typeof IStateManager === "undefined" ? Object : IStateManager,
+    typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
+    typeof IGuidFactory === "undefined" ? Object : IGuidFactory,
+    typeof IValueMetadata === "undefined" ? Object : IValueMetadata
+  ])
+], ExpressionServices);
+
+// lib/expressions/parameterized-abstract-expression.ts
+var ParameterizedExpression = class extends AbstractExpression {
+  static {
+    __name(this, "ParameterizedExpression");
+  }
+  constructor(type, expressionString, ...childExpressions) {
+    super(type, expressionString, ...childExpressions);
+  }
+  bind(settings) {
+    super.bind(settings);
+    this._childExpressions.forEach((childExpression) => {
+      childExpression.bind(settings);
+    });
+    return this;
+  }
+  prepareReevaluation() {
+    const args = this._childExpressions.map((childExpression) => childExpression.value);
+    if (args.some((arg) => arg === void 0)) {
+      return false;
+    }
+    return true;
+  }
+  evaluate() {
+    const args = this._childExpressions.map((childExpression) => childExpression.value);
+    return this.evaluateExpression(...args);
+  }
+};
+
+// lib/expressions/binary-expression.ts
+var BinaryExpression = class extends ParameterizedExpression {
+  static {
+    __name(this, "BinaryExpression");
+  }
+  constructor(expressionType, expressionString, leftExpression, rightExpression) {
+    super(expressionType, expressionString, leftExpression, rightExpression);
+  }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions[0].clone(), this._childExpressions[1].clone());
+  }
+};
+
+// lib/expressions/expression-parser.interface.ts
+var ExpressionType = /* @__PURE__ */ (function(ExpressionType2) {
+  ExpressionType2["And"] = "and";
+  ExpressionType2["Or"] = "or";
+  ExpressionType2["Not"] = "not";
+  ExpressionType2["Conditional"] = "conditional";
+  ExpressionType2["Equality"] = "equality";
+  ExpressionType2["Inequality"] = "inequality";
+  ExpressionType2["StrictEquality"] = "strict equality";
+  ExpressionType2["StrictInequality"] = "strict inequality";
+  ExpressionType2["GreaterThan"] = "greater than";
+  ExpressionType2["GreaterThanOrEqual"] = "Greater than or equal";
+  ExpressionType2["LessThan"] = "less than";
+  ExpressionType2["LessThanOrEqual"] = "less than or equal";
+  ExpressionType2["In"] = "in";
+  ExpressionType2["Instanceof"] = "instanceof";
+  ExpressionType2["Typeof"] = "typeof";
+  ExpressionType2["Remainder"] = "remain";
+  ExpressionType2["Subtraction"] = "subtraction";
+  ExpressionType2["UnaryNegation"] = "unary negation";
+  ExpressionType2["Addition"] = "addition";
+  ExpressionType2["Division"] = "division";
+  ExpressionType2["Multiplication"] = "multiplication";
+  ExpressionType2["Exponentiation"] = "exponentiation";
+  ExpressionType2["NullishCoalescing"] = "nullish coalescing";
+  ExpressionType2["String"] = "string";
+  ExpressionType2["Number"] = "number";
+  ExpressionType2["Boolean"] = "boolean";
+  ExpressionType2["Array"] = "array";
+  ExpressionType2["Identifier"] = "identifier";
+  ExpressionType2["Function"] = "function";
+  ExpressionType2["TemlateString"] = "template string";
+  ExpressionType2["Null"] = "null";
+  ExpressionType2["BigInt"] = "big int";
+  ExpressionType2["RegExp"] = "regular expression";
+  ExpressionType2["Member"] = "member";
+  ExpressionType2["Spread"] = "spread";
+  ExpressionType2["BitwiseLeftShift"] = "bitwise left shift";
+  ExpressionType2["BitwiseRightShift"] = "bitwise right shift";
+  ExpressionType2["BitwiseUnsignedRightShift"] = "bitwise unsigned right shift";
+  ExpressionType2["BitwiseNot"] = "bitwise not";
+  ExpressionType2["BitwiseAnd"] = "bitwise and";
+  ExpressionType2["BitwiseOr"] = "bitwise or";
+  ExpressionType2["BitwiseXor"] = "bitwise xor";
+  ExpressionType2["New"] = "new";
+  ExpressionType2["Sequence"] = "sequence";
+  ExpressionType2["Object"] = "object";
+  ExpressionType2["Property"] = "property";
+  ExpressionType2["PropertyContext"] = "property context";
+  ExpressionType2["Super"] = "super";
+  ExpressionType2["This"] = "this";
+  ExpressionType2["Index"] = "Index";
+  ExpressionType2["UnaryPlus"] = "unary plus";
+  return ExpressionType2;
+})({});
+
+// lib/expressions/addition-expression.ts
+var AdditionExpression = class extends BinaryExpression {
+  static {
+    __name(this, "AdditionExpression");
+  }
+  constructor(expressionString, leftExpression, rightExpression) {
+    super(ExpressionType.Addition, expressionString, leftExpression, rightExpression);
+  }
+  evaluateExpression(a, b) {
+    return a + b;
+  }
+};
+
+// lib/expressions/collection-expression.ts
+var CollectionExpression = class extends ParameterizedExpression {
+  static {
+    __name(this, "CollectionExpression");
+  }
+  constructor(type, expressionString, expressions) {
+    super(type, expressionString, ...expressions);
+  }
+};
+
+// lib/expressions/array-expression.ts
+var ArrayExpression = class _ArrayExpression extends CollectionExpression {
+  static {
+    __name(this, "ArrayExpression");
+  }
+  constructor(expressions) {
+    super(ExpressionType.Array, `[${expressions.map((expression) => expression.expressionString).join(", ")}]`, expressions);
+  }
+  clone() {
+    return new _ArrayExpression(this._childExpressions.map((childExpression) => childExpression.clone()));
+  }
+  evaluateExpression(...args) {
+    const array = [];
+    args.forEach((item, i) => {
+      if (this.childExpressions[i].type === ExpressionType.Spread) {
+        array.push(...item);
+      } else {
+        array.push(item);
+      }
+    });
+    return array;
+  }
+};
+
+// lib/expressions/bitwise-and-expression.ts
+var BitwiseAndExpression = class extends BinaryExpression {
+  static {
+    __name(this, "BitwiseAndExpression");
   }
   constructor(expressionString, leftExpression, rightExpression) {
     super(ExpressionType.BitwiseAnd, expressionString, leftExpression, rightExpression);
@@ -8738,6 +9098,9 @@ var BitwiseNotExpression = class extends ParameterizedExpression {
   constructor(expressionString, expression) {
     super(ExpressionType.BitwiseNot, expressionString, expression);
   }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions[0].clone());
+  }
   evaluateExpression(a) {
     return ~a;
   }
@@ -8803,6 +9166,9 @@ var ConditionalExpression = class extends ParameterizedExpression {
   constructor(expressionString, condition, ifValueExpression, elseValueExpression) {
     super(ExpressionType.Conditional, expressionString, condition, ifValueExpression, elseValueExpression);
   }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions[0].clone(), this._childExpressions[1].clone(), this._childExpressions[2].clone());
+  }
   evaluateExpression(condition, consequent, alternate) {
     return condition ? consequent : alternate;
   }
@@ -8813,19 +9179,21 @@ var ConstantExpression = class extends AbstractExpression {
   static {
     __name(this, "ConstantExpression");
   }
-  _expressionChangeTransactionManager;
   _commitHandler;
-  constructor(type, expressionString, constValue, _expressionChangeTransactionManager) {
-    super(type, expressionString), this._expressionChangeTransactionManager = _expressionChangeTransactionManager;
+  constructor(type, expressionString, constValue) {
+    super(type, expressionString);
     this._commitHandler = {
       owner: this,
       commit: this.commit
     };
     this._value = constValue;
   }
-  initialize(settings) {
-    super.initialize(settings);
-    this._expressionChangeTransactionManager.registerChange(this.root, this._commitHandler);
+  clone() {
+    return new this.constructor(this._value);
+  }
+  bind(settings) {
+    super.bind(settings);
+    this.transactionManager.registerChange(this.root, this._commitHandler);
     return this;
   }
   evaluate() {
@@ -8839,8 +9207,8 @@ var ConstantBigIntExpression = class extends ConstantExpression {
   static {
     __name(this, "ConstantBigIntExpression");
   }
-  constructor(value, expressionChangeTransactionManager) {
-    super(ExpressionType.BigInt, value.toString(), value, expressionChangeTransactionManager);
+  constructor(value) {
+    super(ExpressionType.BigInt, value.toString(), value);
   }
 };
 
@@ -8849,8 +9217,8 @@ var ConstantBooleanExpression = class extends ConstantExpression {
   static {
     __name(this, "ConstantBooleanExpression");
   }
-  constructor(value, expressionChangeTransactionManager) {
-    super(ExpressionType.Boolean, value.toString(), value, expressionChangeTransactionManager);
+  constructor(value) {
+    super(ExpressionType.Boolean, value.toString(), value);
   }
 };
 
@@ -8859,8 +9227,11 @@ var ConstantNullExpression = class extends ConstantExpression {
   static {
     __name(this, "ConstantNullExpression");
   }
-  constructor(expressionChangeTransactionManager) {
-    super(ExpressionType.Null, "null", null, expressionChangeTransactionManager);
+  constructor() {
+    super(ExpressionType.Null, "null", null);
+  }
+  clone() {
+    return new this.constructor();
   }
 };
 
@@ -8869,8 +9240,8 @@ var ConstantNumberExpression = class extends ConstantExpression {
   static {
     __name(this, "ConstantNumberExpression");
   }
-  constructor(value, expressionChangeTransactionManager) {
-    super(ExpressionType.Number, value.toString(), value, expressionChangeTransactionManager);
+  constructor(value) {
+    super(ExpressionType.Number, value.toString(), value);
   }
 };
 
@@ -8879,8 +9250,11 @@ var ConstantRegExpExpression = class extends ConstantExpression {
   static {
     __name(this, "ConstantRegExpExpression");
   }
-  constructor(expressionString, value, expressionChangeTransactionManager) {
-    super(ExpressionType.RegExp, expressionString, value, expressionChangeTransactionManager);
+  constructor(expressionString, value) {
+    super(ExpressionType.RegExp, expressionString, value);
+  }
+  clone() {
+    return new this.constructor(this.expressionString, this._value);
   }
 };
 
@@ -8889,21 +9263,8 @@ var ConstantStringExpression = class extends ConstantExpression {
   static {
     __name(this, "ConstantStringExpression");
   }
-  constructor(value, expressionChangeTransactionManager) {
-    super(ExpressionType.String, value, value, expressionChangeTransactionManager);
-  }
-};
-
-// lib/expressions/unary-plus-expression.ts
-var UnaryPlusExpression = class extends ParameterizedExpression {
-  static {
-    __name(this, "UnaryPlusExpression");
-  }
-  constructor(expressionString, expression) {
-    super(ExpressionType.UnaryPlus, expressionString, expression);
-  }
-  evaluateExpression(a) {
-    return +a;
+  constructor(value) {
+    super(ExpressionType.String, value, value);
   }
 };
 
@@ -8947,7 +9308,7 @@ var ExponentiationExpression = class extends BinaryExpression {
 };
 
 // lib/expressions/function-expression.ts
-import { Assertion, PENDING as PENDING2, Type } from "@rs-x/core";
+import { Assertion, PENDING as PENDING3, Type as Type2 } from "@rs-x/core";
 var FunctionExpression = class extends AbstractExpression {
   static {
     __name(this, "FunctionExpression");
@@ -8957,26 +9318,28 @@ var FunctionExpression = class extends AbstractExpression {
   argumentsExpression;
   computed;
   optional;
-  _stateManager;
   _context;
   _functionContext;
   _functionId;
-  constructor(expressionString, functionExpression, objectExpression, argumentsExpression, computed, optional, expressionChangeTransactionManager, _stateManager, guidFactory) {
-    super(ExpressionType.Function, expressionString, objectExpression ?? new ConstantNullExpression(expressionChangeTransactionManager), functionExpression, argumentsExpression), this.functionExpression = functionExpression, this.objectExpression = objectExpression, this.argumentsExpression = argumentsExpression, this.computed = computed, this.optional = optional, this._stateManager = _stateManager;
-    this._functionId = guidFactory.create();
+  constructor(expressionString, functionExpression, objectExpression, argumentsExpression, computed, optional) {
+    super(ExpressionType.Function, expressionString, objectExpression ?? new ConstantNullExpression(), functionExpression, argumentsExpression), this.functionExpression = functionExpression, this.objectExpression = objectExpression, this.argumentsExpression = argumentsExpression, this.computed = computed, this.optional = optional;
+  }
+  clone() {
+    return new this.constructor(this.expressionString, this.functionExpression.clone(), this.objectExpression?.clone(), this.argumentsExpression.clone(), this.computed, this.optional);
   }
-  initialize(settings) {
-    this._context = settings.context;
-    super.initialize(settings);
+  bind(settings) {
+    super.bind(settings);
+    this._functionId = this.guidFactory.create();
+    this._context = settings.context ?? settings.rootContext;
     if (this.objectExpression) {
-      this.objectExpression.initialize(settings);
+      this.objectExpression.bind(settings);
       if (this.computed) {
-        this.functionExpression.initialize(settings);
+        this.functionExpression.bind(settings);
       }
     } else if (this.functionExpression.type !== ExpressionType.Identifier) {
-      this.functionExpression.initialize(settings);
+      this.functionExpression.bind(settings);
     }
-    this.argumentsExpression.initialize(settings);
+    this.argumentsExpression.bind(settings);
     return this;
   }
   internalDispose() {
@@ -8990,301 +9353,89 @@ var FunctionExpression = class extends AbstractExpression {
     return super.prepareReevaluation(sender, root, pendingCommits);
   }
   evaluate() {
-    const functionContext = Type.toObject(this.objectExpression ? this.objectExpression?.value : this._context);
-    if (!functionContext) {
-      return PENDING2;
-    }
-    if (this._functionContext !== functionContext) {
-      this._functionContext = functionContext;
-    }
-    const { functionName, argumentsExpression } = this;
-    const args = argumentsExpression.value;
-    if (!functionName || !args || !functionContext) {
-      return PENDING2;
-    }
-    const func = Type.cast(functionContext[functionName]);
-    Assertion.assertIsFunction(func, func.name);
-    return this.registerResult(func.call(functionContext, ...args));
-  }
-  get functionName() {
-    return this.computed ? this.functionExpression.value : this.functionExpression.expressionString;
-  }
-  releaseResult() {
-    this._stateManager.releaseState(this._functionContext, this._functionId);
-    this._functionContext = void 0;
-  }
-  registerResult(result) {
-    this._stateManager.setState(this._functionContext, this._functionId, result);
-    return result;
-  }
-};
-
-// lib/expressions/greater-than-expression.ts
-var GreaterThanExpression = class extends BinaryExpression {
-  static {
-    __name(this, "GreaterThanExpression");
-  }
-  constructor(expressionString, leftExpression, rightExpression) {
-    super(ExpressionType.GreaterThan, expressionString, leftExpression, rightExpression);
-  }
-  evaluateExpression(a, b) {
-    return a > b;
-  }
-};
-
-// lib/expressions/greater-than-or-equal-expression.ts
-var GreaterThanOrEqualExpression = class extends BinaryExpression {
-  static {
-    __name(this, "GreaterThanOrEqualExpression");
-  }
-  constructor(expressionString, leftExpression, rightExpression) {
-    super(ExpressionType.GreaterThanOrEqual, expressionString, leftExpression, rightExpression);
-  }
-  evaluateExpression(a, b) {
-    return a >= b;
-  }
-};
-
-// lib/expressions/identifier-expression.ts
-import { emptyFunction as emptyFunction2, truePredicate as truePredicate2 } from "@rs-x/core";
-import { ReplaySubject as ReplaySubject2, Subject as Subject2 } from "rxjs";
-
-// lib/expressions/member-expression.ts
-import { emptyFunction, PENDING as PENDING3, truePredicate, Type as Type2 } from "@rs-x/core";
-var MemberExpression = class extends AbstractExpression {
-  static {
-    __name(this, "MemberExpression");
-  }
-  _indexValueAccessor;
-  _stateManager;
-  _mustProxifyItemHandlerFactory;
-  _expressionChangeTransactionManager;
-  _slotObservers = /* @__PURE__ */ new Map();
-  _rebindingSlot = false;
-  _initializeQueue = /* @__PURE__ */ new Map();
-  constructor(expressionString, pathSeqments, _indexValueAccessor, _stateManager, _mustProxifyItemHandlerFactory, _expressionChangeTransactionManager) {
-    super(ExpressionType.Member, expressionString, ...pathSeqments), this._indexValueAccessor = _indexValueAccessor, this._stateManager = _stateManager, this._mustProxifyItemHandlerFactory = _mustProxifyItemHandlerFactory, this._expressionChangeTransactionManager = _expressionChangeTransactionManager;
-  }
-  initialize(settings) {
-    super.initialize(settings);
-    for (let i = 0; i < this._childExpressions.length; i++) {
-      const currentSegment = this._childExpressions[i];
-      if (i === 0 || this.isCalculated(currentSegment)) {
-        currentSegment.initialize({
-          ...settings,
-          mustProxifyHandler: this.getMustProxifyHandler(i)
-        });
-      }
-    }
-    return this;
-  }
-  internalDispose() {
-    super.internalDispose();
-    for (const slotObserver of this._slotObservers.values()) {
-      this.disposeSlotObserver(slotObserver);
-    }
-    this._slotObservers.clear();
-    this._initializeQueue.clear();
-  }
-  prepareReevaluation(sender, root, pendingCommits) {
-    const senderIndex = this._childExpressions.indexOf(this.isCalculated(root) ? root : sender);
-    if (senderIndex < 0) {
-      return false;
-    }
-    if (this.shouldCancelEvaluate(senderIndex, pendingCommits)) {
-      return false;
-    }
-    const pathSeqments = this._childExpressions;
-    for (let i = senderIndex + 1; i < pathSeqments.length; i++) {
-      if (!this.isCalculated(pathSeqments[i]) && !this.isPending(pathSeqments[i], pendingCommits)) {
-        AbstractExpression.clearValue(pathSeqments[i]);
-      }
-    }
-    return true;
-  }
-  evaluate(sender, root) {
-    const senderIndex = this._childExpressions.indexOf(root.type === ExpressionType.Index ? root : sender);
-    const senderExpr = this._childExpressions[senderIndex];
-    if (senderExpr?.value === void 0) {
-      return void 0;
-    }
-    const startIndex = this.isCalculated(this._childExpressions[senderIndex]) ? senderIndex - 1 : senderIndex + 1;
-    let previousPathSegmentValue = this._childExpressions[startIndex - 1]?.value;
-    if (startIndex > 0 && Type2.isNullOrUndefined(previousPathSegmentValue)) {
-      return PENDING3;
-    }
-    for (let i = startIndex; i < this._childExpressions.length; i++) {
-      const currentPathSegment = this._childExpressions[i];
-      const currentPathSegmentValue = this.resolvePathSegment(currentPathSegment, previousPathSegmentValue, i);
-      if (currentPathSegmentValue === PENDING3) {
-        return currentPathSegmentValue;
-      }
-      previousPathSegmentValue = currentPathSegmentValue;
-    }
-    return previousPathSegmentValue;
-  }
-  isCommitTarget(sender) {
-    return super.isCommitTarget(sender) || this.isCalculated(sender) && this._childExpressions[this._childExpressions.length - 1] === sender;
-  }
-  isPending(pathSegement, pendingCommits) {
-    for (const commit of pendingCommits) {
-      if (commit.owner === pathSegement) {
-        return true;
-      }
-    }
-    return false;
-  }
-  shouldCancelEvaluate(senderIndex, pendingCommits) {
-    for (const commit of pendingCommits) {
-      const index = this._childExpressions.indexOf(commit.owner);
-      if (index >= 0 && index < senderIndex) {
-        return true;
-      }
-    }
-    return false;
-  }
-  initializePathSegement(pathSegment, settings, initialize) {
-    this._initializeQueue.set(pathSegment, initialize ?? (() => pathSegment.initialize(settings)));
-    queueMicrotask(() => {
-      this._initializeQueue.get(pathSegment)?.();
-      this._initializeQueue.delete(pathSegment);
-    });
-  }
-  resolvePathSegment(pathSegment, previousPathSegmentValue, pathSegmentIndex) {
-    const mustProxifyInfo = this.getMustProxifyHandler(pathSegmentIndex);
-    if (!mustProxifyInfo.valid) {
-      return PENDING3;
-    }
-    if (pathSegment.value === void 0) {
-      this.initializePathSegement(pathSegment, {
-        context: previousPathSegmentValue,
-        mustProxifyHandler: mustProxifyInfo
-      });
+    const functionContext = Type2.toObject(this.objectExpression ? this.objectExpression?.value : this._context);
+    if (!functionContext) {
       return PENDING3;
     }
-    if (this.isCalculated(pathSegment)) {
-      return this.resolveCalculated(pathSegment, previousPathSegmentValue, pathSegmentIndex, mustProxifyInfo);
+    if (this._functionContext !== functionContext) {
+      this._functionContext = functionContext;
     }
-    if (pathSegment.value !== void 0) {
-      return pathSegment.value;
+    const { functionName, argumentsExpression } = this;
+    const args = argumentsExpression.value;
+    if (!functionName || !args || !functionContext) {
+      return PENDING3;
     }
-    this.initializePathSegement(pathSegment, {
-      context: previousPathSegmentValue,
-      mustProxifyHandler: mustProxifyInfo
-    });
-    return PENDING3;
+    const func = Type2.cast(functionContext[functionName]);
+    Assertion.assertIsFunction(func, func.name);
+    return this.registerResult(func.call(functionContext, ...args));
   }
-  resolveCalculated(current2, previousContext, index, mustProxifyInfo) {
-    const { value } = current2;
-    if (value === void 0) {
-      return void 0;
-    }
-    const resolved = this._indexValueAccessor.getResolvedValue(previousContext, value);
-    this.observeSlot(previousContext, index, current2, resolved, mustProxifyInfo);
-    return resolved;
+  get functionName() {
+    return this.computed ? this.functionExpression.value : this.functionExpression.expressionString;
   }
-  disposeSlotObserver(slotChangeSubscription) {
-    slotChangeSubscription.changeSubscription.unsubscribe();
-    slotChangeSubscription.staticIndexExpression.dispose();
+  releaseResult() {
+    this.stateManager.releaseState(this._functionContext, this._functionId);
+    this._functionContext = void 0;
   }
-  getMustProxifyHandler(currentIndex) {
-    const nextExpression = this._childExpressions[currentIndex + 1];
-    if (nextExpression === void 0) {
-      return this.createMustProxifyHandler(truePredicate);
-    }
-    if (nextExpression.type === ExpressionType.Identifier) {
-      return {
-        releaseMustProxifyHandler: /* @__PURE__ */ __name(() => this._mustProxifyItemHandlerFactory.release(nextExpression.expressionString), "releaseMustProxifyHandler"),
-        createMustProxifyHandler: /* @__PURE__ */ __name(() => this._mustProxifyItemHandlerFactory.create(nextExpression.expressionString).instance, "createMustProxifyHandler"),
-        valid: true
-      };
-    }
-    if (nextExpression.value !== void 0 && this.isCalculated(nextExpression)) {
-      return {
-        releaseMustProxifyHandler: /* @__PURE__ */ __name(() => this._mustProxifyItemHandlerFactory.release(nextExpression.value), "releaseMustProxifyHandler"),
-        createMustProxifyHandler: /* @__PURE__ */ __name(() => this._mustProxifyItemHandlerFactory.create(nextExpression.value).instance, "createMustProxifyHandler"),
-        valid: true
-      };
-    }
-    return {
-      releaseMustProxifyHandler: void 0,
-      createMustProxifyHandler: void 0,
-      valid: false
-    };
+  registerResult(result) {
+    this.stateManager.setState(this._functionContext, this._functionId, result);
+    return result;
   }
-  createMustProxifyHandler(predicate) {
-    return {
-      releaseMustProxifyHandler: emptyFunction,
-      createMustProxifyHandler: /* @__PURE__ */ __name(() => predicate, "createMustProxifyHandler"),
-      valid: true
-    };
+};
+
+// lib/expressions/greater-than-expression.ts
+var GreaterThanExpression = class extends BinaryExpression {
+  static {
+    __name(this, "GreaterThanExpression");
   }
-  observeSlot(context, pathSegmentIndex, dynamicIndexExpression, value, mustProxifyHandler) {
-    const slotObserver = this._slotObservers.get(dynamicIndexExpression);
-    if (slotObserver) {
-      if (dynamicIndexExpression.value === slotObserver.index) {
-        return;
-      }
-      this.disposeSlotObserver(slotObserver);
-      this._slotObservers.delete(dynamicIndexExpression);
-      this._rebindingSlot = true;
-    }
-    const staticIndexExpression = new IdentifierExpression(context, this._stateManager, "", this._expressionChangeTransactionManager, dynamicIndexExpression.value);
-    this.initializePathSegement(staticIndexExpression, {
-      currentValue: value,
-      mustProxifyHandler
-    }, () => {
-      let initialized = false;
-      const changeSubscription = staticIndexExpression.changed.subscribe(() => {
-        if (initialized) {
-          this.onSlotChanged(staticIndexExpression);
-        }
-        initialized = true;
-      });
-      this._slotObservers.set(dynamicIndexExpression, {
-        staticIndexExpression,
-        changeSubscription,
-        index: dynamicIndexExpression.value,
-        pathSegmentIndex
-      });
-      this._rebindingSlot = false;
-    });
+  constructor(expressionString, leftExpression, rightExpression) {
+    super(ExpressionType.GreaterThan, expressionString, leftExpression, rightExpression);
   }
-  onSlotChanged(sender) {
-    if (!this._rebindingSlot) {
-      this.evaluateBottomToTop(sender, this.root, /* @__PURE__ */ new Set());
-    }
+  evaluateExpression(a, b) {
+    return a > b;
   }
-  isCalculated(expression) {
-    return expression.type === ExpressionType.Index;
+};
+
+// lib/expressions/greater-than-or-equal-expression.ts
+var GreaterThanOrEqualExpression = class extends BinaryExpression {
+  static {
+    __name(this, "GreaterThanOrEqualExpression");
+  }
+  constructor(expressionString, leftExpression, rightExpression) {
+    super(ExpressionType.GreaterThanOrEqual, expressionString, leftExpression, rightExpression);
+  }
+  evaluateExpression(a, b) {
+    return a >= b;
   }
 };
 
 // lib/expressions/identifier-expression.ts
+import { ReplaySubject as ReplaySubject3 } from "rxjs";
+import { IndexWatchRule } from "@rs-x/state-manager";
 var IndexValueObserver = class {
   static {
     __name(this, "IndexValueObserver");
   }
   _context;
-  _key;
-  _mustProxify;
+  _index;
+  _indexWatchRule;
   _stateManager;
+  setContext;
   _changeSubscription;
   _contextChangeSubscription;
-  _changed = new ReplaySubject2(1);
-  _contextChanged = new Subject2();
+  _changed = new ReplaySubject3(1);
   _isDisposed = false;
-  constructor(_context, _key, _mustProxify, _stateManager) {
+  constructor(_context, _index, _indexWatchRule, _stateManager, setContext) {
     this._context = _context;
-    this._key = _key;
-    this._mustProxify = _mustProxify;
+    this._index = _index;
+    this._indexWatchRule = _indexWatchRule;
     this._stateManager = _stateManager;
+    this.setContext = setContext;
     this._changeSubscription = this._stateManager.changed.subscribe(this.emitChange);
     this._contextChangeSubscription = this._stateManager.contextChanged.subscribe(this.onContextCHanged);
-    const value = this._stateManager.watchState(this._context, this._key, _mustProxify);
+    const value = this._stateManager.watchState(this._context, this._index, this._indexWatchRule);
     if (value !== void 0) {
       this.emitChange({
-        key: this._key,
+        index: this._index,
         context: this._context,
         oldContext: this._context,
         oldValue: void 0,
@@ -9295,29 +9446,26 @@ var IndexValueObserver = class {
   get changed() {
     return this._changed;
   }
-  get contextChanged() {
-    return this._contextChanged;
-  }
   dispose() {
     if (this._isDisposed) {
       return;
     }
     this._changeSubscription.unsubscribe();
     this._contextChangeSubscription.unsubscribe();
-    this._stateManager.releaseState(this._context, this._key, this._mustProxify);
+    this._stateManager.releaseState(this._context, this._index, this._indexWatchRule);
     this._isDisposed = true;
   }
   getValue(context, key) {
     return this._stateManager.getState(context, key);
   }
   onContextCHanged = /* @__PURE__ */ __name((change) => {
-    if (this._context === change.oldContext && change.key === this._key) {
+    if (this._context === change.oldContext && change.index === this._index) {
       this._context = change.context;
-      this._contextChanged.next(change);
+      this.setContext(this._context);
     }
   }, "onContextCHanged");
   emitChange = /* @__PURE__ */ __name((change) => {
-    if (this._context === change.context && change.key === this._key) {
+    if (this._context === change.context && change.index === this._index) {
       this._changed.next(change);
     }
   }, "emitChange");
@@ -9326,68 +9474,79 @@ var IdentifierExpression = class extends AbstractExpression {
   static {
     __name(this, "IdentifierExpression");
   }
-  _rootContext;
-  _stateManager;
-  _expressionChangeTransactionManager;
   _indexValue;
   _changeSubscription;
-  _isInitialized = false;
+  _isBound = false;
   _indexValueObserver;
   releaseMustProxifyHandler;
   _commitAfterInitialized;
   _commitHandler;
-  constructor(_rootContext, _stateManager, expressionString, _expressionChangeTransactionManager, _indexValue) {
-    super(ExpressionType.Identifier, expressionString), this._rootContext = _rootContext, this._stateManager = _stateManager, this._expressionChangeTransactionManager = _expressionChangeTransactionManager, this._indexValue = _indexValue;
+  _context;
+  _indexWatchRule;
+  constructor(expressionString, _indexValue) {
+    super(ExpressionType.Identifier, expressionString), this._indexValue = _indexValue;
     this._commitHandler = {
       owner: this,
       commit: this.commit
     };
   }
-  initialize(settings) {
-    this._isInitialized = false;
-    super.initialize(settings);
-    this._commitAfterInitialized = settings.context !== this._rootContext;
+  clone() {
+    return new this.constructor(this.expressionString, this._indexValue);
+  }
+  bind(settings) {
+    this._isBound = false;
+    super.bind(settings);
+    this._context = settings.context ?? settings.rootContext;
+    this._commitAfterInitialized = settings.context !== settings.rootContext;
+    this._indexWatchRule = new IndexWatchRule(this._context, this.shouldWatchIndex);
     if (!this._indexValueObserver) {
-      this.observeChange(settings);
+      this.observeChange();
     } else {
-      const newValue = this._indexValueObserver.getValue(settings.context, this._indexValue ?? this.expressionString);
+      const newValue = this._indexValueObserver.getValue(this._context, this._indexValue ?? this.expressionString);
       this.onValueChanged({
-        key: this._indexValue ?? this.expressionString,
-        context: settings.context,
+        index: this._indexValue ?? this.expressionString,
+        context: this._context,
         oldValue: this._value,
         newValue,
-        oldContext: settings.context
+        oldContext: this._context
       });
     }
-    this._isInitialized = true;
+    this._isBound = true;
     return this;
   }
   internalDispose() {
     super.internalDispose();
     this.releaseMustProxifyHandler?.();
     this.disposeObserver();
+    this._indexWatchRule = void 0;
   }
   evaluate() {
     return this._value;
   }
-  observeChange(settings) {
-    const mustProxifyHandler = settings.mustProxifyHandler ?? this.getDefaultMustProxifyHandler();
-    this.releaseMustProxifyHandler = mustProxifyHandler?.releaseMustProxifyHandler;
-    const index = this._indexValue ?? this.expressionString;
-    this._indexValueObserver = new IndexValueObserver(settings.context ?? this._rootContext, index, mustProxifyHandler?.createMustProxifyHandler?.(), this._stateManager);
-    this._changeSubscription = this._indexValueObserver.changed.subscribe(this.onValueChanged);
+  get isLeaf() {
+    return !this.parent || this.parent.childExpressions[this.parent.childExpressions.length - 1] === this;
   }
-  getDefaultMustProxifyHandler() {
-    if (!this.parent || !(this.parent instanceof MemberExpression || this.parent instanceof FunctionExpression)) {
-      return {
-        createMustProxifyHandler: /* @__PURE__ */ __name(() => truePredicate2, "createMustProxifyHandler"),
-        releaseMustProxifyHandler: emptyFunction2
-      };
+  get isMemberExpressionSegment() {
+    return this.parent?.type === ExpressionType.Member && this.parent.childExpressions.includes(this);
+  }
+  shouldWatchIndex = /* @__PURE__ */ __name((targetIndex, target) => {
+    const index = this._indexValue ?? this.expressionString;
+    if (index !== targetIndex || this._context !== target) {
+      return !!this.leafIndexWatchRule?.test(targetIndex, target);
     }
-    return {
-      createMustProxifyHandler: void 0,
-      releaseMustProxifyHandler: emptyFunction2
-    };
+    const value = this.indexValueAccessor.getValue(target, index);
+    if (!this.isLeaf && this.isMemberExpressionSegment) {
+      return this.valueMetadata.needsProxy(value);
+    }
+    if (this.isLeaf) {
+      return this.valueMetadata.needsProxy(value) || !!this.leafIndexWatchRule?.test(targetIndex, target);
+    }
+    return false;
+  }, "shouldWatchIndex");
+  observeChange() {
+    const index = this._indexValue ?? this.expressionString;
+    this._indexValueObserver = new IndexValueObserver(this._context, index, this._indexWatchRule, this.stateManager, (context) => this._context = context);
+    this._changeSubscription = this._indexValueObserver.changed.subscribe(this.onValueChanged);
   }
   disposeObserver() {
     if (!this._changeSubscription) {
@@ -9404,9 +9563,9 @@ var IdentifierExpression = class extends AbstractExpression {
       return;
     }
     this._value = stateChange.newValue;
-    this._expressionChangeTransactionManager.registerChange(this.root, this._commitHandler);
-    if (!this._isInitialized && this._commitAfterInitialized) {
-      this._expressionChangeTransactionManager.commit();
+    this.transactionManager.registerChange(this.root, this._commitHandler);
+    if (!this._isBound && this._commitAfterInitialized) {
+      this.transactionManager.commit();
     }
   }, "onValueChanged");
 };
@@ -9432,6 +9591,9 @@ var IndexExpression = class extends ParameterizedExpression {
   constructor(expression) {
     super(ExpressionType.Index, `[${expression}]`, expression);
   }
+  clone() {
+    return new this.constructor(this._childExpressions[0].clone());
+  }
   get root() {
     return this;
   }
@@ -9513,6 +9675,9 @@ var LogicalNotExpression = class extends ParameterizedExpression {
   constructor(expressionString, expression) {
     super(ExpressionType.Not, expressionString, expression);
   }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions[0].clone());
+  }
   evaluateExpression(value) {
     return !value;
   }
@@ -9531,6 +9696,195 @@ var LogicalOrExpression = class extends BinaryExpression {
   }
 };
 
+// lib/expressions/member-expression.ts
+import { PENDING as PENDING4, Type as Type3 } from "@rs-x/core";
+var MemberExpression = class extends AbstractExpression {
+  static {
+    __name(this, "MemberExpression");
+  }
+  _slotObservers = /* @__PURE__ */ new Map();
+  _rebindingSlot = false;
+  _initializeQueue = /* @__PURE__ */ new Map();
+  constructor(expressionString, pathSeqments) {
+    super(ExpressionType.Member, expressionString, ...pathSeqments);
+  }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions.map((child) => child.clone()));
+  }
+  bind(settings) {
+    super.bind(settings);
+    for (let i = 0; i < this._childExpressions.length; i++) {
+      const currentSegment = this._childExpressions[i];
+      if (i === 0 || this.isCalculated(currentSegment)) {
+        currentSegment.bind(settings);
+      }
+    }
+    return this;
+  }
+  internalDispose() {
+    super.internalDispose();
+    for (const slotObserver of this._slotObservers.values()) {
+      this.disposeSlotObserver(slotObserver);
+    }
+    this._slotObservers.clear();
+    this._initializeQueue.clear();
+  }
+  prepareReevaluation(sender, root, pendingCommits) {
+    const senderIndex = this._childExpressions.indexOf(this.isCalculated(root) ? root : sender);
+    if (senderIndex < 0) {
+      return false;
+    }
+    if (this.shouldCancelEvaluate(senderIndex, pendingCommits)) {
+      return false;
+    }
+    const pathSeqments = this._childExpressions;
+    for (let i = senderIndex + 1; i < pathSeqments.length; i++) {
+      if (!this.isCalculated(pathSeqments[i]) && !this.isPending(pathSeqments[i], pendingCommits)) {
+        AbstractExpression.clearValue(pathSeqments[i]);
+      }
+    }
+    return true;
+  }
+  evaluate(sender, root) {
+    const senderIndex = this._childExpressions.indexOf(root.type === ExpressionType.Index ? root : sender);
+    const senderExpr = this._childExpressions[senderIndex];
+    if (senderExpr?.value === void 0) {
+      return void 0;
+    }
+    const startIndex = this.isCalculated(this._childExpressions[senderIndex]) ? senderIndex - 1 : senderIndex + 1;
+    let previousPathSegmentValue = this._childExpressions[startIndex - 1]?.value;
+    if (startIndex > 0 && Type3.isNullOrUndefined(previousPathSegmentValue)) {
+      return PENDING4;
+    }
+    for (let i = startIndex; i < this._childExpressions.length; i++) {
+      const currentPathSegment = this._childExpressions[i];
+      const currentPathSegmentValue = this.resolvePathSegment(currentPathSegment, previousPathSegmentValue, i);
+      if (currentPathSegmentValue === PENDING4) {
+        return currentPathSegmentValue;
+      }
+      previousPathSegmentValue = currentPathSegmentValue;
+    }
+    return previousPathSegmentValue;
+  }
+  isCommitTarget(sender) {
+    return super.isCommitTarget(sender) || this.isCalculated(sender) && this._childExpressions[this._childExpressions.length - 1] === sender;
+  }
+  shouldCancelEvaluate(senderIndex, pendingCommits) {
+    for (const commit of pendingCommits) {
+      const index = this._childExpressions.indexOf(commit.owner);
+      if (index >= 0 && index < senderIndex) {
+        return true;
+      }
+    }
+    return false;
+  }
+  bindPathSegement(pathSegment, settings, bind) {
+    this._initializeQueue.set(pathSegment, bind ?? (() => pathSegment.bind(settings)));
+    queueMicrotask(() => {
+      this._initializeQueue.get(pathSegment)?.();
+      this._initializeQueue.delete(pathSegment);
+    });
+  }
+  resolvePathSegment(pathSegment, previousPathSegmentValue, pathSegmentIndex) {
+    const isPending = this.isPathSegmentPending(pathSegmentIndex);
+    if (isPending) {
+      return PENDING4;
+    }
+    if (pathSegment.value === void 0) {
+      this.bindPathSegement(pathSegment, {
+        context: previousPathSegmentValue,
+        services: this.services,
+        leafIndexWatchRule: this.leafIndexWatchRule
+      });
+      return PENDING4;
+    }
+    if (this.isCalculated(pathSegment)) {
+      return this.resolveCalculated(pathSegment, previousPathSegmentValue, pathSegmentIndex);
+    }
+    if (pathSegment.value !== void 0) {
+      return pathSegment.value;
+    }
+    this.bindPathSegement(pathSegment, {
+      context: previousPathSegmentValue,
+      services: this.services,
+      leafIndexWatchRule: this.leafIndexWatchRule
+    });
+    return PENDING4;
+  }
+  resolveCalculated(current2, previousContext, index) {
+    const { value } = current2;
+    if (value === void 0) {
+      return void 0;
+    }
+    const resolved = this.indexValueAccessor.getResolvedValue(previousContext, value);
+    this.observeSlot(previousContext, index, current2, resolved);
+    return resolved;
+  }
+  disposeSlotObserver(slotChangeSubscription) {
+    slotChangeSubscription.changeSubscription.unsubscribe();
+    slotChangeSubscription.staticIndexExpression.dispose();
+  }
+  isPathSegmentPending(currentIndex) {
+    const nextExpression = this._childExpressions[currentIndex + 1];
+    if (nextExpression === void 0 || nextExpression.type === ExpressionType.Identifier) {
+      return false;
+    }
+    return nextExpression.value === void 0 || !this.isCalculated(nextExpression);
+  }
+  observeSlot(context, pathSegmentIndex, dynamicIndexExpression, value) {
+    const slotObserver = this._slotObservers.get(dynamicIndexExpression);
+    if (slotObserver) {
+      if (dynamicIndexExpression.value === slotObserver.index) {
+        return;
+      }
+      this.disposeSlotObserver(slotObserver);
+      this._slotObservers.delete(dynamicIndexExpression);
+      this._rebindingSlot = true;
+    }
+    const staticIndexExpression = new IdentifierExpression("", dynamicIndexExpression.value);
+    this.bindPathSegement(staticIndexExpression, {
+      context,
+      currentValue: value,
+      services: {
+        ...this.services,
+        transactionManager: Type3.cast(void 0)
+      },
+      leafIndexWatchRule: this.leafIndexWatchRule
+    }, () => {
+      let bound = false;
+      const changeSubscription = staticIndexExpression.changed.subscribe(() => {
+        if (bound) {
+          this.onSlotChanged(staticIndexExpression);
+        }
+        bound = true;
+      });
+      this._slotObservers.set(dynamicIndexExpression, {
+        staticIndexExpression,
+        changeSubscription,
+        index: dynamicIndexExpression.value,
+        pathSegmentIndex
+      });
+      this._rebindingSlot = false;
+    });
+  }
+  onSlotChanged(sender) {
+    if (!this._rebindingSlot) {
+      this.evaluateBottomToTop(sender, this.root, /* @__PURE__ */ new Set());
+    }
+  }
+  isPending(pathSegement, pendingCommits) {
+    for (const commit of pendingCommits) {
+      if (commit.owner === pathSegement) {
+        return true;
+      }
+    }
+    return false;
+  }
+  isCalculated(expression) {
+    return expression.type === ExpressionType.Index;
+  }
+};
+
 // lib/expressions/multiplication-expression.ts
 var MultiplicationExpression = class extends BinaryExpression {
   static {
@@ -9552,6 +9906,9 @@ var NewExpression = class extends ParameterizedExpression {
   constructor(expressionString, constructorExpression, argumentExpressions) {
     super(ExpressionType.New, expressionString, constructorExpression, ...argumentExpressions ?? []);
   }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions[0].clone(), this._childExpressions.slice(1).map((arg) => arg.clone()));
+  }
   evaluateExpression(constructorFunction, ...args) {
     if (!constructorFunction) {
       return null;
@@ -9581,6 +9938,9 @@ var ObjectExpression = class extends ParameterizedExpression {
   constructor(expressionString, propertyExpressions) {
     super(ExpressionType.Object, expressionString, ...propertyExpressions);
   }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions.map((child) => child.clone()));
+  }
   evaluateExpression(...args) {
     return Object.assign({}, ...args);
   }
@@ -9622,9 +9982,12 @@ var SequenceExpression = class extends AbstractExpression {
   constructor(expressionString, expressions) {
     super(ExpressionType.Sequence, expressionString, ...expressions);
   }
-  initialize(settings) {
-    super.initialize(settings);
-    this._childExpressions.forEach((childExpression) => childExpression.initialize(settings));
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions.map((child) => child.clone()));
+  }
+  bind(settings) {
+    super.bind(settings);
+    this._childExpressions.forEach((childExpression) => childExpression.bind(settings));
     return this;
   }
   evaluate() {
@@ -9641,6 +10004,9 @@ var SpreadExpression = class extends ParameterizedExpression {
   constructor(expression) {
     super(ExpressionType.Spread, `...${expression.expressionString}`, expression);
   }
+  clone() {
+    return new this.constructor(this._childExpressions[0].clone());
+  }
   evaluateExpression(...args) {
     return args[0];
   }
@@ -9693,6 +10059,9 @@ var TemplateStringExpression = class extends CollectionExpression {
   constructor(expressionString, expressions) {
     super(ExpressionType.TemlateString, expressionString, expressions);
   }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions.map((child) => child.clone()));
+  }
   evaluateExpression(...segments) {
     return segments.join("");
   }
@@ -9706,6 +10075,9 @@ var TypeofExpression = class extends ParameterizedExpression {
   constructor(expressionString, expression) {
     super(ExpressionType.Typeof, expressionString, expression);
   }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions[0].clone());
+  }
   evaluateExpression(value) {
     return typeof value;
   }
@@ -9719,219 +10091,39 @@ var UnaryNegationExpression = class extends ParameterizedExpression {
   constructor(expressionString, expression) {
     super(ExpressionType.UnaryNegation, expressionString, expression);
   }
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions[0].clone());
+  }
   evaluateExpression(value) {
     return -value;
   }
 };
 
-// lib/expression-observer/deep-clone-except-with-expression-support.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");
-function _ts_metadata4(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata4, "_ts_metadata");
-function _ts_param4(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param4, "_ts_param");
-var DeepCloneExceptWithExpressionSupport = class {
-  static {
-    __name(this, "DeepCloneExceptWithExpressionSupport");
-  }
-  _defaultDeepCloneValueGetter;
-  constructor(_defaultDeepCloneValueGetter) {
-    this._defaultDeepCloneValueGetter = _defaultDeepCloneValueGetter;
-  }
-  except(source) {
-    if (source instanceof AbstractExpression) {
-      return source.value;
-    }
-    return this._defaultDeepCloneValueGetter.except(source);
-  }
-};
-DeepCloneExceptWithExpressionSupport = _ts_decorate4([
-  Injectable4(),
-  _ts_param4(0, Inject4(RsXCoreInjectionTokens.IDeepCloneExcept)),
-  _ts_metadata4("design:type", Function),
-  _ts_metadata4("design:paramtypes", [
-    typeof IDeepCloneExcept === "undefined" ? Object : IDeepCloneExcept
-  ])
-], DeepCloneExceptWithExpressionSupport);
-
-// lib/expression-observer/expression-index-accessor.ts
-import { Injectable as Injectable5, Type as Type3, UnsupportedException } from "@rs-x/core";
-function _ts_decorate5(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate5, "_ts_decorate");
-var ExpressionIndexAccessor = class {
-  static {
-    __name(this, "ExpressionIndexAccessor");
-  }
-  priority;
-  isAsync() {
-    return true;
-  }
-  getResolvedValue(context, index) {
-    return Type3.cast((Type3.toObject(context) ?? {})[index])?.value;
-  }
-  hasValue(context, index) {
-    return Type3.cast((Type3.toObject(context) ?? {})[index])?.value !== void 0;
-  }
-  getValue(context, index) {
-    return (Type3.toObject(context) ?? {})[index];
-  }
-  setValue() {
-    throw new UnsupportedException("Cannot set the value of an expression directly. To update it, modify the relevant properties in the expression context.");
-  }
-  getIndexes() {
-    return [].values();
-  }
-  applies(context, index) {
-    return (Type3.toObject(context) ?? {})[index] instanceof AbstractExpression;
-  }
-};
-ExpressionIndexAccessor = _ts_decorate5([
-  Injectable5()
-], ExpressionIndexAccessor);
-
-// lib/expression-observer/expression-observer-proxy-pair.factory.ts
-import { Inject as Inject5, Injectable as Injectable6 } from "@rs-x/core";
-function _ts_decorate6(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate6, "_ts_decorate");
-function _ts_metadata5(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata5, "_ts_metadata");
-function _ts_param5(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param5, "_ts_param");
-var ExpressionObserverProxyPairFactory = class {
-  static {
-    __name(this, "ExpressionObserverProxyPairFactory");
-  }
-  _expressionObserverFactory;
-  priority = 100;
-  constructor(_expressionObserverFactory) {
-    this._expressionObserverFactory = _expressionObserverFactory;
-  }
-  create(owner, proxyTarget) {
-    return {
-      observer: this._expressionObserverFactory.create({
-        owner,
-        expression: proxyTarget.target
-      }).instance
-    };
-  }
-  applies(object) {
-    return object instanceof AbstractExpression;
-  }
-};
-ExpressionObserverProxyPairFactory = _ts_decorate6([
-  Injectable6(),
-  _ts_param5(0, Inject5(RsXExpressionParserInjectionTokens.IExpressionObserverFactory)),
-  _ts_metadata5("design:type", Function),
-  _ts_metadata5("design:paramtypes", [
-    typeof IExpressionObserverFactory === "undefined" ? Object : IExpressionObserverFactory
-  ])
-], ExpressionObserverProxyPairFactory);
-
-// lib/expression-observer/expression-observer.factory.ts
-import { Injectable as Injectable7, SingletonFactory as SingletonFactory2 } from "@rs-x/core";
-import { AbstractObserver } from "@rs-x/state-manager";
-import { ReplaySubject as ReplaySubject3 } from "rxjs";
-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_metadata6(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata6, "_ts_metadata");
-var ExpressionObserver = class ExpressionObserver2 extends AbstractObserver {
-  static {
-    __name(this, "ExpressionObserver");
-  }
-  _changedSubsctiption;
-  constructor(owner, target) {
-    super(owner, target, void 0, new ReplaySubject3(1));
-    this._changedSubsctiption = target.changed.subscribe(this.onExpressionChanged);
-  }
-  disposeInternal() {
-    this._changedSubsctiption.unsubscribe();
-  }
-  onExpressionChanged = /* @__PURE__ */ __name((expression) => {
-    this.emitChange({
-      arguments: [],
-      chain: [],
-      target: this.target,
-      newValue: expression.value
-    });
-  }, "onExpressionChanged");
-};
-var ExpressionObserverFactory = class extends SingletonFactory2 {
+// lib/expressions/unary-plus-expression.ts
+var UnaryPlusExpression = class extends ParameterizedExpression {
   static {
-    __name(this, "ExpressionObserverFactory");
-  }
-  constructor() {
-    super();
-  }
-  getId(data2) {
-    return data2.expression;
+    __name(this, "UnaryPlusExpression");
   }
-  createId(data2) {
-    return data2.expression;
+  constructor(expressionString, expression) {
+    super(ExpressionType.UnaryPlus, expressionString, expression);
   }
-  createInstance(data2, id) {
-    return new ExpressionObserver({
-      canDispose: /* @__PURE__ */ __name(() => this.getReferenceCount(id) === 1, "canDispose"),
-      release: /* @__PURE__ */ __name(() => {
-        this.release(id);
-        data2.owner?.release();
-      }, "release")
-    }, data2.expression);
+  clone() {
+    return new this.constructor(this.expressionString, this._childExpressions[0].clone());
   }
-  releaseInstance(observer) {
-    observer.dispose();
+  evaluateExpression(a) {
+    return +a;
   }
 };
-ExpressionObserverFactory = _ts_decorate7([
-  Injectable7(),
-  _ts_metadata6("design:type", Function),
-  _ts_metadata6("design:paramtypes", [])
-], ExpressionObserverFactory);
 
 // lib/identifier-owner-resolver/array-index-owner-resolver.ts
-import { Injectable as Injectable8 } from "@rs-x/core";
-function _ts_decorate8(decorators, target, key, desc) {
+import { Injectable as Injectable10 } from "@rs-x/core";
+function _ts_decorate10(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate8, "_ts_decorate");
+__name(_ts_decorate10, "_ts_decorate");
 var ArrayIndexOwnerResolver = class {
   static {
     __name(this, "ArrayIndexOwnerResolver");
@@ -9944,29 +10136,29 @@ var ArrayIndexOwnerResolver = class {
     return normalizedIndex >= 0 && normalizedIndex < array.length ? array : null;
   }
 };
-ArrayIndexOwnerResolver = _ts_decorate8([
-  Injectable8()
+ArrayIndexOwnerResolver = _ts_decorate10([
+  Injectable10()
 ], ArrayIndexOwnerResolver);
 
 // lib/identifier-owner-resolver/default-identifier-owner-resolver.ts
-import { Injectable as Injectable9, MultiInject } from "@rs-x/core";
-function _ts_decorate9(decorators, target, key, desc) {
+import { Injectable as Injectable11, MultiInject } from "@rs-x/core";
+function _ts_decorate11(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate9, "_ts_decorate");
-function _ts_metadata7(k, v) {
+__name(_ts_decorate11, "_ts_decorate");
+function _ts_metadata9(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata7, "_ts_metadata");
-function _ts_param6(paramIndex, decorator) {
+__name(_ts_metadata9, "_ts_metadata");
+function _ts_param8(paramIndex, decorator) {
   return function(target, key) {
     decorator(target, key, paramIndex);
   };
 }
-__name(_ts_param6, "_ts_param");
+__name(_ts_param8, "_ts_param");
 var DefaultIdentifierOwnerResolver = class {
   static {
     __name(this, "DefaultIdentifierOwnerResolver");
@@ -9986,24 +10178,24 @@ var DefaultIdentifierOwnerResolver = class {
     return null;
   }
 };
-DefaultIdentifierOwnerResolver = _ts_decorate9([
-  Injectable9(),
-  _ts_param6(0, MultiInject(RsXExpressionParserInjectionTokens.IIdentifierOwnerResolverList)),
-  _ts_metadata7("design:type", Function),
-  _ts_metadata7("design:paramtypes", [
+DefaultIdentifierOwnerResolver = _ts_decorate11([
+  Injectable11(),
+  _ts_param8(0, MultiInject(RsXExpressionParserInjectionTokens.IIdentifierOwnerResolverList)),
+  _ts_metadata9("design:type", Function),
+  _ts_metadata9("design:paramtypes", [
     Object
   ])
 ], DefaultIdentifierOwnerResolver);
 
 // lib/identifier-owner-resolver/map-key-owner-resolver.ts
-import { Injectable as Injectable10 } from "@rs-x/core";
-function _ts_decorate10(decorators, target, key, desc) {
+import { Injectable as Injectable12 } from "@rs-x/core";
+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_decorate10, "_ts_decorate");
+__name(_ts_decorate12, "_ts_decorate");
 var MapKeyOwnerResolver = class {
   static {
     __name(this, "MapKeyOwnerResolver");
@@ -10012,19 +10204,19 @@ var MapKeyOwnerResolver = class {
     return map.has?.(index) ? map : null;
   }
 };
-MapKeyOwnerResolver = _ts_decorate10([
-  Injectable10()
+MapKeyOwnerResolver = _ts_decorate12([
+  Injectable12()
 ], MapKeyOwnerResolver);
 
 // lib/identifier-owner-resolver/property-owner-resolver.ts
-import { Injectable as Injectable11, Type as Type4 } from "@rs-x/core";
-function _ts_decorate11(decorators, target, key, desc) {
+import { Injectable as Injectable13, Type as Type4 } from "@rs-x/core";
+function _ts_decorate13(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate11, "_ts_decorate");
+__name(_ts_decorate13, "_ts_decorate");
 var PropertyOwnerResolver = class {
   static {
     __name(this, "PropertyOwnerResolver");
@@ -10033,13 +10225,11 @@ var PropertyOwnerResolver = class {
     return Type4.hasProperty(context, index) ? context : null;
   }
 };
-PropertyOwnerResolver = _ts_decorate11([
-  Injectable11()
+PropertyOwnerResolver = _ts_decorate13([
+  Injectable13()
 ], PropertyOwnerResolver);
 
 // lib/js-espree-expression-parser.ts
-import { Inject as Inject6, Injectable as Injectable12, ParserException, RsXCoreInjectionTokens as RsXCoreInjectionTokens2, Type as Type5, UnsupportedException as UnsupportedException2 } from "@rs-x/core";
-import { RsXStateManagerInjectionTokens as RsXStateManagerInjectionTokens2 } from "@rs-x/state-manager";
 import { generate as astToString } from "astring";
 
 // ../node_modules/acorn/dist/acorn.mjs
@@ -16538,49 +16728,34 @@ var supportedEcmaVersions = getSupportedEcmaVersions();
 
 // lib/js-espree-expression-parser.ts
 var estraverse = __toESM(require_estraverse(), 1);
-function _ts_decorate12(decorators, target, key, desc) {
+import { Injectable as Injectable14, ParserException, Type as Type5, UnsupportedException as UnsupportedException2 } from "@rs-x/core";
+function _ts_decorate14(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
   else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
-__name(_ts_decorate12, "_ts_decorate");
-function _ts_metadata8(k, v) {
+__name(_ts_decorate14, "_ts_decorate");
+function _ts_metadata10(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-__name(_ts_metadata8, "_ts_metadata");
-function _ts_param7(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param7, "_ts_param");
+__name(_ts_metadata10, "_ts_metadata");
 var JsEspreeExpressionParser = class {
   static {
     __name(this, "JsEspreeExpressionParser");
   }
-  _indexValueAccessor;
-  _mustProxifyItemHandlerFactory;
-  _expressionChangeTransactionManager;
-  _stateManager;
-  _guidFactory;
   static instance;
   createConstantExpression = {
-    string: /* @__PURE__ */ __name((literal2) => new ConstantStringExpression(literal2.value, this._expressionChangeTransactionManager), "string"),
-    number: /* @__PURE__ */ __name((literal2) => new ConstantNumberExpression(Number(literal2.value), this._expressionChangeTransactionManager), "number"),
-    boolean: /* @__PURE__ */ __name((literal2) => new ConstantBooleanExpression(Boolean(literal2.value), this._expressionChangeTransactionManager), "boolean"),
-    bigint: /* @__PURE__ */ __name((literal2) => new ConstantBigIntExpression(BigInt(literal2.value), this._expressionChangeTransactionManager), "bigint")
+    string: /* @__PURE__ */ __name((literal2) => new ConstantStringExpression(literal2.value), "string"),
+    number: /* @__PURE__ */ __name((literal2) => new ConstantNumberExpression(Number(literal2.value)), "number"),
+    boolean: /* @__PURE__ */ __name((literal2) => new ConstantBooleanExpression(Boolean(literal2.value)), "boolean"),
+    bigint: /* @__PURE__ */ __name((literal2) => new ConstantBigIntExpression(BigInt(literal2.value)), "bigint")
   };
   expressionFactories;
   unaryExpressionFactories;
   binaryExpressionFactories;
   logicalExpressionFactories;
-  constructor(_indexValueAccessor, _mustProxifyItemHandlerFactory, _expressionChangeTransactionManager, _stateManager, _guidFactory) {
-    this._indexValueAccessor = _indexValueAccessor;
-    this._mustProxifyItemHandlerFactory = _mustProxifyItemHandlerFactory;
-    this._expressionChangeTransactionManager = _expressionChangeTransactionManager;
-    this._stateManager = _stateManager;
-    this._guidFactory = _guidFactory;
+  constructor() {
     this.expressionFactories = {
       ["UnaryExpression"]: this.createUnaryExpression,
       ["BinaryExpression"]: this.createBinaryExpression,
@@ -16642,42 +16817,36 @@ var JsEspreeExpressionParser = class {
       "??": this.createNullishCoalescingExpression
     };
   }
-  parse(context, expressionString, owner) {
+  parse(expressionString) {
     const espreeExpression = this.tryParse(expressionString);
     let expression;
     try {
-      expression = this.createExpression(espreeExpression, context);
+      expression = this.createExpression(espreeExpression);
     } catch (e) {
       if (e instanceof Error) {
         throw new ParserException(expressionString, e.message);
       }
       throw new ParserException(expressionString, String(e));
     }
-    expression.initialize({
-      context,
-      transactionManager: this._expressionChangeTransactionManager,
-      owner
-    });
-    this._expressionChangeTransactionManager.commit();
     return expression;
   }
   tryParse(expressionString) {
     return this.parseExpression(expressionString).expression;
   }
-  createExpression(expression, context) {
+  createExpression(expression) {
     if (!(expression.type in this.expressionFactories)) {
       throw new UnsupportedException2(`Unsupported expression type ${expression.type}`);
     }
     const factory = this.expressionFactories[expression.type];
-    return factory(Type5.cast(expression), context);
+    return factory(Type5.cast(expression));
   }
   createLiteralExpression = /* @__PURE__ */ __name((expression) => {
     if (expression.regex) {
       const regExpLiteral = expression;
-      return new ConstantRegExpExpression(astToString(expression), new RegExp(regExpLiteral.regex.pattern, regExpLiteral.regex.flags), this._expressionChangeTransactionManager);
+      return new ConstantRegExpExpression(astToString(expression), new RegExp(regExpLiteral.regex.pattern, regExpLiteral.regex.flags));
     }
     if (expression.value === null) {
-      return new ConstantNullExpression(this._expressionChangeTransactionManager);
+      return new ConstantNullExpression();
     }
     const valueType = typeof expression.value;
     if (valueType === "string" || valueType === "number" || valueType === "boolean" || valueType === "bigint") {
@@ -16685,62 +16854,62 @@ var JsEspreeExpressionParser = class {
     }
     throw new UnsupportedException2(`Unsupported literal type: ${valueType}`);
   }, "createLiteralExpression");
-  createBinaryExpression = /* @__PURE__ */ __name((expression, context) => {
-    return this.binaryExpressionFactories[expression.operator](expression, context);
+  createBinaryExpression = /* @__PURE__ */ __name((expression) => {
+    return this.binaryExpressionFactories[expression.operator](expression);
   }, "createBinaryExpression");
   createAssignmentExpression = /* @__PURE__ */ __name(() => {
     throw new UnsupportedException2("Assignment expressions are not supported");
   }, "createAssignmentExpression");
-  createUnaryExpression = /* @__PURE__ */ __name((expression, context) => {
-    return this.unaryExpressionFactories[expression.operator](expression, context);
+  createUnaryExpression = /* @__PURE__ */ __name((expression) => {
+    return this.unaryExpressionFactories[expression.operator](expression);
   }, "createUnaryExpression");
-  createConditionalExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new ConditionalExpression(astToString(expression), this.createExpression(expression.test, context), this.createExpression(expression.consequent, context), this.createExpression(expression.alternate, context));
+  createConditionalExpression = /* @__PURE__ */ __name((expression) => {
+    return new ConditionalExpression(astToString(expression), this.createExpression(expression.test), this.createExpression(expression.consequent), this.createExpression(expression.alternate));
   }, "createConditionalExpression");
-  createLogicalExpression = /* @__PURE__ */ __name((expression, context) => {
-    return this.logicalExpressionFactories[expression.operator](expression, context);
+  createLogicalExpression = /* @__PURE__ */ __name((expression) => {
+    return this.logicalExpressionFactories[expression.operator](expression);
   }, "createLogicalExpression");
-  createChainExpression = /* @__PURE__ */ __name((expression, context) => {
-    return this.createExpression(expression.expression, context);
+  createChainExpression = /* @__PURE__ */ __name((expression) => {
+    return this.createExpression(expression.expression);
   }, "createChainExpression");
-  createMemberExpression = /* @__PURE__ */ __name((expression, context) => {
+  createMemberExpression = /* @__PURE__ */ __name((expression) => {
     const pathSegments = this.flattenMemberExpression(expression).map((e) => {
-      const expression2 = this.createExpression(e.expression, context);
+      const expression2 = this.createExpression(e.expression);
       return e.computed ? new IndexExpression(expression2) : expression2;
     });
-    return new MemberExpression(astToString(expression), pathSegments, this._indexValueAccessor, this._stateManager, this._mustProxifyItemHandlerFactory, this._expressionChangeTransactionManager);
+    return new MemberExpression(astToString(expression), pathSegments);
   }, "createMemberExpression");
-  createSequenceExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new SequenceExpression(astToString(expression), expression.expressions.map((expression2) => this.createExpression(expression2, context)));
+  createSequenceExpression = /* @__PURE__ */ __name((expression) => {
+    return new SequenceExpression(astToString(expression), expression.expressions.map((expression2) => this.createExpression(expression2)));
   }, "createSequenceExpression");
-  createIdentifier = /* @__PURE__ */ __name((expression, context) => {
-    return new IdentifierExpression(context, this._stateManager, expression.name, this._expressionChangeTransactionManager);
+  createIdentifier = /* @__PURE__ */ __name((expression) => {
+    return new IdentifierExpression(expression.name);
   }, "createIdentifier");
-  createArrayExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new ArrayExpression(expression.elements.map((element) => this.createExpression(Type5.cast(element), context)));
+  createArrayExpression = /* @__PURE__ */ __name((expression) => {
+    return new ArrayExpression(expression.elements.map((element) => this.createExpression(Type5.cast(element))));
   }, "createArrayExpression");
-  createSpreadExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new SpreadExpression(this.createExpression(expression.argument, context));
+  createSpreadExpression = /* @__PURE__ */ __name((expression) => {
+    return new SpreadExpression(this.createExpression(expression.argument));
   }, "createSpreadExpression");
-  createNewExpression = /* @__PURE__ */ __name((expression, context) => {
-    const constructorExpression = this.createExpression(expression.callee, context);
-    const argumentExpressions = expression.arguments.map((argumentExpressions2) => this.createExpression(argumentExpressions2, context));
+  createNewExpression = /* @__PURE__ */ __name((expression) => {
+    const constructorExpression = this.createExpression(expression.callee);
+    const argumentExpressions = expression.arguments.map((argumentExpressions2) => this.createExpression(argumentExpressions2));
     return new NewExpression(astToString(expression), Type5.cast(constructorExpression), argumentExpressions);
   }, "createNewExpression");
-  createCallExpression = /* @__PURE__ */ __name((expression, context) => {
+  createCallExpression = /* @__PURE__ */ __name((expression) => {
     let objectExpression = null;
     let functionExpression;
     if (expression.callee.type === "MemberExpression") {
-      objectExpression = this.createExpression(expression.callee.object, context);
-      functionExpression = this.createExpression(expression.callee.property, context);
+      objectExpression = this.createExpression(expression.callee.object);
+      functionExpression = this.createExpression(expression.callee.property);
     } else {
-      functionExpression = this.createExpression(expression.callee, context);
+      functionExpression = this.createExpression(expression.callee);
     }
-    const argumentExpressions = expression.arguments.map((argumentExpression) => this.createExpression(argumentExpression, context));
-    return new FunctionExpression(astToString(expression), Type5.cast(functionExpression), Type5.cast(objectExpression), new ArrayExpression(argumentExpressions), Type5.cast(expression.callee).computed, Type5.cast(expression.callee).optional, this._expressionChangeTransactionManager, this._stateManager, this._guidFactory);
+    const argumentExpressions = expression.arguments.map((argumentExpression) => this.createExpression(argumentExpression));
+    return new FunctionExpression(astToString(expression), Type5.cast(functionExpression), Type5.cast(objectExpression), new ArrayExpression(argumentExpressions), Type5.cast(expression.callee).computed, Type5.cast(expression.callee).optional);
   }, "createCallExpression");
-  createTemplateLiteralExpression = /* @__PURE__ */ __name((templateLiteral, context) => {
-    const { quasis, parameters } = this.createTemplateElementExpression(templateLiteral, context);
+  createTemplateLiteralExpression = /* @__PURE__ */ __name((templateLiteral) => {
+    const { quasis, parameters } = this.createTemplateElementExpression(templateLiteral);
     const expressions = quasis.flatMap((quasi, index) => {
       return [
         quasi,
@@ -16752,127 +16921,127 @@ var JsEspreeExpressionParser = class {
     }
     return new TemplateStringExpression(astToString(templateLiteral), expressions);
   }, "createTemplateLiteralExpression");
-  createTaggedTemplateExpression = /* @__PURE__ */ __name((expression, context) => {
-    const { quasis, parameters } = this.createTemplateElementExpression(expression.quasi, context);
+  createTaggedTemplateExpression = /* @__PURE__ */ __name((expression) => {
+    const { quasis, parameters } = this.createTemplateElementExpression(expression.quasi);
     let objectExpression = null;
     let functionExpression;
     if (expression.tag.type === "MemberExpression") {
-      objectExpression = this.createExpression(expression.tag.object, context);
-      functionExpression = this.createExpression(expression.tag.property, context);
+      objectExpression = this.createExpression(expression.tag.object);
+      functionExpression = this.createExpression(expression.tag.property);
     } else {
-      functionExpression = this.createExpression(expression.tag, context);
+      functionExpression = this.createExpression(expression.tag);
     }
     return new FunctionExpression(astToString(expression), Type5.cast(functionExpression), Type5.cast(objectExpression), new ArrayExpression([
       new ArrayExpression(quasis),
       new SpreadExpression(new ArrayExpression(parameters))
-    ]), false, false, this._expressionChangeTransactionManager, this._stateManager, this._guidFactory);
+    ]), false, false);
   }, "createTaggedTemplateExpression");
-  createTemplateElementExpression(templateLiteral, context) {
+  createTemplateElementExpression(templateLiteral) {
     return {
-      quasis: templateLiteral.quasis.map((quasi) => new ConstantStringExpression(quasi.value.raw, this._expressionChangeTransactionManager)),
-      parameters: templateLiteral.expressions.map((expression) => this.createExpression(expression, context))
+      quasis: templateLiteral.quasis.map((quasi) => new ConstantStringExpression(quasi.value.raw)),
+      parameters: templateLiteral.expressions.map((expression) => this.createExpression(expression))
     };
   }
-  createUnaryPlusExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new UnaryPlusExpression(astToString(expression), this.createExpression(expression.argument, context));
+  createUnaryPlusExpression = /* @__PURE__ */ __name((expression) => {
+    return new UnaryPlusExpression(astToString(expression), this.createExpression(expression.argument));
   }, "createUnaryPlusExpression");
-  createUnaryMinusExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new UnaryNegationExpression(astToString(expression), Type5.cast(this.createExpression(expression.argument, context)));
+  createUnaryMinusExpression = /* @__PURE__ */ __name((expression) => {
+    return new UnaryNegationExpression(astToString(expression), Type5.cast(this.createExpression(expression.argument)));
   }, "createUnaryMinusExpression");
-  createLogicalNotExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new LogicalNotExpression(astToString(expression), this.createExpression(expression.argument, context));
+  createLogicalNotExpression = /* @__PURE__ */ __name((expression) => {
+    return new LogicalNotExpression(astToString(expression), this.createExpression(expression.argument));
   }, "createLogicalNotExpression");
-  createTypeofExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new TypeofExpression(astToString(expression), this.createExpression(expression.argument, context));
+  createTypeofExpression = /* @__PURE__ */ __name((expression) => {
+    return new TypeofExpression(astToString(expression), this.createExpression(expression.argument));
   }, "createTypeofExpression");
   createDeleteExpression = /* @__PURE__ */ __name(() => {
     throw new UnsupportedException2("Delete operator is not supported");
   }, "createDeleteExpression");
-  createEqualToExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new EqualityExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createEqualToExpression = /* @__PURE__ */ __name((expression) => {
+    return new EqualityExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createEqualToExpression");
-  createNotEqualToExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new InequalityExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createNotEqualToExpression = /* @__PURE__ */ __name((expression) => {
+    return new InequalityExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createNotEqualToExpression");
-  createStrictEqualToExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new StrictEqualityExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createStrictEqualToExpression = /* @__PURE__ */ __name((expression) => {
+    return new StrictEqualityExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createStrictEqualToExpression");
-  createStrictNotEqualToExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new StrictInequalityExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createStrictNotEqualToExpression = /* @__PURE__ */ __name((expression) => {
+    return new StrictInequalityExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createStrictNotEqualToExpression");
-  createLessThanExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new LessThanExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createLessThanExpression = /* @__PURE__ */ __name((expression) => {
+    return new LessThanExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createLessThanExpression");
-  createLessThanOrEqualToExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new LessThanOrEqualExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createLessThanOrEqualToExpression = /* @__PURE__ */ __name((expression) => {
+    return new LessThanOrEqualExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createLessThanOrEqualToExpression");
-  createGreaterThanExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new GreaterThanExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createGreaterThanExpression = /* @__PURE__ */ __name((expression) => {
+    return new GreaterThanExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createGreaterThanExpression");
-  createGreaterThanOrEqualToExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new GreaterThanOrEqualExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createGreaterThanOrEqualToExpression = /* @__PURE__ */ __name((expression) => {
+    return new GreaterThanOrEqualExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createGreaterThanOrEqualToExpression");
-  createBitwiseNotExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new BitwiseNotExpression(astToString(expression), Type5.cast(this.createExpression(expression.argument, context)));
+  createBitwiseNotExpression = /* @__PURE__ */ __name((expression) => {
+    return new BitwiseNotExpression(astToString(expression), Type5.cast(this.createExpression(expression.argument)));
   }, "createBitwiseNotExpression");
-  createLeftShiftExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new BitwiseLeftShiftExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createLeftShiftExpression = /* @__PURE__ */ __name((expression) => {
+    return new BitwiseLeftShiftExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createLeftShiftExpression");
-  createRightShiftExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new BitwiseRightShiftExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createRightShiftExpression = /* @__PURE__ */ __name((expression) => {
+    return new BitwiseRightShiftExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createRightShiftExpression");
-  createUnsignedRightShiftExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new BitwiseUnsignedRightShiftExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createUnsignedRightShiftExpression = /* @__PURE__ */ __name((expression) => {
+    return new BitwiseUnsignedRightShiftExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createUnsignedRightShiftExpression");
-  createBitwiseOrExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new BitwiseOrExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createBitwiseOrExpression = /* @__PURE__ */ __name((expression) => {
+    return new BitwiseOrExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createBitwiseOrExpression");
-  createBitwiseXOrExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new BitwiseXorExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createBitwiseXOrExpression = /* @__PURE__ */ __name((expression) => {
+    return new BitwiseXorExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createBitwiseXOrExpression");
-  createBitwiseAndExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new BitwiseAndExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createBitwiseAndExpression = /* @__PURE__ */ __name((expression) => {
+    return new BitwiseAndExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createBitwiseAndExpression");
-  createAdditionExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new AdditionExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createAdditionExpression = /* @__PURE__ */ __name((expression) => {
+    return new AdditionExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createAdditionExpression");
-  createSubstractionExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new SubtractionExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createSubstractionExpression = /* @__PURE__ */ __name((expression) => {
+    return new SubtractionExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createSubstractionExpression");
-  createMultiplicationExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new MultiplicationExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createMultiplicationExpression = /* @__PURE__ */ __name((expression) => {
+    return new MultiplicationExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createMultiplicationExpression");
-  createDivisionExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new DivisionExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createDivisionExpression = /* @__PURE__ */ __name((expression) => {
+    return new DivisionExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createDivisionExpression");
-  createModulusExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new RemainderExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createModulusExpression = /* @__PURE__ */ __name((expression) => {
+    return new RemainderExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createModulusExpression");
-  createExponentiationExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new ExponentiationExpression(astToString(expression), Type5.cast(this.createExpression(expression.left, context)), Type5.cast(this.createExpression(expression.right, context)));
+  createExponentiationExpression = /* @__PURE__ */ __name((expression) => {
+    return new ExponentiationExpression(astToString(expression), Type5.cast(this.createExpression(expression.left)), Type5.cast(this.createExpression(expression.right)));
   }, "createExponentiationExpression");
-  createInstanceOfExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new InstanceofExpression(astToString(expression), this.createExpression(expression.left, context), Type5.cast(this.createExpression(expression.right, context)));
+  createInstanceOfExpression = /* @__PURE__ */ __name((expression) => {
+    return new InstanceofExpression(astToString(expression), this.createExpression(expression.left), Type5.cast(this.createExpression(expression.right)));
   }, "createInstanceOfExpression");
-  createInExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new InExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createInExpression = /* @__PURE__ */ __name((expression) => {
+    return new InExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createInExpression");
-  createLogicalOrExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new LogicalOrExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createLogicalOrExpression = /* @__PURE__ */ __name((expression) => {
+    return new LogicalOrExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createLogicalOrExpression");
-  createLogicalAndExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new LogicalAndExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createLogicalAndExpression = /* @__PURE__ */ __name((expression) => {
+    return new LogicalAndExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createLogicalAndExpression");
-  createNullishCoalescingExpression = /* @__PURE__ */ __name((expression, context) => {
-    return new NullishCoalescingExpression(astToString(expression), this.createExpression(expression.left, context), this.createExpression(expression.right, context));
+  createNullishCoalescingExpression = /* @__PURE__ */ __name((expression) => {
+    return new NullishCoalescingExpression(astToString(expression), this.createExpression(expression.left), this.createExpression(expression.right));
   }, "createNullishCoalescingExpression");
-  createObjectExpression = /* @__PURE__ */ __name((objectExpression, context) => {
-    const propertyExpressions = objectExpression.properties.map((property) => this.createExpression(property, context));
+  createObjectExpression = /* @__PURE__ */ __name((objectExpression) => {
+    const propertyExpressions = objectExpression.properties.map((property) => this.createExpression(property));
     return new ObjectExpression(astToString(objectExpression), propertyExpressions);
   }, "createObjectExpression");
-  createPropertyExpression = /* @__PURE__ */ __name((propertyExpression, context) => {
-    const keyExpression = propertyExpression.key.type === "Identifier" ? new ConstantStringExpression(Type5.cast(propertyExpression.key).name, this._expressionChangeTransactionManager) : this.createExpression(propertyExpression.key, context);
-    return new PropertyExpression(astToString(propertyExpression), keyExpression, this.createExpression(propertyExpression.value, context));
+  createPropertyExpression = /* @__PURE__ */ __name((propertyExpression) => {
+    const keyExpression = propertyExpression.key.type === "Identifier" ? new ConstantStringExpression(Type5.cast(propertyExpression.key).name) : this.createExpression(propertyExpression.key);
+    return new PropertyExpression(astToString(propertyExpression), keyExpression, this.createExpression(propertyExpression.value));
   }, "createPropertyExpression");
   parseExpression(expression) {
     const program = parse3(expression, {
@@ -16937,26 +17106,45 @@ var JsEspreeExpressionParser = class {
     return result;
   }
 };
-JsEspreeExpressionParser = _ts_decorate12([
-  Injectable12(),
-  _ts_param7(0, Inject6(RsXCoreInjectionTokens2.IIndexValueAccessor)),
-  _ts_param7(1, Inject6(RsXStateManagerInjectionTokens2.IMustProxifyItemHandlerFactory)),
-  _ts_param7(2, Inject6(RsXExpressionParserInjectionTokens.IExpressionChangeTransactionManager)),
-  _ts_param7(3, Inject6(RsXStateManagerInjectionTokens2.IStateManager)),
-  _ts_param7(4, Inject6(RsXCoreInjectionTokens2.IGuidFactory)),
-  _ts_metadata8("design:type", Function),
-  _ts_metadata8("design:paramtypes", [
-    typeof IIndexValueAccessor === "undefined" ? Object : IIndexValueAccessor,
-    typeof IMustProxifyItemHandlerFactory === "undefined" ? Object : IMustProxifyItemHandlerFactory,
-    typeof IExpressionChangeTransactionManager === "undefined" ? Object : IExpressionChangeTransactionManager,
-    typeof IStateManager === "undefined" ? Object : IStateManager,
-    typeof IGuidFactory === "undefined" ? Object : IGuidFactory
-  ])
+JsEspreeExpressionParser = _ts_decorate14([
+  Injectable14(),
+  _ts_metadata10("design:type", Function),
+  _ts_metadata10("design:paramtypes", [])
 ], JsEspreeExpressionParser);
 
 // lib/rs-x-expression-parser.module.ts
-import { ContainerModule, defaultIndexValueAccessorList, InjectionContainer, overrideMultiInjectServices, registerMultiInjectServices, RsXCoreInjectionTokens as RsXCoreInjectionTokens3 } from "@rs-x/core";
+import { ContainerModule, defaultIndexValueAccessorList, defaultValueMetadataList, InjectionContainer, overrideMultiInjectServices, registerMultiInjectServices, RsXCoreInjectionTokens as RsXCoreInjectionTokens3 } from "@rs-x/core";
 import { defaultObjectObserverProxyPairFactoryList, RsXStateManagerInjectionTokens as RsXStateManagerInjectionTokens3, RsXStateManagerModule } from "@rs-x/state-manager";
+
+// lib/expression-observer/expression-metadata.ts
+import { Injectable as Injectable15 } from "@rs-x/core";
+function _ts_decorate15(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate15, "_ts_decorate");
+var ExpressionMetadata = class {
+  static {
+    __name(this, "ExpressionMetadata");
+  }
+  priority = 300;
+  isAsync() {
+    return true;
+  }
+  needsProxy() {
+    return true;
+  }
+  applies(value) {
+    return value instanceof AbstractExpression;
+  }
+};
+ExpressionMetadata = _ts_decorate15([
+  Injectable15()
+], ExpressionMetadata);
+
+// lib/rs-x-expression-parser.module.ts
 InjectionContainer.load(RsXStateManagerModule);
 var RsXExpressionParserModule = new ContainerModule((options) => {
   options.unbind(RsXCoreInjectionTokens3.DefaultDeepCloneExcept);
@@ -16967,6 +17155,8 @@ var RsXExpressionParserModule = new ContainerModule((options) => {
   options.bind(RsXExpressionParserInjectionTokens.IdentifierOwnerResolver).to(DefaultIdentifierOwnerResolver).inSingletonScope();
   options.bind(RsXExpressionParserInjectionTokens.IExpressionFactory).to(ExpressionFactory).inSingletonScope();
   options.bind(RsXExpressionParserInjectionTokens.IExpressionObserverFactory).to(ExpressionObserverFactory).inSingletonScope();
+  options.bind(RsXExpressionParserInjectionTokens.IExpressionCache).to(ExpressionCache).inSingletonScope();
+  options.bind(RsXExpressionParserInjectionTokens.IExpressionServices).to(ExpressionServices).inSingletonScope();
   registerMultiInjectServices(options, RsXExpressionParserInjectionTokens.IIdentifierOwnerResolverList, [
     {
       target: PropertyOwnerResolver,
@@ -16995,6 +17185,13 @@ var RsXExpressionParserModule = new ContainerModule((options) => {
     },
     ...defaultObjectObserverProxyPairFactoryList
   ]);
+  overrideMultiInjectServices(options, RsXCoreInjectionTokens3.IValueMetadataList, [
+    {
+      target: ExpressionMetadata,
+      token: RsXExpressionParserInjectionTokens.ExpressiomMetadata
+    },
+    ...defaultValueMetadataList
+  ]);
 });
 async function unloadRsXExpressionParserModule() {
   await InjectionContainer.unload(RsXStateManagerModule);
@@ -17028,12 +17225,14 @@ export {
   DivisionExpression,
   EqualityExpression,
   ExponentiationExpression,
+  ExpressionCache,
   ExpressionChangeTransactionManager,
   ExpressionFactory,
   ExpressionIndexAccessor,
   ExpressionManager,
   ExpressionObserverFactory,
   ExpressionObserverProxyPairFactory,
+  ExpressionServices,
   ExpressionType,
   FunctionExpression,
   GreaterThanExpression,