ifc-expressions 0.3.4 → 2.0.0-beta.0

package/README.md

@@ -0,0 +1,158 @@
+# IFC Expressions
+
+This project defines an expression language for IFC models. An expression is evaluated in the context of an element of the IFC model and a specific property of that element.
+
+## Interface
+
+Two ways to interact with 'ifc-expression':
+
+- evaluate an expression string directly - receive `ExprEvalSuccessResult | ExprEvalError`
+
+or
+
+- parse an expression - receive a `IfcExpressionParseResult`
+- evaluate a `IfcExpressionParseResult` - receive `ExprEvalSuccessResult | ExprEvalError`
+
+## Usage
+
+To connect `ifc-expressions` with your IFC model, you have to provide an
+implementation of `src/context/IfcExpressionContext`. Without such a context, the expressions that
+contain references to the model cannot be evaluated.
+
+```ts
+import {IfcExpression} from "ifc-expression";
+import {IfcExpressionContext} from "./IfcExpressionContext";
+
+const result = IfcExpression.evaluate("1 + 1"); // evaluation without context
+console.log(JSON.stringify(result));
+// ExprEvalSuccessObj {
+//   status: 1000,
+//   result: NumericValue {
+//     value: 2
+//   }
+//}
+const ctx: IfcExpressionContext = ... ; // set to your context here
+const result2 = IfcExpression.evaluate("$element.property('width').value() * 2 ", ctx);
+```
+
+## Quick Reference
+
+Get the current property value:
+
+`$property.value()`
+
+Get the name of the property set the property is in:
+
+`$property.propertySet.name()`
+
+Get the name of the current element:
+
+`$element.name()`
+
+Get the name of the type of the current element:
+
+`$element.type().name()`
+
+Get value of property `myProp` from property set `myPset` in the current element:
+
+`$element.propertySet('myPset').property('myProp').value()`
+
+The last expression can also be written as
+
+`VALUE(PROPERTY(PROPERTY_SET($element, 'myPset'),'myProp'))`
+
+Check if property `myProp` exists in property set `myPset` in the current element:
+
+`$element.propertySet('myPset').property('myProp').exists()`
+
+Hints:
+
+- Function/Method names are case-insensitive
+- you have `+ - * / ^` for numerics
+- you have `&& || >< !` for booleans (`><`is xor)
+- you have `==  !=  >=  <=  >  <` for strings, booleans and numerics
+- you have a `.toString()` method on anything (or, equivalently, a function `toString(x)` for any `x` ).
+- you have `REPLACE`, which only knows the wildcard character `*`. (same for `MATCHES, CONTAINS`)
+- you have `REGEXREPLACE` with full js Regular Expressions (same for `REGEXMATCHES, REGEXCONTAINS`)
+
+## IFC Expression Language Syntax
+
+The project uses ANTLR4 for parsing. The grammar is in src/grammar/ifcExpression.g4.
+
+The result of expression evaluation is a value of type `string, numeric, boolean, ifcObjectRef`, where `ifcObjectRef` is a reference to some object in the IFC model.
+
+The language allows for specifying _a single expression_. There are no control statements and there is no way
+to define custom functions or custom types.
+
+An expression can be
+
+- a literal, such as `'hello world'`, or `17`
+- a variable reference, such as `$property` or `$element`,(for accessing the IFC model).
+
+... or a combination of multiple expressions:
+
+- a function call, such as `REPLACE("hello world", "world", "friends")`
+- a function call in 'method-call style', such as `"hello world".replace("world", "friends")`
+- a combination using operators, such as `+`, `&&`, `==`
+
+### Types
+
+- `string`, e.g. `'abc'` or `"abc"`: text enclosed in single or double quotes
+- `boolean`, e.g. `TRUE` or `false`: true or false, either spelled all-uppercase or all-lowercase
+- `numeric`, e.g. `1` or `3.141`: a decimal number optionally containing one period to separate integer part from fractional part
+- `array`, e.g. `[1,2,"hi there"]: an ordered list of expressions
+
+### Operators
+
+- numeric operators
+  - '+', '-', '\*', '/': plus, minus, multiplication, division - with the ususal precedence rules and associativity
+  - '^': raise to the power or, e.g. `2^3` (= 8)
+- boolean operators
+  - `&&', `||`, `><`: boolean and, or, xor
+  - `!`: boolean not
+- string operators
+  - '+': string concatenation
+
+### Functions
+
+#### comparison functions
+
+`equals(a,b)`, `greaterThan(a,b)`, `greaterThanOrEquals(a,b)`, `lessThan(a,b)`, `lessThanOrEqual(a,b)`",
+
+#### boolean operator functions
+
+`not(a)`, `and(a,b)`, `or(a,b)`, `xor(a,b)`, `implies(a,b)`
+
+#### string matching
+
+`contains(string, pattern)`, e.g. `contains('hello world', 'he*o')` returns true if the string contains the pattern. `*` matches any number of characters.
+
+`regexContains(string, regex)`, e.g. `regexContains('hello, world', 'h[aeiou]ll[aeiou]+\\\s')` returns true if the string contains the regular expression.
+
+`matches(string, pattern)`, e.g. `matches('hello world', 'he*o')` returns true if the whole string matches the pattern. `*` matches any number of characters.
+
+`regexMatches(string, regex)`, e.g. `regexMatches('hello, world', 'h[aeiou]ll[aeiou]+\\\s')` returns true if the whole string matches the regular expression.
+
+#### string replacement
+
+`replace(string, pattern, replacement)`, e.g. `replace('hello world', 'he*o', 'bye')` returns the `string`, with all occurrences of the `pattern` replaced with `replacement`. `*` matches any number of characters.
+
+`regexReplace(string, regex, replacement)`, e.g. `regexReplace('hello, world', 'h([aeiou]ll[aeiou]+) ', 'm$1w ')` returns the `string`, with all occurrences of the `regex` replaced with `replacement`.
+
+#### ifc object accessor functions
+
+`property(object: ifcPropertySetRef|ifcTypeObjectRef|ifcElementRef, name: string)`: returns an `ifcPropertyRef` or an error or an error if object has no property with that name
+
+`propertySet(object: ifcProperty)`: returns an `ifcPropertySetRef`
+
+`propertySet(object: ifcTypeObjectRef|ifcElementRef, name: string)`: returns an `ifcPropertySetRef` or an error if the element or type has no property set with that name.
+
+`type(object: ifcElementRef)`: returns an `ifcTypeObjectRef` or an error.
+
+`exists(object: ifcObjectRef): boolean` check whether an object reference obtained by the above methods actually exists (suppresses the error they generate)
+
+#### Translation functions
+
+`map(input, mapping: [[in, out], [in, out], ... ], default)`: finds the first `[in,out]` pair in the specified mapping where `in == input` and returns that pair's `out` value. If none is found, `default` is returned.
+
+'switch([[condition, out], [condition, out], ... ]', default): finds the first `[condition, out]` pair where `condition == true` and returns its `out` value. In none is found, `default` is returned.

