@rs-x/expression-parser 0.4.10 → 0.4.12

package/readme.md

@@ -12,114 +12,124 @@ This parser forms the core of the **data-binding implementation** for the SPA fr
 
 ### Examples
 
-- **Expression with a promise** — ``promise + 2`` (where `promise` resolves to a number)
-- **Expression with an observable** - ``observable + 2`` (where `observable` emits a number)
+- **Expression with a promise** — `promise + 2` (where `promise` resolves to a number)
+- **Expression with an observable** - `observable + 2` (where `observable` emits a number)
 - **Expression referencing nested async data**
 
-    ```ts
-    import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
-    import {
-        IExpressionFactory,
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
-
-    // Load the expression parser module into the injection container
-    InjectionContainer.load(RsXExpressionParserModule);
-    const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
-    export const run = (async () => {
-        const expressionContext = {
-            a: {
-                b: Promise.resolve({
-                    c: Promise.resolve({
-                        d: 20
-                    })
-                })
-            }
-        };
+  ```ts
+  import {
+    emptyFunction,
+    InjectionContainer,
+    printValue,
+    WaitForEvent,
+  } from '@rs-x/core';
+  import {
+    IExpressionFactory,
+    RsXExpressionParserInjectionTokens,
+    RsXExpressionParserModule,
+  } from '@rs-x/expression-parser';
 
-        const expression = expressionFactory.create(expressionContext, `a.b.c.d`);
+  // Load the expression parser module into the injection container
+  InjectionContainer.load(RsXExpressionParserModule);
+  const expressionFactory: IExpressionFactory = InjectionContainer.get(
+    RsXExpressionParserInjectionTokens.IExpressionFactory,
+  );
 
-        try {
-            // Wait until the expression has been resolved (has a value)
-            await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  export const run = (async () => {
+    const expressionContext = {
+      a: {
+        b: Promise.resolve({
+          c: Promise.resolve({
+            d: 20,
+          }),
+        }),
+      },
+    };
 
-            console.log(`Initial value of 'a.b.c.d':`);
-            expression.changed.subscribe((change) => {
-                printValue(change.value);
-            });
+    const expression = expressionFactory.create(expressionContext, `a.b.c.d`);
 
-            console.log(`Value of 'a.b.c.d' after changing 'a' to '{ b: Promise.resolve({ c: Promise.resolve({ d: 200 }) }) }':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                expressionContext.a =   { b: Promise.resolve({ c: Promise.resolve({ d: 200 }) }) };
-            });
+    try {
+      // Wait until the expression has been resolved (has a value)
+      await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+      console.log(`Initial value of 'a.b.c.d':`);
+      expression.changed.subscribe((change) => {
+        printValue(change.value);
+      });
+
+      console.log(
+        `Value of 'a.b.c.d' after changing 'a' to '{ b: Promise.resolve({ c: Promise.resolve({ d: 200 }) }) }':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a = {
+          b: Promise.resolve({ c: Promise.resolve({ d: 200 }) }),
+        };
+      });
 
-            console.log(`Final value of 'a.b.c.d':`)
-            printValue(expression.value);
-        } finally {
-            // Always dispose of expressions after use.
-            expression.dispose();
-        }
-    })();
-    ```
+      console.log(`Final value of 'a.b.c.d':`);
+      printValue(expression.value);
+    } finally {
+      // Always dispose of expressions after use.
+      expression.dispose();
+    }
+  })();
+  ```
 
 - **Modular expressions** — expressions can reference other expressions:
 
-    ```ts
-    const model = {
-        a: 10,
-        b: 20
-    };
+  ```ts
+  const model = {
+    a: 10,
+    b: 20,
+  };
 
-    const expr1 = expressionFactory.create(model, '(a + 1)');
-    const expr2 = expressionFactory.create(model, '(b + 2)');
+  const expr1 = expressionFactory.create(model, '(a + 1)');
+  const expr2 = expressionFactory.create(model, '(b + 2)');
 
-    const modularModel = {
-        expr1,
-        expr2
-    };
+  const modularModel = {
+    expr1,
+    expr2,
+  };
 
-    const expr3 = expressionFactory.create(modularModel, 'expr1 * expr2');
-    ```
+  const expr3 = expressionFactory.create(modularModel, 'expr1 * expr2');
+  ```
 
 ## Use cases
 
 **Data binding for SPA frameworks and change detection** is the primary reason the expression parser was developed. However, it is a generic solution and can be used in any scenario where actions need to be triggered when data or an expression changes. Below are a few example use cases:
 
 - **Logging and alert conditions**  
-  Trigger alerts based on runtime conditions:  
+  Trigger alerts based on runtime conditions:
   - Monitoring systems
   - Health checks
   - Observability tools
-  
 - **UI logic outside data binding**  
   Declarative UI behavior without relying on a full framework.
 
-- **Workflow and automation engines**  
+- **Workflow and automation engines**
   - CI/CD pipelines
   - Job schedulers
   - Business process automation
-  
-- **Game logic and simulation**  
+- **Game logic and simulation**
   - AI decision trees
   - Ability unlock rules
   - Physics toggles
-  
-- **Spreadsheet-like calculations**  
+- **Spreadsheet-like calculations**
   - Financial dashboards
   - Pricing calculators
   - Quotation systems
-  - 
+  -
 - **Validation engines**  
   Field validation based on the values of other fields.
 
-
 ## Modular Expressions
 
 RS-X supports **modular expressions**, allowing expressions to reference **other expressions** as first-class values.
 
 This enables you to:
+
 - Compose complex calculations from smaller, reusable parts
 - Share intermediate results across multiple expressions
 - Improve readability, maintainability, and testability
@@ -142,7 +152,7 @@ Each expression remains **observable**, and changes propagate efficiently throug
 ```ts
 const model = {
   a: 10,
-  b: 20
+  b: 20,
 };
 
 const expr1 = expressionFactory.create(model, '(a + 1)');
@@ -150,7 +160,7 @@ const expr2 = expressionFactory.create(model, '(b + 2)');
 
 const modularModel = {
   expr1,
-  expr2
+  expr2,
 };
 
 const expr3 = expressionFactory.create(modularModel, 'expr1 * expr2');
@@ -163,6 +173,7 @@ const expr3 = expressionFactory.create(modularModel, 'expr1 * expr2');
 - `expr3` evaluates to `242`
 
 When `a` or `b` changes:
+
 - Only the affected expressions are recalculated
 - Dependent expressions update automatically
 
@@ -177,6 +188,7 @@ expr3.changed.subscribe(() => {
 ```
 
 Changes to:
+
 - `a`
 - `b`
 - `expr1`
@@ -195,6 +207,7 @@ Modular expressions are not only about structure — they also **improve perform
 - No duplicated computation for shared logic
 
 This is especially important when:
+
 - Expressions are computationally expensive
 - Expressions depend on asynchronous or reactive data
 - The same calculation is reused in multiple places (e.g. UI bindings)
@@ -205,7 +218,7 @@ Modular expression support is enabled by adding a **custom index accessor** and
 
 This clearly illustrates the power of the expression parser: **new data types and reactive models can be seamlessly integrated** by extending the **State Manager** via plugins.
 
-## Complex modular expression example 
+## Complex modular expression example
 
 To get a sense of how powerful **modular expressions** are, we will look at a more realistic example.  
 We are going to create an expression that calculates **credit risk**.
@@ -215,50 +228,52 @@ First, we will show an implementation **without modular expressions**, followed
 ---
 
 ### Non-Modular example
