@dronedeploy/rocos-js-sdk 3.0.10 → 3.0.12

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

@@ -13,34 +13,48 @@ class BinaryExpressionNode extends Node_1.default {
     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;
+        }
+        (0, utils_1.construct)(this.node.left, this.context).validate(true);
+        (0, utils_1.construct)(this.node.right, this.context).validate(true);
+    }
     run() {
         const left = (0, utils_1.construct)(this.node.left, this.context).run();
         const right = (0, utils_1.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) {
@@ -101,4 +115,23 @@ class BinaryExpressionNode extends Node_1.default {
         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,
+]);
 exports.default = BinaryExpressionNode;

package/cjs/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/cjs/helpers/kscript/nodes/expressions/CallExpression.js

@@ -9,9 +9,19 @@ class CallExpressionNode extends Node_1.default {
     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;
+        }
+        (0, utils_1.construct)(this.node.callee, this.context).validate(true);
+        for (const arg of this.node.arguments) {
+            (0, utils_1.construct)(arg, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
         const callee = (0, utils_1.construct)(this.node.callee, this.context).run();
         let thisArg = {};
         if (this.node.callee.type === 'MemberExpression') {

package/cjs/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/cjs/helpers/kscript/nodes/expressions/ChainExpression.js

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

package/cjs/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/cjs/helpers/kscript/nodes/expressions/ConditionalExpression.js

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

package/cjs/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/cjs/helpers/kscript/nodes/expressions/LogicalExpression.js

@@ -9,6 +9,16 @@ class BinaryExpressionNode extends Node_1.default {
     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;
+        }
+        (0, utils_1.construct)(this.node.left, this.context).validate(true);
+        (0, utils_1.construct)(this.node.right, this.context).validate(true);
+    }
     run() {
         const left = (0, utils_1.construct)(this.node.left, this.context).run();
         const shortCircuit = this.shortCircuit(left);
@@ -44,4 +54,5 @@ class BinaryExpressionNode extends Node_1.default {
         }
     }
 }
+BinaryExpressionNode.SUPPORTED_OPERATORS = new Set(['||', '&&', '??']);
 exports.default = BinaryExpressionNode;

package/cjs/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/cjs/helpers/kscript/nodes/expressions/MemberExpression.js

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

package/cjs/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/cjs/helpers/kscript/nodes/expressions/NewExpression.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../Node"));
+const utils_1 = require("../../utils");
+class NewExpressionNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'NewExpression');
+    }
+    validate(validateChildren = false) {
+        if (!this.context.isFunctionCallAllowed)
+            throw new Error('Constructors are not allowed');
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.callee, this.context).validate(true);
+        for (const arg of this.node.arguments) {
+            (0, utils_1.construct)(arg, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
+        const callee = (0, utils_1.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(...(0, utils_1.construct)(arg.argument, this.context).run());
+            }
+            else {
+                acc.push((0, utils_1.construct)(arg, this.context).run());
+            }
+            return acc;
+        }, []);
+    }
+}
+exports.default = NewExpressionNode;

package/cjs/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/cjs/helpers/kscript/nodes/expressions/ObjectExpression.js