package/dist/E.d.ts

@@ -0,0 +1,45 @@
+import { ArrayExpr } from "./expression/structure/ArrayExpr.js";
+import { Expr } from "./expression/Expr.js";
+import { StringConcatExpr } from "./expression/string/StringConcatExpr.js";
+import { StringLiteralExpr } from "./expression/string/StringLiteralExpr.js";
+import { ElemObjectReferenceExpr } from "./expression/reference/ElemObjectReferenceExpr.js";
+import { PropObjectReferenceExpr } from "./expression/reference/PropObjectReferenceExpr.js";
+import { NumericValue } from "./value/NumericValue.js";
+import { DivideExpr } from "./expression/numeric/DivideExpr.js";
+import { StringValue } from "./value/StringValue.js";
+import { MinusExpr } from "./expression/numeric/MinusExpr.js";
+import { MultiplyExpr } from "./expression/numeric/MultiplyExpr.js";
+import { PlusExpr } from "./expression/numeric/PlusExpr.js";
+import { NumericLiteralExpr } from "./expression/numeric/NumericLiteralExpr.js";
+import { Decimal } from "decimal.js";
+import { ParenthesisExpr } from "./expression/structure/ParenthesisExpr.js";
+import { PowerExpr } from "./expression/numeric/PowerExpr.js";
+import { UnaryMinusExpr } from "./expression/numeric/UnaryMinusExpr.js";
+import { FunctionExpr } from "./expression/function/FunctionExpr.js";
+import { BooleanValue } from "./value/BooleanValue.js";
+import { AndExpr } from "./expression/boolean/AndExpr.js";
+import { OrExpr } from "./expression/boolean/OrExpr.js";
+import { XorExpr } from "./expression/boolean/XorExpr.js";
+import { BooleanLiteralExpr } from "./expression/boolean/BooleanLiteralExpr.js";
+import { NotExpr } from "./expression/boolean/NotExpr.js";
+export declare class E {
+    static array(...elements: Array<Expr<any>>): ArrayExpr;
+    static concat(left: Expr<StringValue>, right: Expr<StringValue>): StringConcatExpr;
+    static string(literal: string): StringLiteralExpr;
+    static element(): ElemObjectReferenceExpr;
+    static property(): PropObjectReferenceExpr;
+    static div(left: Expr<NumericValue>, right: Expr<NumericValue>): DivideExpr;
+    static minus(left: Expr<NumericValue>, right: Expr<NumericValue>): MinusExpr;
+    static multiply(left: Expr<NumericValue>, right: Expr<NumericValue>): MultiplyExpr;
+    static plus(left: Expr<NumericValue>, right: Expr<NumericValue>): PlusExpr;
+    static number(literal: number | string | Decimal): NumericLiteralExpr;
+    static parenthesis(numericExpression: Expr<NumericValue>): ParenthesisExpr;
+    static power(base: Expr<NumericValue>, power: Expr<NumericValue>): PowerExpr;
+    static unaryMinus(numExpr: Expr<NumericValue>): UnaryMinusExpr;
+    static fun(functionName: string, ...funcArgs: Array<Expr<any>>): FunctionExpr;
+    static and(left: Expr<BooleanValue>, right: Expr<BooleanValue>): AndExpr;
+    static or(left: Expr<BooleanValue>, right: Expr<BooleanValue>): OrExpr;
+    static xor(left: Expr<BooleanValue>, right: Expr<BooleanValue>): XorExpr;
+    static boolean(literal: boolean): BooleanLiteralExpr;
+    static not(booleanExpr: Expr<BooleanValue>): NotExpr;
+}