+
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 import { BehaviorSubject } from 'rxjs';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory =
-    InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    interface IRisk {
-        volatilityIndex: number;
-        recessionProbability: number;
-    }
-
-    const riskModel = {
-        customer: {
-            age: 42,
-            income: 72000,
-            employmentYears: 6
-        },
-        credit: {
-            score: 680,
-            outstandingDebt: 18000
-        },
-        market: {
-            baseInterestRate: 0.035
-        },
-        risk: new BehaviorSubject<IRisk>({
-            volatilityIndex: 0.28,
-            recessionProbability: 0.12
-        }),
-        thresholds: {
-            highRisk: 0.75,
-            mediumRisk: 0.45
-        }
-    };
-
-    const expressionString = `(
+  interface IRisk {
+    volatilityIndex: number;
+    recessionProbability: number;
+  }
+
+  const riskModel = {
+    customer: {
+      age: 42,
+      income: 72000,
+      employmentYears: 6,
+    },
+    credit: {
+      score: 680,
+      outstandingDebt: 18000,
+    },
+    market: {
+      baseInterestRate: 0.035,
+    },
+    risk: new BehaviorSubject<IRisk>({
+      volatilityIndex: 0.28,
+      recessionProbability: 0.12,
+    }),
+    thresholds: {
+      highRisk: 0.75,
+      mediumRisk: 0.45,
+    },
+  };
+
+  const expressionString = `(
       (
         // =========================
         // Numeric risk score
@@ -324,39 +339,43 @@ export const run = (async () => {
         )
     )`;
 
-    const expression = expressionFactory.create(riskModel, expressionString);
-
-    console.log('Initial risk: ')
-    const changeSubscription = expression.changed.subscribe(() => {
-        console.log(expression.value);
-    });
+  const expression = expressionFactory.create(riskModel, expressionString);
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log('Risk after changing risk parameters from  { volatilityIndex: 0.28, recessionProbability: 0.12 } to  { volatilityIndex: 0.41, recessionProbability: 0.35 } :')
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-            riskModel.risk.next({
-                volatilityIndex: 0.45,
-                recessionProbability: 0.35
-            })
-        });
+  console.log('Initial risk: ');
+  const changeSubscription = expression.changed.subscribe(() => {
+    console.log(expression.value);
+  });
 
-        console.log('Risk after change age = 63 and employmentYears = 1 ');
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-            riskModel.customer.age = 63;
-            riskModel.customer.employmentYears = 1;
-        });
-    } finally {
-        changeSubscription.unsubscribe();
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
-})();
+    console.log(
+      'Risk after changing risk parameters from  { volatilityIndex: 0.28, recessionProbability: 0.12 } to  { volatilityIndex: 0.41, recessionProbability: 0.35 } :',
+    );
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      riskModel.risk.next({
+        volatilityIndex: 0.45,
+        recessionProbability: 0.35,
+      });
+    });
 
+    console.log('Risk after change age = 63 and employmentYears = 1 ');
 
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      riskModel.customer.age = 63;
+      riskModel.customer.employmentYears = 1;
+    });
+  } finally {
+    changeSubscription.unsubscribe();
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
+})();
 ```
 
 ### Modular example
@@ -364,131 +383,151 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 import { BehaviorSubject } from 'rxjs';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory =
-    InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    interface IRisk {
-        volatilityIndex: number;
-        recessionProbability: number;
-    }
-
-    const riskModel = {
-        customer: {
-            age: 42,
-            income: 72000,
-            employmentYears: 6
-        },
-        credit: {
-            score: 680,
-            outstandingDebt: 18000
-        },
-        market: {
-            baseInterestRate: 0.035
-        },
-        risk: new BehaviorSubject<IRisk>({
-            volatilityIndex: 0.28,
-            recessionProbability: 0.12
-        }),
-    };
-
-    const basePersonalRisk = expressionFactory.create(riskModel, `
+  interface IRisk {
+    volatilityIndex: number;
+    recessionProbability: number;
+  }
+
+  const riskModel = {
+    customer: {
+      age: 42,
+      income: 72000,
+      employmentYears: 6,
+    },
+    credit: {
+      score: 680,
+      outstandingDebt: 18000,
+    },
+    market: {
+      baseInterestRate: 0.035,
+    },
+    risk: new BehaviorSubject<IRisk>({
+      volatilityIndex: 0.28,
+      recessionProbability: 0.12,
+    }),
+  };
+
+  const basePersonalRisk = expressionFactory.create(
+    riskModel,
+    `
         (credit.score < 600 ? 0.4 : 0.1) +
         (credit.outstandingDebt / customer.income) * 0.6 -
         (customer.employmentYears * 0.03)     
-    `);
+    `,
+  );
 
-    const ageBasedRiskAdjustment = expressionFactory.create(riskModel, `
+  const ageBasedRiskAdjustment = expressionFactory.create(
+    riskModel,
+    `
         customer.age < 25 ? 0.15 :
         customer.age < 35 ? 0.05 :
         customer.age < 55 ? 0.00 :
         0.08
-    `);
+    `,
+  );
 
-    const marketRisk = expressionFactory.create(riskModel, `
+  const marketRisk = expressionFactory.create(
+    riskModel,
+    `
         (risk.volatilityIndex * 0.5) +
         (risk.recessionProbability * 0.5)
-    `);
-
-    const interestRateImpact = expressionFactory.create(riskModel, 'market.baseInterestRate * 2');
-
-    const riskScoreModel = {
-        basePersonalRisk,
-        ageBasedRiskAdjustment,
-        marketRisk,
-        interestRateImpact
-    };
-
-    const riskScore = expressionFactory.create(riskScoreModel, `
+    `,
+  );
+
+  const interestRateImpact = expressionFactory.create(
+    riskModel,
+    'market.baseInterestRate * 2',
+  );
+
+  const riskScoreModel = {
+    basePersonalRisk,
+    ageBasedRiskAdjustment,
+    marketRisk,
+    interestRateImpact,
+  };
+
+  const riskScore = expressionFactory.create(
+    riskScoreModel,
+    `
         basePersonalRisk + 
         ageBasedRiskAdjustment +
         marketRisk + 
         interestRateImpact
-    `);
-
-    const riskClassificationModel = {
-        riskScore,
-        thresholds: {
-            highRisk: 0.75,
-            mediumRisk: 0.45
-        }
-    };
-
-    const riskClassification = expressionFactory.create(riskClassificationModel, `
+    `,
+  );
+
+  const riskClassificationModel = {
+    riskScore,
+    thresholds: {
+      highRisk: 0.75,
+      mediumRisk: 0.45,
+    },
+  };
+
+  const riskClassification = expressionFactory.create(
+    riskClassificationModel,
+    `
         riskScore >= thresholds.highRisk
             ? 'HIGH'
             : riskScore >= thresholds.mediumRisk
                 ? 'MEDIUM'
                 : 'LOW'
-    `);
+    `,
+  );
 
+  console.log('Initial risk: ');
+  const changeSubscription = riskClassification.changed.subscribe(() => {
+    console.log(riskClassification.value);
+  });
 
-    console.log('Initial risk: ')
-    const changeSubscription = riskClassification.changed.subscribe(() => {
-        console.log(riskClassification.value);
-    });
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(riskClassification, 'changed').wait(emptyFunction);
-
-        console.log('Risk after changing risk parameters from  { volatilityIndex: 0.28, recessionProbability: 0.12 } to  { volatilityIndex: 0.41, recessionProbability: 0.35 } :')
-        await new WaitForEvent(riskClassification, 'changed', { ignoreInitialValue: true }).wait(() => {
-            riskModel.risk.next({
-                volatilityIndex: 0.45,
-                recessionProbability: 0.35
-            })
-        });
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(riskClassification, 'changed').wait(emptyFunction);
 
-        console.log('Risk after change age = 63 and employmentYears = 1 ');
+    console.log(
+      'Risk after changing risk parameters from  { volatilityIndex: 0.28, recessionProbability: 0.12 } to  { volatilityIndex: 0.41, recessionProbability: 0.35 } :',
+    );
+    await new WaitForEvent(riskClassification, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      riskModel.risk.next({
+        volatilityIndex: 0.45,
+        recessionProbability: 0.35,
+      });
+    });
 
-        await new WaitForEvent(riskClassification, 'changed', { ignoreInitialValue: true }).wait(() => {
-            riskModel.customer.age = 63;
-            riskModel.customer.employmentYears = 1;
-        });
+    console.log('Risk after change age = 63 and employmentYears = 1 ');
 
-    } finally {
-        changeSubscription.unsubscribe();
-        // Always dispose of expressions after use.
-        riskClassification.dispose();
-        riskScore.dispose();
-        interestRateImpact.dispose();
-        marketRisk.dispose();
-        ageBasedRiskAdjustment.dispose();
-        basePersonalRisk.dispose();
-    }
+    await new WaitForEvent(riskClassification, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      riskModel.customer.age = 63;
+      riskModel.customer.employmentYears = 1;
+    });
+  } finally {
+    changeSubscription.unsubscribe();
+    // Always dispose of expressions after use.
+    riskClassification.dispose();
+    riskScore.dispose();
+    interestRateImpact.dispose();
+    marketRisk.dispose();
+    ageBasedRiskAdjustment.dispose();
+    basePersonalRisk.dispose();
+  }
 })();
