@fincity/kirun-js 1.1.0 → 1.1.3

package/src/engine/json/schema/Schema.ts

@@ -7,6 +7,7 @@ import { TypeUtil } from './type/TypeUtil';
 import { Type } from './type/Type';
 import { isNullValue } from '../../util/NullCheck';
 import { SingleType } from './type/SingleType';
+import { SchemaReferenceException } from './validator/exception/SchemaReferenceException';
 
 const ADDITIONAL_PROPERTY: string = 'additionalProperty';
 const ENUMS: string = 'enums';
@@ -279,14 +280,14 @@ export class Schema {
         if (isNullValue(obj)) return undefined;
 
         let schema: Schema = new Schema();
-        schema.namespace = obj.namespace;
+        schema.namespace = obj.namespace ?? TEMPORARY;
         schema.name = obj.name;
 
-        schema.version = obj.version;
+        schema.version = obj.version ?? 1;
 
         schema.ref = obj.ref;
 
-        if (!isStringSchema) schema.type = TypeUtil.from(schema.type);
+        if (!isStringSchema) schema.type = TypeUtil.from(obj.type);
         else schema.type = new SingleType(SchemaType.STRING);
 
         schema.anyOf = Schema.fromListOfSchemas(obj.anyOf);

package/src/engine/json/schema/SchemaUtil.ts

@@ -49,9 +49,9 @@ export class SchemaUtil {
         let parts: string[] = ref.split('/');
         let i: number = 1;
 
-        schema = SchemaUtil.resolveInternalSchema(schema, sRepository, ref, iteration, parts, i);
+        if (i === parts.length) return schema;
 
-        return schema;
+        return SchemaUtil.resolveInternalSchema(schema, sRepository, ref, iteration, parts, i);
     }
 
     private static resolveInternalSchema(
@@ -61,8 +61,9 @@ export class SchemaUtil {
         iteration: number,
         parts: string[],
         i: number,
-    ): Schema {
+    ): Schema | undefined {
         let schema: Schema | undefined = inSchema;
+        if (i === parts.length) return undefined;
         while (i < parts.length) {
             if (parts[i] === '$defs') {
                 i++;
@@ -117,7 +118,6 @@ export class SchemaUtil {
         sRepository: Repository<Schema> | undefined,
         ref: string,
     ): Tuple2<Schema, string> | undefined {
-
         if (!sRepository) return undefined;
 
         let nms = StringUtil.splitAtFirstOccurance(inSchem?.getRef() ?? '', '/');

package/src/engine/json/schema/type/TypeUtil.ts

@@ -12,12 +12,10 @@ export class TypeUtil {
 
     public static from(types: any): Type | undefined {
         if (typeof types === 'string') {
-            return TypeUtil.of(types as SchemaType);
+            return new SingleType(types as SchemaType);
         } else if (Array.isArray(types)) {
-            return TypeUtil.of(
-                ...Array.of(types)
-                    .map((e) => e as any)
-                    .map((e) => e as SchemaType),
+            return new MultipleType(
+                new Set(types.map((e) => e as any).map((e) => e as SchemaType)),
             );
         }
         return undefined;

package/src/engine/json/schema/validator/SchemaValidator.ts

@@ -25,7 +25,10 @@ export class SchemaValidator {
         element: any,
     ): any {
         if (!schema) {
-            return element;
+            throw new SchemaValidationException(
+                SchemaValidator.path(parents),
+                'No schema found to validate',
+            );
         }
 
         if (!parents) {

package/src/engine/model/Event.ts

@@ -2,6 +2,7 @@ import { AdditionalPropertiesType } from '../json/schema/object/AdditionalProper
 import { Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
+import { SchemaReferenceException } from '../json/schema/validator/exception/SchemaReferenceException';
 import { Namespaces } from '../namespaces/Namespaces';
 
 export class Event {
@@ -59,4 +60,18 @@ export class Event {
     ): [string, Event] {
         return [eventName, new Event(eventName, parameters)];
     }
+
+    public static from(json: any): Event {
+        return new Event(
+            json.name,
+            new Map(
+                Object.entries(json.parameters ?? {}).map((e: any) => {
+                    const eventSchema = Schema.from(e[1]);
+                    if (!eventSchema)
+                        throw new SchemaReferenceException('', 'Event expects a schema');
+                    return [e[0], eventSchema];
+                }),
+            ),
+        );
+    }
 }

package/src/engine/model/FunctionDefinition.ts

@@ -7,39 +7,38 @@ import { Parameter } from './Parameter';
 import { Statement } from './Statement';
 import { StatementGroup } from './StatementGroup';
 
+const SCHEMA_NAME1: string = 'FunctionDefinition';
+const IN_SCHEMA = new Schema()
+    .setNamespace(Namespaces.SYSTEM)
+    .setName(SCHEMA_NAME1)
+    .setProperties(
+        new Map([
+            ['name', Schema.ofString('name')],
+            ['namespace', Schema.ofString('namespace')],
+            ['parameters', Schema.ofArray('parameters', Parameter.SCHEMA)],
+            [
+                'events',
+                Schema.ofObject('events').setAdditionalProperties(
+                    new AdditionalPropertiesType().setSchemaValue(Event.SCHEMA),
+                ),
+            ],
+            [
+                'steps',
+                Schema.ofObject('steps').setAdditionalProperties(
+                    new AdditionalPropertiesType().setSchemaValue(Statement.SCHEMA),
+                ),
+            ],
+        ]),
+    );
+
+IN_SCHEMA.getProperties()?.set('parts', Schema.ofArray('parts', IN_SCHEMA));
+
 export class FunctionDefinition extends FunctionSignature {
-    private static readonly SCHEMA_NAME1: string = 'FunctionDefinition';
-    public static readonly SCHEMA: Schema = new Schema()
-        .setNamespace(Namespaces.SYSTEM)
-        .setName(FunctionDefinition.SCHEMA_NAME1)
-        .setProperties(
-            new Map([
-                ['name', Schema.ofString('name')],
-                ['namespace', Schema.ofString('namespace')],
-                ['parameters', Schema.ofArray('parameters', Parameter.SCHEMA)],
-                [
-                    'events',
-                    Schema.ofObject('events').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(Event.SCHEMA),
-                    ),
-                ],
-                [
-                    'parts',
-                    Schema.ofObject('parts').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(FunctionSignature.SCHEMA),
-                    ),
-                ],
-                [
-                    'steps',
-                    Schema.ofObject('steps').setAdditionalProperties(
-                        new AdditionalPropertiesType().setSchemaValue(Statement.SCHEMA),
-                    ),
-                ],
-            ]),
-        );
+    public static readonly SCHEMA: Schema = IN_SCHEMA;
     private version: number = 1;
     private steps?: Map<string, Statement>;
     private stepGroups?: Map<string, StatementGroup>;
+    private parts?: FunctionDefinition[];
 
     constructor(name: string) {
         super(name);
@@ -66,4 +65,52 @@ export class FunctionDefinition extends FunctionSignature {
         this.stepGroups = stepGroups;
         return this;
     }
+
+    public getParts(): FunctionDefinition[] | undefined {
+        return this.parts;
+    }
+
+    public setParts(parts: FunctionDefinition[]): FunctionDefinition {
+        this.parts = parts;
+        return this;
+    }
+
+    public static from(json: any): FunctionDefinition {
+        if (!json) return new FunctionDefinition('unknown');
+        return new FunctionDefinition(json.name)
+            .setSteps(
+                new Map(
+                    Object.values(json.steps ?? {})
+                        .filter((e) => !!e)
+                        .map((e: any) => [e.statementName, Statement.from(e)]),
+                ),
+            )
+            .setStepGroups(
+                new Map(
+                    Object.values(json.stepGroups ?? {})
+                        .filter((e) => !!e)
+                        .map((e: any) => [e.statementGroupName, StatementGroup.from(e)]),
+                ),
+            )
+            .setParts(
+                Array.from(json.parts ?? [])
+                    .filter((e) => !!e)
+                    .map((e: any) => FunctionDefinition.from(e)),
+            )
+            .setVersion(json.version ?? 1)
+            .setEvents(
+                new Map(
+                    Object.values(json.events ?? {})
+                        .filter((e) => !!e)
+                        .map((e: any) => [e.name, Event.from(e)]),
+                ),
+            )
+            .setParameters(
+                new Map(
+                    Object.values(json.parameters ?? {})
+                        .filter((e) => !!e)
+                        .map((e: any) => [e.parameterName, Parameter.from(e)]),
+                ),
+            ) as FunctionDefinition;
+    }
 }

package/src/engine/model/Parameter.ts

@@ -1,6 +1,7 @@
 import { Schema } from '../json/schema/Schema';
 import { SchemaType } from '../json/schema/type/SchemaType';
 import { TypeUtil } from '../json/schema/type/TypeUtil';
+import { SchemaReferenceException } from '../json/schema/validator/exception/SchemaReferenceException';
 import { Namespaces } from '../namespaces/Namespaces';
 import { ParameterType } from './ParameterType';
 
@@ -20,9 +21,11 @@ export class Parameter {
                     'variableArgument',
                     Schema.of('variableArgument', SchemaType.BOOLEAN).setDefaultValue(false),
                 ],
+                ['type', Schema.ofString('type').setEnums(['EXPRESSION', 'CONSTANT'])],
             ]),
         );
 
+    // Place holder for the expression parameter when required to represent an expression in the value.
     public static readonly EXPRESSION: Schema = new Schema()
         .setNamespace(Namespaces.SYSTEM)
         .setName('ParameterExpression')
@@ -94,4 +97,12 @@ export class Parameter {
     ): Parameter {
         return new Parameter(name, schema).setType(type).setVariableArgument(variableArgument);
     }
+
+    public static from(json: any): Parameter {
+        const paramSchema = Schema.from(json.schema);
+        if (!paramSchema) throw new SchemaReferenceException('', 'Parameter requires Schema');
+        return new Parameter(json.parameterName, paramSchema)
+            .setVariableArgument(!!json.variableArguments)
+            .setType(json.type ?? ParameterType.EXPRESSION);
+    }
 }

package/src/engine/model/ParameterReference.ts

@@ -12,9 +12,9 @@ export class ParameterReference {
         .setType(TypeUtil.of(SchemaType.OBJECT))
         .setProperties(
             new Map([
-                ['references', Schema.ofString('references')],
                 ['value', Schema.ofAny('value')],
                 ['expression', Schema.ofString('expression')],
+                ['type', Schema.ofString('type').setEnums(['EXPRESSION', 'VALUE'])],
             ]),
         );
     private type: ParameterReferenceType;
@@ -54,4 +54,11 @@ export class ParameterReference {
     public static ofValue(value: any): ParameterReference {
         return new ParameterReference(ParameterReferenceType.VALUE).setValue(value);
     }
+
+    public static from(json: any): ParameterReference[] {
+        if (!json) return [];
+        return Array.from(json).map((e: any) =>
+            new ParameterReference(e.type).setValue(e.value).setExpression(e.expression),
+        );
+    }
 }

package/src/engine/model/Position.ts

@@ -37,4 +37,9 @@ export class Position {
         this.top = top;
         return this;
     }
+
+    public static from(json: any): Position {
+        if (!json) return new Position(-1, -1);
+        return new Position(json.left, json.top);
+    }
 }

package/src/engine/model/Statement.ts

@@ -98,4 +98,20 @@ export class Statement extends AbstractStatement {
     public static ofEntry(statement: Statement): [string, Statement] {
         return [statement.statementName, statement];
     }
+
+    public static from(json: any): Statement {
+        return new Statement(json.statementName, json.namespace, json.name)
+            .setParameterMap(
+                new Map<string, ParameterReference[]>(
+                    Object.entries(json.parameterMap ?? {}).map(([k, v]) => [
+                        k,
+                        ParameterReference.from(v),
+                    ]),
+                ),
+            )
+            .setDependentStatements(json.dependentStatements)
+            .setPosition(Position.from(json.position))
+            .setComment(json.comment)
+            .setDescription(json.description) as Statement;
+    }
 }

package/src/engine/model/StatementGroup.ts

@@ -34,4 +34,11 @@ export class StatementGroup extends AbstractStatement {
         this.statementGroupName = statementGroupName;
         return this;
     }
+
+    public static from(json: any): StatementGroup {
+        return new StatementGroup(json.statementGroupName)
+            .setPosition(Position.from(json.position))
+            .setComment(json.comment)
+            .setDescription(json.description) as StatementGroup;
+    }
 }

package/src/engine/runtime/FunctionExecutionParameters.ts

@@ -1,3 +1,6 @@
+import { Function } from '../function/Function';
+import { Schema } from '../json/schema/Schema';
+import { Repository } from '../Repository';
 import { ContextElement } from './ContextElement';
 import { TokenValueExtractor } from './expression/tokenextractor/TokenValueExtractor';
 import { StatementExecution } from './StatementExecution';
@@ -12,9 +15,19 @@ export class FunctionExecutionParameters {
     private statementExecution?: StatementExecution;
     private steps?: Map<string, Map<string, Map<string, any>>>;
     private count: number = 0;
+    private functionRepository: Repository<Function>;
+    private schemaRepository: Repository<Schema>;
 
     private valueExtractors: Map<string, TokenValueExtractor> = new Map();
 
+    public constructor(
+        functionRepository: Repository<Function>,
+        schemaRepository: Repository<Schema>,
+    ) {
+        this.functionRepository = functionRepository;
+        this.schemaRepository = schemaRepository;
+    }
+
     public getContext(): Map<string, ContextElement> | undefined {
         return this.context;
     }
@@ -71,4 +84,21 @@ export class FunctionExecutionParameters {
     public getValuesMap(): Map<string, TokenValueExtractor> {
         return this.valueExtractors;
     }
+
+    public getFunctionRepository(): Repository<Function> {
+        return this.functionRepository;
+    }
+    public setFunctionRepository(
+        functionRepository: Repository<Function>,
+    ): FunctionExecutionParameters {
+        this.functionRepository = functionRepository;
+        return this;
+    }
+    public getSchemaRepository(): Repository<Schema> {
+        return this.schemaRepository;
+    }
+    public setSchemaRepository(schemaRepository: Repository<Schema>): FunctionExecutionParameters {
+        this.schemaRepository = schemaRepository;
+        return this;
+    }
 }

package/src/engine/runtime/KIRuntime.ts

@@ -43,15 +43,7 @@ export class KIRuntime extends AbstractFunction {
 
     private fd: FunctionDefinition;
 
-    private fRepo: Repository<Function>;
-
-    private sRepo: Repository<Schema>;
-
-    public constructor(
-        fd: FunctionDefinition,
-        functionRepository: Repository<Function>,
-        schemaRepository: Repository<Schema>,
-    ) {
+    public constructor(fd: FunctionDefinition) {
         super();
         this.fd = fd;
         if (this.fd.getVersion() > KIRuntime.VERSION) {
@@ -63,9 +55,6 @@ export class KIRuntime extends AbstractFunction {
                     '.',
             );
         }
-
-        this.fRepo = functionRepository;
-        this.sRepo = schemaRepository;
     }
 
     public getSignature(): FunctionSignature {
@@ -74,10 +63,18 @@ export class KIRuntime extends AbstractFunction {
 
     private async getExecutionPlan(
         context: Map<string, ContextElement>,
+        fep: FunctionExecutionParameters,
     ): Promise<ExecutionGraph<string, StatementExecution>> {
         let g: ExecutionGraph<string, StatementExecution> = new ExecutionGraph();
         for (let s of Array.from(this.fd.getSteps().values()))
-            g.addVertex(this.prepareStatementExecution(context, s));
+            g.addVertex(
+                this.prepareStatementExecution(
+                    context,
+                    s,
+                    fep.getFunctionRepository(),
+                    fep.getSchemaRepository(),
+                ),
+            );
 
         let unresolvedList: Tuple2<string, string>[] = this.makeEdges(g);
 
@@ -106,6 +103,7 @@ export class KIRuntime extends AbstractFunction {
 
         let eGraph: ExecutionGraph<string, StatementExecution> = await this.getExecutionPlan(
             inContext.getContext()!,
+            inContext,
         );
 
         // if (logger.isDebugEnabled()) {
@@ -185,7 +183,14 @@ export class KIRuntime extends AbstractFunction {
 
             if (!(await this.allDependenciesResolvedVertex(vertex, inContext.getSteps()!)))
                 executionQue.add(vertex);
-            else await this.executeVertex(vertex, inContext, branchQue, executionQue);
+            else
+                await this.executeVertex(
+                    vertex,
+                    inContext,
+                    branchQue,
+                    executionQue,
+                    inContext.getFunctionRepository(),
+                );
         }
     }
 
@@ -265,10 +270,11 @@ export class KIRuntime extends AbstractFunction {
             >
         >,
         executionQue: LinkedList<GraphVertex<string, StatementExecution>>,
+        fRepo: Repository<Function>,
     ) {
         let s: Statement = vertex.getData().getStatement();
 
-        let fun: Function | undefined = this.fRepo.find(s.getNamespace(), s.getName());
+        let fun: Function | undefined = fRepo.find(s.getNamespace(), s.getName());
 
         if (!fun) {
             throw new KIRuntimeException(
@@ -287,7 +293,10 @@ export class KIRuntime extends AbstractFunction {
         let context: Map<string, ContextElement> = inContext.getContext()!;
 
         let result: FunctionOutput = await fun.execute(
-            new FunctionExecutionParameters()
+            new FunctionExecutionParameters(
+                inContext.getFunctionRepository(),
+                inContext.getSchemaRepository(),
+            )
                 .setContext(context)
                 .setArguments(args)
                 .setEvents(inContext.getEvents()!)
@@ -455,10 +464,12 @@ export class KIRuntime extends AbstractFunction {
     private prepareStatementExecution(
         context: Map<string, ContextElement>,
         s: Statement,
+        fRepo: Repository<Function>,
+        sRepo: Repository<Schema>,
     ): StatementExecution {
         let se: StatementExecution = new StatementExecution(s);
 
-        let fun: Function | undefined = this.fRepo.find(s.getNamespace(), s.getName());
+        let fun: Function | undefined = fRepo.find(s.getNamespace(), s.getName());
 
         if (!fun) {
             throw new KIRuntimeException(
@@ -475,7 +486,7 @@ export class KIRuntime extends AbstractFunction {
             let refList: ParameterReference[] = param[1];
 
             if (!refList.length) {
-                if (isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), this.sRepo)))
+                if (isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), sRepo)))
                     se.addMessage(
                         StatementMessageType.ERROR,
                         StringFormatter.format(
@@ -487,10 +498,11 @@ export class KIRuntime extends AbstractFunction {
             }
 
             if (p.isVariableArgument()) {
-                for (let ref of refList) this.parameterReferenceValidation(context, se, p, ref);
+                for (let ref of refList)
+                    this.parameterReferenceValidation(context, se, p, ref, sRepo);
             } else {
                 let ref: ParameterReference = refList[0];
-                this.parameterReferenceValidation(context, se, p, ref);
+                this.parameterReferenceValidation(context, se, p, ref, sRepo);
             }
 
             paramSet.delete(p.getParameterName());
@@ -503,7 +515,7 @@ export class KIRuntime extends AbstractFunction {
 
         if (paramSet.size) {
             for (let param of Array.from(paramSet.values())) {
-                if (isNullValue(SchemaUtil.getDefaultValue(param.getSchema(), this.sRepo)))
+                if (isNullValue(SchemaUtil.getDefaultValue(param.getSchema(), sRepo)))
                     se.addMessage(
                         StatementMessageType.ERROR,
                         StringFormatter.format(
@@ -522,11 +534,12 @@ export class KIRuntime extends AbstractFunction {
         se: StatementExecution,
         p: Parameter,
         ref: ParameterReference,
+        sRepo: Repository<Schema>,
     ): void {
         // Breaking this execution doesn't make sense.
 
         if (!ref) {
-            if (isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), this.sRepo)))
+            if (isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), sRepo)))
                 se.addMessage(
                     StatementMessageType.ERROR,
                     StringFormatter.format(KIRuntime.PARAMETER_NEEDS_A_VALUE, p.getParameterName()),
@@ -534,7 +547,7 @@ export class KIRuntime extends AbstractFunction {
         } else if (ref.getType() == ParameterReferenceType.VALUE) {
             if (
                 isNullValue(ref.getValue()) &&
-                isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), this.sRepo))
+                isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), sRepo))
             )
                 se.addMessage(
                     StatementMessageType.ERROR,
@@ -598,7 +611,7 @@ export class KIRuntime extends AbstractFunction {
             }
         } else if (ref.getType() == ParameterReferenceType.EXPRESSION) {
             if (StringUtil.isNullOrBlank(ref.getExpression())) {
-                if (isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), this.sRepo)))
+                if (isNullValue(SchemaUtil.getDefaultValue(p.getSchema(), sRepo)))
                     se.addMessage(
                         StatementMessageType.ERROR,
                         StringFormatter.format(

package/src/index.ts

@@ -23,36 +23,6 @@ export * from './engine/runtime/KIRuntime';
 export * from './engine/runtime/StatementMessageType';
 export * from './engine/runtime/FunctionExecutionParameters';
 export * from './engine/runtime/expression/Expression';
-export * from './engine/runtime/expression/operators/unary/BitwiseComplementOperator';
-export * from './engine/runtime/expression/operators/unary/LogicalNotOperator';
-export * from './engine/runtime/expression/operators/unary/ArithmeticUnaryPlusOperator';
-export * from './engine/runtime/expression/operators/unary/ArithmeticUnaryMinusOperator';
-export * from './engine/runtime/expression/operators/unary/index';
-export * from './engine/runtime/expression/operators/unary/UnaryOperator';
-export * from './engine/runtime/expression/operators/binary/ArithmeticSubtractionOperator';
-export * from './engine/runtime/expression/operators/binary/ArrayOperator';
-export * from './engine/runtime/expression/operators/binary/BitwiseUnsignedRightShiftOperator';
-export * from './engine/runtime/expression/operators/binary/LogicalLessThanEqualOperator';
-export * from './engine/runtime/expression/operators/binary/ObjectOperator';
-export * from './engine/runtime/expression/operators/binary/BitwiseLeftShiftOperator';
-export * from './engine/runtime/expression/operators/binary/LogicalGreaterThanEqualOperator';
-export * from './engine/runtime/expression/operators/binary/LogicalGreaterThanOperator';
-export * from './engine/runtime/expression/operators/binary/ArithmeticMultiplicationOperator';
-export * from './engine/runtime/expression/operators/binary/BitwiseRightShiftOperator';
-export * from './engine/runtime/expression/operators/binary/BitwiseOrOperator';
-export * from './engine/runtime/expression/operators/binary/LogicalNotEqualOperator';
-export * from './engine/runtime/expression/operators/binary/ArithmeticAdditionOperator';
-export * from './engine/runtime/expression/operators/binary/BitwiseAndOperator';
-export * from './engine/runtime/expression/operators/binary/BinaryOperator';
-export * from './engine/runtime/expression/operators/binary/LogicalAndOperator';
-export * from './engine/runtime/expression/operators/binary/LogicalLessThanOperator';
-export * from './engine/runtime/expression/operators/binary/LogicalOrOperator';
-export * from './engine/runtime/expression/operators/binary/index';
-export * from './engine/runtime/expression/operators/binary/ArithmeticDivisionOperator';
-export * from './engine/runtime/expression/operators/binary/BitwiseXorOperator';
-export * from './engine/runtime/expression/operators/binary/ArithmeticModulusOperator';
-export * from './engine/runtime/expression/operators/binary/ArithmeticInetgerDivisionOperator';
-export * from './engine/runtime/expression/operators/binary/LogicalEqualOperator';
 export * from './engine/runtime/expression/tokenextractor/TokenValueExtractor';
 export * from './engine/runtime/expression/tokenextractor/LiteralTokenValueExtractor';
 export * from './engine/runtime/expression/ExpressionEvaluator';
@@ -104,3 +74,5 @@ export * from './engine/model/Argument';
 export * from './engine/model/ParameterReference';
 export * from './engine/exception/ExecutionException';
 export * from './engine/exception/KIRuntimeException';
+export * from './engine/runtime/expression/operators/unary';
+export * from './engine/runtime/expression/operators/binary';