package/dist/ExprVisitor.d.ts

@@ -1,26 +1,37 @@
 import IfcExpressionVisitor from "./gen/parser/IfcExpressionVisitor.js";
-import { ArrayContext, ArrayElementListContext, AttributeRefContext, ExprContext, ExprListContext, FunctionCallContext, NestedObjectChainEndContext, NestedObjectChainInnerContext, NumAddSubContext, NumAttributeRefContext, NumLitContext, NumLiteralContext, NumMulDivContext, NumParensContext, ObjectRefContext, StringAttributeRefContext, StringConcatContext, StringLiteralContext } from "./gen/parser/IfcExpressionParser.js";
+import { ArrayElementListContext, ArrayExprContext, BooleanLiteralContext, ExprContext, ExprListContext, FunctionCallContext, LiteralContext, MethodCallChainEndContext, MethodCallChainInnerContext, NumLiteralContext, SEAddSubContext, SEArrayExprContext, SEBooleanBinaryOpContext, SEComparisonContext, SEFunctionCallContext, SELiteralContext, SEMethodCallContext, SEMulDivContext, SENotContext, SEParenthesisContext, SEPowerContext, SEUnaryMinusContext, SEUnaryMultipleMinusContext, SEVariableRefContext, StringLiteralContext, VariableRefContext } from "./gen/parser/IfcExpressionParser.js";
 import { Expr } from "./expression/Expr.js";
