@fincity/kirun-js 1.0.0

package/src/engine/function/system/array/Copy.ts

@@ -0,0 +1,56 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { isNullValue } from '../../../util/NullCheck';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Copy extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Copy',
+            [
+                Copy.PARAMETER_ARRAY_SOURCE,
+                Copy.PARAMETER_INT_SOURCE_FROM,
+                Copy.PARAMETER_INT_LENGTH,
+                Copy.PARAMETER_BOOLEAN_DEEP_COPY,
+            ],
+            Copy.EVENT_RESULT_ARRAY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        var source = context?.getArguments()?.get(Copy.PARAMETER_ARRAY_SOURCE.getParameterName());
+        var srcfrom = context
+            ?.getArguments()
+            ?.get(Copy.PARAMETER_INT_SOURCE_FROM.getParameterName());
+        var length = context?.getArguments()?.get(Copy.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (length == -1) length = source.length - srcfrom;
+
+        if (srcfrom + length > source.length)
+            throw new KIRuntimeException(
+                StringFormatter.format(
+                    'Array has no elements from $ to $ as the array size is $',
+                    srcfrom,
+                    srcfrom + length,
+                    source.length,
+                ),
+            );
+
+        var deep = context
+            ?.getArguments()
+            ?.get(Copy.PARAMETER_BOOLEAN_DEEP_COPY.getParameterName());
+
+        const ja: any[] = new Array(length);
+
+        for (let i = srcfrom; i < srcfrom + length; i++) {
+            if (!isNullValue(source[i]))
+                ja[i - srcfrom] = deep ? JSON.parse(JSON.stringify(source[i])) : source[i];
+        }
+
+        return new FunctionOutput([EventResult.outputOf(MapUtil.of(Copy.EVENT_RESULT_NAME, ja))]);
+    }
+}

package/src/engine/function/system/array/Delete.ts

