ifc-expressions 0.2.2 → 0.3.0

package/dist/context/NamedObjectAccessor.d.ts

@@ -1,5 +1,5 @@
-import { ObjectAccessor } from "./ObjectAccessor";
-import { LiteralValueAnyArity } from "../value/LiteralValueAnyArity";
+import { ObjectAccessor } from "./ObjectAccessor.js";
+import { LiteralValueAnyArity } from "../value/LiteralValueAnyArity.js";
 export declare abstract class NamedObjectAccessor implements ObjectAccessor {
     abstract getName(): string;
     abstract getDescription(): string;

package/dist/context/ObjectAccessor.d.ts

@@ -1,4 +1,4 @@
-import { LiteralValueAnyArity } from "../value/LiteralValueAnyArity";
+import { LiteralValueAnyArity } from "../value/LiteralValueAnyArity.js";
 export interface ObjectAccessor {
     /**
      * If there is a nested object with the specified name (.e.g the 'pset' in $prop.pset),
@@ -14,3 +14,4 @@ export interface ObjectAccessor {
     listNestedObjects(): Array<string>;
     listAttributes(): Array<string>;
 }
+export declare function isObjectAccessor(arg: any): arg is ObjectAccessor;

package/dist/expression/Expr.d.ts

@@ -1,4 +1,7 @@
-import { IfcExpressionContext } from "../context/IfcExpressionContext";
+import { IfcExpressionContext } from "../context/IfcExpressionContext.js";
+import { ExprKind } from "./ExprKind";
+import { ExprEvalResult } from "./ExprEvalResult";
 export interface Expr<T> {
-    evaluate(ctx: IfcExpressionContext): T;
+    evaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalResult<T>;
+    getKind(): ExprKind;
 }

package/dist/expression/Expr0.d.ts

@@ -1,6 +1,10 @@
-import { Expr } from "./Expr";
-import { IfcExpressionContext } from "../context/IfcExpressionContext";
-export declare abstract class Expr0<E> implements Expr<E> {
-    protected constructor();
-    abstract evaluate(ctx: IfcExpressionContext): E;
+import { IfcExpressionContext } from "../context/IfcExpressionContext.js";
+import { ExprKind } from "./ExprKind";
+import { ExprBase } from "./ExprBase";
+import { ExprEvalError, ExprEvalResult } from "./ExprEvalResult";
+export declare abstract class Expr0<E> extends ExprBase<E> {
+    protected constructor(kind: ExprKind);
+    protected abstract doEvaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): E | ExprEvalError;
+    evaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalResult<E>;
+    protected handleError(error: any): ExprEvalError;
 }

package/dist/expression/Expr1.d.ts

@@ -1,7 +1,22 @@
+import { IfcExpressionContext } from "../context/IfcExpressionContext.js";
+import { ExprKind } from "./ExprKind";
+import { ExprEvalError, ExprEvalResult } from "./ExprEvalResult";
+import { ExprBase } from "./ExprBase";
 import { Expr } from "./Expr";
-import { IfcExpressionContext } from "../context/IfcExpressionContext";
-export declare abstract class Expr1<V, E> implements Expr<E> {
-    readonly value: V;
-    protected constructor(value: V);
-    abstract evaluate(ctx: IfcExpressionContext): E;
+export declare abstract class Expr1<V, E> extends ExprBase<E> {
+    readonly value: Expr<V>;
+    protected constructor(exprKind: ExprKind, value: Expr<V>);
+    protected abstract calculateResult(ctx: IfcExpressionContext, localCtx: Map<string, any>, subExpressionResult: V): E | ExprEvalError;
+    /**
+     * Override to generate a more specific error result.
+     * @param ctx
+     * @param localCtx
+     * @param subExpressionResult
+     * @protected
+     */
+    protected obtainResultForSubExpressionError(ctx: IfcExpressionContext, localCtx: Map<string, any>, subExpressionResult: ExprEvalError): ExprEvalResult<E>;
+    private makeErrorOrCalculate;
+    protected onBeforeRecusion(ctx: IfcExpressionContext, localCtx: Map<string, any>): undefined | ExprEvalError;
+    evaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalResult<E>;
+    protected handleError(error: any, subResult: ExprEvalResult<V>): ExprEvalError;
 }

package/dist/expression/Expr2.d.ts

@@ -1,8 +1,17 @@
+import { IfcExpressionContext } from "../context/IfcExpressionContext.js";
+import { ExprBase } from "./ExprBase";
+import { ExprKind } from "./ExprKind";
+import { ExprEvalError, ExprEvalResult } from "./ExprEvalResult";
 import { Expr } from "./Expr";
-import { IfcExpressionContext } from "../context/IfcExpressionContext";
-export declare abstract class Expr2<L, R, E> implements Expr<E> {
-    readonly left: L;
-    readonly right: R;
-    protected constructor(left: L, right: R);
-    abstract evaluate(ctx: IfcExpressionContext): E;
+export declare abstract class Expr2<L, R, E> extends ExprBase<E> {
+    readonly left: Expr<L>;
+    readonly right: Expr<R>;
+    protected constructor(exprKind: ExprKind, left: Expr<L>, right: Expr<R>);
+    protected abstract calculateResult(ctx: IfcExpressionContext, localCtx: Map<string, any>, leftOperand: L, rightOperand: R): E | ExprEvalError;
+    protected onBeforeRecursion(ctx: IfcExpressionContext, localCtx: Map<string, any>): void;
+    protected onAfterLeftRecursion(ctx: IfcExpressionContext, localCtx: Map<string, any>, leftResult: L): void;
+    evaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalResult<E>;
+    protected makeResultForRightSubExprError(ctx: IfcExpressionContext, localCtx: Map<string, any>, leftResult: ExprEvalResult<L>, rightResult: ExprEvalError): ExprEvalResult<E>;
+    protected makeErrorForLeftSubExprError(ctx: IfcExpressionContext, localCtx: Map<string, any>, leftResult: ExprEvalError): ExprEvalError;
+    protected handleError(error: any, leftResult: ExprEvalResult<L>, rightResult: ExprEvalResult<R>): ExprEvalError;
 }

package/dist/expression/Expr2LeftBeforeRight.d.ts

@@ -0,0 +1,14 @@
+import { IfcExpressionContext } from "../context/IfcExpressionContext.js";
+import { ExprBase } from "./ExprBase";
+import { ExprKind } from "./ExprKind";
+import { ExprEvalError, ExprEvalResult } from "./ExprEvalResult";
+import { Expr } from "./Expr";
+export declare abstract class Expr2LeftBeforeRight<L, R, E> extends ExprBase<E> {
+    readonly left: Expr<L>;
+    readonly right: Expr<R>;
+    protected constructor(exprKind: ExprKind, left: Expr<L>, right: Expr<R>);
+    protected abstract doEvaluate(ctx: IfcExpressionContext, leftOperand: L, rightOperand: R): E | ExprEvalError;
+    protected abstract handleLeftResult(leftResult: ExprEvalResult<L>): any;
+    evaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalResult<E>;
+    protected handleError(error: any, leftResult: ExprEvalResult<L>, rightResult: ExprEvalResult<R>): ExprEvalError;
+}

package/dist/expression/ExprBase.d.ts

@@ -0,0 +1,11 @@
+import { Expr } from "./Expr";
+import { IfcExpressionContext } from "../context/IfcExpressionContext";
+import { ExprEvalError, ExprEvalResult } from "./ExprEvalResult";
+import { ExprKind } from "./ExprKind";
+export declare abstract class ExprBase<T> implements Expr<T> {
+    private readonly exprKind;
+    constructor(exprKind: ExprKind);
+    abstract evaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalResult<T>;
+    getKind(): ExprKind;
+    protected wrapInResultIfNecessary(result: T | ExprEvalError): ExprEvalResult<T>;
+}

package/dist/expression/ExprEvalResult.d.ts

@@ -0,0 +1,125 @@
+import { Expr } from "./Expr";
+import { ExprKind } from "./ExprKind";
+export declare enum ExprEvalStatus {
+    SUCCESS = 1000,
+    ERROR = 2000,
+    UNDEFINED_RESULT = 2001,
+    REFERENCE_ERROR = 2010,
+    MISSING_OPERAND = 2011,
+    MISSING_REQUIRED_FUNCTION_ARGUMENT = 2012,
+    UNKNOWN_FUNCTION = 2014,
+    CONSEQUENTIAL_ERROR = 2020,
+    MATH_ERROR = 2030,
+    TYPE_ERROR = 2040
+}
+export declare function isExprEvalStatus(candidate: number): boolean;
+export type ExprEvalResult<T> = ExprEvalSuccess<T> | ExprEvalError;
+export type ExprEvalSuccess<T> = {
+    status: ExprEvalStatus;
+    result: T;
+};
+export declare function isExprEvalSuccess(arg: any): arg is ExprEvalSuccess<unknown>;
+export declare class ExprEvalSuccessObj<T> {
+    readonly result: T;
+    readonly status: ExprEvalStatus;
+    constructor(result: T);
+}
+export declare class ExprEvalErrorObj {
+    readonly status: ExprEvalStatus;
+    readonly exprKind: ExprKind;
+    readonly message?: string;
+    constructor(exprKind: ExprKind, status?: ExprEvalStatus, message?: any);
+}
+export declare function mapErrorObjectToMessage(errorObjectOrMessage: any): string;
+export declare class ExprEvalErrorUndefinedResult extends ExprEvalErrorObj {
+    constructor(epxrKind: ExprKind);
+}
+export declare class ExprEvalRefChainErrorObj extends ExprEvalErrorObj {
+    readonly errorPathElement: string;
+    readonly path: Array<string>;
+    constructor(exprKind: ExprKind, status: ExprEvalStatus, errorPathElement: string, message?: any);
+    static bubbleUp(error: ExprEvalRefChainError, currentPathElement: any): ExprEvalRefChainError;
+}
+export declare class ExprEvalError1Obj extends ExprEvalErrorObj {
+    readonly sub: ExprEvalResult<unknown>;
+    constructor(exprKind: ExprKind, sub: ExprEvalResult<unknown>, status: ExprEvalStatus, message?: any);
+}
+export declare class ExprEvalError2Obj extends ExprEvalErrorObj {
+    readonly left: ExprEvalResult<unknown>;
+    readonly right: ExprEvalResult<unknown>;
+    constructor(exprKind: ExprKind, left: ExprEvalResult<unknown>, right: ExprEvalResult<unknown>, status?: ExprEvalStatus, message?: any);
+}
+export declare function isExprEvalError(arg: any): arg is ExprEvalError;
+export type ExprEvalError = ExprEvalUnspecificError | ExprEvalReferencError | ExprEvalErrorUndefinedResult | ExprEvalMissingRequiredFunctionArgumentError | ExprEvalValueError<unknown>;
+type ExprEvalUnspecificError = {
+    readonly exprKind: ExprKind;
+    readonly status: ExprEvalStatus;
+    readonly message?: string;
+};
+export type ExprEvalRefChainError = ExprEvalUnspecificError & {
+    readonly errorPathElement: string;
+    readonly path: Array<string>;
+};
+export declare function isExprEvalRefChainError(arg: any): arg is ExprEvalRefChainError;
+export type ExprEvalReferencError = ExprEvalUnspecificError & {
+    readonly status: ExprEvalStatus.REFERENCE_ERROR;
+    readonly expr: Expr<unknown>;
+};
+export type ExprEvalConsequentialError1 = ExprEvalUnspecificError & {
+    readonly status: ExprEvalStatus.CONSEQUENTIAL_ERROR;
+    readonly exprKind: ExprKind;
+    readonly cause: ExprEvalError;
+};
+export declare class ExprEvalConsequentialError1Obj extends ExprEvalErrorObj {
+    readonly exprKind: ExprKind;
+    readonly cause: ExprEvalResult<unknown>;
+    constructor(exprKind: ExprKind, cause: ExprEvalResult<unknown>, message?: any);
+}
+export type ExprEvalConsequentialError2 = ExprEvalUnspecificError & {
+    readonly status: ExprEvalStatus.CONSEQUENTIAL_ERROR;
+    readonly exprKind: ExprKind;
+    readonly leftCause: ExprEvalResult<unknown>;
+    readonly rightCause: ExprEvalResult<unknown>;
+};
+export declare class ExprEvalConsequentialError2Obj extends ExprEvalErrorObj {
+    readonly leftCause: ExprEvalResult<unknown>;
+    readonly rightCause: ExprEvalResult<unknown>;
+    constructor(exprKind: ExprKind, leftCause: ExprEvalResult<unknown>, rightCause: ExprEvalResult<unknown>, message?: any);
+}
+export type ExprEvalFunctionEvaluationError = ExprEvalUnspecificError & {
+    functionName: string;
+};
+export type ExprEvalMissingRequiredFunctionArgumentError = ExprEvalFunctionEvaluationError & {
+    argumentName: string;
+    argumentIndex: number;
+};
+export type ExprEvalFunctionEvaluationConsequentialError = ExprEvalFunctionEvaluationError & {
+    cause: ExprEvalUnspecificError;
+};
+export declare class ExprEvalFunctionEvaluationErrorObj extends ExprEvalErrorObj {
+    readonly functionName: string;
+    constructor(exprKind: ExprKind, status: ExprEvalStatus, message: any, functionName: string);
+}
+export declare class ExprEvalFunctionEvaluationConsequentialErrorObj extends ExprEvalFunctionEvaluationErrorObj {
+    readonly cause: ExprEvalError;
+    constructor(exprKind: ExprKind, functionName: string, cause: ExprEvalError);
+}
+export declare class ExprEvalMissingRequiredFunctionArgumentErrorObj extends ExprEvalFunctionEvaluationErrorObj {
+    readonly argumentName: string;
+    readonly argumentIndex: number;
+    constructor(exprKind: ExprKind, message: any, functionName: string, argumentName: string, argumentIndex: number);
+}
+export type ExprEvalTypeError = ExprEvalUnspecificError & {
+    status: ExprEvalStatus.TYPE_ERROR;
+};
+export type ExprEvalValueError<T> = ExprEvalUnspecificError & {
+    offendingValue: T;
+};
+export declare class ExprEvalValueErrorObj<T> extends ExprEvalErrorObj {
+    readonly offendingValue: T;
+    constructor(exprKind: ExprKind, status: ExprEvalStatus, message: any, offendingValue: T);
+}
+export declare class ExprEvalTypeErrorObj<T> extends ExprEvalValueErrorObj<T> {
+    constructor(exprKind: ExprKind, message: any, offendingValue: T);
+}
+export {};

package/dist/expression/ExprKind.d.ts

@@ -0,0 +1,19 @@
+export declare enum ExprKind {
+    NUM_DIVIDE = "NUM_DIVIDE",
+    NUM_MULTIPLY = "NUM_MULTIPLY",
+    NUM_PLUS = "NUM_PLUS",
+    NUM_MINUS = "NUM_MINUS",
+    NUM_LITERAL = "NUM_LiTERAL",
+    NUM_PARENTHESIS = "NUM_PARENTHESIS",
+    REF_ATTRIBUTE = "REF_ATTRIBUTE",
+    REF_ELEMENT = "REF_ELEMENT",
+    REF_NESTED_OBJECT_CHAIN_END = "REF_NESTED_OBJECT_CHAIN_END",
+    REF_NESTED_OBJECT_CHAIN = "REF_NESTED_OBJECT_CHAIN ",
+    REF_OBJECT = "REF_OBJECT",
+    REF_PROPERTY = "REF_PROPERTY",
+    STR_CONCAT = "STR_CONCAT",
+    STR_LITERAL = "STR_LITERAL",
+    FUNCTION_ARGUMENTS = "FUNCTION_ARGUMENTS",
+    FUNCTION = "FUNCTION",
+    ARRAY = "ARRAY"
+}

package/dist/expression/LiteralExpr.d.ts

@@ -0,0 +1,11 @@
+import { IfcExpressionContext } from "../context/IfcExpressionContext.js";
+import { ExprKind } from "./ExprKind";
+import { ExprEvalError, ExprEvalResult } from "./ExprEvalResult";
+import { ExprBase } from "./ExprBase";
+export declare abstract class LiteralExpr<V, E> extends ExprBase<E> {
+    readonly value: V;
+    protected constructor(exprKind: ExprKind, value: V);
+    protected abstract calculateResult(ctx: IfcExpressionContext): E | ExprEvalError;
+    evaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalResult<E>;
+    protected handleError(error: any): ExprEvalError;
+}

package/dist/expression/LocalContextKeys.d.ts

@@ -0,0 +1,3 @@
+export declare const LocalContextKeys: Readonly<{
+    OBJECT_ACCESSOR: "OBJECT_ACCESSOR";
+}>;

package/dist/expression/function/Func.d.ts

@@ -0,0 +1,30 @@
+import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity";
+import { FuncArg } from "./FuncArg";
+import { ExprEvalError, ExprEvalResult } from "../ExprEvalResult";
+export declare abstract class Func {
+    protected name: string;
+    protected formalArguments: Array<FuncArg<unknown>>;
+    constructor(name: string, args: Array<FuncArg<unknown>>);
+    evaluate(funcArgs: Array<ExprEvalResult<LiteralValueAnyArity>>): ExprEvalResult<LiteralValueAnyArity>;
+    /**
+     * Subclasses must provide the funcation evaluation code here.
+     * @param evaluatedArguments
+     * @protected
+     */
+    protected abstract calculateResult(evaluatedArguments: Map<string, LiteralValueAnyArity>): ExprEvalResult<LiteralValueAnyArity>;
+    /**
+     * Override to transform individual arguments if needed. After this step, if any of the ExprEvalResult objects in the
+     * returned array is an ExprEvalError, the function evaluation fails.
+     * @param evaluatedArguments
+     * @protected
+     */
+    protected transformArguments(evaluatedArguments: Map<string, ExprEvalResult<LiteralValueAnyArity>>): Map<string, ExprEvalResult<LiteralValueAnyArity>>;
+    /**
+     * Gets the argument values from the list of provided arguments in the form of 'name' -> ExprEvalResult (which may contain errors).
+     * Generates an error if a required value is missing.
+     * @param provided
+     * @protected
+     */
+    protected getArgumentValues(provided: Array<ExprEvalResult<LiteralValueAnyArity>>): Map<string, ExprEvalResult<LiteralValueAnyArity>> | ExprEvalError;
+    private checkArgs;
+}

package/dist/expression/function/FuncArg.d.ts

@@ -0,0 +1,18 @@
+import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity";
+import { ExprEvalResult } from "../ExprEvalResult";
+export declare class FuncArg<T> {
+    protected _required: boolean;
+    protected _name: string;
+    protected _defaultValue?: T;
+    constructor(required: boolean, name: string, defaultValue?: T);
+    /**
+     * For the value provided for a specific invocation of the function, return an appropriate result (maybe some kind of type conversion or type check might happen here)
+     *
+     * @param invocationValue
+     */
+    transformValue(invocationValue: ExprEvalResult<LiteralValueAnyArity>): ExprEvalResult<LiteralValueAnyArity>;
+    get required(): boolean;
+    get name(): string;
+    get defaultValue(): T | undefined;
+    hasDefaultValue(): boolean;
+}

package/dist/expression/function/FunctionExpr.d.ts

@@ -0,0 +1,13 @@
+import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity";
+import { IfcExpressionContext } from "../../context/IfcExpressionContext";
+import { ExprEvalError } from "../ExprEvalResult";
+import { Expr } from "../Expr";
+import { Expr0 } from "../Expr0";
+import { LiteralValue } from "../../value/LiteralValue";
+export declare class FunctionExpr extends Expr0<LiteralValueAnyArity> {
+    private name;
+    private elements;
+    private functionImplementation;
+    constructor(name: string, elements: Array<Expr<LiteralValue>>);
+    protected doEvaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalError | LiteralValueAnyArity;
+}

package/dist/expression/function/IfcExpressionFunctionConfigException.d.ts

@@ -0,0 +1,3 @@
+export declare class IfcExpressionFunctionConfigException extends Error {
+    constructor(message: string);
+}

package/dist/expression/function/IfcExpressionFunctions.d.ts

@@ -0,0 +1,7 @@
+import { ExprEvalResult } from "../ExprEvalResult";
+import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity";
+import { Func } from "./Func";
+export declare class IfcExpressionFunctions {
+    static getFunction(name: string): Func;
+    static applyFunction(name: string, functionArgs: Array<ExprEvalResult<LiteralValueAnyArity>>): ExprEvalResult<LiteralValueAnyArity>;
+}

package/dist/expression/function/arg/FuncArgBase.d.ts

@@ -0,0 +1,19 @@
+import { FuncArg } from "../FuncArg";
+import { ExprEvalError, ExprEvalResult, ExprEvalSuccess } from "../../ExprEvalResult";
+import { LiteralValueAnyArity } from "../../../value/LiteralValueAnyArity";
+export declare abstract class FuncArgBase<T> extends FuncArg<T> {
+    constructor(required: boolean, name: string, defaultValue?: T);
+    transformValue(invocationValue: ExprEvalResult<LiteralValueAnyArity>): ExprEvalResult<LiteralValueAnyArity>;
+    /**
+     * Override to type-check the successfully evaluated invocationValue.
+     * @param result
+     * @protected
+     */
+    protected transformForTypeCheck(invocationValue: ExprEvalSuccess<LiteralValueAnyArity>): ExprEvalResult<LiteralValueAnyArity>;
+    /**
+     * Override to transform the error result obtained from evaluating the invocation value.
+     * @param invocationValue
+     * @protected
+     */
+    protected transformForError(invocationValue: ExprEvalError): ExprEvalResult<LiteralValueAnyArity>;
+}

package/dist/expression/function/arg/FuncArgInt.d.ts

@@ -0,0 +1,8 @@
+import { FuncArgBase } from "./FuncArgBase";
+import { LiteralValueAnyArity } from "../../../value/LiteralValueAnyArity";
+import { ExprEvalResult, ExprEvalSuccess } from "../../ExprEvalResult";
+import { NumericValue } from "../../../value/NumericValue";
+export declare class FuncArgInt extends FuncArgBase<NumericValue> {
+    constructor(required: boolean, name: string, defaultValue?: NumericValue);
+    protected transformForTypeCheck(invocationValue: ExprEvalSuccess<LiteralValueAnyArity>): ExprEvalResult<LiteralValueAnyArity>;
+}

package/dist/expression/function/arg/FuncArgNumeric.d.ts

@@ -0,0 +1,8 @@
+import { FuncArgBase } from "./FuncArgBase";
+import { LiteralValueAnyArity } from "../../../value/LiteralValueAnyArity";
+import { ExprEvalResult, ExprEvalSuccess } from "../../ExprEvalResult";
+import { NumericValue } from "../../../value/NumericValue";
+export declare class FuncArgNumeric extends FuncArgBase<NumericValue> {
+    constructor(required: boolean, name: string, defaultValue?: NumericValue);
+    protected transformForTypeCheck(invocationValue: ExprEvalSuccess<LiteralValueAnyArity>): ExprEvalResult<LiteralValueAnyArity>;
+}

package/dist/expression/function/impl/MAP.d.ts

@@ -0,0 +1,10 @@
+import { Func } from "../Func";
+import { LiteralValueAnyArity } from "../../../value/LiteralValueAnyArity";
+import { ExprEvalResult } from "../../ExprEvalResult";
+export declare class MAP extends Func {
+    private static readonly ARG_NAME_MAPPINGS;
+    private static readonly ARG_NAME_MAPPING_INPUT;
+    private static readonly ARG_NAME_DEFAULT_VALUE;
+    constructor();
+    protected calculateResult(evaluatedArguments: Map<string, LiteralValueAnyArity>): ExprEvalResult<LiteralValueAnyArity>;
+}

package/dist/expression/function/impl/ROUND.d.ts

@@ -0,0 +1,9 @@
+import { Func } from "../Func";
+import { LiteralValueAnyArity } from "../../../value/LiteralValueAnyArity";
+import { ExprEvalResult } from "../../ExprEvalResult";
+export declare class ROUND extends Func {
+    private static KEY_INPUT;
+    private static KEY_NUM_DECMIALS;
+    constructor();
+    protected calculateResult(evaluatedArguments: Map<string, LiteralValueAnyArity>): ExprEvalResult<LiteralValueAnyArity>;
+}

package/dist/expression/numeric/DivideExpr.d.ts

@@ -1,8 +1,10 @@
-import { Expr2 } from "../Expr2";
-import { Expr } from "../Expr";
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { NumericValue } from "../../value/NumericValue";
-export declare class DivideExpr extends Expr2<Expr<NumericValue>, Expr<NumericValue>, NumericValue> {
+import { Expr2 } from "../Expr2.js";
+import { Expr } from "../Expr.js";
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { NumericValue } from "../../value/NumericValue.js";
+import { ExprEvalError, ExprEvalResult } from "../ExprEvalResult";
+export declare class DivideExpr extends Expr2<NumericValue, NumericValue, NumericValue> {
     constructor(left: Expr<NumericValue>, right: Expr<NumericValue>);
-    evaluate(ctx: IfcExpressionContext): NumericValue;
+    protected calculateResult(ctx: IfcExpressionContext, localCtx: Map<string, any>, left: NumericValue, right: NumericValue): NumericValue | ExprEvalError;
+    protected handleError(error: any, leftResult: ExprEvalResult<NumericValue>, rightResult: ExprEvalResult<NumericValue>): ExprEvalError;
 }

package/dist/expression/numeric/MinusExpr.d.ts

@@ -1,8 +1,9 @@
-import { Expr2 } from "../Expr2";
-import { Expr } from "../Expr";
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { NumericValue } from "../../value/NumericValue";
-export declare class MinusExpr extends Expr2<Expr<NumericValue>, Expr<NumericValue>, NumericValue> {
+import { Expr2 } from "../Expr2.js";
+import { Expr } from "../Expr.js";
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { NumericValue } from "../../value/NumericValue.js";
+import { ExprEvalError } from "../ExprEvalResult";
+export declare class MinusExpr extends Expr2<NumericValue, NumericValue, NumericValue> {
     constructor(left: Expr<NumericValue>, right: Expr<NumericValue>);
-    evaluate(ctx: IfcExpressionContext): NumericValue;
+    protected calculateResult(ctx: IfcExpressionContext, localCtx: Map<string, any>, left: NumericValue, right: NumericValue): NumericValue | ExprEvalError;
 }

package/dist/expression/numeric/MultiplyExpr.d.ts

@@ -1,8 +1,9 @@
-import { Expr2 } from "../Expr2";
-import { Expr } from "../Expr";
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { NumericValue } from "../../value/NumericValue";
-export declare class MultiplyExpr extends Expr2<Expr<NumericValue>, Expr<NumericValue>, NumericValue> {
+import { Expr2 } from "../Expr2.js";
+import { Expr } from "../Expr.js";
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { NumericValue } from "../../value/NumericValue.js";
+import { ExprEvalError } from "../ExprEvalResult";
+export declare class MultiplyExpr extends Expr2<NumericValue, NumericValue, NumericValue> {
     constructor(left: Expr<NumericValue>, right: Expr<NumericValue>);
-    evaluate(ctx: IfcExpressionContext): NumericValue;
+    protected calculateResult(ctx: IfcExpressionContext, localCtx: Map<string, any>, left: NumericValue, right: NumericValue): NumericValue | ExprEvalError;
 }

package/dist/expression/numeric/NumParenthesisExpr.d.ts

@@ -1,8 +1,8 @@
-import { Expr1 } from "../Expr1";
-import { Expr } from "../Expr";
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { NumericValue } from "../../value/NumericValue";
-export declare class NumParenthesisExpr extends Expr1<Expr<NumericValue>, NumericValue> {
+import { Expr1 } from "../Expr1.js";
+import { Expr } from "../Expr.js";
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { NumericValue } from "../../value/NumericValue.js";
+export declare class NumParenthesisExpr extends Expr1<NumericValue, NumericValue> {
     constructor(expression: Expr<NumericValue>);
-    evaluate(ctx: IfcExpressionContext): NumericValue;
+    protected calculateResult(ctx: IfcExpressionContext, localCtx: Map<string, any>, subExpressionValue: NumericValue): NumericValue;
 }

package/dist/expression/numeric/NumericLiteralExpr.d.ts

@@ -1,7 +1,8 @@
-import { Expr1 } from "../Expr1";
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { NumericValue } from "../../value/NumericValue";
-export declare class NumericLiteralExpr extends Expr1<NumericValue, NumericValue> {
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { NumericValue } from "../../value/NumericValue.js";
+import { ExprEvalError } from "../ExprEvalResult";
+import { LiteralExpr } from "../LiteralExpr";
+export declare class NumericLiteralExpr extends LiteralExpr<NumericValue, NumericValue> {
     constructor(value: NumericValue);
-    evaluate(ctx: IfcExpressionContext): NumericValue;
+    protected calculateResult(ctx: IfcExpressionContext): NumericValue | ExprEvalError;
 }

package/dist/expression/numeric/PlusExpr.d.ts

@@ -1,8 +1,8 @@
-import { Expr2 } from "../Expr2";
-import { Expr } from "../Expr";
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { NumericValue } from "../../value/NumericValue";
-export declare class PlusExpr extends Expr2<Expr<NumericValue>, Expr<NumericValue>, NumericValue> {
+import { Expr2 } from "../Expr2.js";
+import { Expr } from "../Expr.js";
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { NumericValue } from "../../value/NumericValue.js";
+export declare class PlusExpr extends Expr2<NumericValue, NumericValue, NumericValue> {
     constructor(left: Expr<NumericValue>, right: Expr<NumericValue>);
-    evaluate(ctx: IfcExpressionContext): NumericValue;
+    calculateResult(ctx: IfcExpressionContext, localCtx: Map<string, any>, leftResult: NumericValue, rightResult: NumericValue): NumericValue;
 }

package/dist/expression/reference/AttributeReferenceExpr.d.ts

@@ -1,9 +1,13 @@
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { Expr2 } from "../Expr2";
-import { NestedObjectChainExpr } from "./NestedObjectChainExpr";
-import { ObjectReferenceExpr } from "./ObjectReferenceExpr";
-import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity";
-export declare class AttributeReferenceExpr extends Expr2<ObjectReferenceExpr, NestedObjectChainExpr, LiteralValueAnyArity> {
-    constructor(left: ObjectReferenceExpr, right: NestedObjectChainExpr);
-    evaluate(ctx: IfcExpressionContext): LiteralValueAnyArity;
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { Expr2 } from "../Expr2.js";
+import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity.js";
+import { ObjectAccessor } from "../../context/ObjectAccessor.js";
+import { ExprEvalError, ExprEvalResult } from "../ExprEvalResult";
+import { Expr } from "../Expr";
+export declare class AttributeReferenceExpr extends Expr2<ObjectAccessor, LiteralValueAnyArity, LiteralValueAnyArity> {
+    constructor(left: Expr<ObjectAccessor>, right: Expr<LiteralValueAnyArity>);
+    protected onAfterLeftRecursion(ctx: IfcExpressionContext, localCtx: Map<string, any>, leftResult: ObjectAccessor): void;
+    calculateResult(ctx: IfcExpressionContext, localCtx: any, objectAccessor: ObjectAccessor, dereferencedValue: LiteralValueAnyArity): LiteralValueAnyArity | ExprEvalError;
+    protected makeResultForRightSubExprError(ctx: IfcExpressionContext, localCtx: Map<string, any>, leftResult: ExprEvalResult<ObjectAccessor>, rightResult: ExprEvalError): ExprEvalResult<LiteralValueAnyArity>;
+    protected handleError(error: any, leftResult: ExprEvalResult<ObjectAccessor>, rightResult: ExprEvalResult<LiteralValueAnyArity>): ExprEvalError;
 }

package/dist/expression/reference/ElemObjectReferenceExpr.d.ts

@@ -1,8 +1,8 @@
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { ObjectReferenceExpr } from "./ObjectReferenceExpr";
-import { ObjectAccessor } from "../../context/ObjectAccessor";
-import { Expr0 } from "../Expr0";
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { ObjectReferenceExpr } from "./ObjectReferenceExpr.js";
+import { ObjectAccessor } from "../../context/ObjectAccessor.js";
+import { Expr0 } from "../Expr0.js";
 export declare class ElemObjectReferenceExpr extends Expr0<ObjectAccessor> implements ObjectReferenceExpr {
     constructor();
-    evaluate(ctx: IfcExpressionContext): ObjectAccessor;
+    doEvaluate(ctx: IfcExpressionContext): ObjectAccessor;
 }

package/dist/expression/reference/NestedObjectChainEndExpr.d.ts

@@ -1,8 +1,9 @@
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { Expr1 } from "../Expr1";
-import { ObjectAccessor } from "../../context/ObjectAccessor";
-import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity";
-export declare class NestedObjectChainEndExpr extends Expr1<string, (oa: ObjectAccessor) => LiteralValueAnyArity> {
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity.js";
+import { ExprEvalError } from "../ExprEvalResult";
+import { Expr0 } from "../Expr0";
+export declare class NestedObjectChainEndExpr extends Expr0<LiteralValueAnyArity> {
+    private readonly attributeName;
     constructor(value: string);
-    evaluate(ctx: IfcExpressionContext): (oa: ObjectAccessor) => LiteralValueAnyArity;
+    protected doEvaluate(ctx: IfcExpressionContext, localCtx: Map<string, any>): ExprEvalError | LiteralValueAnyArity;
 }

package/dist/expression/reference/NestedObjectChainExpr.d.ts

@@ -1,9 +1,12 @@
-import { IfcExpressionContext } from "../../context/IfcExpressionContext";
-import { Expr2 } from "../Expr2";
-import { NestedObjectChainEndExpr } from "./NestedObjectChainEndExpr";
-import { ObjectAccessor } from "../../context/ObjectAccessor";
-import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity";
-export declare class NestedObjectChainExpr extends Expr2<string, NestedObjectChainExpr | NestedObjectChainEndExpr, (oa: ObjectAccessor) => LiteralValueAnyArity> {
-    constructor(left: string, right: NestedObjectChainExpr);
-    evaluate(ctx: IfcExpressionContext): (oa: ObjectAccessor) => LiteralValueAnyArity;
+import { IfcExpressionContext } from "../../context/IfcExpressionContext.js";
+import { LiteralValueAnyArity } from "../../value/LiteralValueAnyArity.js";
+import { ExprEvalError, ExprEvalResult } from "../ExprEvalResult";
+import { Expr1 } from "../Expr1";
+export declare class NestedObjectChainExpr extends Expr1<LiteralValueAnyArity, LiteralValueAnyArity> {
+    private readonly literalObjectRef;
+    constructor(literalObjectRef: string, nextLink: NestedObjectChainExpr);
+    protected onBeforeRecusion(ctx: IfcExpressionContext, localCtx: Map<string, any>): undefined | ExprEvalError;
+    calculateResult(ctx: IfcExpressionContext, localCtx: Map<string, any>, result: LiteralValueAnyArity): LiteralValueAnyArity | ExprEvalError;
+    protected obtainResultForSubExpressionError(ctx: IfcExpressionContext, localCtx: Map<string, any>, subExpressionResult: ExprEvalError): ExprEvalResult<LiteralValueAnyArity>;
+    protected handleError(error: any, subResult: ExprEvalResult<LiteralValueAnyArity>): ExprEvalError;
 }