+import { TypeManager } from "./type/TypeManager.js";
 export declare class ExprVisitor extends IfcExpressionVisitor<Expr<any>> {
-    constructor();
-    visitAttributeRef: (ctx: AttributeRefContext) => Expr<any>;
-    visitObjectRef: (ctx: ObjectRefContext) => Expr<any>;
-    visitNestedObjectChainInner: (ctx: NestedObjectChainInnerContext) => Expr<any>;
-    visitNestedObjectChainEnd: (ctx: NestedObjectChainEndContext) => Expr<any>;
-    private stripBrackets;
+    private readonly methodCallTargetStack;
+    private readonly typeManager;
+    constructor(typeManager: TypeManager);
+    visitExpr: (ctx: ExprContext) => Expr<any>;
+    visitVariableRef: (ctx: VariableRefContext) => Expr<any>;
+    visitSEComparison: (ctx: SEComparisonContext) => Expr<any>;
+    visitSEMethodCall: (ctx: SEMethodCallContext) => Expr<any>;
+    visitSELiteral: (ctx: SELiteralContext) => Expr<any>;
+    visitSEVariableRef: (ctx: SEVariableRefContext) => Expr<any>;
+    visitSEArrayExpr: (ctx: SEArrayExprContext) => Expr<any>;
+    visitSEFunctionCall: (ctx: SEFunctionCallContext) => Expr<any>;
+    visitSEParenthesis: (ctx: SEParenthesisContext) => Expr<any>;
+    visitMethodCallChainInner: (ctx: MethodCallChainInnerContext) => Expr<any>;
+    visitMethodCallChainEnd: (ctx: MethodCallChainEndContext) => Expr<any>;
+    visitSEAddSub: (ctx: SEAddSubContext) => Expr<any>;
+    private makePlusExpr;
+    visitSEMulDiv: (ctx: SEMulDivContext) => Expr<any>;
     visitStringLiteral: (ctx: StringLiteralContext) => Expr<any>;
-    visitStringAttributeRef: (ctx: StringAttributeRefContext) => Expr<any>;
-    visitStringConcat: (ctx: StringConcatContext) => Expr<any>;
-    visitNumAttributeRef: (ctx: NumAttributeRefContext) => Expr<any>;
     visitNumLiteral: (ctx: NumLiteralContext) => Expr<any>;
-    visitNumAddSub: (ctx: NumAddSubContext) => Expr<any>;
-    visitNumMulDiv: (ctx: NumMulDivContext) => Expr<any>;
-    visitNumParens: (ctx: NumParensContext) => Expr<any>;
-    visitExpr: (ctx: ExprContext) => Expr<any>;
-    visitNumLit: (ctx: NumLitContext) => Expr<any>;
-    visitArray: (ctx: ArrayContext) => Expr<any>;
+    visitSEUnaryMultipleMinus: (ctx: SEUnaryMultipleMinusContext) => Expr<any>;
+    visitSEPower: (ctx: SEPowerContext) => Expr<any>;
+    visitSEUnaryMinus: (ctx: SEUnaryMinusContext) => Expr<any>;
+    visitSEBooleanBinaryOp: (ctx: SEBooleanBinaryOpContext) => Expr<any>;
+    visitBooleanLiteral: (ctx: BooleanLiteralContext) => Expr<any>;
+    visitSENot: (ctx: SENotContext) => Expr<any>;
+    visitArrayExpr: (ctx: ArrayExprContext) => Expr<any>;
     collectArrayElements: (ctx: ArrayElementListContext) => Array<Expr<any>>;
     visitFunctionCall: (ctx: FunctionCallContext) => Expr<any>;
-    collectFunctionArguments: (ctx: ExprListContext) => Array<Expr<any>>;
-    private failNode;
+    collectFunctionArguments: (ctx: ExprListContext, resultSoFar?: Array<Expr<any>>) => Array<Expr<any>>;
+    private static failNode;
+    visitLiteral: (ctx: LiteralContext) => Expr<any>;
 }

package/dist/IfcExpression.d.ts

@@ -1,4 +1,4 @@
-import { ErrorListener, Token } from "antlr4";
+import { ErrorListener, ParserRuleContext, Token } from "antlr4";
 import { ExprVisitor } from "./ExprVisitor.js";
 import { IfcExpressionErrorListener } from "./IfcExpressionErrorListener.js";
 import { isNullish, isPresent } from "./IfcExpressionUtils.js";
@@ -10,25 +10,31 @@ import { StringValue } from "./value/StringValue.js";
 import { NumericValue } from "./value/NumericValue.js";
 import { BooleanValue } from "./value/BooleanValue.js";
 import { LogicalValue } from "./value/LogicalValue.js";
-import { LiteralValue } from "./value/LiteralValue.js";
 import { ReferenceValue } from "./value/ReferenceValue.js";
 import { IfcPropertySetAccessor } from "./context/IfcPropertySetAccessor.js";
 import { IfcPropertyAccessor } from "./context/IfcPropertyAccessor.js";
 import { IfcRootObjectAccessor } from "./context/IfcRootObjectAccessor.js";
 import { IfcTypeObjectAccessor } from "./context/IfcTypeObjectAccessor.js";
 import { NamedObjectAccessor } from "./context/NamedObjectAccessor.js";