-
-
 ```
 
 ### Limitations of the Non-Modular Implementation
@@ -528,8 +567,8 @@ to use it.
 ```ts
 import { InjectionContainer } from '@rs-x/core';
 import {
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 InjectionContainer.load(RsXExpressionParserModule);
@@ -539,45 +578,45 @@ There are two ways to get an instance:
 
 1. Using the injection container
 
-    ```ts
-    import { InjectionContainer } from '@rs-x/core';
-    import {
-        IExpressionFactory,
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
+   ```ts
+   import { InjectionContainer } from '@rs-x/core';
+   import {
+     IExpressionFactory,
+     RsXExpressionParserInjectionTokens,
+     RsXExpressionParserModule,
+   } from '@rs-x/expression-parser';
 
-    const expressionFactory: IExpressionFactory = InjectionContainer.get(
-        RsXExpressionParserInjectionTokens.IExpressionFactory
-    );
-    ```
+   const expressionFactory: IExpressionFactory = InjectionContainer.get(
+     RsXExpressionParserInjectionTokens.IExpressionFactory,
+   );
+   ```
 
 2. Using the `@Inject` decorator
 
-    ```ts
-    import { Inject } from '@rs-x/core';
-    import {
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
-
-    export class MyClass {
-
-        constructor(
-            @Inject(RsXExpressionParserInjectionTokens.IExpressionFactory)
-            private readonly _expressionFactory: IExpressionFactory
-        ) {}
-    }
-    ```
+   ```ts
+   import { Inject } from '@rs-x/core';
+   import {
+     RsXExpressionParserInjectionTokens,
+     RsXExpressionParserModule,
+   } from '@rs-x/expression-parser';
+
+   export class MyClass {
+     constructor(
+       @Inject(RsXExpressionParserInjectionTokens.IExpressionFactory)
+       private readonly _expressionFactory: IExpressionFactory,
+     ) {}
+   }
+   ```
 
 ## Resolving Identifier Owner
 
 Expressions resolve to data values for there leaves. These values may be constants (such as numbers or strings), but more commonly they are stored as **indexes** within a given **context**. For example, when the context is an object instance, indexes refer to properties or fields; when the context is a `Map`, indexes refer to map keys.
 
 The interface responsible for resolving the owner of an identifier is defined as follows:
+
 ```ts
 export interface IIdentifierOwnerResolver {
-    resolve(index: unknown, context: unknown): object | null;
+  resolve(index: unknown, context: unknown): object | null;
 }
 ```
 
@@ -587,13 +626,22 @@ In `rs-x-expression-parser.module.ts`, the default resolver list is configured a
 
 ```ts
 registerMultiInjectServices(
-    options,
-    RsXExpressionParserInjectionTokens.IIdentifierOwnerResolverList,
-    [
-        { target: PropertyOwnerResolver, token: RsXExpressionParserInjectionTokens.PropertyOwnerResolver },
-        { target: ArrayIndexOwnerResolver, token: RsXExpressionParserInjectionTokens.ArrayIndexOwnerResolver },
-        { target: MapKeyOwnerResolver, token: RsXExpressionParserInjectionTokens.MapKeyOwnerResolver },
-    ]
+  options,
+  RsXExpressionParserInjectionTokens.IIdentifierOwnerResolverList,
+  [
+    {
+      target: PropertyOwnerResolver,
+      token: RsXExpressionParserInjectionTokens.PropertyOwnerResolver,
+    },
+    {
+      target: ArrayIndexOwnerResolver,
+      token: RsXExpressionParserInjectionTokens.ArrayIndexOwnerResolver,
+    },
+    {
+      target: MapKeyOwnerResolver,
+      token: RsXExpressionParserInjectionTokens.MapKeyOwnerResolver,
+    },
+  ],
 );
 ```
 
@@ -609,18 +657,19 @@ The default configuration includes the following resolvers:
   Resolves the identifier if the context is a `Map` and the specified index exists as a key in that map. Returns the context if resolved; otherwise, returns `null`.
 
 The default resolver list may be overridden by registering a custom list in a consuming module:
+
 ```ts
-    overrideMultiInjectServices(
-      options,
-      RsXExpressionParserInjectionTokens.IIdentifierOwnerResolverList,
-      CUSTOM_LIST
-    );
+overrideMultiInjectServices(
+  options,
+  RsXExpressionParserInjectionTokens.IIdentifierOwnerResolverList,
+  CUSTOM_LIST,
+);
 ```
+
 A common use case for a custom resolver occurs during data binding. In such scenarios, the initial context is the HTML element on which the data-binding expression is declared, while the identifier may be defined on an ancestor element (for example, a custom element). In this case, the resolver must traverse the parent chain until an element defining the identifier is found. The resolved context is then that element.
 
 This behavior can be implemented by providing a custom `IIdentifierOwnerResolver` that encapsulates the required traversal logic.
 
-
 ## Supported Expresssion types
 
 All non-assignment JavaScript expressions are supported. These expressions can be combined to form more complex expressions. The following expressions are the basic supported expressions:
@@ -630,95 +679,129 @@ All non-assignment JavaScript expressions are supported. These expressions can b
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 1,
-        b: 3
-    };
+  const expressionContext = {
+    a: 1,
+    b: 3,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a + b');
+  const expression = expressionFactory.create(expressionContext, 'a + b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a + b':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a + b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a + b' after changing 'a' to '6':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 6; })
+    console.log(`Value of 'a + b' after changing 'a' to '6':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 6;
+    });
 
-        console.log(`Value of 'a + b' after changing 'b' to '4':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 4; })
+    console.log(`Value of 'a + b' after changing 'b' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 4;
+    });
 
-        console.log(`Final value of 'a + b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a + b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Array expression
 
 ```ts
-import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  emptyFunction,
+  InjectionContainer,
+  printValue,
+  WaitForEvent,
+} from '@rs-x/core';
+import {
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 3,
-        array: [1, 2]
-    };
-
-    const expression = expressionFactory.create(expressionContext, '[a, ...array, 100]');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of '[a, ...array, 100]':`)
-        expression.changed.subscribe((change) => {
-            printValue(change.value);
-        });
+  const expressionContext = {
+    a: 3,
+    array: [1, 2],
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    '[a, ...array, 100]',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of '[a, ...array, 100]':`);
+    expression.changed.subscribe((change) => {
+      printValue(change.value);
+    });
 
-        console.log(`Value of [a, ...array, 100]' after changing 'a' to '6':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 6; });
+    console.log(`Value of [a, ...array, 100]' after changing 'a' to '6':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 6;
+    });
 
-        console.log(`Value of '[a, ...array, 100]' after changing 'array' to '[1, 2, 3]':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.array.push(3); });
+    console.log(
+      `Value of '[a, ...array, 100]' after changing 'array' to '[1, 2, 3]':`,
+    );
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.array.push(3);
+    });
 
-        console.log(`Value of '[a, ...array, 100]' after setting 'array' to '[100, 200]':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.array = [100, 200]; });
+    console.log(
+      `Value of '[a, ...array, 100]' after setting 'array' to '[100, 200]':`,
+    );
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.array = [100, 200];
+    });
 
-        console.log(`Final value of '[a, ...array, 100]':`)
-        printValue(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of '[a, ...array, 100]':`);
+    printValue(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
 ```
 
@@ -727,46 +810,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 5,
-        b: 3
-    };
+  const expressionContext = {
+    a: 5,
+    b: 3,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a & b');
+  const expression = expressionFactory.create(expressionContext, 'a & b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a & b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a & b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a & b' after changing 'a' to '2':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 2; });
+    console.log(`Value of 'a & b' after changing 'a' to '2':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 2;
+    });
 
-        console.log(`Value of 'a & b' after changing 'b' to '8':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 8; });
+    console.log(`Value of 'a & b' after changing 'b' to '8':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 8;
+    });
 
-        console.log(`Final value of 'a & b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a & b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
 ```
 
 ### Bitwise left shift expression
@@ -774,48 +866,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 5,
-        b: 2
-    };
+  const expressionContext = {
+    a: 5,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a << b');
+  const expression = expressionFactory.create(expressionContext, 'a << b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a << b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a << b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a << b' after changing 'a' to '4':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 4; });
+    console.log(`Value of 'a << b' after changing 'a' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 4;
+    });
 
-        console.log(`Value of 'a << b' after changing 'b' to '3':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 3; });
+    console.log(`Value of 'a << b' after changing 'b' to '3':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 3;
+    });
 
-        console.log(`Final value of 'a << b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a << b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
-
 ```
 
 ### Bitwise not expression
@@ -823,43 +922,47 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 5,
-    };
+  const expressionContext = {
+    a: 5,
+  };
 
-    const expression = expressionFactory.create(expressionContext, '~a');
+  const expression = expressionFactory.create(expressionContext, '~a');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of '~a':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of '~a':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of ~a' after changing 'a' to '3':`);
-         await new WaitForEvent(expression, 'changed', {ignoreInitialValue: true}).wait(() => {expressionContext.a = 3;});
+    console.log(`Value of ~a' after changing 'a' to '3':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 3;
+    });
 
-        console.log(`Final value of '~a':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of '~a':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
 ```
 
 ### Bitwise or expression
@@ -867,47 +970,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 5,
-        b: 2
-    };
+  const expressionContext = {
+    a: 5,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a | b');
+  const expression = expressionFactory.create(expressionContext, 'a | b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a | b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a | b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a | b' after changing 'a' to '10':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 10; });
+    console.log(`Value of 'a | b' after changing 'a' to '10':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 10;
+    });
 
-        console.log(`Value of 'a | b' after changing 'b' to '3':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 3; });
+    console.log(`Value of 'a | b' after changing 'b' to '3':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 3;
+    });
 
-        console.log(`Final value of 'a | b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a | b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Bitwise right shift expression
@@ -915,48 +1026,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
-
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 5,
-        b: 2
-    };
+  const expressionContext = {
+    a: 5,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a >> b');
+  const expression = expressionFactory.create(expressionContext, 'a >> b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a >> b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a >> b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a >> b' after changing 'a' to '10':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 10; });
+    console.log(`Value of 'a >> b' after changing 'a' to '10':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 10;
+    });
 
-        console.log(`Value of 'a >> b' after changing 'b' to '3':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 3; });
+    console.log(`Value of 'a >> b' after changing 'b' to '3':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 3;
+    });
 
-        console.log(`Final value of 'a >> b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a >> b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Bitwise unsigned right shift expression
@@ -964,47 +1082,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 5,
-        b: 2
-    };
+  const expressionContext = {
+    a: 5,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a >>> b');
+  const expression = expressionFactory.create(expressionContext, 'a >>> b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a >>> b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a >>> b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a >>> b' after changing 'a' to '-5':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = -5; });
+    console.log(`Value of 'a >>> b' after changing 'a' to '-5':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = -5;
+    });
 
-        console.log(`Value of 'a >>> b' after changing 'b' to '3':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 3; });
+    console.log(`Value of 'a >>> b' after changing 'b' to '3':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 3;
+    });
 
-        console.log(`Final value of 'a >>> b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a >>> b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Bitwise xor expression
@@ -1012,46 +1138,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 5,
-        b: 3
-    };
+  const expressionContext = {
+    a: 5,
+    b: 3,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a ^ b');
+  const expression = expressionFactory.create(expressionContext, 'a ^ b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a ^ b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a ^ b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a ^ b' after changing 'a' to '10':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 10; });
+    console.log(`Value of 'a ^ b' after changing 'a' to '10':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 10;
+    });
 
