@garrix82/reactgenie-dsl 1.0.0

package/dist/dsl/dsl-interpreter.js

@@ -0,0 +1,767 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DslInterpreter = exports.InvalidParameterTypeError = exports.FunctionStaticError = exports.FunctionMissingError = exports.FieldStaticError = exports.FieldMissingError = exports.ClassMissingError = exports.InterpreterError = void 0;
+const parser_gen_js_1 = require("./parser.gen.js");
+const dsl_descriptor_1 = require("../dsl-descriptor");
+function parseType(value_type) {
+    if (value_type.endsWith("[]")) {
+        return {
+            is_array: true,
+            original_type: value_type.substring(0, value_type.length - 2),
+        };
+    }
+    else {
+        return { is_array: false, original_type: value_type };
+    }
+}
+class InterpreterError extends Error {
+}
+exports.InterpreterError = InterpreterError;
+class ClassMissingError extends InterpreterError {
+    constructor(class_name) {
+        super(`Class ${class_name} is missing`);
+        this.class_name = class_name;
+    }
+}
+exports.ClassMissingError = ClassMissingError;
+class FieldMissingError extends InterpreterError {
+    constructor(class_name, field_name) {
+        super(`Field ${class_name}.${field_name} is missing`);
+        this.class_name = class_name;
+        this.field_name = field_name;
+    }
+}
+exports.FieldMissingError = FieldMissingError;
+class FieldStaticError extends InterpreterError {
+    constructor(class_name, field_name) {
+        super(`Field ${class_name}.${field_name} should be static`);
+        this.class_name = class_name;
+        this.field_name = field_name;
+    }
+}
+exports.FieldStaticError = FieldStaticError;
+class FunctionMissingError extends InterpreterError {
+    constructor(class_name, func_name) {
+        super(`Function ${class_name}.${func_name} is missing`);
+        this.class_name = class_name;
+        this.func_name = func_name;
+    }
+}
+exports.FunctionMissingError = FunctionMissingError;
+class FunctionStaticError extends InterpreterError {
+    constructor(class_name, func_name) {
+        super(`Function ${class_name}.${func_name} should be static`);
+        this.class_name = class_name;
+        this.func_name = func_name;
+    }
+}
+exports.FunctionStaticError = FunctionStaticError;
+class InvalidParameterTypeError extends InterpreterError {
+    constructor(func_name, parameter_name, expected_type, received_type) {
+        super(`Invalid DSL: ${func_name}(${parameter_name}: ...) requires a dotted accessor such as .name, but received ${received_type}.`);
+        this.func_name = func_name;
+        this.parameter_name = parameter_name;
+        this.expected_type = expected_type;
+        this.received_type = received_type;
+    }
+}
+exports.InvalidParameterTypeError = InvalidParameterTypeError;
+class DslInterpreter {
+    matching(value, template) {
+        if (typeof value === "string" && typeof template === "string") {
+            return value.toLowerCase().includes(template.toLowerCase());
+        }
+        if (typeof value === "string" && typeof template === "number") {
+            const parsed = new Date(value);
+            if (!isNaN(parsed.getTime())) {
+                return parsed.getMonth() + 1 === template;
+            }
+            return value.includes(String(template));
+        }
+        if ((typeof value === "number" || typeof value === "boolean") && typeof template === "string") {
+            const asNum = Number(template);
+            if (!isNaN(asNum))
+                return value === asNum;
+            return String(value).toLowerCase() === template.toLowerCase();
+        }
+        if (typeof value === "number" || typeof value === "boolean") {
+            return value === template;
+        }
+        if (value && template && typeof value === "object" && typeof template === "object") {
+            if (typeof value._getConstructorParams === "function" && typeof template._getConstructorParams === "function") {
+                return (JSON.stringify(value._getConstructorParams()) ===
+                    JSON.stringify(template._getConstructorParams()));
+            }
+            return JSON.stringify(value) === JSON.stringify(template);
+        }
+        return false;
+    }
+    contains(value, template) {
+        if (typeof value === "string" && typeof template === "string") {
+            return value.toLowerCase().includes(template.toLowerCase());
+        }
+        if (typeof value === "string" && typeof template === "number") {
+            const parsed = new Date(value);
+            if (!isNaN(parsed.getTime())) {
+                return parsed.getMonth() + 1 === template;
+            }
+            return value.includes(String(template));
+        }
+        else if (Array.isArray(value)) {
+            let contains = false;
+            for (let i = 0; i < value.length; i++) {
+                if (this.matching(value[i], template)) {
+                    contains = true;
+                    break;
+                }
+            }
+            return contains;
+        }
+        else {
+            return value === template;
+        }
+    }
+    equals(a, b) {
+        if (a === b) {
+            return true;
+        }
+        else if (typeof a === "string" && typeof b === "string") {
+            return a.toLowerCase() === b.toLowerCase();
+        }
+        else {
+            return false;
+        }
+    }
+    compareObjectsSafely(left, right) {
+        const leftCompare = left?.constructor?.compare;
+        if (typeof leftCompare === "function") {
+            return leftCompare(left, right);
+        }
+        const rightCompare = right?.constructor?.compare;
+        if (typeof rightCompare === "function") {
+            return rightCompare(left, right);
+        }
+        return null;
+    }
+    constructor(classDescriptors, dry_run = false) {
+        this.dry_run = dry_run;
+        this.arrayFunctionDescriptors = [
+            new dsl_descriptor_1.FuncDescriptor("matching", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("value", "object"),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("contains", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("value", "object"),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("between", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("from", "object", false),
+                new dsl_descriptor_1.ParamDescriptor("to", "object", false),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("equals", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("value", "object"),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("sort", [
+                new dsl_descriptor_1.ParamDescriptor("field", "accessor"),
+                new dsl_descriptor_1.ParamDescriptor("ascending", "boolean"),
+            ], "object[]", false),
+            new dsl_descriptor_1.FuncDescriptor("index", [new dsl_descriptor_1.ParamDescriptor("index", "int")], "object", false),
+            new dsl_descriptor_1.FuncDescriptor("length", [], "int", false)
+        ];
+        this.arrayFunctionImplementations = {
+            matching: async ({ value, array, }) => {
+                return array.filter((element) => {
+                    return this.matching(element.fieldValue, value);
+                }).map((v) => v.element);
+            },
+            contains: async ({ value, array, }) => {
+                return array.filter((element) => {
+                    return this.contains(element.fieldValue, value);
+                }).map((v) => v.element);
+            },
+            between: async ({ from, to, array, }) => {
+                let newArray = [];
+                for (const element of array) {
+                    let first = true;
+                    let second = true;
+                    let value = element.fieldValue;
+                    let valueIsPrimitive = typeof value === "string" ||
+                        typeof value === "number" ||
+                        typeof value === "boolean";
+                    if (from !== undefined) {
+                        let fromIsPrimitive = typeof from === "string" ||
+                            typeof from === "number" ||
+                            typeof from === "boolean";
+                        if (fromIsPrimitive && valueIsPrimitive) {
+                            first = value >= from;
+                        }
+                        else if (fromIsPrimitive && !valueIsPrimitive) {
+                            const compareResult = this.compareObjectsSafely(value, from);
+                            first = compareResult !== null ? compareResult >= 0 : false;
+                        }
+                        else if (!fromIsPrimitive && valueIsPrimitive) {
+                            const compareResult = this.compareObjectsSafely(value, from);
+                            first = compareResult !== null ? compareResult >= 0 : false;
+                        }
+                        else {
+                            const compareResult = this.compareObjectsSafely(value, from);
+                            first = compareResult !== null ? compareResult >= 0 : false;
+                        }
+                    }
+                    if (to !== undefined) {
+                        let toIsPrimitive = typeof to === "string" ||
+                            typeof to === "number" ||
+                            typeof to === "boolean";
+                        if (toIsPrimitive && valueIsPrimitive) {
+                            second = value <= to;
+                        }
+                        else if (toIsPrimitive && !valueIsPrimitive) {
+                            const compareResult = this.compareObjectsSafely(value, to);
+                            second = compareResult !== null ? compareResult <= 0 : false;
+                        }
+                        else if (!toIsPrimitive && valueIsPrimitive) {
+                            const compareResult = this.compareObjectsSafely(value, to);
+                            second = compareResult !== null ? compareResult <= 0 : false;
+                        }
+                        else {
+                            const compareResult = this.compareObjectsSafely(value, to);
+                            second = compareResult !== null ? compareResult <= 0 : false;
+                        }
+                    }
+                    if (first && second) {
+                        newArray.push(element.element);
+                    }
+                }
+                return newArray;
+            },
+            equals: async ({ value, array, }) => {
+                return array.filter((element) => {
+                    return this.equals(element.fieldValue, value);
+                }).map((v) => v.element);
+            },
+            sort: async ({ ascending, array, }) => {
+                return array.sort((a, b) => {
+                    if (ascending) {
+                        if (a.fieldValue < b.fieldValue) {
+                            return -1;
+                        }
+                        else if (a.fieldValue > b.fieldValue) {
+                            return 1;
+                        }
+                        else {
+                            return 0;
+                        }
+                    }
+                    else {
+                        if (a.fieldValue < b.fieldValue) {
+                            return 1;
+                        }
+                        else if (a.fieldValue > b.fieldValue) {
+                            return -1;
+                        }
+                        else {
+                            return 0;
+                        }
+                    }
+                }).map((v) => v.element);
+            },
+            index: async ({ index, array }) => {
+                console.assert(typeof index === "number");
+                if (index < 0) {
+                    index = array.length + index;
+                }
+                return array[index];
+            },
+            length: async ({ array }) => {
+                return array.length;
+            }
+        };
+        this.resolveSteps = [];
+        this.resolveStepsEnabled = false;
+        this.classDescriptors = [...classDescriptors];
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("String", [], [], null));
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("Number", [], [], null));
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("float", [], [], null));
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("int", [], [], null));
+        this.classDescriptors.push(new dsl_descriptor_1.ClassDescriptor("Boolean", [], [], null));
+    }
+    async interpret(input) {
+        const ast = (0, parser_gen_js_1.parse)(input);
+        var lastResult = null;
+        for (const statement of ast) {
+            lastResult = await this.resolve(statement);
+        }
+        return lastResult;
+    }
+    async interpretSteps(input) {
+        const ast = (0, parser_gen_js_1.parse)(input);
+        var lastResult = null;
+        let allSteps = [];
+        for (const statement of ast) {
+            this.resolveSteps = [];
+            this.resolveStepsEnabled = true;
+            lastResult = await this.resolve(statement);
+            this.resolveStepsEnabled = false;
+            allSteps.push({ ast: statement, result: lastResult, steps: this.resolveSteps });
+        }
+        return allSteps;
+    }
+    async describe(ast) {
+        switch (ast.type) {
+            case "array":
+                const elements = [];
+                for (const e of ast.value) {
+                    elements.push(await this.describe(e));
+                }
+                return {
+                    type: "array",
+                    elements: elements,
+                };
+            case "string":
+            case "int":
+            case "boolean":
+                return ast.value;
+            case "object":
+                if (ast.value !== undefined) {
+                    if (ast.objectType == "string" || ast.objectType == "int" || ast.objectType == "float" || ast.objectType == "number") {
+                        return {
+                            type: "object",
+                            objectType: ast.objectType,
+                            value: ast.value,
+                        };
+                    }
+                    else {
+                        if (ast.value.update !== undefined) {
+                            await ast.value.update();
+                        }
+                        return { type: "object", value: await ast.value.description() };
+                    }
+                }
+                else {
+                    console.assert(ast.objectType == "void");
+                    return { type: "object", value: "undefined" };
+                }
+        }
+    }
+    async describeSteps(list) {
+        const steps = [];
+        for (const e of list) {
+            steps.push(await this.describe(e.result));
+        }
+        return steps;
+    }
+    strip(ast) {
+        switch (ast.type) {
+            case "class":
+                return this.classDescriptors.find((c) => c.className === ast.value)
+                    .classConstructor;
+            case "array":
+                return ast.value.map((v) => this.strip(v));
+            case "accessor":
+                return ast;
+            case "string":
+            case "int":
+            case "boolean":
+            case "object":
+                return ast.value;
+        }
+    }
+    async resolve(ast, env = null) {
+        let result = null;
+        switch (ast.type) {
+            case "access":
+                result = await this.resolveAccess(ast, env);
+                break;
+            case "index":
+                result = await this.resolveIndex(ast, env);
+                break;
+            case "function_call":
+                result = await this.resolveFunctionCall(ast, env);
+                break;
+            case "array":
+                result = await this.resolveArray(ast, env);
+                break;
+            case "string":
+            case "int":
+            case "float":
+            case "boolean":
+            case "accessor":
+            case "object":
+                result = ast;
+                break;
+            default:
+                throw new Error("Unsupported AST type: " + ast.type);
+        }
+        if (this.resolveStepsEnabled) {
+            this.resolveSteps.push({ ast: ast, result: result });
+        }
+        return result;
+    }
+    describeResolvedParameterType(param) {
+        if (!param || typeof param !== "object") {
+            return typeof param;
+        }
+        if (param.type === "object" && typeof param.objectType === "string") {
+            return param.objectType;
+        }
+        return param.type || typeof param;
+    }
+    validateResolvedParameters(func_name, funcDescriptor, parameters) {
+        for (const descriptor of funcDescriptor.parameters) {
+            const param = parameters.get(descriptor.name);
+            if (param == null) {
+                continue;
+            }
+            if (descriptor.type === "accessor" && param.type !== "accessor") {
+                throw new InvalidParameterTypeError(func_name, descriptor.name, descriptor.type, this.describeResolvedParameterType(param));
+            }
+        }
+    }
+    async resolveAccess(ast, env) {
+        console.assert(env == null);
+        let parent;
+        if (typeof ast.parent === "string") {
+            parent = { type: "class", value: ast.parent };
+        }
+        else if (ast.parent.type === "object") {
+            parent = ast.parent;
+        }
+        else {
+            parent = await this.resolve(ast.parent, null);
+        }
+        if (typeof ast.access === "string") {
+            const isObject = parent.type === "object";
+            const className = isObject ? parent.objectType : parent.value;
+            const classDescriptor = this.classDescriptors.find((c) => c.className === className);
+            if (classDescriptor === undefined) {
+                if (parent.type == "array") {
+                    const arrayValue = [];
+                    for (const v of parent.value) {
+                        try {
+                            arrayValue.push(await this.resolveAccess({
+                                ...ast,
+                                parent: v
+                            }, env));
+                        }
+                        catch (e) {
+                            console.log(e);
+                        }
+                    }
+                    let objType = null;
+                    if (arrayValue.length > 0) {
+                        objType = arrayValue[0].objectType;
+                    }
+                    return {
+                        type: "array",
+                        value: arrayValue,
+                        objectType: objType
+                    };
+                }
+                else {
+                    throw new ClassMissingError(className);
+                }
+            }
+            const fieldDescriptor = Array.from(classDescriptor.fields).find((f) => f.field === ast.access);
+            if (fieldDescriptor === undefined) {
+                throw new FieldMissingError(className, ast.access);
+            }
+            if (!isObject && !fieldDescriptor.isStatic) {
+                throw new FieldStaticError(className, ast.access);
+            }
+            const fieldType = parseType(fieldDescriptor.fieldType);
+            let fieldValue;
+            if (this.dry_run) {
+                if (fieldType.is_array) {
+                    fieldValue = [null];
+                }
+                else {
+                    fieldValue = null;
+                }
+            }
+            else {
+                if (isObject) {
+                    const parentObject = this.strip(parent);
+                    if (parentObject === undefined || parentObject === null) {
+                        throw new InterpreterError(`Cannot access ${className}.${ast.access}: target object is undefined`);
+                    }
+                    if (!this.dry_run) {
+                        await parentObject.update();
+                    }
+                    fieldValue = parentObject[ast.access];
+                }
+                else {
+                    fieldValue = classDescriptor.classConstructor[ast.access];
+                }
+            }
+            if (fieldType.is_array) {
+                return {
+                    type: "array",
+                    value: fieldValue.map((v) => {
+                        return {
+                            type: "object",
+                            value: v,
+                            objectType: fieldType.original_type,
+                        };
+                    }),
+                };
+            }
+            else {
+                return {
+                    type: "object",
+                    value: fieldValue,
+                    objectType: fieldType.original_type,
+                };
+            }
+        }
+        else {
+            return await this.resolve(ast.access, parent);
+        }
+    }
+    async resolveIndex(ast, env) {
+        console.assert(env == null);
+        let indexParam;
+        if (typeof ast.index === "number") {
+            indexParam = { type: "int", value: ast.index };
+        }
+        else {
+            indexParam = ast.index;
+        }
+        return await this.resolve({
+            type: "access",
+            parent: ast.parent,
+            access: {
+                type: "function_call",
+                func_name: "index",
+                parameters: [{ parameter: "index", value: indexParam }],
+            },
+        }, env);
+    }
+    async resolveArray(ast, env) {
+        console.assert(env == null);
+        const values = [];
+        for (const v of ast.value) {
+            values.push(await this.resolve(v, null));
+        }
+        console.assert(values.every((v) => v.type === "object"));
+        console.assert(values.every((v) => v.objectType === values[0].objectType));
+        return {
+            type: "array",
+            value: values,
+        };
+    }
+    async resolveFunctionCall(ast, env) {
+        const parameter_entries = [];
+        if (ast.parameters !== null) {
+            for (const p of ast.parameters) {
+                parameter_entries.push([p.parameter, await this.resolve(p.value, null)]);
+            }
+        }
+        const parameters = new Map(parameter_entries);
+        let classDescriptor;
+        let funcDescriptor;
+        let isArray = false;
+        let isArrayElementFunction = false;
+        if (env !== null) {
+            switch (env.type) {
+                case "class":
+                    classDescriptor =
+                        this.classDescriptors.find((c) => c.className === env.value);
+                    if (classDescriptor === undefined) {
+                        throw new ClassMissingError(env.value);
+                    }
+                    funcDescriptor = Array.from(classDescriptor.functions).find((f) => f.func_name === ast.func_name);
+                    if (funcDescriptor === undefined) {
+                        throw new FunctionMissingError(env.value, ast.func_name);
+                    }
+                    else if (!funcDescriptor.isStatic) {
+                        throw new FunctionStaticError(env.value, ast.func_name);
+                    }
+                    break;
+                case "object":
+                    classDescriptor = this.classDescriptors.find((c) => c.className === env.objectType);
+                    if (classDescriptor === undefined) {
+                        throw new ClassMissingError(env.objectType);
+                    }
+                    funcDescriptor = Array.from(classDescriptor.functions).find((f) => f.func_name === ast.func_name);
+                    if (funcDescriptor === undefined) {
+                        throw new FunctionMissingError(env.objectType, ast.func_name);
+                    }
+                    break;
+                case "array":
+                    if (env.value.length == 0)
+                        return {
+                            type: "array",
+                            value: [],
+                            objectType: null
+                        };
+                    funcDescriptor = this.arrayFunctionDescriptors.find((f) => f.func_name === ast.func_name);
+                    if (funcDescriptor === undefined || env.value[0]["type"] === "array") {
+                        const arrayValue = [];
+                        for (const v of env.value) {
+                            arrayValue.push(await this.resolveFunctionCall(ast, v));
+                        }
+                        return {
+                            type: "array",
+                            value: arrayValue,
+                            objectType: arrayValue[0].objectType
+                        };
+                    }
+                    if (env.value.length > 0) {
+                        funcDescriptor = JSON.parse(JSON.stringify(funcDescriptor));
+                        funcDescriptor.returnType = funcDescriptor.returnType.replace("object", env.value[0].objectType);
+                    }
+                    isArray = true;
+                    break;
+            }
+        }
+        else {
+            const classDescriptor = this.classDescriptors.find((c) => c.className === ast.func_name);
+            funcDescriptor = Array.from(classDescriptor.functions).find((f) => f.func_name === "constructor");
+        }
+        this.validateResolvedParameters(ast.func_name, funcDescriptor, parameters);
+        let matchedParameters = {};
+        for (const descriptor of funcDescriptor.parameters) {
+            const param = parameters.get(descriptor.name);
+            if (param != null) {
+                matchedParameters[descriptor.name] = this.strip(param);
+            }
+        }
+        if (env === null) {
+            const classDescriptor = this.classDescriptors.find((c) => c.className === ast.func_name);
+            if (this.dry_run) {
+                return {
+                    type: "object",
+                    value: null,
+                    objectType: ast.func_name,
+                };
+            }
+            else {
+                return {
+                    type: "object",
+                    value: new classDescriptor.classConstructor(matchedParameters),
+                    objectType: ast.func_name,
+                };
+            }
+        }
+        const returnType = parseType(funcDescriptor.returnType);
+        if (isArray) {
+            for (const element of env.value) {
+                if (element.type == "object" && !this.dry_run) {
+                    await element.value.update();
+                }
+            }
+            matchedParameters["array"] = this.strip(env);
+            if (matchedParameters["field"] !== undefined) {
+                function constructAccess(accessor, parent) {
+                    if (typeof accessor == "string") {
+                        return {
+                            type: "access",
+                            parent: parent,
+                            access: accessor,
+                        };
+                    }
+                    else {
+                        if (accessor.type == "access") {
+                            return {
+                                type: "access",
+                                parent: constructAccess(accessor.parent, parent),
+                                access: accessor.access,
+                            };
+                        }
+                    }
+                }
+                const field = matchedParameters["field"].field;
+                if (this.dry_run) {
+                    await this.resolve(constructAccess(field, {
+                        type: "object",
+                        value: null,
+                        objectType: returnType.original_type,
+                    }), null);
+                }
+                else {
+                    if (ast.func_name != "index" && ast.func_name != "length") {
+                        const originalArray = matchedParameters["array"];
+                        const array = [];
+                        for (const element of originalArray) {
+                            const fieldValue = await this.strip(await this.resolve(constructAccess(field, {
+                                type: "object",
+                                value: element,
+                                objectType: returnType.original_type,
+                            })));
+                            array.push({
+                                element: element,
+                                fieldValue: fieldValue,
+                            });
+                        }
+                        matchedParameters["array"] = array;
+                    }
+                }
+            }
+        }
+        const targetImplementation = isArray
+            ? this.arrayFunctionImplementations
+            : this.strip(env);
+        if (!isArray &&
+            env?.type === "object" &&
+            !this.dry_run &&
+            (targetImplementation === undefined || targetImplementation === null)) {
+            throw new InterpreterError(`Cannot call ${ast.func_name}: target object is undefined`);
+        }
+        if (returnType.is_array) {
+            if (this.dry_run) {
+                return {
+                    type: "array",
+                    value: [{
+                            type: "object",
+                            value: null,
+                            objectType: returnType.original_type,
+                        }],
+                };
+            }
+            else {
+                if (env.type === "object" && !this.dry_run) {
+                    if (typeof targetImplementation.update !== "function") {
+                        throw new InterpreterError(`Cannot call ${ast.func_name}: target object has no update method`);
+                    }
+                    await targetImplementation.update();
+                }
+                return {
+                    type: "array",
+                    value: (await targetImplementation[ast.func_name](matchedParameters)).map((v) => {
+                        return {
+                            type: "object",
+                            value: v,
+                            objectType: returnType.original_type,
+                        };
+                    }),
+                };
+            }
+        }
+        else {
+            if (this.dry_run) {
+                return {
+                    type: "object",
+                    value: null,
+                    objectType: returnType.original_type,
+                };
+            }
+            else {
+                if (env.type === "object" && !this.dry_run) {
+                    if (typeof targetImplementation.update !== "function") {
+                        throw new InterpreterError(`Cannot call ${ast.func_name}: target object has no update method`);
+                    }
+                    await targetImplementation.update();
+                }
+                return {
+                    type: "object",
+                    value: await (targetImplementation[ast.func_name](matchedParameters)),
+                    objectType: returnType.original_type,
+                };
+            }
+        }
+    }
+}
+exports.DslInterpreter = DslInterpreter;
+//# sourceMappingURL=dsl-interpreter.js.map