@fincity/kirun-js 2.8.6 → 2.10.0

package/src/engine/repository/KIRunFunctionRepository.ts

@@ -19,51 +19,59 @@ import { Wait } from '../function/system/Wait';
 import { HybridRepository } from '../HybridRepository';
 import { Namespaces } from '../namespaces/Namespaces';
 import mapEntry from '../util/mapEntry';
+import { Repository } from '../Repository';
 
-const map: Map<string, Map<string, Function>> = new Map([
-    [
-        Namespaces.SYSTEM_CTX,
-        new Map([mapEntry(new Create()), mapEntry(new Get()), mapEntry(new SetFunction())]),
-    ],
-    [
-        Namespaces.SYSTEM_LOOP,
-        new Map([
-            mapEntry(new RangeLoop()),
-            mapEntry(new CountLoop()),
-            mapEntry(new Break()),
-            mapEntry(new ForEachLoop()),
-        ]),
-    ],
-    [
-        Namespaces.SYSTEM,
-        new Map([
-            mapEntry(new If()),
-            mapEntry(new GenerateEvent()),
-            mapEntry(new Print()),
-            mapEntry(new Wait()),
-            mapEntry(new Join()),
-        ]),
-    ],
-]);
+class SystemFunctionRepository implements Repository<Function> {
+    private readonly map: Map<string, Map<string, Function>>;
+    private readonly filterableNames: string[];
 
-const filterableNames = Array.from(map.values())
-    .flatMap((e) => Array.from(e.values()))
-    .map((e) => e.getSignature().getFullName());
+    public constructor() {
+        this.map = new Map([
+            [
+                Namespaces.SYSTEM_CTX,
+                new Map([mapEntry(new Create()), mapEntry(new Get()), mapEntry(new SetFunction())]),
+            ],
+            [
+                Namespaces.SYSTEM_LOOP,
+                new Map([
+                    mapEntry(new RangeLoop()),
+                    mapEntry(new CountLoop()),
+                    mapEntry(new Break()),
+                    mapEntry(new ForEachLoop()),
+                ]),
+            ],
+            [
+                Namespaces.SYSTEM,
+                new Map([
+                    mapEntry(new If()),
+                    mapEntry(new GenerateEvent()),
+                    mapEntry(new Print()),
+                    mapEntry(new Wait()),
+                    mapEntry(new Join()),
+                ]),
+            ],
+        ]);
+
+        this.filterableNames = Array.from(this.map.values())
+            .flatMap((e) => Array.from(e.values()))
+            .map((e) => e.getSignature().getFullName());
+    }
+
+    async find(namespace: string, name: string): Promise<Function | undefined> {
+        return this.map.get(namespace)?.get(name);
+    }
+
+    async filter(name: string): Promise<string[]> {
+        return Array.from(this.filterableNames).filter(
+            (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
+        );
+    }
+}
 
 export class KIRunFunctionRepository extends HybridRepository<Function> {
     public constructor() {
         super(
-            {
-                async find(namespace: string, name: string): Promise<Function | undefined> {
-                    return map.get(namespace)?.get(name);
-                },
-
-                async filter(name: string): Promise<string[]> {
-                    return Array.from(filterableNames).filter(
-                        (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
-                    );
-                },
-            },
+            new SystemFunctionRepository(),
             new MathFunctionRepository(),
             new StringFunctionRepository(),
             new ArrayFunctionRepository(),

package/src/engine/repository/KIRunSchemaRepository.ts

@@ -4,86 +4,91 @@ import { Namespaces } from '../namespaces/Namespaces';
 import { Repository } from '../Repository';
 import { MapUtil } from '../util/MapUtil';
 
-const map: Map<string, Schema> = new Map([
-    ['any', Schema.ofAny('any').setNamespace(Namespaces.SYSTEM)],
-    ['boolean', Schema.ofBoolean('boolean').setNamespace(Namespaces.SYSTEM)],
-    ['double', Schema.ofDouble('double').setNamespace(Namespaces.SYSTEM)],
-    ['float', Schema.ofFloat('float').setNamespace(Namespaces.SYSTEM)],
-    ['integer', Schema.ofInteger('integer').setNamespace(Namespaces.SYSTEM)],
-    ['long', Schema.ofLong('long').setNamespace(Namespaces.SYSTEM)],
-    ['number', Schema.ofNumber('number').setNamespace(Namespaces.SYSTEM)],
-    ['string', Schema.ofString('string').setNamespace(Namespaces.SYSTEM)],
-    ['Timestamp', Schema.ofString('Timestamp').setNamespace(Namespaces.DATE)],
-    [
-        'Timeunit',
-        Schema.ofString('Timeunit')
-            .setNamespace(Namespaces.DATE)
-            .setEnums([
-                'YEARS',
-                'QUARTERS',
-                'MONTHS',
-                'WEEKS',
-                'DAYS',
-                'HOURS',
-                'MINUTES',
-                'SECONDS',
-                'MILLISECONDS',
-            ]),
-    ],
-    [
-        'Duration',
-        Schema.ofObject('Duration')
-            .setNamespace(Namespaces.DATE)
-            .setProperties(
-                MapUtil.ofArrayEntries(
-                    ['years', Schema.ofNumber('years')],
-                    ['quarters', Schema.ofNumber('quarters')],
-                    ['months', Schema.ofNumber('months')],
-                    ['weeks', Schema.ofNumber('weeks')],
-                    ['days', Schema.ofNumber('days')],
-                    ['hours', Schema.ofNumber('hours')],
-                    ['minutes', Schema.ofNumber('minutes')],
-                    ['seconds', Schema.ofNumber('seconds')],
-                    ['milliseconds', Schema.ofNumber('milliseconds')],
-                ),
-            )
-            .setAdditionalItems(AdditionalType.from(false)!),
-    ],
-    [
-        'TimeObject',
-        Schema.ofObject('TimeObject')
-            .setNamespace(Namespaces.DATE)
-            .setProperties(
-                MapUtil.ofArrayEntries(
-                    ['year', Schema.ofNumber('year')],
-                    ['month', Schema.ofNumber('month')],
-                    ['day', Schema.ofNumber('day')],
-                    ['hour', Schema.ofNumber('hour')],
-                    ['minute', Schema.ofNumber('minute')],
-                    ['second', Schema.ofNumber('second')],
-                    ['millisecond', Schema.ofNumber('millisecond')],
-                ),
-            )
-            .setAdditionalItems(AdditionalType.from(false)!),
-    ],
-    [Parameter.EXPRESSION.getName()!, Parameter.EXPRESSION],
-    [Schema.NULL.getName()!, Schema.NULL],
-    [Schema.SCHEMA.getName()!, Schema.SCHEMA],
-]);
+export class KIRunSchemaRepository implements Repository<Schema> {
+    private readonly map: Map<string, Schema>;
+    private readonly filterableNames: string[];
 
-const filterableNames = Array.from(map.values()).map((e) => e.getFullName());
+    public constructor() {
+        this.map = new Map([
+            ['any', Schema.ofAny('any').setNamespace(Namespaces.SYSTEM)],
+            ['boolean', Schema.ofBoolean('boolean').setNamespace(Namespaces.SYSTEM)],
+            ['double', Schema.ofDouble('double').setNamespace(Namespaces.SYSTEM)],
+            ['float', Schema.ofFloat('float').setNamespace(Namespaces.SYSTEM)],
+            ['integer', Schema.ofInteger('integer').setNamespace(Namespaces.SYSTEM)],
+            ['long', Schema.ofLong('long').setNamespace(Namespaces.SYSTEM)],
+            ['number', Schema.ofNumber('number').setNamespace(Namespaces.SYSTEM)],
+            ['string', Schema.ofString('string').setNamespace(Namespaces.SYSTEM)],
+            ['Timestamp', Schema.ofString('Timestamp').setNamespace(Namespaces.DATE)],
+            [
+                'Timeunit',
+                Schema.ofString('Timeunit')
+                    .setNamespace(Namespaces.DATE)
+                    .setEnums([
+                        'YEARS',
+                        'QUARTERS',
+                        'MONTHS',
+                        'WEEKS',
+                        'DAYS',
+                        'HOURS',
+                        'MINUTES',
+                        'SECONDS',
+                        'MILLISECONDS',
+                    ]),
+            ],
+            [
+                'Duration',
+                Schema.ofObject('Duration')
+                    .setNamespace(Namespaces.DATE)
+                    .setProperties(
+                        MapUtil.ofArrayEntries(
+                            ['years', Schema.ofNumber('years')],
+                            ['quarters', Schema.ofNumber('quarters')],
+                            ['months', Schema.ofNumber('months')],
+                            ['weeks', Schema.ofNumber('weeks')],
+                            ['days', Schema.ofNumber('days')],
+                            ['hours', Schema.ofNumber('hours')],
+                            ['minutes', Schema.ofNumber('minutes')],
+                            ['seconds', Schema.ofNumber('seconds')],
+                            ['milliseconds', Schema.ofNumber('milliseconds')],
+                        ),
+                    )
+                    .setAdditionalItems(AdditionalType.from(false)!),
+            ],
+            [
+                'TimeObject',
+                Schema.ofObject('TimeObject')
+                    .setNamespace(Namespaces.DATE)
+                    .setProperties(
+                        MapUtil.ofArrayEntries(
+                            ['year', Schema.ofNumber('year')],
+                            ['month', Schema.ofNumber('month')],
+                            ['day', Schema.ofNumber('day')],
+                            ['hour', Schema.ofNumber('hour')],
+                            ['minute', Schema.ofNumber('minute')],
+                            ['second', Schema.ofNumber('second')],
+                            ['millisecond', Schema.ofNumber('millisecond')],
+                        ),
+                    )
+                    .setAdditionalItems(AdditionalType.from(false)!),
+            ],
+            [Parameter.EXPRESSION.getName()!, Parameter.EXPRESSION],
+            [Schema.NULL.getName()!, Schema.NULL],
+            [Schema.SCHEMA.getName()!, Schema.SCHEMA],
+        ]);
+
+        this.filterableNames = Array.from(this.map.values()).map((e) => e.getFullName());
+    }
 
-export class KIRunSchemaRepository implements Repository<Schema> {
     public async find(namespace: string, name: string): Promise<Schema | undefined> {
         if (Namespaces.SYSTEM != namespace && Namespaces.DATE != namespace)
             return Promise.resolve(undefined);
 
-        return Promise.resolve(map.get(name));
+        return Promise.resolve(this.map.get(name));
     }
 
     public async filter(name: string): Promise<string[]> {
         return Promise.resolve(
-            filterableNames.filter((e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1),
+            this.filterableNames.filter((e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1),
         );
     }
 }

package/src/engine/runtime/expression/Expression.ts

@@ -21,10 +21,21 @@ export class Expression extends ExpressionToken {
         op?: Operation,
     ) {
         super(expression ? expression : '');
+        if (op?.getOperator() == '..') {
+            if (!l) l = new ExpressionTokenValue('', '');
+            else if (!r) r = new ExpressionTokenValue('', '');
+        }
         if (l) this.tokens.push(l);
         if (r) this.tokens.push(r);
         if (op) this.ops.push(op);
         this.evaluate();
+        if (
+            !this.ops.isEmpty() &&
+            this.ops.peekLast().getOperator() == '..' &&
+            this.tokens.length == 1
+        ) {
+            this.tokens.push(new ExpressionToken(''));
+        }
     }
 
     public getTokens(): LinkedList<ExpressionToken> {
@@ -198,6 +209,9 @@ export class Expression extends ExpressionToken {
                 if (!StringUtil.isNullOrBlank(buff)) {
                     this.tokens.push(new ExpressionToken(buff));
                     isPrevOp = false;
+                } else if (op == '..' && this.tokens.isEmpty()) {
+                    this.tokens.push(new ExpressionToken('0'));
+                    isPrevOp = false;
                 }
                 this.checkUnaryOperator(
                     this.tokens,
@@ -465,7 +479,7 @@ export class Expression extends ExpressionToken {
                         0,
                         temp instanceof Expression
                             ? (temp as Expression).toString()
-                            : temp.toString(),
+                            : temp?.toString(),
                     )
                     .insert(0, '(')
                     .append(')');

package/src/engine/runtime/expression/ExpressionEvaluator.ts

@@ -2,41 +2,45 @@ import { ExecutionException } from '../../exception/ExecutionException';
 import { LinkedList } from '../../util/LinkedList';
 import { StringBuilder } from '../../util/string/StringBuilder';
 import { StringFormatter } from '../../util/string/StringFormatter';
-import { FunctionExecutionParameters } from '../FunctionExecutionParameters';
 import { ExpressionEvaluationException } from './exception/ExpressionEvaluationException';
 import { Expression } from './Expression';
 import { ExpressionToken } from './ExpressionToken';
 import { ExpressionTokenValue } from './ExpressionTokenValue';
 import { Operation } from './Operation';
-import { LogicalNullishCoalescingOperator } from './operators/binary/LogicalNullishCoalescingOperator';
-import { ArithmeticAdditionOperator } from './operators/binary/ArithmeticAdditionOperator';
-import { ArithmeticDivisionOperator } from './operators/binary/ArithmeticDivisionOperator';
-import { ArithmeticIntegerDivisionOperator } from './operators/binary/ArithmeticInetgerDivisionOperator';
-import { ArithmeticModulusOperator } from './operators/binary/ArithmeticModulusOperator';
-import { ArithmeticMultiplicationOperator } from './operators/binary/ArithmeticMultiplicationOperator';
-import { ArithmeticSubtractionOperator } from './operators/binary/ArithmeticSubtractionOperator';
-import { ArrayOperator } from './operators/binary/ArrayOperator';
-import { BinaryOperator } from './operators/binary/BinaryOperator';
-import { BitwiseAndOperator } from './operators/binary/BitwiseAndOperator';
-import { BitwiseLeftShiftOperator } from './operators/binary/BitwiseLeftShiftOperator';
-import { BitwiseOrOperator } from './operators/binary/BitwiseOrOperator';
-import { BitwiseRightShiftOperator } from './operators/binary/BitwiseRightShiftOperator';
-import { BitwiseUnsignedRightShiftOperator } from './operators/binary/BitwiseUnsignedRightShiftOperator';
-import { BitwiseXorOperator } from './operators/binary/BitwiseXorOperator';
-import { LogicalAndOperator } from './operators/binary/LogicalAndOperator';
-import { LogicalEqualOperator } from './operators/binary/LogicalEqualOperator';
-import { LogicalGreaterThanEqualOperator } from './operators/binary/LogicalGreaterThanEqualOperator';
-import { LogicalGreaterThanOperator } from './operators/binary/LogicalGreaterThanOperator';
-import { LogicalLessThanEqualOperator } from './operators/binary/LogicalLessThanEqualOperator';
-import { LogicalLessThanOperator } from './operators/binary/LogicalLessThanOperator';
-import { LogicalNotEqualOperator } from './operators/binary/LogicalNotEqualOperator';
-import { LogicalOrOperator } from './operators/binary/LogicalOrOperator';
-import { ObjectOperator } from './operators/binary/ObjectOperator';
-import { ArithmeticUnaryMinusOperator } from './operators/unary/ArithmeticUnaryMinusOperator';
-import { ArithmeticUnaryPlusOperator } from './operators/unary/ArithmeticUnaryPlusOperator';
-import { BitwiseComplementOperator } from './operators/unary/BitwiseComplementOperator';
-import { LogicalNotOperator } from './operators/unary/LogicalNotOperator';
-import { UnaryOperator } from './operators/unary/UnaryOperator';
+import { LogicalNullishCoalescingOperator } from './operators/binary';
+import {
+    ArithmeticAdditionOperator,
+    ArithmeticDivisionOperator,
+    ArithmeticIntegerDivisionOperator,
+    ArithmeticModulusOperator,
+    ArithmeticMultiplicationOperator,
+    ArithmeticSubtractionOperator,
+    ArrayOperator,
+    ArrayRangeOperator,
+    BinaryOperator,
+    BitwiseAndOperator,
+    BitwiseLeftShiftOperator,
+    BitwiseOrOperator,
+    BitwiseRightShiftOperator,
+    BitwiseUnsignedRightShiftOperator,
+    BitwiseXorOperator,
+    LogicalAndOperator,
+    LogicalEqualOperator,
+    LogicalGreaterThanEqualOperator,
+    LogicalGreaterThanOperator,
+    LogicalLessThanEqualOperator,
+    LogicalLessThanOperator,
+    LogicalNotEqualOperator,
+    LogicalOrOperator,
+    ObjectOperator,
+} from './operators/binary/';
+import {
+    ArithmeticUnaryMinusOperator,
+    ArithmeticUnaryPlusOperator,
+    BitwiseComplementOperator,
+    LogicalNotOperator,
+    UnaryOperator,
+} from './operators/unary';
 import { LiteralTokenValueExtractor } from './tokenextractor/LiteralTokenValueExtractor';
 import { TokenValueExtractor } from './tokenextractor/TokenValueExtractor';
 import { Tuple2 } from '../../util/Tuples';
@@ -82,6 +86,7 @@ export class ExpressionEvaluator {
         [Operation.NULLISH_COALESCING_OPERATOR, new LogicalNullishCoalescingOperator()],
 
         [Operation.ARRAY_OPERATOR, new ArrayOperator()],
+        [Operation.ARRAY_RANGE_INDEX_OPERATOR, new ArrayRangeOperator()],
         [Operation.OBJECT_OPERATOR, new ObjectOperator()],
     ]);
 
@@ -315,7 +320,7 @@ export class ExpressionEvaluator {
         if (key.length > 2 && valuesMap.has(key))
             tokens.push(new ExpressionTokenValue(str, this.getValue(str, valuesMap)));
         else {
-            let v: any = undefined;
+            let v: any;
             try {
                 v = LiteralTokenValueExtractor.INSTANCE.getValue(str);
             } catch (err) {

package/src/engine/runtime/expression/Operation.ts

@@ -30,6 +30,7 @@ export class Operation {
     public static readonly UNARY_BITWISE_COMPLEMENT: Operation = new Operation('UN: ~', '~');
 
     public static readonly ARRAY_OPERATOR: Operation = new Operation('[');
+    public static readonly ARRAY_RANGE_INDEX_OPERATOR: Operation = new Operation('..');
     public static readonly OBJECT_OPERATOR: Operation = new Operation('.');
 
     public static readonly NULLISH_COALESCING_OPERATOR: Operation = new Operation('??');
@@ -39,7 +40,7 @@ export class Operation {
     private static readonly VALUE_OF: Map<string, Operation> = new Map([
         ['MULTIPLICATION', Operation.MULTIPLICATION],
         ['DIVISION', Operation.DIVISION],
-        ['INTEGER_DIVISON', Operation.INTEGER_DIVISION],
+        ['INTEGER_DIVISION', Operation.INTEGER_DIVISION],
         ['MOD', Operation.MOD],
         ['ADDITION', Operation.ADDITION],
         ['SUBTRACTION', Operation.SUBTRACTION],
@@ -64,6 +65,7 @@ export class Operation {
         ['UNARY_LOGICAL_NOT', Operation.UNARY_LOGICAL_NOT],
         ['UNARY_BITWISE_COMPLEMENT', Operation.UNARY_BITWISE_COMPLEMENT],
         ['ARRAY_OPERATOR', Operation.ARRAY_OPERATOR],
+        ['ARRAY_RANGE_INDEX_OPERATOR', Operation.ARRAY_RANGE_INDEX_OPERATOR],
         ['OBJECT_OPERATOR', Operation.OBJECT_OPERATOR],
         ['NULLISH_COALESCING_OPERATOR', Operation.NULLISH_COALESCING_OPERATOR],
         ['CONDITIONAL_TERNARY_OPERATOR', Operation.CONDITIONAL_TERNARY_OPERATOR],
@@ -123,6 +125,7 @@ export class Operation {
         [Operation.UNARY_BITWISE_COMPLEMENT, 1],
         [Operation.ARRAY_OPERATOR, 1],
         [Operation.OBJECT_OPERATOR, 1],
+        [Operation.ARRAY_RANGE_INDEX_OPERATOR, 2],
         [Operation.MULTIPLICATION, 2],
         [Operation.DIVISION, 2],
         [Operation.INTEGER_DIVISION, 2],
@@ -153,6 +156,7 @@ export class Operation {
             ...Array.from(Operation.LOGICAL_OPERATORS),
             ...Array.from(Operation.BITWISE_OPERATORS),
             Operation.ARRAY_OPERATOR,
+            Operation.ARRAY_RANGE_INDEX_OPERATOR,
             Operation.OBJECT_OPERATOR,
             ...Array.from(Operation.CONDITIONAL_OPERATORS),
         ].map((e) => e.getOperator()),
@@ -164,6 +168,7 @@ export class Operation {
             ...Array.from(Operation.LOGICAL_OPERATORS),
             ...Array.from(Operation.BITWISE_OPERATORS),
             Operation.ARRAY_OPERATOR,
+            Operation.ARRAY_RANGE_INDEX_OPERATOR,
             Operation.OBJECT_OPERATOR,
             ...Array.from(Operation.CONDITIONAL_OPERATORS),
         ]
@@ -192,9 +197,10 @@ export class Operation {
         .map((e) => e.length)
         .reduce((a, c) => (a > c ? a : c), 0);
 
-    private operator: string;
-    private operatorName: string;
-    private _shouldBeWrappedInSpace: boolean;
+    private readonly operator: string;
+    private readonly operatorName: string;
+    private readonly _shouldBeWrappedInSpace: boolean;
+
     public constructor(
         operator: string,
         operatorName?: string,

package/src/engine/runtime/expression/operators/binary/ArrayRangeOperator.ts

@@ -0,0 +1,7 @@
+import { BinaryOperator } from './BinaryOperator';
+
+export class ArrayRangeOperator extends BinaryOperator {
+    public apply(t: any, u: any): any {
+        return `${t ?? ''}..${u ?? ''}`;
+    }
+}

package/src/engine/runtime/expression/operators/binary/index.ts

@@ -22,3 +22,4 @@ export * from './LogicalLessThanOperator';
 export * from './LogicalOrOperator';
 export * from './ObjectOperator';
 export * from './LogicalNullishCoalescingOperator';
+export * from './ArrayRangeOperator';

package/src/engine/runtime/expression/tokenextractor/TokenValueExtractor.ts

@@ -6,7 +6,7 @@ import { ExpressionEvaluationException } from '../exception/ExpressionEvaluation
 
 export abstract class TokenValueExtractor {
     public static readonly REGEX_SQUARE_BRACKETS: RegExp = /[\[\]]/;
-    public static readonly REGEX_DOT: RegExp = /\./;
+    public static readonly REGEX_DOT: RegExp = /(?<!\.)\.(?!\.)/;
 
     public getValue(token: string): any {
         let prefix: string = this.getPrefix();
@@ -71,7 +71,8 @@ export abstract class TokenValueExtractor {
 
         if (cPart === 'length') return this.getLength(token, cElement);
 
-        if (Array.isArray(cElement)) return this.handleArrayAccess(token, cPart, cElement);
+        if (typeof cElement == 'string' || Array.isArray(cElement))
+            return this.handleArrayAccess(token, cPart, cElement);
 
         return this.handleObjectAccess(token, parts, partNumber, cPart, cElement);
     }
@@ -91,8 +92,29 @@ export abstract class TokenValueExtractor {
         );
     }
 
-    private handleArrayAccess(token: string, cPart: string, cArray: any[]): any {
-        const index: number = parseInt(cPart);
+    private handleArrayAccess(token: string, cPart: string, cArray: any[] | string): any {
+        const dotDotIndex = cPart.indexOf('..');
+        if (dotDotIndex >= 0) {
+            const startIndex = cPart.substring(0, dotDotIndex);
+            const endIndex = cPart.substring(dotDotIndex + 2);
+
+            let intStart = startIndex.length == 0 ? 0 : parseInt(startIndex);
+            let intEnd = endIndex.length == 0 ? cArray.length : parseInt(endIndex);
+
+            if (isNaN(intStart) || isNaN(intEnd)) return undefined;
+
+            while (intStart < 0) intStart += cArray.length;
+            while (intEnd < 0) intEnd += cArray.length;
+
+            const cArrayType = typeof cArray;
+            if (intStart >= intEnd) return cArrayType == 'string' ? '' : [];
+
+            return cArrayType == 'string'
+                ? (cArray as string).substring(intStart, intEnd)
+                : cArray.slice(intStart, intEnd);
+        }
+
+        let index: number = parseInt(cPart);
 
         if (isNaN(index)) {
             throw new ExpressionEvaluationException(
@@ -101,7 +123,8 @@ export abstract class TokenValueExtractor {
             );
         }
 
-        if (index < 0 || index >= cArray.length) {
+        while (index < 0) index = cArray.length + index;
+        if (index >= cArray.length) {
             return undefined;
         }
 
@@ -137,7 +160,11 @@ export abstract class TokenValueExtractor {
         partNumber: number,
         jsonElement: any,
     ): void {
-        if (typeof jsonElement != 'object' || Array.isArray(jsonElement))
+        const jsonElementType = typeof jsonElement;
+        if (
+            (jsonElementType != 'object' && jsonElementType != 'string') ||
+            Array.isArray(jsonElement)
+        )
             throw new ExpressionEvaluationException(
                 token,
                 StringFormatter.format(

package/src/engine/util/duplicate.ts

@@ -1,5 +1,5 @@
 export function duplicate(obj: any): any {
     if (!obj) return obj;
-    if (globalThis.structuredClone) return globalThis.structuredClone(obj);
+    if (typeof globalThis.structuredClone === 'function') return globalThis.structuredClone(obj);
     return JSON.parse(JSON.stringify(obj));
 }

package/tsconfig.json

@@ -1,10 +1,12 @@
 {
     "compilerOptions": {
-        "module": "commonjs",
+        "module": "ESNext",
+        "target": "ESNext",
         "strict": true,
         "esModuleInterop": true,
         "skipLibCheck": true,
         "forceConsistentCasingInFileNames": true,
-        "lib": ["ES2022"]
+        "lib": ["ES2022"],
+        "moduleResolution": "node"
     }
 }