@rs-x/expression-parser 0.4.4

package/dist/index.d.ts

@@ -0,0 +1,701 @@
+import { IDisposable, IDisposableOwner, AnyFunction, ConstructorType, IIndexValueAccessor, ISingletonFactory, SingletonFactory, IDeepCloneValueGetter, ContainerModule } from '@rs-x/core';
+import { Observable } from 'rxjs';
+import { MustProxify as MustProxify$1, IStateManager as IStateManager$1, IStateChange as IStateChange$1, IContextChanged as IContextChanged$1, IMustProxifyItemHandlerFactory, IObjectObserverProxyPairFactory, IObserverProxyPair, IObserver, IProxyTarget } from '@rs-x/state-manager';
+
+interface IExpression<T = unknown, PT = unknown> extends IDisposable {
+    readonly changed: Observable<IExpression>;
+    readonly type: ExpressionType;
+    readonly expressionString: string;
+    readonly parent: IExpression<PT> | undefined;
+    readonly childExpressions: readonly IExpression[];
+    readonly value: T | undefined;
+    readonly isRoot: boolean;
+    toString(): string;
+}
+interface IPropertyPath {
+    object: IPropertyPath;
+    name: string;
+}
+interface IChangePathValue<T> {
+    readonly path: string;
+    readonly value: T;
+}
+declare enum ExpressionType {
+    And = "and",
+    Or = "or",
+    Not = "not",
+    Conditional = "conditional",
+    Equality = "equality",
+    Inequality = "inequality",
+    StrictEquality = "strict equality",
+    StrictInequality = "strict inequality",
+    GreaterThan = "greater than",
+    GreaterThanOrEqual = "Greater than or equal",
+    LessThan = "less than",
+    LessThanOrEqual = "less than or equal",
+    In = "in",
+    Instanceof = "instanceof",
+    Typeof = "typeof",
+    Remainder = "remain",
+    Subtraction = "subtraction",
+    UnaryNegation = "unary negation",
+    Addition = "addition",
+    Division = "division",
+    Multiplication = "multiplication",
+    Exponentiation = "exponentiation",
+    NullishCoalescing = "nullish coalescing",
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Array = "array",
+    Identifier = "identifier",
+    Function = "function",
+    TemlateString = "template string",
+    Null = "null",
+    BigInt = "big int",
+    RegExp = "regular expression",
+    Member = "member",
+    Spread = "spread",
+    BitwiseLeftShift = "bitwise left shift",
+    BitwiseRightShift = "bitwise right shift",
+    BitwiseUnsignedRightShift = "bitwise unsigned right shift",
+    BitwiseNot = "bitwise not",
+    BitwiseAnd = "bitwise and",
+    BitwiseOr = "bitwise or",
+    BitwiseXor = "bitwise xor",
+    New = "new",
+    Sequence = "sequence",
+    Object = "object",
+    Property = "property",
+    PropertyContext = "property context",
+    Super = "super",
+    This = "this",
+    Index = "Index",
+    UnaryPlus = "unary plus"
+}
+interface IExpressionParser {
+    parse(context: object, expression: string, owner?: IDisposableOwner): AbstractExpression;
+}
+
+interface IMustProxifyHandler {
+    createMustProxifyHandler: (() => MustProxify$1) | undefined;
+    releaseMustProxifyHandler: (() => void) | undefined;
+}
+interface IExpressionInitializeConfig {
+    context?: unknown;
+    mustProxifyHandler?: IMustProxifyHandler;
+    transactionManager?: IExpressionChangeTransactionManager;
+    owner?: IDisposableOwner;
+}
+declare abstract class AbstractExpression<T = unknown, PT = unknown> implements IExpression<T> {
+    readonly type: ExpressionType;
+    readonly expressionString: string;
+    protected readonly _childExpressions: AbstractExpression[];
+    private readonly _changed;
+    private _parent;
+    protected _value: T | undefined;
+    private _isDisposed;
+    private _oldValue;
+    private _commitedSubscription;
+    private _owner;
+    protected constructor(type: ExpressionType, expressionString: string, ...childExpressions: AbstractExpression[]);
+    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    get value(): T | undefined;
+    get isRoot(): boolean;
+    get changed(): Observable<IExpression>;
+    get childExpressions(): readonly IExpression[];
+    get parent(): AbstractExpression<PT> | undefined;
+    dispose(): void;
+    toString(): string;
+    protected get root(): AbstractExpression;
+    protected static setValue(expression: AbstractExpression, evaluate: () => unknown): void;
+    protected static setParent(expression: AbstractExpression, parent: AbstractExpression): void;
+    protected static clearValue(expression: AbstractExpression): void;
+    protected abstract evaluate(sender: AbstractExpression, root: AbstractExpression): T | undefined;
+    protected internalDispose(): void;
+    protected prepareReevaluation(sender: AbstractExpression, root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>): boolean;
+    protected reevaluated(sender: AbstractExpression, root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>): boolean;
+    protected evaluateBottomToTop(sender: AbstractExpression, root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>): boolean;
+    protected isCommitTarget(sender: AbstractExpression): boolean;
+    private onCommited;
+    private addChildExpressions;
+}
+
+declare abstract class ParameterizedExpression<T = unknown, PT = unknown> extends AbstractExpression<T, PT> {
+    protected constructor(type: ExpressionType, expressionString: string, ...childExpressions: AbstractExpression[]);
+    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    protected abstract evaluateExpression(...args: unknown[]): T;
+    protected prepareReevaluation(): boolean;
+    protected evaluate(): T;
+}
+
+declare abstract class BinaryExpression<T = unknown, PT = unknown> extends ParameterizedExpression<T, PT> {
+    protected constructor(expressionType: ExpressionType, expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+}
+
+declare class AdditionExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare abstract class CollectionExpression<T = unknown> extends ParameterizedExpression<T> {
+    constructor(type: ExpressionType, expressionString: string, expressions: AbstractExpression[]);
+}
+
+declare class ArrayExpression extends CollectionExpression<unknown[]> {
+    constructor(expressions: AbstractExpression[]);
+    protected evaluateExpression(...args: unknown[]): unknown[];
+}
+
+declare class BitwiseAndExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class BitwiseLeftShiftExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class BitwiseNotExpression extends ParameterizedExpression<number, number> {
+    constructor(expressionString: string, expression: AbstractExpression<number>);
+    protected evaluateExpression(a: number): number;
+}
+
+declare class BitwiseOrExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class BitwiseRightShiftExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class BitwiseUnsignedRightShiftExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class BitwiseXorExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class ConditionalExpression extends ParameterizedExpression {
+    constructor(expressionString: string, condition: AbstractExpression, ifValueExpression: AbstractExpression, elseValueExpression: AbstractExpression);
+    protected evaluateExpression(condition: unknown, consequent: unknown, alternate: unknown): unknown;
+}
+
+declare class ConstantExpression<T> extends AbstractExpression<T> {
+    private readonly _expressionChangeTransactionManager;
+    private readonly _commitHandler;
+    constructor(type: ExpressionType, expressionString: string, constValue: T, _expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    protected evaluate(): T | undefined;
+    private commit;
+}
+
+declare class ConstantBigIntExpression extends ConstantExpression<bigint> {
+    constructor(value: bigint, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+}
+
+declare class ConstantBooleanExpression extends ConstantExpression<boolean> {
+    constructor(value: boolean, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+}
+
+declare class ConstantNullExpression extends ConstantExpression<null> {
+    constructor(expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+}
+
+declare class ConstantNumberExpression extends ConstantExpression<number> {
+    constructor(value: number, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+}
+
+declare class ConstantRegExpExpression extends ConstantExpression<RegExp> {
+    constructor(expressionString: string, value: RegExp, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+}
+
+declare class ConstantStringExpression extends ConstantExpression<string> {
+    constructor(value: string, expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+}
+
+declare class UnaryPlusExpression extends ParameterizedExpression<number> {
+    constructor(expressionString: string, expression: AbstractExpression);
+    protected evaluateExpression(a: string | number): number;
+}
+
+declare class DivisionExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class EqualityExpression extends BinaryExpression<boolean> {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: unknown, b: unknown): boolean;
+}
+
+declare class ExponentiationExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(base: number, exponent: number): number;
+}
+
+interface IGuidFactory {
+    create(): string;
+}
+
+type MustProxify = (index: unknown, target?: unknown) => boolean;
+
+interface IContextChanged {
+    oldContext: unknown;
+    context: unknown;
+    key: unknown;
+}
+interface IStateChange extends IContextChanged {
+    oldValue: unknown;
+    newValue?: unknown;
+    watched?: boolean;
+}
+interface IStateManager {
+    readonly changed: Observable<IStateChange>;
+    readonly contextChanged: Observable<IContextChanged>;
+    readonly startChangeCycle: Observable<void>;
+    readonly endChangeCycle: Observable<void>;
+    isWatched(context: unknown, index: unknown, mustProxify?: MustProxify): boolean;
+    watchState(context: unknown, index: unknown, mustProxify?: MustProxify): unknown;
+    releaseState(oontext: unknown, index: unknown, mustProxify?: MustProxify): void;
+    getState<T>(context: unknown, index: unknown): T;
+    setState<T>(context: unknown, index: unknown, value: T): void;
+    clear(): void;
+}
+
+declare class FunctionExpression extends AbstractExpression {
+    readonly functionExpression: AbstractExpression<AnyFunction | string | number>;
+    readonly objectExpression: AbstractExpression<object>;
+    readonly argumentsExpression: ArrayExpression;
+    readonly computed: boolean;
+    readonly optional: boolean;
+    private readonly _stateManager;
+    private _context;
+    private _functionContext;
+    private readonly _functionId;
+    constructor(expressionString: string, functionExpression: AbstractExpression<AnyFunction | string | number>, objectExpression: AbstractExpression<object>, argumentsExpression: ArrayExpression, computed: boolean, optional: boolean, expressionChangeTransactionManager: IExpressionChangeTransactionManager, _stateManager: IStateManager, guidFactory: IGuidFactory);
+    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    protected internalDispose(): void;
+    protected prepareReevaluation(sender: AbstractExpression, root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>): boolean;
+    protected evaluate(): unknown;
+    private get functionName();
+    private releaseResult;
+    private registerResult;
+}
+
+declare class GreaterThanExpression extends BinaryExpression {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: number, b: number): boolean;
+}
+
+declare class GreaterThanOrEqualExpression extends BinaryExpression {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: number, b: number): boolean;
+}
+
+declare class IndexValueObserver {
+    private _context;
+    private readonly _key;
+    private readonly _mustProxify;
+    private readonly _stateManager;
+    private readonly _changeSubscription;
+    private readonly _contextChangeSubscription;
+    private readonly _changed;
+    private readonly _contextChanged;
+    private _isDisposed;
+    constructor(_context: unknown, _key: unknown, _mustProxify: MustProxify$1 | undefined, _stateManager: IStateManager$1);
+    get changed(): Observable<IStateChange$1>;
+    get contextChanged(): Observable<IContextChanged$1>;
+    dispose(): void;
+    getValue(context: unknown, key: unknown): unknown;
+    private onContextCHanged;
+    private emitChange;
+}
+interface IIdentifierInitializeConfig extends IExpressionInitializeConfig {
+    currentValue?: unknown;
+}
+declare class IdentifierExpression extends AbstractExpression {
+    private readonly _rootContext;
+    private readonly _stateManager;
+    private readonly _expressionChangeTransactionManager;
+    private readonly _indexValue?;
+    private _changeSubscription;
+    private _isInitialized;
+    private _indexValueObserver;
+    private releaseMustProxifyHandler;
+    private _commitAfterInitialized;
+    private readonly _commitHandler;
+    constructor(_rootContext: unknown, _stateManager: IStateManager$1, expressionString: string, _expressionChangeTransactionManager: IExpressionChangeTransactionManager, _indexValue?: unknown | undefined);
+    initialize(settings: IIdentifierInitializeConfig): AbstractExpression;
+    protected internalDispose(): void;
+    protected evaluate(): unknown;
+    private observeChange;
+    private getDefaultMustProxifyHandler;
+    private disposeObserver;
+    private commit;
+    private onValueChanged;
+}
+
+declare class InExpression extends BinaryExpression<boolean> {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: string, b: object): boolean;
+}
+
+declare class IndexExpression extends ParameterizedExpression {
+    constructor(expression: AbstractExpression);
+    protected get root(): AbstractExpression;
+    protected evaluateExpression(index: unknown): unknown;
+}
+
+declare class InequalityExpression extends BinaryExpression<boolean> {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: unknown, b: unknown): boolean;
+}
+
+declare class InstanceofExpression extends BinaryExpression<boolean, ConstructorType> {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression<ConstructorType>);
+    protected evaluateExpression(object: object, type: ConstructorType): boolean;
+}
+
+declare class LessThanExpression extends BinaryExpression<boolean> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): boolean;
+}
+
+declare class LessThanOrEqualExpression extends BinaryExpression<boolean> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): boolean;
+}
+
+declare class LogicalAndExpression extends BinaryExpression {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: unknown, b: unknown): unknown;
+}
+
+declare class LogicalNotExpression extends ParameterizedExpression {
+    constructor(expressionString: string, expression: AbstractExpression);
+    protected evaluateExpression(value: unknown): boolean;
+}
+
+declare class LogicalOrExpression extends BinaryExpression {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: unknown, b: unknown): unknown;
+}
+
+declare class MemberExpression extends AbstractExpression {
+    private readonly _indexValueAccessor;
+    private readonly _stateManager;
+    private readonly _mustProxifyItemHandlerFactory;
+    private readonly _expressionChangeTransactionManager;
+    private _slotObservers;
+    private _rebindingSlot;
+    private readonly _initializeQueue;
+    constructor(expressionString: string, pathSeqments: AbstractExpression[], _indexValueAccessor: IIndexValueAccessor, _stateManager: IStateManager$1, _mustProxifyItemHandlerFactory: IMustProxifyItemHandlerFactory, _expressionChangeTransactionManager: IExpressionChangeTransactionManager);
+    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    protected internalDispose(): void;
+    protected prepareReevaluation(sender: AbstractExpression, root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>): boolean;
+    protected evaluate(sender: AbstractExpression, root: AbstractExpression): unknown;
+    protected isCommitTarget(sender: AbstractExpression): boolean;
+    private isPending;
+    private shouldCancelEvaluate;
+    private initializePathSegement;
+    private resolvePathSegment;
+    private resolveCalculated;
+    private disposeSlotObserver;
+    private getMustProxifyHandler;
+    private createMustProxifyHandler;
+    private observeSlot;
+    private onSlotChanged;
+    private isCalculated;
+}
+
+declare class MultiplicationExpression extends BinaryExpression {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class NewExpression extends ParameterizedExpression {
+    constructor(expressionString: string, constructorExpression: AbstractExpression<ConstructorType>, argumentExpressions: AbstractExpression[]);
+    protected evaluateExpression(constructorFunction: ConstructorType, ...args: unknown[]): unknown;
+}
+
+declare class NullishCoalescingExpression extends BinaryExpression {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: unknown, b: unknown): unknown;
+}
+
+declare class PropertyExpression extends BinaryExpression<object, number | string> {
+    constructor(expressionString: string, keyExpression: AbstractExpression<PropertyKey>, valueExpression: AbstractExpression);
+    protected evaluateExpression(key: PropertyKey, value: unknown): object;
+}
+
+declare class SpreadExpression extends ParameterizedExpression<unknown[] | object> {
+    constructor(expression: ArrayExpression | ObjectExpression | IdentifierExpression);
+    protected evaluateExpression(...args: unknown[]): unknown[] | object;
+}
+
+declare class ObjectExpression extends ParameterizedExpression<object> {
+    constructor(expressionString: string, propertyExpressions: (PropertyExpression | SpreadExpression)[]);
+    protected evaluateExpression(...args: unknown[]): object;
+}
+
+declare class RemainderExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class SequenceExpression extends AbstractExpression {
+    constructor(expressionString: string, expressions: AbstractExpression[]);
+    initialize(settings: IExpressionInitializeConfig): AbstractExpression;
+    protected evaluate(): unknown;
+}
+
+declare class StrictEqualityExpression extends BinaryExpression<boolean> {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: unknown, b: unknown): boolean;
+}
+
+declare class StrictInequalityExpression extends BinaryExpression<boolean> {
+    constructor(expressionString: string, leftExpression: AbstractExpression, rightExpression: AbstractExpression);
+    protected evaluateExpression(a: unknown, b: unknown): boolean;
+}
+
+declare class SubtractionExpression extends BinaryExpression<number, number> {
+    constructor(expressionString: string, leftExpression: AbstractExpression<number>, rightExpression: AbstractExpression<number>);
+    protected evaluateExpression(a: number, b: number): number;
+}
+
+declare class TemplateStringExpression extends CollectionExpression<string> {
+    constructor(expressionString: string, expressions: AbstractExpression[]);
+    protected evaluateExpression(...segments: unknown[]): string;
+}
+
+declare class TypeofExpression extends ParameterizedExpression<string> {
+    constructor(expressionString: string, expression: AbstractExpression);
+    protected evaluateExpression(value: unknown): string;
+}
+
+declare class UnaryNegationExpression extends ParameterizedExpression<number> {
+    constructor(expressionString: string, expression: AbstractExpression<number>);
+    protected evaluateExpression(value: number): number;
+}
+
+interface IExpressionChangeCommitHandler {
+    owner: AbstractExpression;
+    commit: (root: AbstractExpression, pendingCommits: Set<IExpressionChangeCommitHandler>) => boolean;
+}
+interface IExpressionChangeTransactionManager extends IDisposable {
+    readonly commited: Observable<AbstractExpression>;
+    registerChange(rootExpression: AbstractExpression, commitHandler: IExpressionChangeCommitHandler): void;
+    suspend(): void;
+    continue(): void;
+    commit(): void;
+}
+
+declare class ExpressionChangeTransactionManager implements IExpressionChangeTransactionManager {
+    private readonly _commited;
+    private readonly _changes;
+    private readonly _startChangeCycleSubscription;
+    private readonly _endChangeCycleSubscription;
+    private _emittedChangeCounter;
+    private _suspended;
+    constructor(stateManager: IStateManager$1);
+    get commited(): Observable<AbstractExpression>;
+    dispose(): void;
+    suspend(): void;
+    continue(): void;
+    commit(): void;
+    private tryCommit;
+    registerChange(rootExpression: AbstractExpression, commitHandler: IExpressionChangeCommitHandler): void;
+    private onStartChangeCycle;
+    private onEndChangeCycle;
+}
+
+interface IExpressionFactory {
+    create(context: object, expression: string): IExpression;
+}
+
+interface IExpressionInfo {
+    context: object;
+    expression: string;
+}
+type IExpressionForContextManager = ISingletonFactory<string, string, IExpression>;
+type IExpressionManager = ISingletonFactory<object, object, IExpressionForContextManager>;
+
+declare class ExpressionFactory implements IExpressionFactory {
+    private readonly _expressionManager;
+    constructor(_expressionManager: IExpressionManager);
+    create(context: object, expression: string): IExpression;
+}
+
+declare class ExpressionManager extends SingletonFactory<object, object, IExpressionForContextManager> implements IExpressionManager {
+    private readonly _expressionParser;
+    getId(context: object): object;
+    protected createId(context: object): object;
+    constructor(_expressionParser: IExpressionParser);
+    protected createInstance(context: object, id: object): IExpressionForContextManager;
+}
+
+declare class DeepCloneValueGetterWithExpressionSupport implements IDeepCloneValueGetter {
+    private readonly _defaultDeepCloneValueGetter;
+    constructor(_defaultDeepCloneValueGetter: IDeepCloneValueGetter);
+    get(source: unknown): unknown;
+}
+
+type IExpressionIndexAccessor = IIndexValueAccessor<unknown, string>;
+
+declare class ExpressionIndexAccessor implements IExpressionIndexAccessor {
+    readonly priority: 300;
+    isAsync(): boolean;
+    getResolvedValue(context: unknown, index: string): unknown;
+    hasValue(context: unknown, index: string): boolean;
+    getValue(context: unknown, index: string): unknown;
+    setValue(): void;
+    getIndexes(): IterableIterator<string>;
+    applies(context: unknown, index: string): boolean;
+}
+
+type IExpressionObserverProxyPairFactory = IObjectObserverProxyPairFactory<AbstractExpression>;
+
+type IExpressionObserverProxyPair = IObserverProxyPair<AbstractExpression>;
+
+interface IExpressionObserverData {
+    owner?: IDisposableOwner;
+    expression: AbstractExpression;
+}
+type IExpressionObserverFactory = ISingletonFactory<AbstractExpression, IExpressionObserverData, IObserver>;
+
+declare class ExpressionObserverProxyPairFactory implements IExpressionObserverProxyPairFactory {
+    private readonly _expressionObserverFactory;
+    readonly priority = 100;
+    constructor(_expressionObserverFactory: IExpressionObserverFactory);
+    create(owner: IDisposableOwner, proxyTarget: IProxyTarget<AbstractExpression>): IExpressionObserverProxyPair;
+    applies(object: unknown): boolean;
+}
+
+declare class ExpressionObserverFactory extends SingletonFactory<AbstractExpression, IExpressionObserverData, IObserver> implements IExpressionObserverFactory {
+    constructor();
+    getId(data: IExpressionObserverData): AbstractExpression;
+    protected createId(data: IExpressionObserverData): AbstractExpression;
+    protected createInstance(data: IExpressionObserverData, id: AbstractExpression): IObserver;
+    protected releaseInstance(observer: IObserver): void;
+}
+
+interface IIdentifierOwnerResolver {
+    resolve(index: unknown, context?: unknown): object | null;
+}
+
+declare class ArrayIndexOwnerResolver implements IIdentifierOwnerResolver {
+    resolve(index: string | number, array: unknown[]): object | null;
+}
+
+declare class DefaultIdentifierOwnerResolver implements IIdentifierOwnerResolver {
+    private readonly _identifierOwnerResolvers;
+    constructor(_identifierOwnerResolvers: readonly IIdentifierOwnerResolver[]);
+    resolve(index: unknown, context?: unknown): object | null;
+}
+
+declare class MapKeyOwnerResolver implements IIdentifierOwnerResolver {
+    resolve(index: unknown, map: Map<unknown, unknown>): object | null;
+}
+
+declare class PropertyOwnerResolver implements IIdentifierOwnerResolver {
+    resolve(index: string, context: object): object | null;
+}
+
+declare class JsEspreeExpressionParser implements IExpressionParser {
+    private readonly _indexValueAccessor;
+    private readonly _mustProxifyItemHandlerFactory;
+    private readonly _expressionChangeTransactionManager;
+    private readonly _stateManager;
+    private readonly _guidFactory;
+    static readonly instance: IExpressionParser;
+    private readonly createConstantExpression;
+    private readonly expressionFactories;
+    private readonly unaryExpressionFactories;
+    private readonly binaryExpressionFactories;
+    private readonly logicalExpressionFactories;
+    constructor(_indexValueAccessor: IIndexValueAccessor, _mustProxifyItemHandlerFactory: IMustProxifyItemHandlerFactory, _expressionChangeTransactionManager: IExpressionChangeTransactionManager, _stateManager: IStateManager$1, _guidFactory: IGuidFactory);
+    parse(context: unknown, expressionString: string, owner: IDisposableOwner): AbstractExpression;
+    private tryParse;
+    private createExpression;
+    private createLiteralExpression;
+    private createBinaryExpression;
+    private createAssignmentExpression;
+    private createUnaryExpression;
+    private createConditionalExpression;
+    private createLogicalExpression;
+    private createChainExpression;
+    private createMemberExpression;
+    private createSequenceExpression;
+    private createIdentifier;
+    private createArrayExpression;
+    private createSpreadExpression;
+    private createNewExpression;
+    private createCallExpression;
+    private createTemplateLiteralExpression;
+    private createTaggedTemplateExpression;
+    private createTemplateElementExpression;
+    private createUnaryPlusExpression;
+    private createUnaryMinusExpression;
+    private createLogicalNotExpression;
+    private createTypeofExpression;
+    private createDeleteExpression;
+    private createEqualToExpression;
+    private createNotEqualToExpression;
+    private createStrictEqualToExpression;
+    private createStrictNotEqualToExpression;
+    private createLessThanExpression;
+    private createLessThanOrEqualToExpression;
+    private createGreaterThanExpression;
+    private createGreaterThanOrEqualToExpression;
+    private createBitwiseNotExpression;
+    private createLeftShiftExpression;
+    private createRightShiftExpression;
+    private createUnsignedRightShiftExpression;
+    private createBitwiseOrExpression;
+    private createBitwiseXOrExpression;
+    private createBitwiseAndExpression;
+    private createAdditionExpression;
+    private createSubstractionExpression;
+    private createMultiplicationExpression;
+    private createDivisionExpression;
+    private createModulusExpression;
+    private createExponentiationExpression;
+    private createInstanceOfExpression;
+    private createInExpression;
+    private createLogicalOrExpression;
+    private createLogicalAndExpression;
+    private createNullishCoalescingExpression;
+    private createObjectExpression;
+    private createPropertyExpression;
+    private parseExpression;
+    private normalizeAST;
+    private flattenMemberExpression;
+}
+
+declare const RsXExpressionParserInjectionTokens: {
+    PropertyOwnerResolver: symbol;
+    ArrayIndexOwnerResolver: symbol;
+    MapKeyOwnerResolver: symbol;
+    IdentifierOwnerResolver: symbol;
+    IIdentifierOwnerResolverList: symbol;
+    IExpressionManager: symbol;
+    IExpressionChangeTransactionManager: symbol;
+    IExpressionParser: symbol;
+    IExpressionFactory: symbol;
+    IExpressionObserverProxyPairFactory: symbol;
+    IExpressionIndexAccessor: symbol;
+    IExpressionObserverFactory: symbol;
+};
+
+declare const RsXExpressionParserModule: ContainerModule;
+declare function unloadRsXExpressionParserModule(): Promise<void>;
+
+export { AbstractExpression, AdditionExpression, ArrayExpression, ArrayIndexOwnerResolver, BinaryExpression, BitwiseAndExpression, BitwiseLeftShiftExpression, BitwiseNotExpression, BitwiseOrExpression, BitwiseRightShiftExpression, BitwiseUnsignedRightShiftExpression, BitwiseXorExpression, CollectionExpression, ConditionalExpression, ConstantBigIntExpression, ConstantBooleanExpression, ConstantExpression, ConstantNullExpression, ConstantNumberExpression, ConstantRegExpExpression, ConstantStringExpression, DeepCloneValueGetterWithExpressionSupport, DefaultIdentifierOwnerResolver, DivisionExpression, EqualityExpression, ExponentiationExpression, ExpressionChangeTransactionManager, ExpressionFactory, ExpressionIndexAccessor, ExpressionManager, ExpressionObserverFactory, ExpressionObserverProxyPairFactory, ExpressionType, FunctionExpression, GreaterThanExpression, GreaterThanOrEqualExpression, type IChangePathValue, type IExpression, type IExpressionChangeCommitHandler, type IExpressionChangeTransactionManager, type IExpressionFactory, type IExpressionForContextManager, type IExpressionIndexAccessor, type IExpressionInfo, type IExpressionInitializeConfig, type IExpressionManager, type IExpressionObserverData, type IExpressionObserverFactory, type IExpressionObserverProxyPair, type IExpressionParser, type IIdentifierInitializeConfig, type IIdentifierOwnerResolver, type IMustProxifyHandler, type IPropertyPath, IdentifierExpression, InExpression, IndexExpression, IndexValueObserver, InequalityExpression, InstanceofExpression, JsEspreeExpressionParser, LessThanExpression, LessThanOrEqualExpression, LogicalAndExpression, LogicalNotExpression, LogicalOrExpression, MapKeyOwnerResolver, MemberExpression, MultiplicationExpression, NewExpression, NullishCoalescingExpression, ObjectExpression, ParameterizedExpression, PropertyExpression, PropertyOwnerResolver, RemainderExpression, RsXExpressionParserInjectionTokens, RsXExpressionParserModule, SequenceExpression, SpreadExpression, StrictEqualityExpression, StrictInequalityExpression, SubtractionExpression, TemplateStringExpression, TypeofExpression, UnaryNegationExpression, UnaryPlusExpression, unloadRsXExpressionParserModule };