-        console.log(`Value of 'a ^ b' after changing 'b' to '8':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 8; });
+    console.log(`Value of 'a ^ b' after changing 'b' to '8':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 8;
+    });
 
-        console.log(`Final value of 'a ^ b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a ^ b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
 ```
 
 ### Conditional expression
@@ -1059,55 +1194,74 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 1,
-        b: 2,
-        c: 100,
-        d: 200
-    };
-
-    const expression = expressionFactory.create(expressionContext, 'a > b ? c : d');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of 'a > b ? c : d':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+  const expressionContext = {
+    a: 1,
+    b: 2,
+    c: 100,
+    d: 200,
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    'a > b ? c : d',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of 'a > b ? c : d':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a > b ? c : d' after changing d to '300':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.d = 300; });
+    console.log(`Value of 'a > b ? c : d' after changing d to '300':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.d = 300;
+    });
 
-        console.log(`Value of 'a > b ? c : d' after changing 'a' to '3':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 3; });
+    console.log(`Value of 'a > b ? c : d' after changing 'a' to '3':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 3;
+    });
 
-        console.log(`Value of 'a > b ? c : d' after changing c to '2000':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.c = 2000; });
+    console.log(`Value of 'a > b ? c : d' after changing c to '2000':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.c = 2000;
+    });
 
-        console.log(`Value of 'a > b ? c : d' after changing 'b' to '4':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 4; });
+    console.log(`Value of 'a > b ? c : d' after changing 'b' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 4;
+    });
 
-        console.log(`Final value of 'a > b ? c : d':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a > b ? c : d':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Division expression
@@ -1115,47 +1269,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 20,
-        b: 2
-    };
+  const expressionContext = {
+    a: 20,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a / b');
+  const expression = expressionFactory.create(expressionContext, 'a / b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a / b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a / b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a / b' after changing 'a' to '10':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 10; });
+    console.log(`Value of 'a / b' after changing 'a' to '10':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 10;
+    });
 
-        console.log(`Value of 'a /b b' after changing 'b' to '2':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 2; });
+    console.log(`Value of 'a /b b' after changing 'b' to '2':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 2;
+    });
 
-        console.log(`Final value of 'a / b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a / b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Equality expression
@@ -1163,47 +1325,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 3,
-        b: 2
-    };
+  const expressionContext = {
+    a: 3,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a == b');
+  const expression = expressionFactory.create(expressionContext, 'a == b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a == b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a == b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a == b' after changing 'a' to '2':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 2; });
+    console.log(`Value of 'a == b' after changing 'a' to '2':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 2;
+    });
 
-        console.log(`Value of 'a == b' after changing 'b' to '4':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 4; });
+    console.log(`Value of 'a == b' after changing 'b' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 4;
+    });
 
-        console.log(`Final value of 'a == b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a == b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Exponentiation expression
@@ -1211,47 +1381,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 2,
-        b: 3
-    };
+  const expressionContext = {
+    a: 2,
+    b: 3,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a ** b');
+  const expression = expressionFactory.create(expressionContext, 'a ** b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a ** b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a ** b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a ** b' after changing 'a' to '4':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 4; });
+    console.log(`Value of 'a ** b' after changing 'a' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 4;
+    });
 
-        console.log(`Value of 'a ** b' after changing 'b' to '5':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 5; });
+    console.log(`Value of 'a ** b' after changing 'b' to '5':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 5;
+    });
 
-        console.log(`Final value of 'a ** b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a ** b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Function expression
@@ -1259,49 +1437,61 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 2,
-        b: 3,
-        multiply(a: number, b: number) {
-            return a * b;
-        }
-    };
-
-    const expression = expressionFactory.create(expressionContext, 'multiply(a, b)');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of 'multiply(a, b)'`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+  const expressionContext = {
+    a: 2,
+    b: 3,
+    multiply(a: number, b: number) {
+      return a * b;
+    },
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    'multiply(a, b)',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of 'multiply(a, b)'`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'multiply(a, b)' after changing 'a' to '4':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 4; });
+    console.log(`Value of 'multiply(a, b)' after changing 'a' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 4;
+    });
 
-        console.log(`Value of 'mutiply(a, b)' after changing 'b' to '5':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 5; });
+    console.log(`Value of 'mutiply(a, b)' after changing 'b' to '5':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 5;
+    });
 
-        console.log(`Final value of 'multiply(a, b)':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'multiply(a, b)':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
 ```
 
 ### Greater than expression
@@ -1309,47 +1499,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 3,
-        b: 2
-    };
+  const expressionContext = {
+    a: 3,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a > b');
+  const expression = expressionFactory.create(expressionContext, 'a > b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a > b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a > b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a > b' after changing 'a' to '2':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 2; });
+    console.log(`Value of 'a > b' after changing 'a' to '2':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 2;
+    });
 
-        console.log(`Value of 'a > b' after changing 'b' to '1':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 1; });
+    console.log(`Value of 'a > b' after changing 'b' to '1':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 1;
+    });
 
-        console.log(`Final value of 'a > b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a > b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Greater than or equal expression
@@ -1357,97 +1555,121 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 3,
-        b: 2
-    };
+  const expressionContext = {
+    a: 3,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a >= b');
+  const expression = expressionFactory.create(expressionContext, 'a >= b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a >= b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a >= b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a >= b' after changing 'a' to '1':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 1; });
+    console.log(`Value of 'a >= b' after changing 'a' to '1':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 1;
+    });
 
-        console.log(`Value of 'a >= b' after changing 'b' to '0':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 0; });
+    console.log(`Value of 'a >= b' after changing 'b' to '0':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 0;
+    });
 
-        console.log(`Final value of 'a >= b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a >= b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### In expression
 
 ```ts
-import { emptyFunction, InjectionContainer, Type, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  emptyFunction,
+  InjectionContainer,
+  Type,
+  WaitForEvent,
+} from '@rs-x/core';
+import {
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        propertyName: 'hello',
-        b: {
-            hello: 'hi',
-        },
-    };
-
-    const expression = expressionFactory.create(expressionContext, 'propertyName in b');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of 'propertyName in b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+  const expressionContext = {
+    propertyName: 'hello',
+    b: {
+      hello: 'hi',
+    },
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    'propertyName in b',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of 'propertyName in b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'propertyName in b' after changing 'a' to 'x':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.propertyName = 'x'; });
+    console.log(`Value of 'propertyName in b' after changing 'a' to 'x':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.propertyName = 'x';
+    });
 
-        console.log(`Value of 'propertyName in b' after changing 'b' to '{x: 1}':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = Type.cast({ x: 1 }); });
+    console.log(`Value of 'propertyName in b' after changing 'b' to '{x: 1}':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = Type.cast({ x: 1 });
+    });
 
-        console.log(`Final value of 'propertyName in b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'propertyName in b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Inequality expression
@@ -1455,95 +1677,123 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 1,
-        b: 2
-    };
+  const expressionContext = {
+    a: 1,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a != b');
+  const expression = expressionFactory.create(expressionContext, 'a != b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a != b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a != b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a != b' after changing 'a' to '2':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 2; });
+    console.log(`Value of 'a != b' after changing 'a' to '2':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 2;
+    });
 
-        console.log(`Value of 'a != b' after changing 'b' to '2':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 2; });
+    console.log(`Value of 'a != b' after changing 'b' to '2':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 2;
+    });
 
-        console.log(`Final value of 'a != b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a != b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Instanceof expression
 
 ```ts
-import { emptyFunction, InjectionContainer, Type, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  emptyFunction,
+  InjectionContainer,
+  Type,
+  WaitForEvent,
+} from '@rs-x/core';
+import {
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        type: Date,
-        a: new Date(),
-    };
-
-    const expression = expressionFactory.create(expressionContext, 'a instanceof type');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of 'a instanceof type':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+  const expressionContext = {
+    type: Date,
+    a: new Date(),
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    'a instanceof type',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of 'a instanceof type':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a instanceof type' after changing 'a' to 'new Number(2)':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = Type.cast(new Number(2)); });
+    console.log(
+      `Value of 'a instanceof type' after changing 'a' to 'new Number(2)':`,
+    );
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = Type.cast(new Number(2));
+    });
 
-        console.log(`Value of 'a instanceof type' after changing 'type' to 'Number':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.type = Type.cast(Number); });
+    console.log(
+      `Value of 'a instanceof type' after changing 'type' to 'Number':`,
+    );
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.type = Type.cast(Number);
+    });
 
-        console.log(`Final value of 'a instanceof type':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a instanceof type':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Less than expression
@@ -1551,47 +1801,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 2,
-        b: 3
-    };
+  const expressionContext = {
+    a: 2,
+    b: 3,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a < b');
+  const expression = expressionFactory.create(expressionContext, 'a < b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a < b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a < b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a < b' after changing 'a' to '3':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 3; });
+    console.log(`Value of 'a < b' after changing 'a' to '3':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 3;
+    });
 
-        console.log(`Value of 'a < b' after changing 'b' to '4':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 4; });
+    console.log(`Value of 'a < b' after changing 'b' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 4;
+    });
 
-        console.log(`Final value of 'a < b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a < b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Less than or equal expression
@@ -1599,47 +1857,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 2,
-        b: 3
-    };
+  const expressionContext = {
+    a: 2,
+    b: 3,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a <= b');
+  const expression = expressionFactory.create(expressionContext, 'a <= b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a <= b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a <= b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a <= b' after changing 'a' to '4':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 4; });
+    console.log(`Value of 'a <= b' after changing 'a' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 4;
+    });
 
