@fincity/kirun-js 1.0.5 → 1.1.2

package/src/engine/function/system/context/Create.ts

@@ -44,7 +44,7 @@ export class Create extends AbstractFunction {
         return SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         const name: string = context?.getArguments()?.get(NAME);
 
         if (context?.getContext()?.has(name))

package/src/engine/function/system/context/Get.ts

@@ -40,7 +40,7 @@ export class Get extends AbstractFunction {
         return SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         const name: string = context?.getArguments()?.get(NAME);
 
         if (!context.getContext()?.has(name))

package/src/engine/function/system/context/SetFunction.ts

@@ -47,7 +47,7 @@ export class SetFunction extends AbstractFunction {
         return SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let key: string = context?.getArguments()?.get(NAME);
 
         if (StringUtil.isNullOrBlank(key)) {

package/src/engine/function/system/loop/CountLoop.ts

@@ -35,7 +35,7 @@ export class CountLoop extends AbstractFunction {
         return SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let count: number = context.getArguments()?.get(COUNT);
         let current = 0;
 

package/src/engine/function/system/loop/RangeLoop.ts

@@ -92,7 +92,7 @@ export class RangeLoop extends AbstractFunction {
         return SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let from: number = context.getArguments()?.get(FROM);
         let to: number = context.getArguments()?.get(TO);
         let step: number = context.getArguments()?.get(STEP);

package/src/engine/function/system/math/Add.ts

@@ -13,9 +13,7 @@ const VALUE = 'value';
 const SIGNATURE = new FunctionSignature('Add')
     .setNamespace(Namespaces.MATH)
     .setParameters(
-        new Map([
-            [VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)],
-        ]),
+        new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)]]),
     )
     .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]));
 
@@ -24,7 +22,7 @@ export class Add extends AbstractFunction {
         return SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let nums: number[] = context.getArguments()?.get(VALUE);
 
         return new FunctionOutput([

package/src/engine/function/system/math/GenericMathFunction.ts

@@ -17,9 +17,7 @@ const VALUE2 = 'value2';
 
 const paramFunctions = [
     () => {
-        return new Map([
-            [VALUE,new Parameter(VALUE,Schema.ofNumber(VALUE))],
-        ]);
+        return new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE))]]);
     },
     () => {
         return new Map([
@@ -65,7 +63,7 @@ export class GenericMathFunction extends AbstractFunction {
         return this.signature;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let v1 = PrimitiveUtil.findPrimitiveNumberType(
             context.getArguments()?.get(this.parametersNumber == 1 ? VALUE : VALUE1),
         ).getT2();

package/src/engine/function/system/math/Hypotenuse.ts

@@ -17,11 +17,7 @@ export class Hypotenuse extends AbstractFunction {
         .setNamespace(Namespaces.MATH)
         .setParameters(
             new Map([
-                [
-                    VALUE,
-                   new Parameter(VALUE,Schema.ofNumber(VALUE))
-                        .setVariableArgument(true),
-                ],
+                [VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)],
             ]),
         )
         .setEvents(
@@ -45,7 +41,7 @@ export class Hypotenuse extends AbstractFunction {
         return Hypotenuse.SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let nums: number[] = context.getArguments()?.get(VALUE);
 
         return new FunctionOutput([

package/src/engine/function/system/math/Maximum.ts

@@ -13,9 +13,7 @@ const VALUE = 'value';
 const SIGNATURE = new FunctionSignature('Maximum')
     .setNamespace(Namespaces.MATH)
     .setParameters(
-        new Map([
-            [VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)],
-        ]),
+        new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)]]),
     )
     .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]));
 
@@ -24,7 +22,7 @@ export class Maximum extends AbstractFunction {
         return SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let nums: number[] = context.getArguments()?.get(VALUE);
 
         return new FunctionOutput([

package/src/engine/function/system/math/Minimum.ts

@@ -13,9 +13,7 @@ const VALUE = 'value';
 const SIGNATURE = new FunctionSignature('Minimum')
     .setNamespace(Namespaces.MATH)
     .setParameters(
-        new Map([
-            [VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)],
-        ]),
+        new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)]]),
     )
     .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]));
 
