@dronedeploy/rocos-js-sdk 3.0.10 → 3.0.12

package/esm/helpers/kscript/nodes/expressions/AssignmentExpression.js

@@ -0,0 +1,27 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class AssignmentExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'AssignmentExpression');
+    }
+    validate(validateChildren = false) {
+        if (this.node.operator !== '=') {
+            throw new Error('Only = operator is supported');
+        }
+        if (this.node.left.type !== 'Identifier') {
+            throw new Error('Left side of assignment must be an identifier');
+        }
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.left, this.context).validate(true);
+        construct(this.node.right, this.context).validate(true);
+    }
+    run() {
+        this.validate();
+        const identifier = this.node.left.name;
+        const right = construct(this.node.right, this.context).run();
+        this.context.set(identifier, right);
+        return right;
+    }
+}

package/esm/helpers/kscript/nodes/expressions/BinaryExpression.d.ts

@@ -6,9 +6,17 @@ import Node from '../Node';
  * e.g. `1 + 2`, `a === b`, `c < d`
  */
 export default class BinaryExpressionNode extends Node<BinaryExpression> {
+    private static readonly EQUALITY_OPERATORS;
+    private static readonly COMPARISON_OPERATORS;
+    private static readonly ARITHMETIC_OPERATORS;
+    private static readonly BITWISE_OPERATORS;
+    private static readonly IN_OPERATOR;
+    private static readonly SUPPORTED_OPERATORS;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
     private operate;
+    private bitwise;
     private arithmetic;
     private comparison;
     private equality;

package/esm/helpers/kscript/nodes/expressions/BinaryExpression.js

@@ -4,38 +4,52 @@ import { construct } from '../../utils';
  *
  * e.g. `1 + 2`, `a === b`, `c < d`
  */
-export default class BinaryExpressionNode extends Node {
+class BinaryExpressionNode extends Node {
     constructor(node, context) {
         super(node, context, 'BinaryExpression');
     }
+    validate(validateChildren = false) {
+        if (!BinaryExpressionNode.SUPPORTED_OPERATORS.has(this.node.operator)) {
+            throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.left, this.context).validate(true);
+        construct(this.node.right, this.context).validate(true);
+    }
     run() {
         const left = construct(this.node.left, this.context).run();
         const right = construct(this.node.right, this.context).run();
         return this.operate(left, right);
     }
     operate(left, right) {
-        switch (this.node.operator) {
-            case '==':
-            case '!=':
-            case '===':
-            case '!==':
-                return this.equality(this.node.operator, left, right);
-            case '<':
-            case '<=':
-            case '>':
-            case '>=':
-                return this.comparison(this.node.operator, left, right);
-            case 'in':
-                return this.checkIn(left, right);
-            case '**':
-            case '+':
-            case '-':
-            case '*':
-            case '/':
-            case '%':
-                return this.arithmetic(this.node.operator, left, right);
-            default:
-                throw new Error(`Unsupported operator: ${this.node.operator}`);
+        if (BinaryExpressionNode.EQUALITY_OPERATORS.has(this.node.operator)) {
+            return this.equality(this.node.operator, left, right);
+        }
+        if (BinaryExpressionNode.COMPARISON_OPERATORS.has(this.node.operator)) {
+            return this.comparison(this.node.operator, left, right);
+        }
+        if (BinaryExpressionNode.ARITHMETIC_OPERATORS.has(this.node.operator)) {
+            return this.arithmetic(this.node.operator, left, right);
+        }
+        if (BinaryExpressionNode.BITWISE_OPERATORS.has(this.node.operator)) {
+            return this.bitwise(this.node.operator, left, right);
+        }
+        if (this.node.operator === BinaryExpressionNode.IN_OPERATOR) {
+            return this.checkIn(left, right);
+        }
+        throw new Error(`Unsupported operator: ${this.node.operator}`);
+    }
+    bitwise(operator, left, right) {
+        if (typeof left !== 'number' || typeof right !== 'number') {
+            throw new Error('Bitwise operators are only supported for numbers');
+        }
+        switch (operator) {
+            case '<<':
+                return left << right;
+            case '>>':
+                return left >> right;
         }
     }
     arithmetic(operator, left, right) {
@@ -96,3 +110,23 @@ export default class BinaryExpressionNode extends Node {
         return right.includes(left);
     }
 }
+BinaryExpressionNode.EQUALITY_OPERATORS = new Set(['==', '!=', '===', '!==']);
+BinaryExpressionNode.COMPARISON_OPERATORS = new Set(['<', '<=', '>', '>=']);
+BinaryExpressionNode.ARITHMETIC_OPERATORS = new Set([
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '**',
+]);
+BinaryExpressionNode.BITWISE_OPERATORS = new Set(['<<', '>>']);
+BinaryExpressionNode.IN_OPERATOR = 'in';
+BinaryExpressionNode.SUPPORTED_OPERATORS = new Set([
+    ...BinaryExpressionNode.EQUALITY_OPERATORS,
+    ...BinaryExpressionNode.COMPARISON_OPERATORS,
+    ...BinaryExpressionNode.ARITHMETIC_OPERATORS,
+    ...BinaryExpressionNode.BITWISE_OPERATORS,
+    BinaryExpressionNode.IN_OPERATOR,
+]);
+export default BinaryExpressionNode;

package/esm/helpers/kscript/nodes/expressions/CallExpression.d.ts

@@ -3,6 +3,7 @@ import Context from '../../Context';
 import Node from '../Node';
 export default class CallExpressionNode extends Node<CallExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
     private spreadArgs;
 }

package/esm/helpers/kscript/nodes/expressions/CallExpression.js

@@ -4,9 +4,19 @@ export default class CallExpressionNode extends Node {
     constructor(node, context) {
         super(node, context, 'CallExpression');
     }
-    run() {
+    validate(validateChildren = false) {
         if (!this.context.isFunctionCallAllowed)
             throw new Error('Function calls are not allowed');
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.callee, this.context).validate(true);
+        for (const arg of this.node.arguments) {
+            construct(arg, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
         const callee = construct(this.node.callee, this.context).run();
         let thisArg = {};
         if (this.node.callee.type === 'MemberExpression') {

package/esm/helpers/kscript/nodes/expressions/ChainExpression.d.ts

@@ -12,5 +12,6 @@ import Node from '../Node';
  */
 export default class ExpressionStatementNode extends Node<ChainExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(): void;
     run(): unknown;
 }

package/esm/helpers/kscript/nodes/expressions/ChainExpression.js

@@ -13,6 +13,7 @@ export default class ExpressionStatementNode extends Node {
     constructor(node, context) {
         super(node, context, 'ChainExpression');
     }
+    validate() { }
     run() {
         return construct(this.node.expression, this.context).run();
     }

package/esm/helpers/kscript/nodes/expressions/ConditionalExpression.d.ts

@@ -10,5 +10,6 @@ import Node from '../Node';
  */
 export default class ConditionalExpressionNode extends Node<IfStatement | ConditionalExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren: boolean): void;
     run(): unknown;
 }

package/esm/helpers/kscript/nodes/expressions/ConditionalExpression.js

@@ -11,6 +11,16 @@ export default class ConditionalExpressionNode extends Node {
     constructor(node, context) {
         super(node, context, ['ConditionalExpression', 'IfStatement']);
     }
+    validate(validateChildren) {
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.test, this.context).validate(true);
+        construct(this.node.consequent, this.context).validate(true);
+        if (this.node.alternate !== null && this.node.alternate !== undefined) {
+            construct(this.node.alternate, this.context).validate(true);
+        }
+    }
     run() {
         const test = construct(this.node.test, this.context).run();
         if (test) {

package/esm/helpers/kscript/nodes/expressions/LogicalExpression.d.ts

@@ -2,7 +2,9 @@ import { AnyNode, LogicalExpression } from 'acorn';
 import Context from '../../Context';
 import Node from '../Node';
 export default class BinaryExpressionNode extends Node<LogicalExpression> {
+    private static readonly SUPPORTED_OPERATORS;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren: boolean): void;
     run(): unknown;
     /** Try and skip evaluating the right operand */
     private shortCircuit;

package/esm/helpers/kscript/nodes/expressions/LogicalExpression.js

@@ -1,9 +1,19 @@
 import Node from '../Node';
 import { construct } from '../../utils';
-export default class BinaryExpressionNode extends Node {
+class BinaryExpressionNode extends Node {
     constructor(node, context) {
         super(node, context, 'LogicalExpression');
     }
+    validate(validateChildren) {
+        if (!BinaryExpressionNode.SUPPORTED_OPERATORS.has(this.node.operator)) {
+            throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.left, this.context).validate(true);
+        construct(this.node.right, this.context).validate(true);
+    }
     run() {
         const left = construct(this.node.left, this.context).run();
         const shortCircuit = this.shortCircuit(left);
@@ -39,3 +49,5 @@ export default class BinaryExpressionNode extends Node {
         }
     }
 }
+BinaryExpressionNode.SUPPORTED_OPERATORS = new Set(['||', '&&', '??']);
+export default BinaryExpressionNode;

package/esm/helpers/kscript/nodes/expressions/MemberExpression.d.ts

@@ -22,6 +22,7 @@ import Node from '../Node';
  */
 export default class MemberExpressionNode extends Node<MemberExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
     /** Returns the name of the property being accessed.
      *

package/esm/helpers/kscript/nodes/expressions/MemberExpression.js

@@ -23,6 +23,13 @@ export default class MemberExpressionNode extends Node {
     constructor(node, context) {
         super(node, context, 'MemberExpression');
     }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.object, this.context).validate(true);
+        construct(this.node.property, this.context).validate(true);
+    }
     run() {
         const object = construct(this.node.object, this.context).run();
         if (object === null || object === undefined) {

package/esm/helpers/kscript/nodes/expressions/NewExpression.d.ts

@@ -0,0 +1,9 @@
+import { AnyNode, NewExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class NewExpressionNode extends Node<NewExpression> {
+    constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
+    run(): unknown;
+    private spreadArgs;
+}

package/esm/helpers/kscript/nodes/expressions/NewExpression.js

@@ -0,0 +1,38 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class NewExpressionNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'NewExpression');
+    }
+    validate(validateChildren = false) {
+        if (!this.context.isFunctionCallAllowed)
+            throw new Error('Constructors are not allowed');
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.callee, this.context).validate(true);
+        for (const arg of this.node.arguments) {
+            construct(arg, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
+        const callee = construct(this.node.callee, this.context).run();
+        if (typeof callee !== 'function') {
+            throw new Error('callee is not a function');
+        }
+        const args = this.spreadArgs(this.node.arguments);
+        return new (Function.prototype.bind.apply(callee, [null, ...args]))();
+    }
+    spreadArgs(args) {
+        return args.reduce((acc, arg) => {
+            if (arg.type === 'SpreadElement') {
+                acc.push(...construct(arg.argument, this.context).run());
+            }
+            else {
+                acc.push(construct(arg, this.context).run());
+            }
+            return acc;
+        }, []);
+    }
+}

package/esm/helpers/kscript/nodes/expressions/ObjectExpression.d.ts

@@ -3,6 +3,7 @@ import type Context from '../../Context';
 import Node from '../Node';
 export default class ObjectExpressionNode extends Node<ObjectExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren: boolean): void;
     run(): unknown;
     private addProperty;
     private spreadProperty;

package/esm/helpers/kscript/nodes/expressions/ObjectExpression.js

@@ -4,6 +4,35 @@ export default class ObjectExpressionNode extends Node {
     constructor(node, context) {
         super(node, context, 'ObjectExpression');
     }
+    validate(validateChildren) {
+        for (const property of this.node.properties) {
+            // SpreadElements do not need to be validated - they only have a single argument
+            if (property.type === 'SpreadElement') {
+                continue;
+            }
+            if (property.kind !== 'init') {
+                // do not support getters or setters
+                throw new Error('Only init properties are supported');
+            }
+            if (!property.computed) {
+                // ensure that the key is valid
+                this.getStaticKey(property.key);
+            }
+        }
+        if (!validateChildren) {
+            return;
+        }
+        for (const property of this.node.properties) {
+            if (property.type === 'SpreadElement') {
+                construct(property.argument, this.context).validate(true);
+                continue;
+            }
+            if (property.computed) {
+                construct(property.key, this.context).validate(true);
+            }
+            construct(property.value, this.context).validate(true);
+        }
+    }
     run() {
         const object = {};
         for (const property of this.node.properties) {

package/esm/helpers/kscript/nodes/expressions/UnaryExpression.d.ts

@@ -6,7 +6,9 @@ import Node from '../Node';
  * e.g. `+1`, `-2`, `!true`, `typeof x`
  */
 export default class UnaryExpressionNode extends Node<UnaryExpression> {
+    private static readonly SUPPORTED_OPERATORS;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren: boolean): void;
     run(): unknown;
     private arithmetic;
 }

package/esm/helpers/kscript/nodes/expressions/UnaryExpression.js

@@ -4,10 +4,18 @@ import { construct } from '../../utils';
  *
  * e.g. `+1`, `-2`, `!true`, `typeof x`
  */
-export default class UnaryExpressionNode extends Node {
+class UnaryExpressionNode extends Node {
     constructor(node, context) {
         super(node, context, 'UnaryExpression');
     }
+    validate(validateChildren) {
+        if (!UnaryExpressionNode.SUPPORTED_OPERATORS.has(this.node.operator)) {
+            throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+        if (validateChildren) {
+            construct(this.node.argument, this.context).validate(true);
+        }
+    }
     run() {
         const argument = construct(this.node.argument, this.context).run();
         switch (this.node.operator) {
@@ -36,3 +44,5 @@ export default class UnaryExpressionNode extends Node {
         }
     }
 }
+UnaryExpressionNode.SUPPORTED_OPERATORS = new Set(['+', '-', '!', 'typeof']);
+export default UnaryExpressionNode;

package/esm/helpers/kscript/nodes/expressions/index.d.ts

@@ -1,4 +1,3 @@
-export { default as ExpressionStatement } from './ExpressionStatement';
 export { default as ArrayExpression } from './ArrayExpression';
 export { default as ObjectExpression } from './ObjectExpression';
 export { default as BinaryExpression } from './BinaryExpression';
@@ -9,3 +8,5 @@ export { default as CallExpression } from './CallExpression';
 export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
 export { default as MemberExpression } from './MemberExpression';
 export { default as ChainExpression } from './ChainExpression';
+export { default as NewExpression } from './NewExpression';
+export { default as AssignmentExpression } from './AssignmentExpression';

package/esm/helpers/kscript/nodes/expressions/index.js

@@ -1,4 +1,3 @@
-export { default as ExpressionStatement } from './ExpressionStatement';
 export { default as ArrayExpression } from './ArrayExpression';
 export { default as ObjectExpression } from './ObjectExpression';
 export { default as BinaryExpression } from './BinaryExpression';
@@ -9,3 +8,5 @@ export { default as CallExpression } from './CallExpression';
 export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
 export { default as MemberExpression } from './MemberExpression';
 export { default as ChainExpression } from './ChainExpression';
+export { default as NewExpression } from './NewExpression';
+export { default as AssignmentExpression } from './AssignmentExpression';

package/esm/helpers/kscript/nodes/nodeTypes.d.ts

@@ -1,4 +1,5 @@
-import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression } from './expressions';
+import { ArrayExpression, ArrowFunctionExpression, AssignmentExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, LogicalExpression, MemberExpression, NewExpression, ObjectExpression, UnaryExpression } from './expressions';
+import { BlockStatement, ExpressionStatement, ReturnStatement, SwitchStatement } from './statements';
 import { AnyNode } from 'acorn';
 import type Context from '../Context';
 import Identifier from './Identifier';
@@ -6,6 +7,7 @@ import Literal from './Literal';
 import Node from './Node';
 import Program from './Program';
 import TemplateLiteral from './TemplateLiteral';
+import VariableDeclaration from './VariableDeclaration';
 type NodeConstructor = {
     new (node: AnyNode, scope: Context): Node<AnyNode>;
 };
@@ -27,6 +29,12 @@ declare const nodes: {
     readonly CallExpression: typeof CallExpression;
     readonly MemberExpression: typeof MemberExpression;
     readonly ChainExpression: typeof ChainExpression;
+    readonly NewExpression: typeof NewExpression;
+    readonly BlockStatement: typeof BlockStatement;
+    readonly ReturnStatement: typeof ReturnStatement;
+    readonly VariableDeclaration: typeof VariableDeclaration;
+    readonly AssignmentExpression: typeof AssignmentExpression;
+    readonly SwitchStatement: typeof SwitchStatement;
 };
 export type NodeType = keyof typeof nodes;
 declare const _default: NodeMap;

package/esm/helpers/kscript/nodes/nodeTypes.js

@@ -1,8 +1,10 @@
-import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression, } from './expressions';
+import { ArrayExpression, ArrowFunctionExpression, AssignmentExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, LogicalExpression, MemberExpression, NewExpression, ObjectExpression, UnaryExpression, } from './expressions';
+import { BlockStatement, ExpressionStatement, ReturnStatement, SwitchStatement } from './statements';
 import Identifier from './Identifier';
 import Literal from './Literal';
 import Program from './Program';
 import TemplateLiteral from './TemplateLiteral';
+import VariableDeclaration from './VariableDeclaration';
 const nodes = {
     Program,
     Literal,
@@ -20,5 +22,11 @@ const nodes = {
     CallExpression,
     MemberExpression,
     ChainExpression,
+    NewExpression,
+    BlockStatement,
+    ReturnStatement,
+    VariableDeclaration,
+    AssignmentExpression,
+    SwitchStatement,
 };
 export default new Map(Object.entries(nodes));

package/esm/helpers/kscript/nodes/statements/BlockStatement.d.ts

@@ -0,0 +1,8 @@
+import { AnyNode, BlockStatement } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class BlockStatementNode extends Node<BlockStatement> {
+    constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
+    run(): unknown;
+}

package/esm/helpers/kscript/nodes/statements/BlockStatement.js

@@ -0,0 +1,23 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class BlockStatementNode extends Node {
+    constructor(node, context) {
+        super(node, context.newChild(), 'BlockStatement');
+    }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        for (const statement of this.node.body) {
+            construct(statement, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
+        let result;
+        for (const statement of this.node.body) {
+            result = construct(statement, this.context).run();
+        }
+        return result;
+    }
+}

package/esm/helpers/kscript/nodes/{expressions → statements}/ExpressionStatement.d.ts

@@ -3,5 +3,6 @@ import Context from '../../Context';
 import Node from '../Node';
 export default class ExpressionStatementNode extends Node<ExpressionStatement> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/esm/helpers/kscript/nodes/{expressions → statements}/ExpressionStatement.js

@@ -4,9 +4,16 @@ export default class ExpressionStatementNode extends Node {
     constructor(node, context) {
         super(node, context, 'ExpressionStatement');
     }
-    run() {
+    validate(validateChildren = false) {
         if (this.node.directive)
             throw new Error('Directives are not supported');
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.expression, this.context).validate(true);
+    }
+    run() {
+        this.validate();
         return construct(this.node.expression, this.context).run();
     }
 }

package/esm/helpers/kscript/nodes/statements/ReturnStatement.d.ts

@@ -0,0 +1,12 @@
+import { AnyNode, ReturnStatement } from 'acorn';
+import type Context from '../../Context';
+import Node from '../Node';
+export declare class ReturnStatementError extends Error {
+    readonly value: unknown;
+    constructor(value: unknown);
+}
+export default class ReturnStatementNode extends Node<ReturnStatement> {
+    constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
+    run(): unknown;
+}

package/esm/helpers/kscript/nodes/statements/ReturnStatement.js

@@ -0,0 +1,25 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export class ReturnStatementError extends Error {
+    constructor(value) {
+        super('Illegal return statement');
+        this.value = value;
+    }
+}
+export default class ReturnStatementNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'ReturnStatement');
+    }
+    validate(validateChildren = false) {
+        const arg = this.node.argument;
+        if (!validateChildren || arg === undefined || arg === null) {
+            return;
+        }
+        construct(arg, this.context).validate(true);
+    }
+    run() {
+        this.validate();
+        const result = this.node.argument ? construct(this.node.argument, this.context).run() : undefined;
+        throw new ReturnStatementError(result);
+    }
+}

package/esm/helpers/kscript/nodes/statements/SwitchStatement.d.ts

@@ -0,0 +1,9 @@
+import { AnyNode, SwitchStatement } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class SwitchStatementNode extends Node<SwitchStatement> {
+    constructor(node: AnyNode, context: Context);
+    private test_match;
+    validate(validateChildren?: boolean): void;
+    run(): unknown;
+}

package/esm/helpers/kscript/nodes/statements/SwitchStatement.js

@@ -0,0 +1,46 @@
+import Node from '../Node';
+import { construct } from '../../utils';
+export default class SwitchStatementNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'SwitchStatement');
+    }
+    test_match(test, discriminant) {
+        if (!test) {
+            return true;
+        }
+        const testValue = construct(test, this.context).run();
+        return testValue === discriminant;
+    }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        construct(this.node.discriminant, this.context).validate(true);
+        for (const c of this.node.cases) {
+            if (c.test) {
+                construct(c.test, this.context).validate(true);
+            }
+            for (const s of c.consequent) {
+                construct(s, this.context).validate(true);
+            }
+        }
+    }
+    run() {
+        this.validate();
+        const discriminant = construct(this.node.discriminant, this.context).run();
+        let result;
+        let matched = false;
+        for (const c of this.node.cases) {
+            if (!matched && this.test_match(c.test, discriminant)) {
+                matched = true;
+            }
+            if (!matched) {
+                continue;
+            }
+            for (const s of c.consequent) {
+                result = construct(s, this.context).run();
+            }
+        }
+        return result;
+    }
+}