@fincity/kirun-js 2.8.6 → 2.10.0

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

@@ -13,105 +13,122 @@ import { Minimum } from './Minimum';
 import { Random } from './Random';
 import { RandomAny } from './RandomAny';
 
-const functionObjectsIndex: { [key: string]: AbstractFunction } = {
-    Absolute: new GenericMathFunction(
-        'Absolute',
-        (v) => Math.abs(v),
-        1,
-        SchemaType.INTEGER,
-        SchemaType.LONG,
-        SchemaType.FLOAT,
-        SchemaType.DOUBLE,
-    ),
-    ArcCosine: new GenericMathFunction('ArcCosine', (v) => Math.acos(v)),
-    ArcSine: new GenericMathFunction('ArcSine', (v) => Math.asin(v)),
-    ArcTangent: new GenericMathFunction('ArcTangent', (v) => Math.atan(v)),
-    Ceiling: new GenericMathFunction('Ceiling', (v) => Math.ceil(v)),
-    Cosine: new GenericMathFunction('Cosine', (v) => Math.cos(v)),
-    HyperbolicCosine: new GenericMathFunction('HyperbolicCosine', (v) => Math.cosh(v)),
-    CubeRoot: new GenericMathFunction('CubeRoot', (v) => Math.cbrt(v)),
-    Exponential: new GenericMathFunction('Exponential', (v) => Math.exp(v)),
-    ExponentialMinus1: new GenericMathFunction('ExponentialMinus1', (v) => Math.expm1(v)),
-    Floor: new GenericMathFunction('Floor', (v) => Math.floor(v)),
-    LogNatural: new GenericMathFunction('LogNatural', (v) => Math.log(v)),
-    Log10: new GenericMathFunction('Log10', (v) => Math.log10(v)),
-    Round: new GenericMathFunction(
-        'Round',
-        (v) => Math.round(v),
-        1,
-        SchemaType.INTEGER,
-        SchemaType.LONG,
-    ),
-    Sine: new GenericMathFunction('Sine', (v) => Math.sin(v)),
-    HyperbolicSine: new GenericMathFunction('HyperbolicSine', (v) => Math.sinh(v)),
-    Tangent: new GenericMathFunction('Tangent', (v) => Math.tan(v)),
-    HyperbolicTangent: new GenericMathFunction('HyperbolicTangent', (v) => Math.tanh(v)),
-    ToDegrees: new GenericMathFunction('ToDegrees', (v) => v * (Math.PI / 180)),
-    ToRadians: new GenericMathFunction('ToRadians', (v) => v * (180 / Math.PI)),
-    SquareRoot: new GenericMathFunction('SquareRoot', (v) => Math.sqrt(v)),
-    ArcTangent2: new GenericMathFunction('ArcTangent2', (v1, v2) => Math.atan2(v1, v2!), 2),
-    Power: new GenericMathFunction('Power', (v1, v2) => Math.pow(v1, v2!), 2),
-    Add: new Add(),
-    Hypotenuse: new Hypotenuse(),
-    Maximum: new Maximum(),
-    Minimum: new Minimum(),
-    Random: new Random(),
-    RandomFloat: new RandomAny(
-        'RandomFloat',
-        Parameter.of(RandomAny.MIN_VALUE, Schema.ofFloat(RandomAny.MIN_VALUE).setDefaultValue(0)),
-        Parameter.of(
-            RandomAny.MAX_VALUE,
-            Schema.ofFloat(RandomAny.MAX_VALUE).setDefaultValue(2147483647),
-        ),
-        Schema.ofFloat(RandomAny.VALUE),
-        (min, max) => Math.random() * (max - min) + min,
-    ),
-    RandomInt: new RandomAny(
-        'RandomInt',
-        Parameter.of(RandomAny.MIN_VALUE, Schema.ofInteger(RandomAny.MIN_VALUE).setDefaultValue(0)),
-        Parameter.of(
-            RandomAny.MAX_VALUE,
-            Schema.ofInteger(RandomAny.MAX_VALUE).setDefaultValue(2147483647),
-        ),
-        Schema.ofInteger(RandomAny.VALUE),
-        (min, max) => Math.round(Math.random() * (max - min) + min),
-    ),
-    RandomLong: new RandomAny(
-        'RandomLong',
-        Parameter.of(RandomAny.MIN_VALUE, Schema.ofLong(RandomAny.MIN_VALUE).setDefaultValue(0)),
-        Parameter.of(
-            RandomAny.MAX_VALUE,
-            Schema.ofLong(RandomAny.MAX_VALUE).setDefaultValue(Number.MAX_SAFE_INTEGER),
-        ),
-        Schema.ofLong(RandomAny.VALUE),
-        (min, max) => Math.round(Math.random() * (max - min) + min),
-    ),
-    RandomDouble: new RandomAny(
-        'RandomDouble',
-        Parameter.of(RandomAny.MIN_VALUE, Schema.ofDouble(RandomAny.MIN_VALUE).setDefaultValue(0)),
-        Parameter.of(
-            RandomAny.MAX_VALUE,
-            Schema.ofDouble(RandomAny.MAX_VALUE).setDefaultValue(Number.MAX_VALUE),
-        ),
-        Schema.ofDouble(RandomAny.VALUE),
-        (min, max) => Math.random() * (max - min) + min,
-    ),
-};
+export class MathFunctionRepository implements Repository<Function> {
+    private readonly functionObjectsIndex: { [key: string]: AbstractFunction };
+    private readonly filterableNames: string[];
 
-const filterableNames = Object.values(functionObjectsIndex).map((e) =>
-    e.getSignature().getFullName(),
-);
+    public constructor() {
+        this.functionObjectsIndex = {
+            Absolute: new GenericMathFunction(
+                'Absolute',
+                (v) => Math.abs(v),
+                1,
+                SchemaType.INTEGER,
+                SchemaType.LONG,
+                SchemaType.FLOAT,
+                SchemaType.DOUBLE,
+            ),
+            ArcCosine: new GenericMathFunction('ArcCosine', (v) => Math.acos(v)),
+            ArcSine: new GenericMathFunction('ArcSine', (v) => Math.asin(v)),
+            ArcTangent: new GenericMathFunction('ArcTangent', (v) => Math.atan(v)),
+            Ceiling: new GenericMathFunction('Ceiling', (v) => Math.ceil(v)),
+            Cosine: new GenericMathFunction('Cosine', (v) => Math.cos(v)),
+            HyperbolicCosine: new GenericMathFunction('HyperbolicCosine', (v) => Math.cosh(v)),
+            CubeRoot: new GenericMathFunction('CubeRoot', (v) => Math.cbrt(v)),
+            Exponential: new GenericMathFunction('Exponential', (v) => Math.exp(v)),
+            ExponentialMinus1: new GenericMathFunction('ExponentialMinus1', (v) => Math.expm1(v)),
+            Floor: new GenericMathFunction('Floor', (v) => Math.floor(v)),
+            LogNatural: new GenericMathFunction('LogNatural', (v) => Math.log(v)),
+            Log10: new GenericMathFunction('Log10', (v) => Math.log10(v)),
+            Round: new GenericMathFunction(
+                'Round',
+                (v) => Math.round(v),
+                1,
+                SchemaType.INTEGER,
+                SchemaType.LONG,
+            ),
+            Sine: new GenericMathFunction('Sine', (v) => Math.sin(v)),
+            HyperbolicSine: new GenericMathFunction('HyperbolicSine', (v) => Math.sinh(v)),
+            Tangent: new GenericMathFunction('Tangent', (v) => Math.tan(v)),
+            HyperbolicTangent: new GenericMathFunction('HyperbolicTangent', (v) => Math.tanh(v)),
+            ToDegrees: new GenericMathFunction('ToDegrees', (v) => v * (Math.PI / 180)),
+            ToRadians: new GenericMathFunction('ToRadians', (v) => v * (180 / Math.PI)),
+            SquareRoot: new GenericMathFunction('SquareRoot', (v) => Math.sqrt(v)),
+            ArcTangent2: new GenericMathFunction('ArcTangent2', (v1, v2) => Math.atan2(v1, v2!), 2),
+            Power: new GenericMathFunction('Power', (v1, v2) => Math.pow(v1, v2!), 2),
+            Add: new Add(),
+            Hypotenuse: new Hypotenuse(),
+            Maximum: new Maximum(),
+            Minimum: new Minimum(),
+            Random: new Random(),
+            RandomFloat: new RandomAny(
+                'RandomFloat',
+                Parameter.of(
+                    RandomAny.MIN_VALUE,
+                    Schema.ofFloat(RandomAny.MIN_VALUE).setDefaultValue(0),
+                ),
+                Parameter.of(
+                    RandomAny.MAX_VALUE,
+                    Schema.ofFloat(RandomAny.MAX_VALUE).setDefaultValue(2147483647),
+                ),
+                Schema.ofFloat(RandomAny.VALUE),
+                (min, max) => Math.random() * (max - min) + min,
+            ),
+            RandomInt: new RandomAny(
+                'RandomInt',
+                Parameter.of(
+                    RandomAny.MIN_VALUE,
+                    Schema.ofInteger(RandomAny.MIN_VALUE).setDefaultValue(0),
+                ),
+                Parameter.of(
+                    RandomAny.MAX_VALUE,
+                    Schema.ofInteger(RandomAny.MAX_VALUE).setDefaultValue(2147483647),
+                ),
+                Schema.ofInteger(RandomAny.VALUE),
+                (min, max) => Math.round(Math.random() * (max - min) + min),
+            ),
+            RandomLong: new RandomAny(
+                'RandomLong',
+                Parameter.of(
+                    RandomAny.MIN_VALUE,
+                    Schema.ofLong(RandomAny.MIN_VALUE).setDefaultValue(0),
+                ),
+                Parameter.of(
+                    RandomAny.MAX_VALUE,
+                    Schema.ofLong(RandomAny.MAX_VALUE).setDefaultValue(Number.MAX_SAFE_INTEGER),
+                ),
+                Schema.ofLong(RandomAny.VALUE),
+                (min, max) => Math.round(Math.random() * (max - min) + min),
+            ),
+            RandomDouble: new RandomAny(
+                'RandomDouble',
+                Parameter.of(
+                    RandomAny.MIN_VALUE,
+                    Schema.ofDouble(RandomAny.MIN_VALUE).setDefaultValue(0),
+                ),
+                Parameter.of(
+                    RandomAny.MAX_VALUE,
+                    Schema.ofDouble(RandomAny.MAX_VALUE).setDefaultValue(Number.MAX_VALUE),
+                ),
+                Schema.ofDouble(RandomAny.VALUE),
+                (min, max) => Math.random() * (max - min) + min,
+            ),
+        };
+
+        this.filterableNames = Object.values(this.functionObjectsIndex).map((e) =>
+            e.getSignature().getFullName(),
+        );
+    }
 
-export class MathFunctionRepository implements Repository<Function> {
     public async find(namespace: string, name: string): Promise<Function | undefined> {
         if (namespace != Namespaces.MATH) return Promise.resolve(undefined);
 
-        return Promise.resolve(functionObjectsIndex[name]);
+        return Promise.resolve(this.functionObjectsIndex[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/function/system/math/Maximum.ts

@@ -10,16 +10,19 @@ import { AbstractFunction } from '../../AbstractFunction';
 
 const VALUE = 'value';
 
-const SIGNATURE = new FunctionSignature('Maximum')
-    .setNamespace(Namespaces.MATH)
-    .setParameters(
-        new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)]]),
-    )
-    .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]));
-
 export class Maximum extends AbstractFunction {
+    private readonly signature = new FunctionSignature('Maximum')
+        .setNamespace(Namespaces.MATH)
+        .setParameters(
+            new Map([
+                [VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)],
+            ]),
+        )
+        .setEvents(
+            new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]),
+        );
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
@@ -27,9 +30,7 @@ export class Maximum extends AbstractFunction {
 
         return new FunctionOutput([
             EventResult.outputOf(
-                new Map([
-                    [VALUE, nums.reduce((a, c) => ((!a && a !== 0) || c > a ? c : a))],
-                ]),
+                new Map([[VALUE, nums.reduce((a, c) => ((!a && a !== 0) || c > a ? c : a))]]),
             ),
         ]);
     }

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