-import { ExprContext } from "./gen/parser/IfcExpressionParser.js";
 import IfcExpressionVisitor from "./gen/parser/IfcExpressionVisitor.js";
 import { ObjectAccessor } from "./context/ObjectAccessor.js";
 import { IfcExpressionEvaluationException } from "./expression/IfcExpressionEvaluationException.js";
-import type { LiteralValueAnyArity } from "./value/LiteralValueAnyArity.js";
-import type { PrimitiveValueType } from "./value/PrimitiveValueType.js";
-import { ExprEvalResult, isExprEvalSuccess, ExprEvalError, isExprEvalError } from "./expression/ExprEvalResult.js";
+import type { ExpressionValue } from "./value/ExpressionValue.js";
+import type { BoxedValueTypes } from "./value/BoxedValueTypes.js";
+import { ExprEvalError, ExprEvalResult, isExprEvalError, isExprEvalSuccess } from "./expression/ExprEvalResult.js";
 import { ExprKind } from "./expression/ExprKind.js";
-export { IfcElementAccessor, IfcExpressionContext, Value, StringValue, BooleanValue, LogicalValue, NumericValue, LiteralValue, ReferenceValue, IfcPropertySetAccessor, IfcPropertyAccessor, IfcRootObjectAccessor, IfcTypeObjectAccessor, NamedObjectAccessor, ObjectAccessor, Expr, ExprVisitor, ExprKind, IfcExpressionEvaluationException, IfcExpressionErrorListener, IfcExpressionVisitor, isPresent, isNullish, ExprEvalResult, ExprEvalError, isExprEvalError, isExprEvalSuccess, };
-export type { PrimitiveValueType, LiteralValueAnyArity };
+import { TypeManager } from "./type/TypeManager.js";
+export { IfcElementAccessor, IfcExpressionContext, Value, StringValue, BooleanValue, LogicalValue, NumericValue, ExpressionValue, ReferenceValue, IfcPropertySetAccessor, IfcPropertyAccessor, IfcRootObjectAccessor, IfcTypeObjectAccessor, NamedObjectAccessor, ObjectAccessor, Expr, ExprVisitor, ExprKind, IfcExpressionEvaluationException, IfcExpressionErrorListener, IfcExpressionVisitor, isPresent, isNullish, ExprEvalResult, ExprEvalError, isExprEvalError, isExprEvalSuccess, };
+export type { BoxedValueTypes };
+export declare class IfcExpressionParseResult {
+    private readonly _typeManager;
+    private readonly _parseTree;
+    constructor(typeManager: TypeManager, exprContext: any);
+    get typeManager(): TypeManager;
+    get parseTree(): ParserRuleContext;
+}
 export declare class IfcExpression {
-    static parse(input: string, errorListener?: ErrorListener<Token>): ExprContext;
-    static evaluate(expression: string, context: IfcExpressionContext): ExprEvalResult<any>;
-    private static extractExprTree;
+    static parse(input: string, errorListener?: ErrorListener<Token | number>): IfcExpressionParseResult;
+    private static compile;
+    static evaluate(expression: string, context?: IfcExpressionContext): ExprEvalResult<ExpressionValue>;
 }

package/dist/IfcExpressionErrorListener.d.ts

@@ -1,8 +1,10 @@
 import { ErrorListener, RecognitionException, Recognizer, Token } from "antlr4";