@@ -0,0 +1,63 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Delete extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Delete',
+            [
+                AbstractArrayFunction.PARAMETER_ARRAY_SOURCE_PRIMITIVE,
+                AbstractArrayFunction.PARAMETER_ARRAY_SECOND_SOURCE,
+            ],
+            AbstractArrayFunction.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Delete.PARAMETER_ARRAY_SOURCE_PRIMITIVE.getParameterName());
+
+        let deletable: any[] = context
+            ?.getArguments()
+            ?.get(Delete.PARAMETER_ARRAY_SECOND_SOURCE.getParameterName());
+
+        if (source.length == 0 || deletable.length == 0 || deletable.length > source.length)
+            throw new KIRuntimeException(
+                'Expected a source or deletable for an array but not found any or the deletable size of the array is more than the source array',
+            );
+
+        let deletableSize: number = deletable.length;
+
+        let index: number = -1;
+
+        for (let i = 0; i < source.length; i++) {
+            let j: number = 0;
+            if (source[i] !== null && deletable[j] !== null && source[i] == deletable[j]) {
+                while (j < deletableSize) {
+                    if (
+                        source[i] == null ||
+                        deletable[j] == null ||
+                        source[i + j] != deletable[j]
+                    ) {
+                        break;
+                    }
+                    j++;
+                }
+                if (j == deletableSize) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+
+        if (index != -1) {
+            source.splice(index, deletableSize);
+        }
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}

package/src/engine/function/system/array/DeleteFirst.ts

@@ -0,0 +1,22 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class DeleteFirst extends AbstractArrayFunction {
+    public constructor() {
+        super('DeleteFirst', [DeleteFirst.PARAMETER_ARRAY_SOURCE], DeleteFirst.EVENT_RESULT_EMPTY);
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(DeleteFirst.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        if (source.length == 0) throw new KIRuntimeException('Given source array is empty');
+
+        source.shift();
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}

package/src/engine/function/system/array/DeleteFrom.ts

@@ -0,0 +1,51 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class DeleteFrom extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'DeleteFrom',
+            [
+                DeleteFrom.PARAMETER_ARRAY_SOURCE,
+                DeleteFrom.PARAMETER_INT_SOURCE_FROM,
+                DeleteFrom.PARAMETER_INT_LENGTH,
+            ],
+            DeleteFrom.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(DeleteFrom.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let start: number = context
+            ?.getArguments()
+            ?.get(DeleteFrom.PARAMETER_INT_SOURCE_FROM.getParameterName());
+
+        let len: number = context
+            ?.getArguments()
+            ?.get(DeleteFrom.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (source.length == 0) throw new KIRuntimeException('There are no elements to be deleted');
+
+        if (start >= source.length || start < 0)
+            throw new KIRuntimeException(
+                'The int source for the array should be in between 0 and length of the array ',
+            );
+
+        if (len == -1) len = source.length - start;
+
+        if (start + len > source.length)
+            throw new KIRuntimeException(
+                'Requested length to be deleted is more than the size of array ',
+            );
+
+        source.splice(start, len);
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}

package/src/engine/function/system/array/DeleteLast.ts

@@ -0,0 +1,23 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class DeleteLast extends AbstractArrayFunction {
+    public constructor() {
+        super('DeleteLast', [DeleteLast.PARAMETER_ARRAY_SOURCE], DeleteLast.EVENT_RESULT_EMPTY);
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(DeleteLast.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        if (source.length == 0) throw new KIRuntimeException('Given source array is empty');
+
+        source.pop();
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}

package/src/engine/function/system/array/Disjoint.ts

@@ -0,0 +1,85 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Disjoint extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Disjoint',
+            [
+                Disjoint.PARAMETER_ARRAY_SOURCE,
+                Disjoint.PARAMETER_INT_SOURCE_FROM,
+                Disjoint.PARAMETER_ARRAY_SECOND_SOURCE,
+                Disjoint.PARAMETER_INT_SECOND_SOURCE_FROM,
+                Disjoint.PARAMETER_INT_LENGTH,
+            ],
+            Disjoint.EVENT_RESULT_ARRAY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let firstSource: any[] = context
+            ?.getArguments()
+            ?.get(Disjoint.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let first: number = context
+            ?.getArguments()
+            ?.get(Disjoint.PARAMETER_INT_SOURCE_FROM.getParameterName());
+
+        let secondSource: any[] = context
+            ?.getArguments()
+            ?.get(Disjoint.PARAMETER_ARRAY_SECOND_SOURCE.getParameterName());
+
+        let second: number = context
+            ?.getArguments()
+            ?.get(Disjoint.PARAMETER_INT_SECOND_SOURCE_FROM.getParameterName());
+
+        let len: number = context
+            ?.getArguments()
+            ?.get(Disjoint.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (len == -1)
+            len =
+                firstSource.length <= secondSource.length
+                    ? firstSource.length - first
+                    : secondSource.length - second;
+
+        if (
+            len > firstSource.length ||
+            len > secondSource.length ||
+            first + len > firstSource.length ||
+            second + len > secondSource.length
+        )
+            throw new KIRuntimeException(
+                'The length which was being requested is more than than the size either source array or second source array',
+            );
+
+        let set1: Set<any> = new Set<any>();
+        let set2: Set<any> = new Set<any>();
+
+        for (let i: number = 0; i < len; i++) set1.add(firstSource[i + first]);
+
+        for (let i: number = 0; i < len; i++) set2.add(secondSource[i + second]);
+
+        let set3: Set<any> = new Set<any>();
+
+        set1.forEach((element) => {
+            if (set2.has(element)) set2.delete(element);
+            else set3.add(element);
+        });
+
+        set2.forEach((element) => {
+            if (!set1.has(element)) set3.add(element);
+        });
+
+        let disjointArray: any[] = [];
+
+        set3.forEach((element) => disjointArray.push(element));
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[Disjoint.EVENT_RESULT_ARRAY.getName(), disjointArray]])),
+        ]);
+    }
+}

package/src/engine/function/system/array/Equals.ts

@@ -0,0 +1,36 @@
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+import { Compare } from './Compare';
+
+export class Equals extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Equals',
+            [
+                Equals.PARAMETER_ARRAY_SOURCE,
+                Equals.PARAMETER_INT_SOURCE_FROM,
+                Equals.PARAMETER_ARRAY_FIND,
+                Equals.PARAMETER_INT_FIND_FROM,
+                Equals.PARAMETER_INT_LENGTH,
+            ],
+            Equals.EVENT_RESULT_BOOLEAN,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let compare: Compare = new Compare();
+
+        let fo: FunctionOutput = compare.execute(context);
+
+        let resultMap: Map<string, any> = fo.allResults()[0].getResult();
+
+        let v: number = resultMap.get(Equals.EVENT_RESULT_NAME);
+
+        return new FunctionOutput([
+            EventResult.outputOf(MapUtil.of(Equals.EVENT_RESULT_NAME, v == 0)),
+        ]);
+    }
+}