@@ -10,16 +10,19 @@ import { AbstractFunction } from '../../AbstractFunction';
 
 const VALUE = 'value';
 
-const SIGNATURE = new FunctionSignature('Minimum')
-    .setNamespace(Namespaces.MATH)
-    .setParameters(
-        new Map([[VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)]]),
-    )
-    .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]));
-
 export class Minimum extends AbstractFunction {
+    private readonly signature = new FunctionSignature('Minimum')
+        .setNamespace(Namespaces.MATH)
+        .setParameters(
+            new Map([
+                [VALUE, new Parameter(VALUE, Schema.ofNumber(VALUE)).setVariableArgument(true)],
+            ]),
+        )
+        .setEvents(
+            new Map([Event.outputEventMapEntry(new Map([[VALUE, Schema.ofNumber(VALUE)]]))]),
+        );
     public getSignature(): FunctionSignature {
-        return SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
@@ -27,9 +30,7 @@ export class Minimum extends AbstractFunction {
 
         return new FunctionOutput([
             EventResult.outputOf(
-                new Map([
-                    [VALUE, nums.reduce((a, c) => ((!a && a !== 0) || c < a ? c : a))],
-                ]),
+                new Map([[VALUE, nums.reduce((a, c) => ((!a && a !== 0) || c < a ? c : a))]]),
             ),
         ]);
     }

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

@@ -10,7 +10,7 @@ import { AbstractFunction } from '../../AbstractFunction';
 
 const VALUE = 'value';
 export class Random extends AbstractFunction {
-    private static readonly SIGNATURE: FunctionSignature = new FunctionSignature('Random')
+    private readonly signature: FunctionSignature = new FunctionSignature('Random')
         .setNamespace(Namespaces.MATH)
         .setEvents(
             new Map<string, Event>([
@@ -19,7 +19,7 @@ export class Random extends AbstractFunction {
         );
 
     public getSignature(): FunctionSignature {
-        return Random.SIGNATURE;
+        return this.signature;
     }
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {
         return new FunctionOutput([EventResult.outputOf(new Map([[VALUE, Math.random()]]))]);

package/src/engine/function/system/object/AbstractObjectFunction.ts

@@ -13,8 +13,6 @@ const VALUE = 'value';
 const SOURCE = 'source';
 
 export abstract class AbstractObjectFunction extends AbstractFunction {
-    private signature: FunctionSignature;
-
     protected constructor(functionName: string, valueSchema: Schema) {
         super();
         this.signature = new FunctionSignature(functionName)
@@ -23,6 +21,7 @@ export abstract class AbstractObjectFunction extends AbstractFunction {
             .setEvents(new Map([Event.outputEventMapEntry(new Map([[VALUE, valueSchema]]))]));
     }
 
+    private readonly signature;
     public getSignature(): FunctionSignature {
         return this.signature;
     }

package/src/engine/function/system/object/ObjectConvert.ts

@@ -24,33 +24,33 @@ export class ObjectConvert extends AbstractFunction {
     private static readonly VALUE: string = 'value';
     private static readonly CONVERSION_MODE: string = 'conversionMode';
 
+    private readonly signature: FunctionSignature = new FunctionSignature('ObjectConvert')
+        .setNamespace(Namespaces.SYSTEM_OBJECT)
+        .setParameters(
+            new Map([
+                Parameter.ofEntry(ObjectConvert.SOURCE, Schema.ofAny(ObjectConvert.SCHEMA)),
+                Parameter.ofEntry(
+                    ObjectConvert.SCHEMA,
+                    Schema.SCHEMA,
+                    false,
+                    ParameterType.CONSTANT,
+                ),
+                Parameter.ofEntry(
+                    ObjectConvert.CONVERSION_MODE,
+                    Schema.ofString(ObjectConvert.CONVERSION_MODE).setEnums(getConversionModes()),
+                ),
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.outputEventMapEntry(
+                    MapUtil.of(ObjectConvert.VALUE, Schema.ofAny(ObjectConvert.VALUE)),
+                ),
+            ]),
+        );
+
     getSignature(): FunctionSignature {
-        return new FunctionSignature('ObjectConvert')
-            .setNamespace(Namespaces.SYSTEM_OBJECT)
-            .setParameters(
-                new Map([
-                    Parameter.ofEntry(ObjectConvert.SOURCE, Schema.ofAny(ObjectConvert.SCHEMA)),
-                    Parameter.ofEntry(
-                        ObjectConvert.SCHEMA,
-                        Schema.SCHEMA,
-                        false,
-                        ParameterType.CONSTANT,
-                    ),
-                    Parameter.ofEntry(
-                        ObjectConvert.CONVERSION_MODE,
-                        Schema.ofString(ObjectConvert.CONVERSION_MODE).setEnums(
-                            getConversionModes(),
-                        ),
-                    ),
-                ]),
-            )
-            .setEvents(
-                new Map([
-                    Event.outputEventMapEntry(
-                        MapUtil.of(ObjectConvert.VALUE, Schema.ofAny(ObjectConvert.VALUE)),
-                    ),
-                ]),
-            );
+        return this.signature;
     }
 
     protected internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

package/src/engine/function/system/object/ObjectDeleteKey.ts

@@ -16,8 +16,6 @@ const SOURCE = 'source';
 const KEY = 'key';
 
 export class ObjectDeleteKey extends AbstractFunction {
-    private signature: FunctionSignature;
-
     public constructor() {
         super();
         this.signature = new FunctionSignature('ObjectDeleteKey')
@@ -33,6 +31,7 @@ export class ObjectDeleteKey extends AbstractFunction {
             );
     }
 
+    private readonly signature;
     public getSignature(): FunctionSignature {
         return this.signature;
     }

package/src/engine/function/system/object/ObjectFunctionRepository.ts

@@ -9,29 +9,33 @@ import { ObjectKeys } from './ObjectKeys';
 import { ObjectPutValue } from './ObjectPutValue';
 import { ObjectValues } from './ObjectValues';
 
-const functionObjectsIndex: { [key: string]: AbstractFunction } = {
-    ObjectValues: new ObjectValues(),
-    ObjectKeys: new ObjectKeys(),
-    ObjectEntries: new ObjectEntries(),
-    ObjectDeleteKey: new ObjectDeleteKey(),
-    ObjectPutValue: new ObjectPutValue(),
-    ObjectConvert: new ObjectConvert(),
-};
+export class ObjectFunctionRepository implements Repository<Function> {
+    private readonly functionObjectsIndex: { [key: string]: AbstractFunction };
+    private readonly filterableNames: string[];
 
-const filterableNames = Object.values(functionObjectsIndex).map((e) =>
-    e.getSignature().getFullName(),
-);
+    public constructor() {
+        this.functionObjectsIndex = {
+            ObjectValues: new ObjectValues(),
+            ObjectKeys: new ObjectKeys(),
+            ObjectEntries: new ObjectEntries(),
+            ObjectDeleteKey: new ObjectDeleteKey(),
+            ObjectPutValue: new ObjectPutValue(),
+            ObjectConvert: new ObjectConvert(),
+        };
+        this.filterableNames = Object.values(this.functionObjectsIndex).map((e) =>
+            e.getSignature().getFullName(),
+        );
+    }
 
-export class ObjectFunctionRepository implements Repository<Function> {
     public async find(namespace: string, name: string): Promise<Function | undefined> {
         if (namespace != Namespaces.SYSTEM_OBJECT) return Promise.resolve(undefined);
 
-        return Promise.resolve(functionObjectsIndex[name]);
+        return Promise.resolve(this.functionObjectsIndex[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/function/system/string/Concatenate.ts

@@ -13,17 +13,18 @@ import { AbstractFunction } from '../../AbstractFunction';
 export class Concatenate extends AbstractFunction {
     public static VALUE: string = 'value';
 
-    private static SCHEMA: Schema = new Schema()
-        .setName(Concatenate.VALUE)
-        .setType(new SingleType(SchemaType.STRING));
-
-    private static SIGNATURE: FunctionSignature = new FunctionSignature('Concatenate')
+    private readonly signature: FunctionSignature = new FunctionSignature('Concatenate')
         .setNamespace(Namespaces.STRING)
         .setParameters(
             new Map([
                 [
                     Concatenate.VALUE,
-                    new Parameter(Concatenate.VALUE, Concatenate.SCHEMA).setVariableArgument(true),
+                    new Parameter(
+                        Concatenate.VALUE,
+                        new Schema()
+                            .setName(Concatenate.VALUE)
+                            .setType(new SingleType(SchemaType.STRING)),
+                    ).setVariableArgument(true),
                 ],
             ]),
         )
@@ -40,7 +41,7 @@ export class Concatenate extends AbstractFunction {
     }
 
     public getSignature(): FunctionSignature {
-        return Concatenate.SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

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

@@ -16,7 +16,7 @@ export class Matches extends AbstractFunction {
 
     protected static EVENT_RESULT_NAME: string = 'result';
 
-    private static signature: FunctionSignature = new FunctionSignature('Matches')
+    private readonly signature: FunctionSignature = new FunctionSignature('Matches')
         .setNamespace(Namespaces.STRING)
         .setParameters(
             MapUtil.ofEntries(
@@ -50,7 +50,7 @@ export class Matches extends AbstractFunction {
         );
 
     public getSignature(): FunctionSignature {
-        return Matches.signature;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

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

@@ -14,7 +14,7 @@ import { SchemaType } from '../../../json/schema/type/SchemaType';
 export class Reverse extends AbstractFunction {
     protected readonly VALUE: string = 'value';
 
-    private readonly SIGNATURE: FunctionSignature = new FunctionSignature('Reverse')
+    private readonly signature: FunctionSignature = new FunctionSignature('Reverse')
         .setNamespace(Namespaces.STRING)
         .setParameters(
             new Map([
@@ -46,7 +46,7 @@ export class Reverse extends AbstractFunction {
     }
 
     public getSignature(): FunctionSignature {
-        return this.SIGNATURE;
+        return this.signature;
     }
 
     protected async internalExecute(context: FunctionExecutionParameters): Promise<FunctionOutput> {

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

@@ -29,22 +29,23 @@ export class Split extends AbstractFunction {
         MapUtil.of(this.EVENT_RESULT_NAME, Schema.ofArray(this.EVENT_RESULT_NAME)),
     );
 
+    private readonly signature = new FunctionSignature('Split')
+        .setNamespace(Namespaces.STRING)
+        .setParameters(
+            new Map([
+                [this.PARAMETER_STRING_NAME, this.PARAMETER_STRING],
+                [this.PARAMETER_SPLIT_STRING_NAME, this.PARAMETER_SPLIT_STRING],
+            ]),
+        )
+        .setEvents(
+            new Map([
+                Event.outputEventMapEntry(
+                    new Map([[this.EVENT_RESULT_NAME, Schema.ofArray(this.EVENT_RESULT_NAME)]]),
+                ) as [string, Event],
+            ]),
+        );
     public getSignature(): FunctionSignature {
-        return new FunctionSignature('Split')
-            .setNamespace(Namespaces.STRING)
-            .setParameters(
-                new Map([
-                    [this.PARAMETER_STRING_NAME, this.PARAMETER_STRING],
-                    [this.PARAMETER_SPLIT_STRING_NAME, this.PARAMETER_SPLIT_STRING],
-                ]),
-            )
-            .setEvents(
-                new Map([
-                    Event.outputEventMapEntry(
-                        new Map([[this.EVENT_RESULT_NAME, Schema.ofArray(this.EVENT_RESULT_NAME)]]),
-                    ) as [string, Event],
-                ]),
-            );
+        return this.signature;
     }
 
     public constructor() {

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

@@ -18,7 +18,7 @@ import { ToString } from './ToString';
 import { TrimTo } from './TrimTo';
 
 export class StringFunctionRepository implements Repository<Function> {
-    private static readonly repoMap: Map<string, Function> = MapUtil.ofArrayEntries(
+    private readonly repoMap: Map<string, Function> = MapUtil.ofArrayEntries(
         AbstractStringFunction.ofEntryStringAndStringOutput('Trim', (e) => e.trim()),
         AbstractStringFunction.ofEntryStringAndStringOutput('TrimStart', (e) => e.trimStart()),
         AbstractStringFunction.ofEntryStringAndStringOutput('TrimEnd', (e) => e.trimEnd()),
@@ -98,22 +98,20 @@ export class StringFunctionRepository implements Repository<Function> {
         mapEntry(new Matches()),
     );
 
-    private static readonly filterableNames = Array.from(
-        StringFunctionRepository.repoMap.values(),
-    ).map((e) => e.getSignature().getFullName());
+    private readonly filterableNames = Array.from(this.repoMap.values()).map((e) =>
+        e.getSignature().getFullName(),
+    );
 
     public async find(namespace: string, name: string): Promise<Function | undefined> {
         if (namespace != Namespaces.STRING) {
             return Promise.resolve(undefined);
         }
-        return Promise.resolve(StringFunctionRepository.repoMap.get(name));
+        return Promise.resolve(this.repoMap.get(name));
     }
 
     public async filter(name: string): Promise<string[]> {
         return Promise.resolve(
-            StringFunctionRepository.filterableNames.filter(
-                (e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1,
-            ),
+            this.filterableNames.filter((e) => e.toLowerCase().indexOf(name.toLowerCase()) !== -1),
         );
     }
 }

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

@@ -23,15 +23,16 @@ export class ToString extends AbstractFunction {
         new Map([[this.EVENT_RESULT_NAME, Schema.ofString(this.EVENT_RESULT_NAME)]]),
     );
 
+    private readonly signature = new FunctionSignature('ToString')
+        .setNamespace(Namespaces.STRING)
+        .setParameters(
+            new Map([
+                [this.PARAMETER_INPUT_ANYTYPE.getParameterName(), this.PARAMETER_INPUT_ANYTYPE],
+            ]),
+        )
+        .setEvents(new Map([[this.EVENT_STRING.getName(), this.EVENT_STRING]]));
     public getSignature(): FunctionSignature {
-        return new FunctionSignature('ToString')
-            .setNamespace(Namespaces.STRING)
-            .setParameters(
-                new Map([
-                    [this.PARAMETER_INPUT_ANYTYPE.getParameterName(), this.PARAMETER_INPUT_ANYTYPE],
-                ]),
-            )
-            .setEvents(new Map([[this.EVENT_STRING.getName(), this.EVENT_STRING]]));
+        return this.signature;
     }
 
     public constructor() {