-        console.log(`Value of 'a < b' after changing 'b' to '4':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 4; });
+    console.log(`Value of 'a < b' after changing 'b' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 4;
+    });
 
-        console.log(`Final value of 'a <= b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a <= b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Logical and expression
@@ -1647,46 +1913,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: false,
-        b: true
-    };
+  const expressionContext = {
+    a: false,
+    b: true,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a && b');
+  const expression = expressionFactory.create(expressionContext, 'a && b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a && b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a && b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a && b' after changing 'a' to 'true':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = true; });
+    console.log(`Value of 'a && b' after changing 'a' to 'true':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = true;
+    });
 
-        console.log(`Value of 'a && b' after changing 'b' to 'false':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = false; });
+    console.log(`Value of 'a && b' after changing 'b' to 'false':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = false;
+    });
 
-        console.log(`Final value of 'a && b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a && b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
 ```
 
 ### Logical not expression
@@ -1694,40 +1969,46 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: false
-    };
+  const expressionContext = {
+    a: false,
+  };
 
-   const expression = expressionFactory.create(expressionContext, '!a');
+  const expression = expressionFactory.create(expressionContext, '!a');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of '!a':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of '!a':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of !a' after changing 'a' to 'true':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = true; });
+    console.log(`Value of !a' after changing 'a' to 'true':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = true;
+    });
 
-        console.log(`Final value of '!a':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of '!a':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
 ```
 
@@ -1736,537 +2017,693 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
+  const expressionContext = {
+    a: true,
+    b: false,
+  };
+
+  const expression = expressionFactory.create(expressionContext, 'a || b');
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of 'a || b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
+
+    console.log(`Value of 'a || b' after changing 'a' to 'false':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = false;
+    });
+
+    console.log(`Value of 'a || b' after changing 'b' to 'true':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = true;
+    });
+
+    console.log(`Final value of 'a || b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
+})();
+```
+
+### Member expression
+
+- Member expression
+
+  ```ts
+  import {
+    emptyFunction,
+    InjectionContainer,
+    printValue,
+    WaitForEvent,
+  } from '@rs-x/core';
+  import {
+    IExpressionFactory,
+    RsXExpressionParserInjectionTokens,
+    RsXExpressionParserModule,
+  } from '@rs-x/expression-parser';
+
+  // Load the expression parser module into the injection container
+  InjectionContainer.load(RsXExpressionParserModule);
+  const expressionFactory: IExpressionFactory = InjectionContainer.get(
+    RsXExpressionParserInjectionTokens.IExpressionFactory,
+  );
+
+  export const run = (async () => {
     const expressionContext = {
-        a: true,
-        b: false
+      a: {
+        b: {
+          c: 10,
+        },
+      },
     };
 
-    const expression = expressionFactory.create(expressionContext, 'a || b');
+    const expression = expressionFactory.create(expressionContext, 'a.b.c');
 
     try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+      // Wait until the expression has been resolved (has a value)
+      await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+      console.log(`Initial value of 'a.b.c':`);
+      expression.changed.subscribe((change) => {
+        printValue(change.value);
+      });
+
+      console.log(`Value of 'a.b.c' after changing 'a' to '{b : {c: 20}}':`);
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a = { b: { c: 20 } };
+      });
+
+      console.log(`Value of 'a.b.c' after changing 'b' to '{c: 30}':`);
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a.b = { c: 30 };
+      });
+
+      console.log(`Value of 'a.b.c' after changing c to '40':`);
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a.b.c = 40;
+      });
+
+      console.log(`Final value of 'a.b.c':`);
+      printValue(expression.value);
+    } finally {
+      // Always dispose of expressions after use.
+      expression.dispose();
+    }
+  })();
+  ```
+
+- Member expression with array
+
+  ```ts
+  import {
+    emptyFunction,
+    InjectionContainer,
+    printValue,
+    WaitForEvent,
+  } from '@rs-x/core';
+  import {
+    IExpressionFactory,
+    RsXExpressionParserInjectionTokens,
+    RsXExpressionParserModule,
+  } from '@rs-x/expression-parser';
 
-        console.log(`Initial value of 'a || b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+  // Load the expression parser module into the injection container
+  InjectionContainer.load(RsXExpressionParserModule);
+  const expressionFactory: IExpressionFactory = InjectionContainer.get(
+    RsXExpressionParserInjectionTokens.IExpressionFactory,
+  );
 
-        console.log(`Value of 'a || b' after changing 'a' to 'false':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = false; });
+  export const run = (async () => {
+    const expressionContext = {
+      a: {
+        b: [
+          {
+            c: {
+              d: 10,
+            },
+          },
+          {
+            c: {
+              d: 11,
+            },
+          },
+        ],
+      },
+      x: { y: 1 },
+    };
 
-        console.log(`Value of 'a || b' after changing 'b' to 'true':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = true; });
+    const expression = expressionFactory.create(
+      expressionContext,
+      'a.b[1].c.d',
+    );
 
-        console.log(`Final value of 'a || b':`)
-        console.log(expression.value);
+    try {
+      // Wait until the expression has been resolved (has a value)
+      await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+      console.log(`Initial value of 'a.b[1].c.d':`);
+      expression.changed.subscribe((change) => {
+        printValue(change.value);
+      });
+
+      console.log(
+        `Value of 'a.b.c' after changing 'a' to '{b: [{ c: { d: 100}},{ c: { d: 110}}}':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a = {
+          b: [
+            {
+              c: {
+                d: 100,
+              },
+            },
+            {
+              c: {
+                d: 110,
+              },
+            },
+          ],
+        };
+      });
+
+      console.log(
+        `Value of 'a.b[1].c.d' after changing b[1] to '{ c: { d: 120}}':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a.b[1] = {
+          c: {
+            d: 120,
+          },
+        };
+      });
+
+      console.log(`Value of 'a.b[1].c.d' after changing b[1].c to '{d: 220}':`);
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a.b[1].c = { d: 220 };
+      });
+
+      console.log(`Value of 'a.b[1].c.d' after changing b[1].c.d to '330':`);
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a.b[1].c.d = 330;
+      });
+
+      console.log(`Final value of 'a.b[1].c.d':`);
+      printValue(expression.value);
     } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
+      // Always dispose of expressions after use.
+      expression.dispose();
     }
-})();
+  })();
+  ```
+
+- Member expression with map
+
+  ```ts
+  import {
+    emptyFunction,
+    InjectionContainer,
+    printValue,
+    WaitForEvent,
+  } from '@rs-x/core';
+  import {
+    IExpressionFactory,
+    RsXExpressionParserInjectionTokens,
+    RsXExpressionParserModule,
+  } from '@rs-x/expression-parser';
 
+  // Load the expression parser module into the injection container
+  InjectionContainer.load(RsXExpressionParserModule);
+  const expressionFactory: IExpressionFactory = InjectionContainer.get(
+    RsXExpressionParserInjectionTokens.IExpressionFactory,
+  );
 
-```
+  export const run = (async () => {
+    const expressionContext = {
+      a: {
+        b: new Map([
+          ['a', { c: { d: 1 } }],
+          ['b', { c: { d: 2 } }],
+        ]),
+      },
+    };
 
-### Member expression
+    const expression = expressionFactory.create(
+      expressionContext,
+      `a.b['b'].c.d`,
+    );
 
-* Member expression
-    ```ts
-    import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
-    import {
-        IExpressionFactory,
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
-
-    // Load the expression parser module into the injection container
-    InjectionContainer.load(RsXExpressionParserModule);
-    const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
-    export const run = (async () => {
-        const expressionContext = {
-            a: {
-                b: {
-                    c: 10
-                }
-            }
+    try {
+      // Wait until the expression has been resolved (has a value)
+      await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+      console.log(`Initial value of 'a.b['b'].c.d':`);
+      expression.changed.subscribe((change) => {
+        printValue(change.value);
+      });
+
+      console.log(
+        `Value of 'a.b['b'].c.d' after changing 'a' to '{ b: new Map([['a', { c: { d: 11 } }], ['b', { c: { d: 21 } }]]) }':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a = {
+          b: new Map([
+            ['a', { c: { d: 11 } }],
+            ['b', { c: { d: 21 } }],
+          ]),
         };
+      });
+
+      console.log(
+        `Value of 'a.b['b'].c.d' after changing b['b'] to '{ c: { d: 120 } }':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a.b.set('b', { c: { d: 120 } });
+      });
+
+      console.log(
+        `Value of 'a.b['b'].c.d' after changing b['b'].c to '{ d: 220 }':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a.b.get('b').c = { d: 220 };
+      });
+
+      console.log(`Value of 'a.b['b'].c.d' after changing b[1].c.d to '330':`);
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a.b.get('b').c.d = 330;
+      });
+
+      console.log(`Final value of 'a.b['b'].c.d':`);
+      printValue(expression.value);
+    } finally {
+      // Always dispose of expressions after use.
+      expression.dispose();
+    }
+  })();
+  ```
+
+- Member expression with method
+
+  ```ts
+  import {
+    emptyFunction,
+    InjectionContainer,
+    printValue,
+    WaitForEvent,
+  } from '@rs-x/core';
+  import {
+    IExpressionFactory,
+    RsXExpressionParserInjectionTokens,
+    RsXExpressionParserModule,
+  } from '@rs-x/expression-parser';
 