@@ -9,6 +9,35 @@ class ObjectExpressionNode extends Node_1.default {
     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') {
+                (0, utils_1.construct)(property.argument, this.context).validate(true);
+                continue;
+            }
+            if (property.computed) {
+                (0, utils_1.construct)(property.key, this.context).validate(true);
+            }
+            (0, utils_1.construct)(property.value, this.context).validate(true);
+        }
+    }
     run() {
         const object = {};
         for (const property of this.node.properties) {

package/cjs/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/cjs/helpers/kscript/nodes/expressions/UnaryExpression.js

@@ -13,6 +13,14 @@ class UnaryExpressionNode extends Node_1.default {
     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) {
+            (0, utils_1.construct)(this.node.argument, this.context).validate(true);
+        }
+    }
     run() {
         const argument = (0, utils_1.construct)(this.node.argument, this.context).run();
         switch (this.node.operator) {
@@ -41,4 +49,5 @@ class UnaryExpressionNode extends Node_1.default {
         }
     }
 }
+UnaryExpressionNode.SUPPORTED_OPERATORS = new Set(['+', '-', '!', 'typeof']);
 exports.default = UnaryExpressionNode;

package/cjs/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/cjs/helpers/kscript/nodes/expressions/index.js

@@ -3,9 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChainExpression = exports.MemberExpression = exports.ArrowFunctionExpression = exports.CallExpression = exports.ConditionalExpression = exports.LogicalExpression = exports.UnaryExpression = exports.BinaryExpression = exports.ObjectExpression = exports.ArrayExpression = exports.ExpressionStatement = void 0;
-var ExpressionStatement_1 = require("./ExpressionStatement");
-Object.defineProperty(exports, "ExpressionStatement", { enumerable: true, get: function () { return __importDefault(ExpressionStatement_1).default; } });
+exports.AssignmentExpression = exports.NewExpression = exports.ChainExpression = exports.MemberExpression = exports.ArrowFunctionExpression = exports.CallExpression = exports.ConditionalExpression = exports.LogicalExpression = exports.UnaryExpression = exports.BinaryExpression = exports.ObjectExpression = exports.ArrayExpression = void 0;
 var ArrayExpression_1 = require("./ArrayExpression");
 Object.defineProperty(exports, "ArrayExpression", { enumerable: true, get: function () { return __importDefault(ArrayExpression_1).default; } });
 var ObjectExpression_1 = require("./ObjectExpression");
@@ -26,3 +24,7 @@ var MemberExpression_1 = require("./MemberExpression");
 Object.defineProperty(exports, "MemberExpression", { enumerable: true, get: function () { return __importDefault(MemberExpression_1).default; } });
 var ChainExpression_1 = require("./ChainExpression");
 Object.defineProperty(exports, "ChainExpression", { enumerable: true, get: function () { return __importDefault(ChainExpression_1).default; } });
+var NewExpression_1 = require("./NewExpression");
+Object.defineProperty(exports, "NewExpression", { enumerable: true, get: function () { return __importDefault(NewExpression_1).default; } });
+var AssignmentExpression_1 = require("./AssignmentExpression");
+Object.defineProperty(exports, "AssignmentExpression", { enumerable: true, get: function () { return __importDefault(AssignmentExpression_1).default; } });

package/cjs/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/cjs/helpers/kscript/nodes/nodeTypes.js

@@ -4,14 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const expressions_1 = require("./expressions");
+const statements_1 = require("./statements");
 const Identifier_1 = __importDefault(require("./Identifier"));
 const Literal_1 = __importDefault(require("./Literal"));
 const Program_1 = __importDefault(require("./Program"));
 const TemplateLiteral_1 = __importDefault(require("./TemplateLiteral"));
+const VariableDeclaration_1 = __importDefault(require("./VariableDeclaration"));
 const nodes = {
     Program: Program_1.default,
     Literal: Literal_1.default,
-    ExpressionStatement: expressions_1.ExpressionStatement,
+    ExpressionStatement: statements_1.ExpressionStatement,
     ArrayExpression: expressions_1.ArrayExpression,
     ObjectExpression: expressions_1.ObjectExpression,
     Identifier: Identifier_1.default,
@@ -25,5 +27,11 @@ const nodes = {
     CallExpression: expressions_1.CallExpression,
     MemberExpression: expressions_1.MemberExpression,
     ChainExpression: expressions_1.ChainExpression,
+    NewExpression: expressions_1.NewExpression,
+    BlockStatement: statements_1.BlockStatement,
+    ReturnStatement: statements_1.ReturnStatement,
+    VariableDeclaration: VariableDeclaration_1.default,
+    AssignmentExpression: expressions_1.AssignmentExpression,
+    SwitchStatement: statements_1.SwitchStatement,
 };
 exports.default = new Map(Object.entries(nodes));

package/cjs/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/cjs/helpers/kscript/nodes/statements/BlockStatement.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../Node"));
+const utils_1 = require("../../utils");
+class BlockStatementNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context.newChild(), 'BlockStatement');
+    }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        for (const statement of this.node.body) {
+            (0, utils_1.construct)(statement, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
+        let result;
+        for (const statement of this.node.body) {
+            result = (0, utils_1.construct)(statement, this.context).run();
+        }
+        return result;
+    }
+}
+exports.default = BlockStatementNode;

package/cjs/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/cjs/helpers/kscript/nodes/{expressions → statements}/ExpressionStatement.js

@@ -9,9 +9,16 @@ class ExpressionStatementNode extends Node_1.default {
     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;
+        }
+        (0, utils_1.construct)(this.node.expression, this.context).validate(true);
+    }
+    run() {
+        this.validate();
         return (0, utils_1.construct)(this.node.expression, this.context).run();
     }
 }

package/cjs/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/cjs/helpers/kscript/nodes/statements/ReturnStatement.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnStatementError = void 0;
+const Node_1 = __importDefault(require("../Node"));
+const utils_1 = require("../../utils");
+class ReturnStatementError extends Error {
+    constructor(value) {
+        super('Illegal return statement');
+        this.value = value;
+    }
+}
+exports.ReturnStatementError = ReturnStatementError;
+class ReturnStatementNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'ReturnStatement');
+    }
+    validate(validateChildren = false) {
+        const arg = this.node.argument;
+        if (!validateChildren || arg === undefined || arg === null) {
+            return;
+        }
+        (0, utils_1.construct)(arg, this.context).validate(true);
+    }
+    run() {
+        this.validate();
+        const result = this.node.argument ? (0, utils_1.construct)(this.node.argument, this.context).run() : undefined;
+        throw new ReturnStatementError(result);
+    }
+}
+exports.default = ReturnStatementNode;

package/cjs/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/cjs/helpers/kscript/nodes/statements/SwitchStatement.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../Node"));
+const utils_1 = require("../../utils");
+class SwitchStatementNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'SwitchStatement');
+    }
+    test_match(test, discriminant) {
+        if (!test) {
+            return true;
+        }
+        const testValue = (0, utils_1.construct)(test, this.context).run();
+        return testValue === discriminant;
+    }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.discriminant, this.context).validate(true);
+        for (const c of this.node.cases) {
+            if (c.test) {
+                (0, utils_1.construct)(c.test, this.context).validate(true);
+            }
+            for (const s of c.consequent) {
+                (0, utils_1.construct)(s, this.context).validate(true);
+            }
+        }
+    }
+    run() {
+        this.validate();
+        const discriminant = (0, utils_1.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 = (0, utils_1.construct)(s, this.context).run();
+            }
+        }
+        return result;
+    }
+}
+exports.default = SwitchStatementNode;

package/cjs/helpers/kscript/nodes/statements/index.d.ts

@@ -0,0 +1,4 @@
+export { default as BlockStatement } from './BlockStatement';
+export { default as ReturnStatement } from './ReturnStatement';
+export { default as ExpressionStatement } from './ExpressionStatement';
+export { default as SwitchStatement } from './SwitchStatement';