@@ -24,7 +22,7 @@ export class Minimum extends AbstractFunction {
         return SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let nums: number[] = context.getArguments()?.get(VALUE);
 
         return new FunctionOutput([

package/src/engine/function/system/math/Random.ts

@@ -21,7 +21,7 @@ export class Random extends AbstractFunction {
     public getSignature(): FunctionSignature {
         return Random.SIGNATURE;
     }
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, Math.random()]]))]);
     }
 }

package/src/engine/function/system/math/RandomFloat.ts

@@ -0,0 +1,56 @@
+import { Schema } from '../../../json/schema/Schema';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+
+export class RandomFloat extends AbstractFunction {
+    public static readonly MIN_VALUE = 'minValue';
+
+    public static readonly MAX_VALUE = 'maxValue';
+
+    public static readonly VALUE = 'value';
+
+    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Random')
+        .setParameters(
+            MapUtil.of(
+                RandomFloat.MIN_VALUE,
+                Parameter.of(
+                    RandomFloat.MIN_VALUE,
+                    Schema.ofFloat(RandomFloat.MIN_VALUE).setDefaultValue(0),
+                ),
+                RandomFloat.MAX_VALUE,
+                Parameter.of(
+                    RandomFloat.MAX_VALUE,
+                    Schema.ofFloat(RandomFloat.MAX_VALUE).setDefaultValue(2147483647),
+                ),
+            ),
+        )
+        .setNamespace(Namespaces.MATH)
+        .setEvents(
+            new Map<string, Event>([
+                Event.outputEventMapEntry(
+                    MapUtil.of(RandomFloat.VALUE, Schema.ofFloat(RandomFloat.VALUE)),
+                ),
+            ]),
+        );
+
+    public getSignature(): FunctionSignature {
+        return RandomFloat.SIGNATURE;
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let min: number = context.getArguments()?.get(RandomFloat.MIN_VALUE);
+
+        let max: number = context.getArguments()?.get(RandomFloat.MAX_VALUE);
+
+        let num: number = Math.floor(Math.random() * (max - min) + min);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[RandomFloat.VALUE, num]]))]);
+    }
+}

package/src/engine/function/system/math/RandomInt.ts

@@ -0,0 +1,56 @@
+import { Schema } from '../../../json/schema/Schema';
+import { Event } from '../../../model/Event';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionSignature } from '../../../model/FunctionSignature';
+import { Parameter } from '../../../model/Parameter';
+import { Namespaces } from '../../../namespaces/Namespaces';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractFunction } from '../../AbstractFunction';
+
+export class RandomInt extends AbstractFunction {
+    public static readonly MIN_VALUE = 'minValue';
+
+    public static readonly MAX_VALUE = 'maxValue';
+
+    public static readonly VALUE = 'value';
+
+    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Random')
+        .setParameters(
+            MapUtil.of(
+                RandomInt.MIN_VALUE,
+                Parameter.of(
+                    RandomInt.MIN_VALUE,
+                    Schema.ofInteger(RandomInt.MIN_VALUE).setDefaultValue(0),
+                ),
+                RandomInt.MAX_VALUE,
+                Parameter.of(
+                    RandomInt.MAX_VALUE,
+                    Schema.ofInteger(RandomInt.MAX_VALUE).setDefaultValue(2147483647),
+                ),
+            ),
+        )
+        .setNamespace(Namespaces.MATH)
+        .setEvents(
+            new Map<string, Event>([
+                Event.outputEventMapEntry(
+                    MapUtil.of(RandomInt.VALUE, Schema.ofInteger(RandomInt.VALUE)),
+                ),
+            ]),
+        );
+
+    public getSignature(): FunctionSignature {
+        return RandomInt.SIGNATURE;
+    }
+
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
+        let min: number = context.getArguments()?.get(RandomInt.MIN_VALUE);
+
+        let max: number = context.getArguments()?.get(RandomInt.MAX_VALUE);
+
+        let num: number = Math.floor(Math.random() * (max - min) + min);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([[RandomInt.VALUE, num]]))]);
+    }
+}

package/src/engine/function/system/string/AbstractStringFunction.ts

@@ -120,7 +120,9 @@ export abstract class AbstractStringFunction extends AbstractFunction {
                     super(namespace, functionName, event, ...parameter);
                 }
 
-                protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
                     let s: string = context
                         ?.getArguments()
                         ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);