-        const expression = expressionFactory.create(expressionContext, 'a.b.c');
-
-        try {
-            // Wait until the expression has been resolved (has a value)
-            await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-            console.log(`Initial value of 'a.b.c':`)
-            expression.changed.subscribe((change) => {
-                printValue(change.value);
-            });
-
-            console.log(`Value of 'a.b.c' after changing 'a' to '{b : {c: 20}}':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = { b: { c: 20 } }; });
-
-            console.log(`Value of 'a.b.c' after changing 'b' to '{c: 30}':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a.b = { c: 30 }; });
-
-            console.log(`Value of 'a.b.c' after changing c to '40':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a.b.c = 40; });
-
-            console.log(`Final value of 'a.b.c':`)
-            printValue(expression.value);
-        } finally {
-            // Always dispose of expressions after use.
-            expression.dispose();
-        }
-    })();
-
-
-    ```
-* Member expression with array
-    ```ts
-    import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
-    import {
-        IExpressionFactory,
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
-
-
-    // Load the expression parser module into the injection container
-    InjectionContainer.load(RsXExpressionParserModule);
-    const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
-    export const run = (async () => {
-        const expressionContext = {
-            a: {
-                b: [
-                    {
-                        c: {
-                            d: 10
-                        }
-                    },
-                    {
-                        c: {
-                            d: 11
-                        }
-                    },
-                ]
-            },
-            x: { y: 1 }
-        };
+  // Load the expression parser module into the injection container
+  InjectionContainer.load(RsXExpressionParserModule);
+  const expressionFactory: IExpressionFactory = InjectionContainer.get(
+    RsXExpressionParserInjectionTokens.IExpressionFactory,
+  );
 
-        const expression = expressionFactory.create(expressionContext, 'a.b[1].c.d');
-
-        try {
-            // Wait until the expression has been resolved (has a value)
-            await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-            console.log(`Initial value of 'a.b[1].c.d':`);
-            expression.changed.subscribe((change) => {
-                printValue(change.value);
-            });
-
-            console.log(`Value of 'a.b.c' after changing 'a' to '{b: [{ c: { d: 100}},{ c: { d: 110}}}':`);
-            await new WaitForEvent(expression, 'changed', {ignoreInitialValue: true}).wait(() => {
-                expressionContext.a = {
-                    b: [
-                        {
-                            c: {
-                                d: 100
-                            }
-                        },
-                        {
-                            c: {
-                                d: 110
-                            }
-                        },
-                    ]
-                };
-            });
-
-            console.log(`Value of 'a.b[1].c.d' after changing b[1] to '{ c: { d: 120}}':`);
-            await new WaitForEvent(expression, 'changed', {ignoreInitialValue: true}).wait(() => {
-                expressionContext.a.b[1] = {
-                    c: {
-                        d: 120
-                    }
-                };
-            });
-
-            console.log(`Value of 'a.b[1].c.d' after changing b[1].c to '{d: 220}':`);
-            await new WaitForEvent(expression, 'changed', {ignoreInitialValue: true}).wait(() => { expressionContext.a.b[1].c = { d: 220 }; });
-
-            console.log(`Value of 'a.b[1].c.d' after changing b[1].c.d to '330':`);
-            await new WaitForEvent(expression, 'changed', {ignoreInitialValue: true}).wait(() => { expressionContext.a.b[1].c.d = 330; });
-
-            console.log(`Final value of 'a.b[1].c.d':`)
-            printValue(expression.value);
-        } finally {
-            // Always dispose of expressions after use.
-            expression.dispose();
-        }
-    })();
-    ```
-* Member expression with map
-    ```ts
-    import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
-    import {
-        IExpressionFactory,
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
-
-
-    // Load the expression parser module into the injection container
-    InjectionContainer.load(RsXExpressionParserModule);
-    const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
-    export const run = (async () => {
-        const expressionContext = {
-            a: {
-                b: new Map([
-                    ['a', { c: { d: 1 } }],
-                    ['b', { c: { d: 2 } }]
-                ])
-            }
-        };
+  export const run = (async () => {
+    const expressionContext = {
+      message: 'Hello',
+      subject: 'Message',
+      a: {
+        b: {
+          mail: (message: string, subject: string) => {
+            return {
+              messageWithSubject: `message: ${message}, subject: ${subject}`,
+            };
+          },
+        },
+      },
+    };
 
-        const expression = expressionFactory.create(expressionContext, `a.b['b'].c.d`);
-
-        try {
-            // Wait until the expression has been resolved (has a value)
-            await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-            console.log(`Initial value of 'a.b['b'].c.d':`);
-            expression.changed.subscribe((change) => {
-                printValue(change.value);
-            });
-
-            console.log(`Value of 'a.b['b'].c.d' after changing 'a' to '{ b: new Map([['a', { c: { d: 11 } }], ['b', { c: { d: 21 } }]]) }':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                expressionContext.a = {
-                    b: new Map([
-                        ['a', { c: { d: 11 } }],
-                        ['b', { c: { d: 21 } }]
-                    ])
-                }
-            });
-
-            console.log(`Value of 'a.b['b'].c.d' after changing b['b'] to '{ c: { d: 120 } }':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                expressionContext.a.b.set('b', { c: { d: 120 } });
-            });
-
-            console.log(`Value of 'a.b['b'].c.d' after changing b['b'].c to '{ d: 220 }':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { 
-                expressionContext.a.b.get('b').c = { d: 220 }; 
-            });
-
-            console.log(`Value of 'a.b['b'].c.d' after changing b[1].c.d to '330':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { 
-                expressionContext.a.b.get('b').c.d = 330; 
-            });
-
-            console.log(`Final value of 'a.b['b'].c.d':`)
-            printValue(expression.value);
-        } finally {
-            // Always dispose of expressions after use.
-            expression.dispose();
-        }
-    })();
-    ```
-* Member expression with method
-    ```ts
-    import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
-    import {
-        IExpressionFactory,
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
-
-    // Load the expression parser module into the injection container
-    InjectionContainer.load(RsXExpressionParserModule);
-    const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
-    export const run = (async () => {
-        const expressionContext = {
-            message: 'Hello',
-            subject: 'Message',
-            a: {
-                b: {
-                    mail: (message: string, subject: string) => {
-                        return  {
-                            messageWithSubject: `message: ${message}, subject: ${subject}`
-                        };
-
-                    }
-                }
-            }
-        };
+    const expression = expressionFactory.create(
+      expressionContext,
+      'a.b.mail(message, subject).messageWithSubject',
+    );
 
-        const expression = expressionFactory.create(expressionContext, 'a.b.mail(message, subject).messageWithSubject');
-
-        try {
-            // Wait until the expression has been resolved (has a value)
-            await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-            console.log(`Initial value of 'a.b.mail(message, subject).messageWithSubject':`);
-            expression.changed.subscribe((change) => {
-                printValue(change.value);
-            });
-
-            console.log(`Value of 'a.b.mail(message, subject).messageWithSubject' after changing 'message' to 'hi'`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                expressionContext.message = 'hi';
-            });
-
-            console.log(`Value of 'a.b.mail(message, subject).messageWithSubject' after changing 'subject' to 'urgent message'`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                expressionContext.subject  = 'urgent message';
-            });
-
-            console.log(`Final value of 'a.b.mail(message, subject).messageWithSubject':`)
-            printValue(expression.value);
-        } finally {
-            // Always dispose of expressions after use.
-            expression.dispose();
-        }
-    })();
-    ```
-* Member expression with observable
-    ```ts
-    import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
-    import {
-        IExpressionFactory,
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
-    import { BehaviorSubject } from 'rxjs';
-
-    // Load the expression parser module into the injection container
-    InjectionContainer.load(RsXExpressionParserModule);
-    const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
-    export const run = (async () => {
-        const nestedObservable = new BehaviorSubject({ d: 200 });
-        const rootObservable = new BehaviorSubject({ c: nestedObservable });
-        const expressionContext = {
-            a: {
-                b: new BehaviorSubject(
-                    {
-                        c: new BehaviorSubject({ d: 20 })
-                    }
-                )
-            }
-        };
-        const expression = expressionFactory.create(expressionContext, `a.b.c.d`);
-
-        try {
-            // Wait until the expression has been resolved (has a value)
-            await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-            console.log(`Initial value of 'a.b.c.d':`);
-            expression.changed.subscribe((change) => {
-                printValue(change.value);
-            });
-
-
-            console.log(`Value of 'a.b.c.d' after changing 'a' to '{ b: BehaviorSubject({ c: BehaviorSubject({ d: 200 }) }) }':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                expressionContext.a = { b: rootObservable }
-
-            });
-
-            console.log(`Value of 'a.b.c.d' after emitting a new value '{ d: 300 }' for c':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                nestedObservable.next({ d: 300 });
-            });
-
-            console.log(`Value of 'a.b.c.d' after emitting a new value '{ c: new BehaviorSubject({ d: 400 }) }' for b':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                rootObservable.next({
-                    c: new BehaviorSubject({ d: 400 })
-                })
-            });
-
-            console.log(`Final value of 'a.b.c.d':`)
-            printValue(expression.value);
-        } finally {
-            // Always dispose of expressions after use.
-            expression.dispose();
-        }
-    })();
-    ```
-* Member expression with promise
-    ```ts
-    import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
-    import {
-        IExpressionFactory,
-        RsXExpressionParserInjectionTokens,
-        RsXExpressionParserModule
-    } from '@rs-x/expression-parser';
-
-    // Load the expression parser module into the injection container
-    InjectionContainer.load(RsXExpressionParserModule);
-    const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
-
-    export const run = (async () => {
-        const expressionContext = {
-            a: {
-                b: Promise.resolve({
-                    c: Promise.resolve({
-                        d: 20
-                    })
-                })
-            }
-        };
+    try {
+      // Wait until the expression has been resolved (has a value)
+      await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+      console.log(
+        `Initial value of 'a.b.mail(message, subject).messageWithSubject':`,
+      );
+      expression.changed.subscribe((change) => {
+        printValue(change.value);
+      });
+
+      console.log(
+        `Value of 'a.b.mail(message, subject).messageWithSubject' after changing 'message' to 'hi'`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.message = 'hi';
+      });
+
+      console.log(
+        `Value of 'a.b.mail(message, subject).messageWithSubject' after changing 'subject' to 'urgent message'`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.subject = 'urgent message';
+      });
+
+      console.log(
+        `Final value of 'a.b.mail(message, subject).messageWithSubject':`,
+      );
+      printValue(expression.value);
+    } finally {
+      // Always dispose of expressions after use.
+      expression.dispose();
+    }
+  })();
+  ```
+
+- Member expression with observable
+
+  ```ts
+  import {
+    emptyFunction,
+    InjectionContainer,
+    printValue,
+    WaitForEvent,
+  } from '@rs-x/core';
+  import {
+    IExpressionFactory,
+    RsXExpressionParserInjectionTokens,
+    RsXExpressionParserModule,
+  } from '@rs-x/expression-parser';
+  import { BehaviorSubject } from 'rxjs';
+
+  // Load the expression parser module into the injection container
+  InjectionContainer.load(RsXExpressionParserModule);
+  const expressionFactory: IExpressionFactory = InjectionContainer.get(
+    RsXExpressionParserInjectionTokens.IExpressionFactory,
+  );
+
+  export const run = (async () => {
+    const nestedObservable = new BehaviorSubject({ d: 200 });
+    const rootObservable = new BehaviorSubject({ c: nestedObservable });
+    const expressionContext = {
+      a: {
+        b: new BehaviorSubject({
+          c: new BehaviorSubject({ d: 20 }),
+        }),
+      },
+    };
+    const expression = expressionFactory.create(expressionContext, `a.b.c.d`);
 
-        const expression = expressionFactory.create(expressionContext, `a.b.c.d`);
+    try {
+      // Wait until the expression has been resolved (has a value)
+      await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+      console.log(`Initial value of 'a.b.c.d':`);
+      expression.changed.subscribe((change) => {
+        printValue(change.value);
+      });
+
+      console.log(
+        `Value of 'a.b.c.d' after changing 'a' to '{ b: BehaviorSubject({ c: BehaviorSubject({ d: 200 }) }) }':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a = { b: rootObservable };
+      });
+
+      console.log(
+        `Value of 'a.b.c.d' after emitting a new value '{ d: 300 }' for c':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        nestedObservable.next({ d: 300 });
+      });
+
+      console.log(
+        `Value of 'a.b.c.d' after emitting a new value '{ c: new BehaviorSubject({ d: 400 }) }' for b':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        rootObservable.next({
+          c: new BehaviorSubject({ d: 400 }),
+        });
+      });
 
-        try {
-            // Wait until the expression has been resolved (has a value)
-            await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+      console.log(`Final value of 'a.b.c.d':`);
+      printValue(expression.value);
+    } finally {
+      // Always dispose of expressions after use.
+      expression.dispose();
+    }
+  })();
+  ```
+
+- Member expression with promise
+
+  ```ts
+  import {
+    emptyFunction,
+    InjectionContainer,
+    printValue,
+    WaitForEvent,
+  } from '@rs-x/core';
+  import {
+    IExpressionFactory,
+    RsXExpressionParserInjectionTokens,
+    RsXExpressionParserModule,
+  } from '@rs-x/expression-parser';
 
-            console.log(`Initial value of 'a.b.c.d':`);
-            expression.changed.subscribe((change) => {
-                printValue(change.value);
-            });
+  // Load the expression parser module into the injection container
+  InjectionContainer.load(RsXExpressionParserModule);
+  const expressionFactory: IExpressionFactory = InjectionContainer.get(
+    RsXExpressionParserInjectionTokens.IExpressionFactory,
+  );
 
-            console.log(`Value of 'a.b.c.d' after changing 'a' to '{ b: Promise.resolve({ c: Promise.resolve({ d: 200 }) }) }':`);
-            await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => {
-                expressionContext.a =   { b: Promise.resolve({ c: Promise.resolve({ d: 200 }) }) };
-            });
+  export const run = (async () => {
+    const expressionContext = {
+      a: {
+        b: Promise.resolve({
+          c: Promise.resolve({
+            d: 20,
+          }),
+        }),
+      },
+    };
 
-            console.log(`Final value of 'a.b.c.d':`)
-            printValue(expression.value);
-        } finally {
-            // Always dispose of expressions after use.
-            expression.dispose();
-        }
-    })();
-    ```
+    const expression = expressionFactory.create(expressionContext, `a.b.c.d`);
+
+    try {
+      // Wait until the expression has been resolved (has a value)
+      await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+      console.log(`Initial value of 'a.b.c.d':`);
+      expression.changed.subscribe((change) => {
+        printValue(change.value);
+      });
+
+      console.log(
+        `Value of 'a.b.c.d' after changing 'a' to '{ b: Promise.resolve({ c: Promise.resolve({ d: 200 }) }) }':`,
+      );
+      await new WaitForEvent(expression, 'changed', {
+        ignoreInitialValue: true,
+      }).wait(() => {
+        expressionContext.a = {
+          b: Promise.resolve({ c: Promise.resolve({ d: 200 }) }),
+        };
+      });
+
+      console.log(`Final value of 'a.b.c.d':`);
+      printValue(expression.value);
+    } finally {
+      // Always dispose of expressions after use.
+      expression.dispose();
+    }
+  })();
+  ```
 
 ### Multiplication expression
 
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 1,
-        b: 3
-    };
+  const expressionContext = {
+    a: 1,
+    b: 3,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a * b');
+  const expression = expressionFactory.create(expressionContext, 'a * b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a * b':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a * b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a * b' after changing 'a' to '6':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 6; })
+    console.log(`Value of 'a * b' after changing 'a' to '6':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 6;
+    });
 