-import { SyntaxErrorException } from "./SyntaxErrorException.js";
-export declare class IfcExpressionErrorListener extends ErrorListener<Token> {
+import { SyntaxErrorException } from "./error/SyntaxErrorException.js";
+import { ValidationException } from "./error/ValidationException.js";
+export declare class IfcExpressionErrorListener extends ErrorListener<Token | number> {
     private exception;
-    syntaxError(recognizer: Recognizer<Token>, offendingSymbol: Token, line: number, column: number, msg: string, e: RecognitionException | undefined): void;
+    validationException(validationException: ValidationException): void;
+    syntaxError(recognizer: Recognizer<Token | number>, offendingSymbol: Token | number, line: number, column: number, msg: string, e: RecognitionException | undefined): void;
     isErrorOccurred(): boolean;
-    getException(): SyntaxErrorException;
+    getException(): SyntaxErrorException | ValidationException;
 }

package/dist/IfcExpressionUtils.d.ts

@@ -1,2 +1,3 @@
 export declare function isNullish(val: any): boolean;
 export declare function isPresent(val: any): boolean;
+export declare function isFunction(val: any): boolean;

package/dist/IfcExpressionValidationListener.d.ts

@@ -0,0 +1,41 @@
+import IfcExpressionListener from "./gen/parser/IfcExpressionListener.js";
+import { ArrayElementListContext, ArrayExprContext, BooleanLiteralContext, ExprContext, ExprListContext, FunctionCallContext, LiteralContext, MethodCallChainEndContext, MethodCallChainInnerContext, NumLiteralContext, SEAddSubContext, SEArrayExprContext, SEBooleanBinaryOpContext, SEComparisonContext, SEFunctionCallContext, SELiteralContext, SEMethodCallContext, SEMulDivContext, SENotContext, SEParenthesisContext, SEPowerContext, SEUnaryMinusContext, SEUnaryMultipleMinusContext, SEVariableRefContext, StringLiteralContext, VariableRefContext } from "./gen/parser/IfcExpressionParser.js";
+import { TypeManager } from "./type/TypeManager.js";
+export declare class IfcExpressionValidationListener extends IfcExpressionListener {
+    private readonly typeManager;
+    private methodCallTargetStack;
+    constructor();
+    getTypeManager(): TypeManager;
+    enterFunctionCall: (ctx: FunctionCallContext) => void;
+    enterSEUnaryMultipleMinus: (ctx: SEUnaryMultipleMinusContext) => void;
+    exitSEBooleanBinaryOp: (ctx: SEBooleanBinaryOpContext) => void;
+    exitSEComparison: (ctx: SEComparisonContext) => void;
+    exitSEParenthesis: (ctx: SEParenthesisContext) => void;
+    exitSELiteral: (ctx: SELiteralContext) => void;
+    exitLiteral: (ctx: LiteralContext) => void;
+    exitNumLiteral: (ctx: NumLiteralContext) => void;
+    exitStringLiteral: (ctx: StringLiteralContext) => void;
+    exitBooleanLiteral: (ctx: BooleanLiteralContext) => void;
+    exitExpr: (ctx: ExprContext) => void;
+    exitSEMulDiv: (ctx: SEMulDivContext) => void;
+    exitSEPower: (ctx: SEPowerContext) => void;
+    exitSEFunctionCall: (ctx: SEFunctionCallContext) => void;
+    exitSEArrayExpr: (ctx: SEArrayExprContext) => void;
+    exitSENot: (ctx: SENotContext) => void;
+    exitSEVariableRef: (ctx: SEVariableRefContext) => void;
+    exitSEUnaryMinus: (ctx: SEUnaryMinusContext) => void;
+    exitSEAddSub: (ctx: SEAddSubContext) => void;
+    exitSEMethodCall: (ctx: SEMethodCallContext) => void;
+    enterMethodCallChainInner: (ctx: MethodCallChainInnerContext) => void;
+    exitMethodCallChainInner: (ctx: MethodCallChainInnerContext) => void;
+    enterMethodCallChainEnd: (ctx: MethodCallChainEndContext) => void;
+    private pushMethodCallTarget;
+    exitMethodCallChainEnd: (ctx: MethodCallChainEndContext) => void;
+    exitFunctionCall: (ctx: FunctionCallContext) => void;
+    private collectArgumentTypes;
+    exitExprList: (ctx: ExprListContext) => void;
+    exitArrayExpr: (ctx: ArrayExprContext) => void;
+    private collectArrayElementTypes;
+    exitArrayElementList: (ctx: ArrayElementListContext) => void;
+    exitVariableRef: (ctx: VariableRefContext) => void;
+}

package/dist/cjs/E.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.E = void 0;
+const ArrayExpr_js_1 = require("./expression/structure/ArrayExpr.js");
+const StringConcatExpr_js_1 = require("./expression/string/StringConcatExpr.js");
+const StringLiteralExpr_js_1 = require("./expression/string/StringLiteralExpr.js");
+const ElemObjectReferenceExpr_js_1 = require("./expression/reference/ElemObjectReferenceExpr.js");
+const PropObjectReferenceExpr_js_1 = require("./expression/reference/PropObjectReferenceExpr.js");
+const DivideExpr_js_1 = require("./expression/numeric/DivideExpr.js");
+const MinusExpr_js_1 = require("./expression/numeric/MinusExpr.js");
+const MultiplyExpr_js_1 = require("./expression/numeric/MultiplyExpr.js");
+const PlusExpr_js_1 = require("./expression/numeric/PlusExpr.js");
+const NumericLiteralExpr_js_1 = require("./expression/numeric/NumericLiteralExpr.js");
+const ParenthesisExpr_js_1 = require("./expression/structure/ParenthesisExpr.js");
+const PowerExpr_js_1 = require("./expression/numeric/PowerExpr.js");
+const UnaryMinusExpr_js_1 = require("./expression/numeric/UnaryMinusExpr.js");
+const FunctionExpr_js_1 = require("./expression/function/FunctionExpr.js");
+const AndExpr_js_1 = require("./expression/boolean/AndExpr.js");
+const OrExpr_js_1 = require("./expression/boolean/OrExpr.js");
+const XorExpr_js_1 = require("./expression/boolean/XorExpr.js");
+const BooleanLiteralExpr_js_1 = require("./expression/boolean/BooleanLiteralExpr.js");
+const NotExpr_js_1 = require("./expression/boolean/NotExpr.js");
+class E {
+    static array(...elements) {
+        return new ArrayExpr_js_1.ArrayExpr(elements);
+    }
+    static concat(left, right) {
+        return new StringConcatExpr_js_1.StringConcatExpr(left, right);
+    }
+    static string(literal) {
+        return new StringLiteralExpr_js_1.StringLiteralExpr(literal);
+    }
+    static element() {
+        return new ElemObjectReferenceExpr_js_1.ElemObjectReferenceExpr();
+    }
+    static property() {
+        return new PropObjectReferenceExpr_js_1.PropObjectReferenceExpr();
+    }
+    static div(left, right) {
+        return new DivideExpr_js_1.DivideExpr(left, right);
+    }
+    static minus(left, right) {
+        return new MinusExpr_js_1.MinusExpr(left, right);
+    }
+    static multiply(left, right) {
+        return new MultiplyExpr_js_1.MultiplyExpr(left, right);
+    }
+    static plus(left, right) {
+        return new PlusExpr_js_1.PlusExpr(left, right);
+    }
+    static number(literal) {
+        return new NumericLiteralExpr_js_1.NumericLiteralExpr(literal);
+    }
+    static parenthesis(numericExpression) {
+        return new ParenthesisExpr_js_1.ParenthesisExpr(numericExpression);
+    }
+    static power(base, power) {
+        return new PowerExpr_js_1.PowerExpr(base, power);
+    }
+    static unaryMinus(numExpr) {
+        return new UnaryMinusExpr_js_1.UnaryMinusExpr(numExpr);
+    }
+    static fun(functionName, ...funcArgs) {
+        return new FunctionExpr_js_1.FunctionExpr(functionName, funcArgs);
+    }
+    static and(left, right) {
+        return new AndExpr_js_1.AndExpr(left, right);
+    }
+    static or(left, right) {
+        return new OrExpr_js_1.OrExpr(left, right);
+    }
+    static xor(left, right) {
+        return new XorExpr_js_1.XorExpr(left, right);
+    }
+    static boolean(literal) {
+        return new BooleanLiteralExpr_js_1.BooleanLiteralExpr(literal);
+    }
+    static not(booleanExpr) {
+        return new NotExpr_js_1.NotExpr(booleanExpr);
+    }
+}
+exports.E = E;
+//# sourceMappingURL=E.js.map

package/dist/cjs/E.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/E.ts"],"names":[],"mappings":"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","file":"E.js","sourcesContent":["import { ArrayExpr } from \"./expression/structure/ArrayExpr.js\";\nimport { Expr } from \"./expression/Expr.js\";\nimport { StringConcatExpr } from \"./expression/string/StringConcatExpr.js\";\nimport { StringLiteralExpr } from \"./expression/string/StringLiteralExpr.js\";\nimport { ElemObjectReferenceExpr } from \"./expression/reference/ElemObjectReferenceExpr.js\";\nimport { PropObjectReferenceExpr } from \"./expression/reference/PropObjectReferenceExpr.js\";\nimport { NumericValue } from \"./value/NumericValue.js\";\nimport { DivideExpr } from \"./expression/numeric/DivideExpr.js\";\nimport { StringValue } from \"./value/StringValue.js\";\nimport { MinusExpr } from \"./expression/numeric/MinusExpr.js\";\nimport { MultiplyExpr } from \"./expression/numeric/MultiplyExpr.js\";\nimport { PlusExpr } from \"./expression/numeric/PlusExpr.js\";\nimport { NumericLiteralExpr } from \"./expression/numeric/NumericLiteralExpr.js\";\nimport { Decimal } from \"decimal.js\";\nimport { ParenthesisExpr } from \"./expression/structure/ParenthesisExpr.js\";\nimport { PowerExpr } from \"./expression/numeric/PowerExpr.js\";\nimport { UnaryMinusExpr } from \"./expression/numeric/UnaryMinusExpr.js\";\nimport { FunctionExpr } from \"./expression/function/FunctionExpr.js\";\nimport { BooleanValue } from \"./value/BooleanValue.js\";\nimport { AndExpr } from \"./expression/boolean/AndExpr.js\";\nimport { OrExpr } from \"./expression/boolean/OrExpr.js\";\nimport { XorExpr } from \"./expression/boolean/XorExpr.js\";\nimport { BooleanLiteralExpr } from \"./expression/boolean/BooleanLiteralExpr.js\";\nimport { NotExpr } from \"./expression/boolean/NotExpr.js\";\n\nexport class E {\n  public static array(...elements: Array<Expr<any>>): ArrayExpr {\n    return new ArrayExpr(elements);\n  }\n  public static concat(\n    left: Expr<StringValue>,\n    right: Expr<StringValue>\n  ): StringConcatExpr {\n    return new StringConcatExpr(left, right);\n  }\n  public static string(literal: string): StringLiteralExpr {\n    return new StringLiteralExpr(literal);\n  }\n  public static element() {\n    return new ElemObjectReferenceExpr();\n  }\n  public static property() {\n    return new PropObjectReferenceExpr();\n  }\n  public static div(\n    left: Expr<NumericValue>,\n    right: Expr<NumericValue>\n  ): DivideExpr {\n    return new DivideExpr(left, right);\n  }\n  public static minus(\n    left: Expr<NumericValue>,\n    right: Expr<NumericValue>\n  ): MinusExpr {\n    return new MinusExpr(left, right);\n  }\n  public static multiply(\n    left: Expr<NumericValue>,\n    right: Expr<NumericValue>\n  ): MultiplyExpr {\n    return new MultiplyExpr(left, right);\n  }\n  public static plus(\n    left: Expr<NumericValue>,\n    right: Expr<NumericValue>\n  ): PlusExpr {\n    return new PlusExpr(left, right);\n  }\n  public static number(literal: number | string | Decimal): NumericLiteralExpr {\n    return new NumericLiteralExpr(literal);\n  }\n  public static parenthesis(\n    numericExpression: Expr<NumericValue>\n  ): ParenthesisExpr {\n    return new ParenthesisExpr(numericExpression);\n  }\n  public static power(\n    base: Expr<NumericValue>,\n    power: Expr<NumericValue>\n  ): PowerExpr {\n    return new PowerExpr(base, power);\n  }\n  public static unaryMinus(numExpr: Expr<NumericValue>): UnaryMinusExpr {\n    return new UnaryMinusExpr(numExpr);\n  }\n  public static fun(\n    functionName: string,\n    ...funcArgs: Array<Expr<any>>\n  ): FunctionExpr {\n    return new FunctionExpr(functionName, funcArgs);\n  }\n  public static and(\n    left: Expr<BooleanValue>,\n    right: Expr<BooleanValue>\n  ): AndExpr {\n    return new AndExpr(left, right);\n  }\n  public static or(\n    left: Expr<BooleanValue>,\n    right: Expr<BooleanValue>\n  ): OrExpr {\n    return new OrExpr(left, right);\n  }\n  public static xor(\n    left: Expr<BooleanValue>,\n    right: Expr<BooleanValue>\n  ): XorExpr {\n    return new XorExpr(left, right);\n  }\n  public static boolean(literal: boolean) {\n    return new BooleanLiteralExpr(literal);\n  }\n  public static not(booleanExpr: Expr<BooleanValue>): NotExpr {\n    return new NotExpr(booleanExpr);\n  }\n}\n"]}