@@ -160,7 +162,9 @@ export abstract class AbstractStringFunction extends AbstractFunction {
                     super(namespace, functionName, event, ...parameter);
                 }
 
-                protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
                     let s: string = context
                         ?.getArguments()
                         ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);
@@ -200,7 +204,9 @@ export abstract class AbstractStringFunction extends AbstractFunction {
                     super(namespace, functionName, event, ...parameter);
                 }
 
-                protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
                     let s1: string = context
                         ?.getArguments()
                         ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);
@@ -237,7 +243,9 @@ export abstract class AbstractStringFunction extends AbstractFunction {
                     super(namespace, functionName, event, ...parameter);
                 }
 
-                protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
                     let s: string = context
                         ?.getArguments()
                         ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);
@@ -272,7 +280,9 @@ export abstract class AbstractStringFunction extends AbstractFunction {
                     super(namespace, functionName, event, ...parameter);
                 }
 
-                protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
                     let s: string = context
                         ?.getArguments()
                         ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);
@@ -308,7 +318,9 @@ export abstract class AbstractStringFunction extends AbstractFunction {
                     super(namespace, functionName, event, ...parameter);
                 }
 
-                protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
                     let s: string = context
                         ?.getArguments()
                         ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);
@@ -353,7 +365,9 @@ export abstract class AbstractStringFunction extends AbstractFunction {
                     super(namespace, functionName, event, ...parameter);
                 }
 
-                protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
                     let s: string = context
                         ?.getArguments()
                         ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);
@@ -401,7 +415,9 @@ export abstract class AbstractStringFunction extends AbstractFunction {
                     super(namespace, functionName, event, ...parameter);
                 }
 