-        console.log(`Value of 'a * b' after changing 'b' to '4':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 4; })
+    console.log(`Value of 'a * b' after changing 'b' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 4;
+    });
 
-        console.log(`Final value of 'a * b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a * b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### New expression
 
 ```ts
-import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  emptyFunction,
+  InjectionContainer,
+  printValue,
+  WaitForEvent,
+} from '@rs-x/core';
+import {
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    class Value {
-        constructor(public readonly value: number) { }
-    }
+  class Value {
+    constructor(public readonly value: number) {}
+  }
 
-    class Add10 {
-        constructor(public readonly value: number) {
-            this.value += 10;
-        }
+  class Add10 {
+    constructor(public readonly value: number) {
+      this.value += 10;
     }
+  }
+
+  const expressionContext = {
+    type: Value,
+    value: 10,
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    'new type(value)',
+  );
+
+  function print(instance: unknown): void {
+    console.log(instance.constructor.name);
+    printValue(instance);
+  }
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of 'new type(value)':`);
+    expression.changed.subscribe((change) => {
+      print(change.value);
+    });
 
-    const expressionContext = {
-        type: Value,
-        value: 10,
-    };
-
-    const expression = expressionFactory.create(expressionContext, 'new type(value)');
-
-    function print(instance: unknown): void {
-        console.log(instance.constructor.name);
-        printValue(instance);
-    }
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of 'new type(value)':`);
-        expression.changed.subscribe((change) => {
-            print(change.value)
-        });
-
-        console.log(`Value of 'new type(value)' after changing 'value' to '20':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.value = 20; })
-
-        console.log(`Value of 'new type(value)' after changing 'type' to 'Add10':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.type = Add10; })
+    console.log(`Value of 'new type(value)' after changing 'value' to '20':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.value = 20;
+    });
 
-        console.log(`Final value of 'new type(value)':`)
-        print(expression.value);
+    console.log(`Value of 'new type(value)' after changing 'type' to 'Add10':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.type = Add10;
+    });
 
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'new type(value)':`);
+    print(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Nullish coalescing expression
@@ -2274,100 +2711,126 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: null,
-        b: 10,
-    };
+  const expressionContext = {
+    a: null,
+    b: 10,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a ?? b');
+  const expression = expressionFactory.create(expressionContext, 'a ?? b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a ?? b':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
-
-        console.log(`Value of 'a ?? b' after changing 'b' to '6':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 6; })
+    console.log(`Initial value of 'a ?? b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a ?? b' after changing 'a' to '10':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 10; })
+    console.log(`Value of 'a ?? b' after changing 'b' to '6':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 6;
+    });
 
-        console.log(`Value of 'a ?? b' after changing 'a' to 'null':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = null; })
+    console.log(`Value of 'a ?? b' after changing 'a' to '10':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 10;
+    });
 