package/src/engine/function/system/array/Fill.ts

@@ -0,0 +1,51 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { MapUtil } from '../../../util/MapUtil';
+import { isNullValue } from '../../../util/NullCheck';
+import { StringFormatter } from '../../../util/string/StringFormatter';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Fill extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Fill',
+            [
+                Fill.PARAMETER_ARRAY_SOURCE,
+                Fill.PARAMETER_INT_SOURCE_FROM,
+                Fill.PARAMETER_INT_LENGTH,
+                Fill.PARAMETER_ANY,
+            ],
+            Fill.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        var source = context?.getArguments()?.get(Fill.PARAMETER_ARRAY_SOURCE.getParameterName());
+        var srcfrom = context
+            ?.getArguments()
+            ?.get(Fill.PARAMETER_INT_SOURCE_FROM.getParameterName());
+        var length = context?.getArguments()?.get(Fill.PARAMETER_INT_LENGTH.getParameterName());
+        var element = context?.getArguments()?.get(Fill.PARAMETER_ANY.getParameterName());
+
+        if (srcfrom < 0)
+            throw new KIRuntimeException(
+                StringFormatter.format('Arrays out of bound trying to access $ index', srcfrom),
+            );
+
+        if (length == -1) length = source.length - srcfrom;
+
+        let add = srcfrom + length - source.length;
+
+        if (add > 0) {
+            for (let i = 0; i < add; i++) source.push();
+        }
+
+        for (let i = srcfrom; i < srcfrom + length; i++) {
+            source[i] = isNullValue(element) ? element : JSON.parse(JSON.stringify(element));
+        }
+
+        return new FunctionOutput([EventResult.outputOf(MapUtil.of())]);
+    }
+}

package/src/engine/function/system/array/Frequency.ts

@@ -0,0 +1,68 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { isNullValue } from '../../../util/NullCheck';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Frequency extends AbstractArrayFunction {
+    FunctionOutput: any;
+
+    public constructor() {
+        super(
+            'Frequency',
+            [
+                Frequency.PARAMETER_ARRAY_SOURCE,
+                Frequency.PARAMETER_ANY,
+                Frequency.PARAMETER_INT_SOURCE_FROM,
+                Frequency.PARAMETER_INT_LENGTH,
+            ],
+            Frequency.EVENT_RESULT_INTEGER,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Frequency.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let find: any = context?.getArguments()?.get(Frequency.PARAMETER_ANY.getParameterName());
+
+        let start: number = context
+            ?.getArguments()
+            ?.get(Frequency.PARAMETER_INT_SOURCE_FROM.getParameterName());
+
+        let length: number = context
+            ?.getArguments()
+            ?.get(Frequency.PARAMETER_INT_LENGTH.getParameterName());
+
+        if (source.length == 0)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_INTEGER.getName(), 0]])),
+            ]);
+
+        if (start > source.length)
+            throw new KIRuntimeException('Given start point is more than the size of source');
+
+        if (isNullValue(find))
+            throw new KIRuntimeException('Given find was null. Hence cannot be found in the array');
+
+        let end: number = start + length;
+
+        if (length == -1) end = source.length - start;
+
+        if (end > source.length)
+            throw new KIRuntimeException('Given length is more than the size of source');
+
+        let frequency: number = 0;
+
+        for (let i: number = start; i < end && i < source.length; i++) {
+            if (PrimitiveUtil.compare(source[i], find) == 0) frequency++;
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[Frequency.EVENT_RESULT_INTEGER.getName(), frequency]])),
+        ]);
+    }
+}

package/src/engine/function/system/array/IndexOf.ts

@@ -0,0 +1,56 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { isNullValue } from '../../../util/NullCheck';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class IndexOf extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'IndexOf',
+            [
+                IndexOf.PARAMETER_ARRAY_SOURCE,
+                IndexOf.PARAMETER_ANY_NOT_NULL,
+                IndexOf.PARAMETER_INT_FIND_FROM,
+            ],
+            IndexOf.EVENT_RESULT_INTEGER,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(IndexOf.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        var find = context?.getArguments()?.get(IndexOf.PARAMETER_ANY_NOT_NULL.getParameterName());
+
+        let len: number = context
+            ?.getArguments()
+            ?.get(IndexOf.PARAMETER_INT_FIND_FROM.getParameterName());
+
+        if (source.length == 0)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_INTEGER.getName(), -1]])),
+            ]);
+
+        if (len < 0 || len > source.length)
+            throw new KIRuntimeException(
+                'The size of the search index of the array is greater than the size of the array',
+            );
+
+        let index: number = -1;
+
+        for (let i: number = len; i < source.length; i++) {
+            if (PrimitiveUtil.compare(source[i], find) == 0) {
+                index = i;
+                break;
+            }
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[IndexOf.EVENT_RESULT_INTEGER.getName(), index]])),
+        ]);
+    }
+}