-                protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+                protected async internalExecute(
+                    context: FunctionExecutionParameters,
+                ): Promise<FunctionOutput> {
                     let s1: string = context
                         ?.getArguments()
                         ?.get(AbstractStringFunction.PARAMETER_STRING_NAME);

package/src/engine/function/system/string/Concatenate.ts

@@ -23,7 +23,7 @@ export class Concatenate extends AbstractFunction {
             new Map([
                 [
                     Concatenate.VALUE,
-                    new Parameter( Concatenate.VALUE, Concatenate.SCHEMA).setVariableArgument(true),
+                    new Parameter(Concatenate.VALUE, Concatenate.SCHEMA).setVariableArgument(true),
                 ],
             ]),
         )
@@ -43,7 +43,7 @@ export class Concatenate extends AbstractFunction {
         return Concatenate.SIGNATURE;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let contextArgs: string[] = context.getArguments()?.get(Concatenate.VALUE);
 
         let concatenatedString: string = '';

package/src/engine/function/system/string/DeleteForGivenLength.ts

@@ -17,20 +17,30 @@ export class DeleteForGivenLength extends AbstractFunction {
 
     public static readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected readonly PARAMETER_STRING: Parameter =new Parameter(DeleteForGivenLength.PARAMETER_STRING_NAME,Schema.ofString(DeleteForGivenLength.PARAMETER_STRING_NAME));
-
-    protected readonly PARAMETER_AT_START: Parameter =new Parameter(DeleteForGivenLength.PARAMETER_AT_START_NAME,Schema.ofInteger(DeleteForGivenLength.PARAMETER_AT_START_NAME));
-
-    protected readonly PARAMETER_AT_END: Parameter =new Parameter(DeleteForGivenLength.PARAMETER_AT_END_NAME,Schema.ofInteger(DeleteForGivenLength.PARAMETER_AT_END_NAME));
-
-    protected readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
-            new Map([
-                [
-                    DeleteForGivenLength.EVENT_RESULT_NAME,
-                    Schema.ofString(DeleteForGivenLength.EVENT_RESULT_NAME),
-                ],
-            ]),
-        );
+    protected readonly PARAMETER_STRING: Parameter = new Parameter(
+        DeleteForGivenLength.PARAMETER_STRING_NAME,
+        Schema.ofString(DeleteForGivenLength.PARAMETER_STRING_NAME),
+    );
+
+    protected readonly PARAMETER_AT_START: Parameter = new Parameter(
+        DeleteForGivenLength.PARAMETER_AT_START_NAME,
+        Schema.ofInteger(DeleteForGivenLength.PARAMETER_AT_START_NAME),
+    );
+
+    protected readonly PARAMETER_AT_END: Parameter = new Parameter(
+        DeleteForGivenLength.PARAMETER_AT_END_NAME,
+        Schema.ofInteger(DeleteForGivenLength.PARAMETER_AT_END_NAME),
+    );
+
+    protected readonly EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        new Map([
+            [
+                DeleteForGivenLength.EVENT_RESULT_NAME,
+                Schema.ofString(DeleteForGivenLength.EVENT_RESULT_NAME),
+            ],
+        ]),
+    );
 
     private signature: FunctionSignature = new FunctionSignature('DeleteForGivenLength')
         .setNamespace(Namespaces.STRING)
@@ -51,7 +61,7 @@ export class DeleteForGivenLength extends AbstractFunction {
         return this.signature;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let inputString: string = context
             ?.getArguments()
             ?.get(DeleteForGivenLength.PARAMETER_STRING_NAME);

package/src/engine/function/system/string/InsertAtGivenPosition.ts

@@ -17,15 +17,25 @@ export class InsertAtGivenPosition extends AbstractFunction {
 
     protected readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected readonly PARAMETER_STRING: Parameter =new Parameter(InsertAtGivenPosition.PARAMETER_STRING_NAME,Schema.ofString(InsertAtGivenPosition.PARAMETER_STRING_NAME));
+    protected readonly PARAMETER_STRING: Parameter = new Parameter(
+        InsertAtGivenPosition.PARAMETER_STRING_NAME,
+        Schema.ofString(InsertAtGivenPosition.PARAMETER_STRING_NAME),
+    );
 
-    protected readonly PARAMETER_AT_POSITION: Parameter =new Parameter(InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME,Schema.ofInteger(InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME));
+    protected readonly PARAMETER_AT_POSITION: Parameter = new Parameter(
+        InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME,
+        Schema.ofInteger(InsertAtGivenPosition.PARAMETER_AT_POSITION_NAME),
+    );
 
-    protected readonly PARAMETER_INSERT_STRING: Parameter =new Parameter(InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME,Schema.ofString(InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME));
+    protected readonly PARAMETER_INSERT_STRING: Parameter = new Parameter(
+        InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME,
+        Schema.ofString(InsertAtGivenPosition.PARAMETER_INSERT_STRING_NAME),
+    );
 
-    protected readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
-            new Map([[this.EVENT_RESULT_NAME, Schema.ofString(this.EVENT_RESULT_NAME)]]),
-        );
+    protected readonly EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        new Map([[this.EVENT_RESULT_NAME, Schema.ofString(this.EVENT_RESULT_NAME)]]),
+    );
 
     private signature: FunctionSignature = new FunctionSignature('InsertAtGivenPosition')
         .setNamespace(Namespaces.STRING)
@@ -48,7 +58,7 @@ export class InsertAtGivenPosition extends AbstractFunction {
         return this.signature;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let inputString: string = context
             ?.getArguments()
             ?.get(InsertAtGivenPosition.PARAMETER_STRING_NAME);

package/src/engine/function/system/string/PostPad.ts

@@ -17,15 +17,25 @@ export class PostPad extends AbstractFunction {
 
     protected static readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected static PARAMETER_STRING: Parameter =new Parameter(PostPad.PARAMETER_STRING_NAME,Schema.ofString(PostPad.PARAMETER_STRING_NAME));
-
-    protected static PARAMETER_POSTPAD_STRING: Parameter =new Parameter(PostPad.PARAMETER_POSTPAD_STRING_NAME,Schema.ofString(PostPad.PARAMETER_POSTPAD_STRING_NAME));
-
-    protected static PARAMETER_LENGTH: Parameter =new Parameter(PostPad.PARAMETER_LENGTH_NAME,Schema.ofInteger(PostPad.PARAMETER_LENGTH_NAME));
-
-    protected static EVENT_STRING: Event =new Event(Event.OUTPUT,
-            new Map([[PostPad.EVENT_RESULT_NAME, Schema.ofString(PostPad.EVENT_RESULT_NAME)]]),
-        );
+    protected static PARAMETER_STRING: Parameter = new Parameter(
+        PostPad.PARAMETER_STRING_NAME,
+        Schema.ofString(PostPad.PARAMETER_STRING_NAME),
+    );
+
+    protected static PARAMETER_POSTPAD_STRING: Parameter = new Parameter(
+        PostPad.PARAMETER_POSTPAD_STRING_NAME,
+        Schema.ofString(PostPad.PARAMETER_POSTPAD_STRING_NAME),
+    );
+
+    protected static PARAMETER_LENGTH: Parameter = new Parameter(
+        PostPad.PARAMETER_LENGTH_NAME,
+        Schema.ofInteger(PostPad.PARAMETER_LENGTH_NAME),
+    );
+
+    protected static EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        new Map([[PostPad.EVENT_RESULT_NAME, Schema.ofString(PostPad.EVENT_RESULT_NAME)]]),
+    );
 
     private signature: FunctionSignature = new FunctionSignature('PostPad')
         .setNamespace(Namespaces.STRING)
@@ -49,7 +59,7 @@ export class PostPad extends AbstractFunction {
         return this.signature;
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let inputString: string = context.getArguments()?.get(PostPad.PARAMETER_STRING_NAME);
         let postpadString: string = context
             ?.getArguments()

package/src/engine/function/system/string/PrePad.ts

@@ -17,15 +17,25 @@ export class PrePad extends AbstractFunction {
 
     public static readonly EVENT_RESULT_NAME: string = 'result';
 
-    protected static readonly PARAMETER_STRING: Parameter =new Parameter(PrePad.PARAMETER_STRING_NAME,Schema.ofString(PrePad.PARAMETER_STRING_NAME));
+    protected static readonly PARAMETER_STRING: Parameter = new Parameter(
+        PrePad.PARAMETER_STRING_NAME,
+        Schema.ofString(PrePad.PARAMETER_STRING_NAME),
+    );
 
-    protected static readonly PARAMETER_PREPAD_STRING: Parameter =new Parameter(PrePad.PARAMETER_PREPAD_STRING_NAME,Schema.ofString(PrePad.PARAMETER_PREPAD_STRING_NAME));
+    protected static readonly PARAMETER_PREPAD_STRING: Parameter = new Parameter(
+        PrePad.PARAMETER_PREPAD_STRING_NAME,
+        Schema.ofString(PrePad.PARAMETER_PREPAD_STRING_NAME),
+    );
 
-    protected static readonly PARAMETER_LENGTH: Parameter =new Parameter(PrePad.PARAMETER_LENGTH_NAME,Schema.ofInteger(PrePad.PARAMETER_LENGTH_NAME));
+    protected static readonly PARAMETER_LENGTH: Parameter = new Parameter(
+        PrePad.PARAMETER_LENGTH_NAME,
+        Schema.ofInteger(PrePad.PARAMETER_LENGTH_NAME),
+    );
 
-    protected static readonly EVENT_STRING: Event =new Event(Event.OUTPUT,
-            new Map([[PrePad.EVENT_RESULT_NAME, Schema.ofString(PrePad.EVENT_RESULT_NAME)]]),
-        );
+    protected static readonly EVENT_STRING: Event = new Event(
+        Event.OUTPUT,
+        new Map([[PrePad.EVENT_RESULT_NAME, Schema.ofString(PrePad.EVENT_RESULT_NAME)]]),
+    );
 
     private readonly signature: FunctionSignature = new FunctionSignature('PrePad')
         .setNamespace(Namespaces.STRING)
@@ -46,7 +56,7 @@ export class PrePad extends AbstractFunction {
         super();
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let inputString: string = context.getArguments()?.get(PrePad.PARAMETER_STRING_NAME);
         let prepadString: string = context.getArguments()?.get(PrePad.PARAMETER_PREPAD_STRING_NAME);
         let length: number = context.getArguments()?.get(PrePad.PARAMETER_LENGTH_NAME);

package/src/engine/function/system/string/RegionMatches.ts

@@ -23,26 +23,42 @@ export class RegionMatches extends AbstractFunction {
 
     public static readonly EVENT_RESULT_NAME: string = 'result';
 
-    public static PARAMETER_STRING: Parameter =new Parameter(RegionMatches.PARAMETER_STRING_NAME,Schema.ofString(RegionMatches.PARAMETER_STRING_NAME));
-
-    protected static PARAMETER_OTHER_STRING: Parameter =new Parameter(RegionMatches.PARAMETER_OTHER_STRING_NAME,Schema.ofString(RegionMatches.PARAMETER_OTHER_STRING_NAME));
-
-    protected static PARAMETER_FIRST_OFFSET: Parameter =new Parameter(RegionMatches.PARAMETER_FIRST_OFFSET_NAME,Schema.ofInteger(RegionMatches.PARAMETER_FIRST_OFFSET_NAME));
-
-    protected static PARAMETER_SECOND_OFFSET: Parameter =new Parameter(RegionMatches.PARAMETER_SECOND_OFFSET_NAME,Schema.ofInteger(RegionMatches.PARAMETER_SECOND_OFFSET_NAME));
-
-    protected static PARAMETER_INTEGER: Parameter =new Parameter(RegionMatches.PARAMETER_INTEGER_NAME,Schema.ofInteger(RegionMatches.PARAMETER_INTEGER_NAME));
-
-    protected static PARAMETER_BOOLEAN: Parameter =new Parameter(RegionMatches.PARAMETER_BOOLEAN_NAME,Schema.ofBoolean(RegionMatches.PARAMETER_BOOLEAN_NAME));
-
-    protected static EVENT_BOOLEAN: Event =new Event(Event.OUTPUT,
-            new Map([
-                [
-                    RegionMatches.EVENT_RESULT_NAME,
-                    Schema.ofBoolean(RegionMatches.EVENT_RESULT_NAME),
-                ],
-            ]),
-        );
+    public static PARAMETER_STRING: Parameter = new Parameter(
+        RegionMatches.PARAMETER_STRING_NAME,
+        Schema.ofString(RegionMatches.PARAMETER_STRING_NAME),
+    );
+
+    protected static PARAMETER_OTHER_STRING: Parameter = new Parameter(
+        RegionMatches.PARAMETER_OTHER_STRING_NAME,
+        Schema.ofString(RegionMatches.PARAMETER_OTHER_STRING_NAME),
+    );
+
+    protected static PARAMETER_FIRST_OFFSET: Parameter = new Parameter(
+        RegionMatches.PARAMETER_FIRST_OFFSET_NAME,
+        Schema.ofInteger(RegionMatches.PARAMETER_FIRST_OFFSET_NAME),
+    );
+
+    protected static PARAMETER_SECOND_OFFSET: Parameter = new Parameter(
+        RegionMatches.PARAMETER_SECOND_OFFSET_NAME,
+        Schema.ofInteger(RegionMatches.PARAMETER_SECOND_OFFSET_NAME),
+    );
+
+    protected static PARAMETER_INTEGER: Parameter = new Parameter(
+        RegionMatches.PARAMETER_INTEGER_NAME,
+        Schema.ofInteger(RegionMatches.PARAMETER_INTEGER_NAME),
+    );
+
+    protected static PARAMETER_BOOLEAN: Parameter = new Parameter(
+        RegionMatches.PARAMETER_BOOLEAN_NAME,
+        Schema.ofBoolean(RegionMatches.PARAMETER_BOOLEAN_NAME),
+    );
+
+    protected static EVENT_BOOLEAN: Event = new Event(
+        Event.OUTPUT,
+        new Map([
+            [RegionMatches.EVENT_RESULT_NAME, Schema.ofBoolean(RegionMatches.EVENT_RESULT_NAME)],
+        ]),
+    );
 
     private signature: FunctionSignature = new FunctionSignature('RegionMatches')
         .setNamespace(Namespaces.STRING)
@@ -81,10 +97,12 @@ export class RegionMatches extends AbstractFunction {
         super();
     }
 
-    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+    protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         let inputString: string = context.getArguments()?.get(RegionMatches.PARAMETER_STRING_NAME);
         let ignoreCase: boolean = context.getArguments()?.get(RegionMatches.PARAMETER_BOOLEAN_NAME);
-        let toffSet: number = context.getArguments()?.get(RegionMatches.PARAMETER_FIRST_OFFSET_NAME);
+        let toffSet: number = context
+            .getArguments()
+            ?.get(RegionMatches.PARAMETER_FIRST_OFFSET_NAME);
         let otherString: string = context
             ?.getArguments()
             ?.get(RegionMatches.PARAMETER_OTHER_STRING_NAME);