+    console.log(`Value of 'a ?? b' after changing 'a' to 'null':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = null;
+    });
 
-        console.log(`Final value of 'a ?? b'':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a ?? b'':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Object expression
 
 ```ts
-import { emptyFunction, InjectionContainer, printValue, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  emptyFunction,
+  InjectionContainer,
+  printValue,
+  WaitForEvent,
+} from '@rs-x/core';
+import {
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        x: 10,
-        y: 20,
-    };
-
-    const expression = expressionFactory.create(expressionContext, '({ a: x, b: y })');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of '({ a: x, b: y })':`);
-        expression.changed.subscribe((change) => {
-            printValue(change.value)
-        });
-
-        console.log(`Value of '({ a: x, b: y })' after changing 'x' to '100':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.x = 100; })
+  const expressionContext = {
+    x: 10,
+    y: 20,
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    '({ a: x, b: y })',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of '({ a: x, b: y })':`);
+    expression.changed.subscribe((change) => {
+      printValue(change.value);
+    });
 
-        console.log(`Value of '({ a: x, b: y })' after changing 'y' to '200':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.y = 200; })
+    console.log(`Value of '({ a: x, b: y })' after changing 'x' to '100':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.x = 100;
+    });
 
-        console.log(`Final value of '({ a: x, b: y })':`)
-        printValue(expression.value);
+    console.log(`Value of '({ a: x, b: y })' after changing 'y' to '200':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.y = 200;
+    });
 
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of '({ a: x, b: y })':`);
+    printValue(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Remainder expression
@@ -2375,47 +2838,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext =  { 
-        a: 5, 
-        b: 2 
-    }
+  const expressionContext = {
+    a: 5,
+    b: 2,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a % b');
+  const expression = expressionFactory.create(expressionContext, 'a % b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of a % b':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of a % b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a % b' after changing 'a' to '6':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 6; })
+    console.log(`Value of 'a % b' after changing 'a' to '6':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 6;
+    });
 
-        console.log(`Value of 'a % b after changing 'b' to '4':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 4; })
+    console.log(`Value of 'a % b after changing 'b' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 4;
+    });
 
-        console.log(`Final value of 'a % b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a % b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Sequence expression
@@ -2423,52 +2894,63 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        b: 2,
-        value: 100,
-        setB(v: number) {
-            this.b = v;
-        },
-    };
-
-    const expression = expressionFactory.create(expressionContext, '(setB(value), b)');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of (setB(value), b)':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
-
-        console.log(`Value of '(setB(value)', b)' after changing 'value' to '200':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.value = 200; })
-
+  const expressionContext = {
+    b: 2,
+    value: 100,
+    setB(v: number) {
+      this.b = v;
+    },
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    '(setB(value), b)',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of (setB(value), b)':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of '(setB(value)', b)' after changing 'b' to '300':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 300; })
+    console.log(
+      `Value of '(setB(value)', b)' after changing 'value' to '200':`,
+    );
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.value = 200;
+    });
 
+    console.log(`Value of '(setB(value)', b)' after changing 'b' to '300':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 300;
+    });
 
-        console.log(`Final value of '(setB(value), b)':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of '(setB(value), b)':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Strict equality expression
@@ -2476,47 +2958,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 3,
-        b: 2 as string| number
-    };
+  const expressionContext = {
+    a: 3,
+    b: 2 as string | number,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a === b');
+  const expression = expressionFactory.create(expressionContext, 'a === b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a === b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a === b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a === b' after changing 'a' to '2':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 2; });
+    console.log(`Value of 'a === b' after changing 'a' to '2':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 2;
+    });
 
-        console.log(`Value of 'a === b' after changing 'b' to '"2"':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = '2'; });
+    console.log(`Value of 'a === b' after changing 'b' to '"2"':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = '2';
+    });
 
-        console.log(`Final value of 'a === b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a === b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Strict inequality expression
@@ -2524,47 +3014,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 2 as string | number,
-        b: 2 as string | number
-    };
+  const expressionContext = {
+    a: 2 as string | number,
+    b: 2 as string | number,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a !== b');
+  const expression = expressionFactory.create(expressionContext, 'a !== b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a !== b':`)
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a !== b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a !== b' after changing 'a' to '"2"':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = '2'; });
+    console.log(`Value of 'a !== b' after changing 'a' to '"2"':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = '2';
+    });
 
-        console.log(`Value of 'a !== b' after changing 'b' to '"2"':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = '2'; });
+    console.log(`Value of 'a !== b' after changing 'b' to '"2"':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = '2';
+    });
 
-        console.log(`Final value of 'a !== b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a !== b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Substraction expression
@@ -2572,47 +3070,55 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        a: 1,
-        b: 3
-    };
+  const expressionContext = {
+    a: 1,
+    b: 3,
+  };
 
-    const expression = expressionFactory.create(expressionContext, 'a - b');
+  const expression = expressionFactory.create(expressionContext, 'a - b');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of 'a - b':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of 'a - b':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'a - b' after changing 'a' to '6':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.a = 6; })
+    console.log(`Value of 'a - b' after changing 'a' to '6':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.a = 6;
+    });
 
-        console.log(`Value of 'a - b' after changing 'b' to '4':`)
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.b = 4; })
+    console.log(`Value of 'a - b' after changing 'b' to '4':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.b = 4;
+    });
 
-        console.log(`Final value of 'a - b':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'a - b':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Template string expression
@@ -2620,43 +3126,52 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        message: 'hi',
-    };
-
-    const expression = expressionFactory.create(expressionContext, '`Say ${message}`');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log("Initial value of '`Say ${message}`':");
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+  const expressionContext = {
+    message: 'hi',
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    '`Say ${message}`',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log("Initial value of '`Say ${message}`':");
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log("Value of '`Say ${message}`' after changing message a to 'hello':");
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.message = 'hello'; })
+    console.log(
+      "Value of '`Say ${message}`' after changing message a to 'hello':",
+    );
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.message = 'hello';
+    });
 
-        console.log("Final value of '`Say ${message}`':")
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log("Final value of '`Say ${message}`':");
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Typeof expression
@@ -2664,44 +3179,51 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        index: 0,
-        a: ['1', 1],
-    };
-
-    const expression = expressionFactory.create(expressionContext, 'typeof a[index]');
-
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
-
-        console.log(`Initial value of 'typeof a[index]':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+  const expressionContext = {
+    index: 0,
+    a: ['1', 1],
+  };
+
+  const expression = expressionFactory.create(
+    expressionContext,
+    'typeof a[index]',
+  );
+
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+
+    console.log(`Initial value of 'typeof a[index]':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of 'typeof a[index]' after changing 'index' to '1':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.index = 1; })
+    console.log(`Value of 'typeof a[index]' after changing 'index' to '1':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.index = 1;
+    });
 
-        console.log(`Final value of 'typeof a[index]':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of 'typeof a[index]':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Unary negation expression
@@ -2709,43 +3231,47 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = {
-        value: 1
-    };
+  const expressionContext = {
+    value: 1,
+  };
 
-    const expression = expressionFactory.create(expressionContext, '-value');
+  const expression = expressionFactory.create(expressionContext, '-value');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of '-value':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of '-value':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of '-value' after changing 'value' to '-5':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.value = -5; })
+    console.log(`Value of '-value' after changing 'value' to '-5':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.value = -5;
+    });
 
-        console.log(`Final value of '-value':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of '-value':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
 ```
 
 ### Unary plus expression
@@ -2753,41 +3279,45 @@ export const run = (async () => {
 ```ts
 import { emptyFunction, InjectionContainer, WaitForEvent } from '@rs-x/core';
 import {
-    IExpressionFactory,
-    RsXExpressionParserInjectionTokens,
-    RsXExpressionParserModule
+  IExpressionFactory,
+  RsXExpressionParserInjectionTokens,
+  RsXExpressionParserModule,
 } from '@rs-x/expression-parser';
 
 // Load the expression parser module into the injection container
 InjectionContainer.load(RsXExpressionParserModule);
-const expressionFactory: IExpressionFactory = InjectionContainer.get(RsXExpressionParserInjectionTokens.IExpressionFactory);
+const expressionFactory: IExpressionFactory = InjectionContainer.get(
+  RsXExpressionParserInjectionTokens.IExpressionFactory,
+);
 
 export const run = (async () => {
-    const expressionContext = { 
-        value: '2' 
-    }
+  const expressionContext = {
+    value: '2',
+  };
 
-    const expression = expressionFactory.create(expressionContext, '+value');
+  const expression = expressionFactory.create(expressionContext, '+value');
 
-    try {
-        // Wait until the expression has been resolved (has a value)
-        await new WaitForEvent(expression, 'changed').wait(emptyFunction);
+  try {
+    // Wait until the expression has been resolved (has a value)
+    await new WaitForEvent(expression, 'changed').wait(emptyFunction);
 
-        console.log(`Initial value of '+value':`);
-        expression.changed.subscribe((change) => {
-            console.log(change.value);
-        });
+    console.log(`Initial value of '+value':`);
+    expression.changed.subscribe((change) => {
+      console.log(change.value);
+    });
 
-        console.log(`Value of '+value' after changing 'value' to '"6"':`);
-        await new WaitForEvent(expression, 'changed', { ignoreInitialValue: true }).wait(() => { expressionContext.value = '6'; })
+    console.log(`Value of '+value' after changing 'value' to '"6"':`);
+    await new WaitForEvent(expression, 'changed', {
+      ignoreInitialValue: true,
+    }).wait(() => {
+      expressionContext.value = '6';
+    });
 
-        console.log(`Final value of '+value':`)
-        console.log(expression.value);
-    } finally {
-        // Always dispose of expressions after use.
-        expression.dispose();
-    }
+    console.log(`Final value of '+value':`);
+    console.log(expression.value);
+  } finally {
+    // Always dispose of expressions after use.
+    expression.dispose();
+  }
 })();
-
-
-```
+```