package/src/engine/function/system/array/IndexOfArray.ts

@@ -0,0 +1,67 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { PrimitiveUtil } from '../../../util/primitive/PrimitiveUtil';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class IndexOfArray extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'IndexOfArray',
+            [
+                IndexOfArray.PARAMETER_ARRAY_SOURCE,
+                IndexOfArray.PARAMETER_ARRAY_SECOND_SOURCE,
+                IndexOfArray.PARAMETER_INT_FIND_FROM,
+            ],
+            IndexOfArray.EVENT_RESULT_INTEGER,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(IndexOfArray.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let secondSource: any[] = context
+            ?.getArguments()
+            ?.get(IndexOfArray.PARAMETER_ARRAY_SECOND_SOURCE.getParameterName());
+
+        let from: number = context
+            ?.getArguments()
+            ?.get(IndexOfArray.PARAMETER_INT_FIND_FROM.getParameterName());
+
+        if (source.length == 0 || secondSource.length == 0)
+            return new FunctionOutput([
+                EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_INTEGER.getName(), -1]])),
+            ]);
+
+        if (from < 0 || from > source.length || source.length < secondSource.length)
+            throw new KIRuntimeException(
+                'Given from second source is more than the size of the source array',
+            );
+
+        let secondSourceSize: number = secondSource.length;
+        let index: number = -1;
+
+        for (let i: number = from; i < source.length; i++) {
+            let j: number = 0;
+            if (PrimitiveUtil.compare(source[i], secondSource[j]) == 0) {
+                while (j < secondSourceSize) {
+                    if (PrimitiveUtil.compare(source[i + j], secondSource[j]) != 0) {
+                        break;
+                    }
+                    j++;
+                }
+                if (j == secondSourceSize) {
+                    index = i;
+                    break;
+                }
+            }
+        }
+
+        return new FunctionOutput([
+            EventResult.outputOf(new Map([[IndexOfArray.EVENT_RESULT_INTEGER.getName(), index]])),
+        ]);
+    }
+}

package/src/engine/function/system/array/Insert.ts

@@ -0,0 +1,48 @@
+import { KIRuntimeException } from '../../../exception/KIRuntimeException';
+import { EventResult } from '../../../model/EventResult';
+import { FunctionOutput } from '../../../model/FunctionOutput';
+import { FunctionExecutionParameters } from '../../../runtime/FunctionExecutionParameters';
+import { isNullValue } from '../../../util/NullCheck';
+import { AbstractArrayFunction } from './AbstractArrayFunction';
+
+export class Insert extends AbstractArrayFunction {
+    public constructor() {
+        super(
+            'Insert',
+            [Insert.PARAMETER_ARRAY_SOURCE, Insert.PARAMETER_INT_OFFSET, Insert.PARAMETER_ANY],
+            Insert.EVENT_RESULT_EMPTY,
+        );
+    }
+
+    protected internalExecute(context: FunctionExecutionParameters): FunctionOutput {
+        let source: any[] = context
+            ?.getArguments()
+            ?.get(Insert.PARAMETER_ARRAY_SOURCE.getParameterName());
+
+        let offset: number = context
+            ?.getArguments()
+            ?.get(Insert.PARAMETER_INT_OFFSET.getParameterName());
+
+        var output = context?.getArguments()?.get(Insert.PARAMETER_ANY.getParameterName());
+
+        if (isNullValue(output) || isNullValue(offset) || offset > source.length)
+            throw new KIRuntimeException('Please valid resouces to insert at the correct location');
+
+        if (source.length == 0) {
+            if (offset == 0) source.push(output);
+            return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+        }
+
+        source.push(output);
+        let len: number = source.length - 1;
+        offset++; // to insert at that point
+
+        while (len >= offset) {
+            let temp: any = source[len - 1];
+            source[len - 1] = source[len];
+            source[len--] = temp;
+        }
+
+        return new FunctionOutput([EventResult.outputOf(new Map([]))]);
+    }
+}