@dronedeploy/rocos-js-sdk 3.0.1-alpha.20 → 3.0.1-alpha.21

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

@@ -0,0 +1,8 @@
+import { AnyNode, CallExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class CallExpressionNode extends Node<CallExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    private spreadArgs;
+}

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

@@ -0,0 +1,38 @@
+"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 CallExpressionNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'CallExpression');
+    }
+    run() {
+        if (!this.context.isFunctionCallAllowed)
+            throw new Error('Function calls are not allowed');
+        const callee = (0, utils_1.construct)(this.node.callee, this.context).run();
+        let thisArg = {};
+        if (this.node.callee.type === 'MemberExpression') {
+            thisArg = (0, utils_1.construct)(this.node.callee.object, this.context).run();
+        }
+        if (typeof callee !== 'function') {
+            throw new Error('callee is not a function');
+        }
+        const args = this.spreadArgs(this.node.arguments);
+        return callee.call(thisArg, ...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 = CallExpressionNode;

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

@@ -0,0 +1,16 @@
+import { AnyNode, ChainExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+/**
+ * A ChainExpression node is created when the chain operator is used.
+ *
+ * e.g. `a?.b?.c`
+ *
+ * This node does not need to do anything special, as the chain operator is handled by the MemberExpressionNode.
+ *
+ * @see MemberExpressionNode
+ */
+export default class ExpressionStatementNode extends Node<ChainExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+}

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

@@ -0,0 +1,25 @@
+"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");
+/**
+ * A ChainExpression node is created when the chain operator is used.
+ *
+ * e.g. `a?.b?.c`
+ *
+ * This node does not need to do anything special, as the chain operator is handled by the MemberExpressionNode.
+ *
+ * @see MemberExpressionNode
+ */
+class ExpressionStatementNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'ChainExpression');
+    }
+    run() {
+        return (0, utils_1.construct)(this.node.expression, this.context).run();
+    }
+}
+exports.default = ExpressionStatementNode;

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

@@ -0,0 +1,14 @@
+import { AnyNode, ConditionalExpression, IfStatement } from 'acorn';
+import type Context from '../../Context';
+import Node from '../Node';
+/** Represents a ternary conditional expression (a ? b : c) or an if statement (if (a) b else c).
+ *
+ * If a (test) is truthy, b (consequent) is returned. Otherwise, c (alternate) is returned.
+ *
+ * Since the if statement and the conditional expression are so similar, they are both handled by this node,
+ * even though they are separate in the AST.
+ */
+export default class ConditionalExpressionNode extends Node<IfStatement | ConditionalExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+}

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

@@ -0,0 +1,30 @@
+"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");
+/** Represents a ternary conditional expression (a ? b : c) or an if statement (if (a) b else c).
+ *
+ * If a (test) is truthy, b (consequent) is returned. Otherwise, c (alternate) is returned.
+ *
+ * Since the if statement and the conditional expression are so similar, they are both handled by this node,
+ * even though they are separate in the AST.
+ */
+class ConditionalExpressionNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, ['ConditionalExpression', 'IfStatement']);
+    }
+    run() {
+        const test = (0, utils_1.construct)(this.node.test, this.context).run();
+        if (test) {
+            return (0, utils_1.construct)(this.node.consequent, this.context).run();
+        }
+        if (this.node.alternate === null || this.node.alternate === undefined) {
+            return undefined;
+        }
+        return (0, utils_1.construct)(this.node.alternate, this.context).run();
+    }
+}
+exports.default = ConditionalExpressionNode;

package/cjs/helpers/kscript/nodes/expressions/ExpressionStatement.d.ts

@@ -0,0 +1,7 @@
+import { AnyNode, ExpressionStatement } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class ExpressionStatementNode extends Node<ExpressionStatement> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+}

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

@@ -0,0 +1,18 @@
+"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 ExpressionStatementNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'ExpressionStatement');
+    }
+    run() {
+        if (this.node.directive)
+            throw new Error('Directives are not supported');
+        return (0, utils_1.construct)(this.node.expression, this.context).run();
+    }
+}
+exports.default = ExpressionStatementNode;

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

@@ -0,0 +1,10 @@
+import { AnyNode, LogicalExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+export default class BinaryExpressionNode extends Node<LogicalExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    /** Try and skip evaluating the right operand */
+    private shortCircuit;
+    private operate;
+}

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

@@ -0,0 +1,47 @@
+"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 BinaryExpressionNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'LogicalExpression');
+    }
+    run() {
+        const left = (0, utils_1.construct)(this.node.left, this.context).run();
+        const shortCircuit = this.shortCircuit(left);
+        if (shortCircuit !== null) {
+            return shortCircuit;
+        }
+        const right = (0, utils_1.construct)(this.node.right, this.context).run();
+        return this.operate(left, right);
+    }
+    /** Try and skip evaluating the right operand */
+    shortCircuit(left) {
+        if (this.node.operator === '&&' && !left) {
+            return false;
+        }
+        if (this.node.operator === '||' && left) {
+            return true;
+        }
+        if (this.node.operator === '??' && left !== null && left !== undefined) {
+            return left;
+        }
+        return null;
+    }
+    operate(left, right) {
+        switch (this.node.operator) {
+            case '||':
+                return left || right;
+            case '&&':
+                return left && right;
+            case '??':
+                return left ?? right;
+            default:
+                throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+    }
+}
+exports.default = BinaryExpressionNode;

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

@@ -0,0 +1,44 @@
+import { AnyNode, MemberExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+/**
+ * A member expression is an expression that accesses a property of an object.
+ *
+ * Examples of member expressions are:
+ *  - `a.b`
+ *  - `a['b']`
+ *  - `a[0]`
+ *  - `a?.b`
+ *  - `a?.['b']`
+ *  - `a?.[0]`
+ *
+ *  A member access in the sandbox is considered secure if the following conditions are met:
+ *    - The property is not named 'constructor'
+ *    - Either:
+ *      * The property is owned by the object and is *not* on the whitelist.
+ *      * The prototype is whitelisted and the property list is null or contains the property.
+ *
+ *  @see Context.isPrototypeAllowed
+ */
+export default class MemberExpressionNode extends Node<MemberExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    /** Returns the name of the property being accessed.
+     *
+     * Handles both computed and non-computed properties.
+     */
+    private getPropertyIdentifier;
+    /** Checks if the property can be accessed on the object.
+     *
+     * @throws {Error} If the property is not allowed to be accessed.
+     */
+    private checkPropertyAccess;
+    /** Searches the prototype chain of the object for the prototype that defines the property. */
+    private getPropertyPrototype;
+    /**
+     * Returns true if the property exists on the object.
+     *
+     * i.e. the property is defined somewhere on the prototype chain.
+     */
+    private propertyExists;
+}

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

@@ -0,0 +1,98 @@
+"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");
+/**
+ * A member expression is an expression that accesses a property of an object.
+ *
+ * Examples of member expressions are:
+ *  - `a.b`
+ *  - `a['b']`
+ *  - `a[0]`
+ *  - `a?.b`
+ *  - `a?.['b']`
+ *  - `a?.[0]`
+ *
+ *  A member access in the sandbox is considered secure if the following conditions are met:
+ *    - The property is not named 'constructor'
+ *    - Either:
+ *      * The property is owned by the object and is *not* on the whitelist.
+ *      * The prototype is whitelisted and the property list is null or contains the property.
+ *
+ *  @see Context.isPrototypeAllowed
+ */
+class MemberExpressionNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'MemberExpression');
+    }
+    run() {
+        const object = (0, utils_1.construct)(this.node.object, this.context).run();
+        if (object === null || object === undefined) {
+            if (this.node.optional)
+                return undefined;
+            throw new Error(`Cannot read property of ${object}`);
+        }
+        const propertyIdentifier = this.getPropertyIdentifier();
+        if (!this.propertyExists(object, propertyIdentifier)) {
+            return undefined;
+        }
+        this.checkPropertyAccess(object, propertyIdentifier);
+        return object[propertyIdentifier];
+    }
+    /** Returns the name of the property being accessed.
+     *
+     * Handles both computed and non-computed properties.
+     */
+    getPropertyIdentifier() {
+        if (this.node.computed) {
+            const name = (0, utils_1.construct)(this.node.property, this.context).run();
+            if (typeof name !== 'string' && typeof name !== 'number') {
+                throw new Error('Only string or number computed properties are supported');
+            }
+            return name;
+        }
+        if (this.node.property.type !== 'Identifier') {
+            throw new Error('Only identifiers are supported for non-computed member expression properties');
+        }
+        return this.node.property.name;
+    }
+    /** Checks if the property can be accessed on the object.
+     *
+     * @throws {Error} If the property is not allowed to be accessed.
+     */
+    checkPropertyAccess(object, propertyIdentifier) {
+        if (typeof propertyIdentifier === 'number')
+            return;
+        if (propertyIdentifier === 'constructor') {
+            throw new Error('Cannot access constructor property');
+        }
+        const definingProto = this.getPropertyPrototype(object, propertyIdentifier);
+        const ownProperty = Object.prototype.hasOwnProperty.call(object, propertyIdentifier);
+        if (!this.context.isPrototypeAllowed(definingProto, propertyIdentifier, ownProperty)) {
+            throw new Error(`SecurityError: Access to property '${propertyIdentifier}' is not allowed`);
+        }
+    }
+    /** Searches the prototype chain of the object for the prototype that defines the property. */
+    getPropertyPrototype(object, propertyIdentifier) {
+        let proto = object;
+        while (proto !== null) {
+            if (Object.prototype.hasOwnProperty.call(proto, propertyIdentifier)) {
+                return proto;
+            }
+            proto = Object.getPrototypeOf(proto);
+        }
+        return null;
+    }
+    /**
+     * Returns true if the property exists on the object.
+     *
+     * i.e. the property is defined somewhere on the prototype chain.
+     */
+    propertyExists(object, propertyIdentifier) {
+        return this.getPropertyPrototype(object, propertyIdentifier) !== null;
+    }
+}
+exports.default = MemberExpressionNode;

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

@@ -0,0 +1,11 @@
+import { AnyNode, ObjectExpression } from 'acorn';
+import type Context from '../../Context';
+import Node from '../Node';
+export default class ObjectExpressionNode extends Node<ObjectExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    private addProperty;
+    private spreadProperty;
+    private getKey;
+    private getStaticKey;
+}

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

@@ -0,0 +1,59 @@
+"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 ObjectExpressionNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'ObjectExpression');
+    }
+    run() {
+        const object = {};
+        for (const property of this.node.properties) {
+            if (property.type === 'SpreadElement') {
+                this.spreadProperty(property, object);
+                continue;
+            }
+            this.addProperty(property, object);
+        }
+        return object;
+    }
+    addProperty(property, object) {
+        if (property.kind !== 'init')
+            throw new Error('Only init properties are supported');
+        const key = this.getKey(property);
+        object[key] = (0, utils_1.construct)(property.value, this.context).run();
+    }
+    spreadProperty(property, object) {
+        const value = (0, utils_1.construct)(property.argument, this.context).run();
+        if (!(typeof value === 'object' && value !== null)) {
+            throw new Error('Spread argument must be an object');
+        }
+        Object.assign(object, value);
+    }
+    getKey(property) {
+        let key;
+        if (property.computed) {
+            key = (0, utils_1.construct)(property.key, this.context).run();
+        }
+        else {
+            key = this.getStaticKey(property.key);
+        }
+        if (key === null || key === undefined)
+            throw new Error('Key cannot be null or undefined');
+        if (typeof key !== 'string' && typeof key !== 'number' && typeof key !== 'symbol') {
+            throw new Error(`Unsupported key type: ${typeof key}`);
+        }
+        return key;
+    }
+    getStaticKey(key) {
+        if (key.type === 'Identifier')
+            return key.name;
+        if (key.type === 'Literal')
+            return key.value;
+        throw new Error('Only identifier and literal keys are supported');
+    }
+}
+exports.default = ObjectExpressionNode;

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

@@ -0,0 +1,12 @@
+import { AnyNode, UnaryExpression } from 'acorn';
+import Context from '../../Context';
+import Node from '../Node';
+/** A unary expression is an expression that consists of a single operand and an operator
+ *
+ * e.g. `+1`, `-2`, `!true`, `typeof x`
+ */
+export default class UnaryExpressionNode extends Node<UnaryExpression> {
+    constructor(node: AnyNode, context: Context);
+    run(): unknown;
+    private arithmetic;
+}

package/cjs/helpers/kscript/nodes/expressions/UnaryExpression.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");
+/** A unary expression is an expression that consists of a single operand and an operator
+ *
+ * e.g. `+1`, `-2`, `!true`, `typeof x`
+ */
+class UnaryExpressionNode extends Node_1.default {
+    constructor(node, context) {
+        super(node, context, 'UnaryExpression');
+    }
+    run() {
+        const argument = (0, utils_1.construct)(this.node.argument, this.context).run();
+        switch (this.node.operator) {
+            case '+':
+            case '-':
+                return this.arithmetic(this.node.operator, argument);
+            case '!':
+                return !argument;
+            case 'typeof':
+                return typeof argument;
+            default:
+                throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+    }
+    arithmetic(operator, argument) {
+        if (typeof argument !== 'number') {
+            throw new Error('Unary arithmetic operators are only supported for numbers');
+        }
+        switch (operator) {
+            case '+':
+                return +argument;
+            case '-':
+                return -argument;
+            default:
+                throw new Error(`Unsupported operator: ${operator}`);
+        }
+    }
+}
+exports.default = UnaryExpressionNode;

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

@@ -0,0 +1,11 @@
+export { default as ExpressionStatement } from './ExpressionStatement';
+export { default as ArrayExpression } from './ArrayExpression';
+export { default as ObjectExpression } from './ObjectExpression';
+export { default as BinaryExpression } from './BinaryExpression';
+export { default as UnaryExpression } from './UnaryExpression';
+export { default as LogicalExpression } from './LogicalExpression';
+export { default as ConditionalExpression } from './ConditionalExpression';
+export { default as CallExpression } from './CallExpression';
+export { default as ArrowFunctionExpression } from './ArrowFunctionExpression';
+export { default as MemberExpression } from './MemberExpression';
+export { default as ChainExpression } from './ChainExpression';

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

@@ -0,0 +1,28 @@
+"use strict";
+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; } });
+var ArrayExpression_1 = require("./ArrayExpression");
+Object.defineProperty(exports, "ArrayExpression", { enumerable: true, get: function () { return __importDefault(ArrayExpression_1).default; } });
+var ObjectExpression_1 = require("./ObjectExpression");
+Object.defineProperty(exports, "ObjectExpression", { enumerable: true, get: function () { return __importDefault(ObjectExpression_1).default; } });
+var BinaryExpression_1 = require("./BinaryExpression");
+Object.defineProperty(exports, "BinaryExpression", { enumerable: true, get: function () { return __importDefault(BinaryExpression_1).default; } });
+var UnaryExpression_1 = require("./UnaryExpression");
+Object.defineProperty(exports, "UnaryExpression", { enumerable: true, get: function () { return __importDefault(UnaryExpression_1).default; } });
+var LogicalExpression_1 = require("./LogicalExpression");
+Object.defineProperty(exports, "LogicalExpression", { enumerable: true, get: function () { return __importDefault(LogicalExpression_1).default; } });
+var ConditionalExpression_1 = require("./ConditionalExpression");
+Object.defineProperty(exports, "ConditionalExpression", { enumerable: true, get: function () { return __importDefault(ConditionalExpression_1).default; } });
+var CallExpression_1 = require("./CallExpression");
+Object.defineProperty(exports, "CallExpression", { enumerable: true, get: function () { return __importDefault(CallExpression_1).default; } });
+var ArrowFunctionExpression_1 = require("./ArrowFunctionExpression");
+Object.defineProperty(exports, "ArrowFunctionExpression", { enumerable: true, get: function () { return __importDefault(ArrowFunctionExpression_1).default; } });
+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; } });

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

@@ -0,0 +1,4 @@
+import { NodeType, default as nodes } from './nodeTypes';
+import Context from '../Context';
+import Node from './Node';
+export { type Node, type NodeType, nodes, Context };

package/cjs/helpers/kscript/nodes/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.nodes = void 0;
+const nodeTypes_1 = __importDefault(require("./nodeTypes"));
+Object.defineProperty(exports, "nodes", { enumerable: true, get: function () { return nodeTypes_1.default; } });
+const Context_1 = __importDefault(require("../Context"));
+exports.Context = Context_1.default;

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

@@ -0,0 +1,33 @@
+import { ArrayExpression, ArrowFunctionExpression, BinaryExpression, CallExpression, ChainExpression, ConditionalExpression, ExpressionStatement, LogicalExpression, MemberExpression, ObjectExpression, UnaryExpression } from './expressions';
+import { AnyNode } from 'acorn';
+import type Context from '../Context';
+import Identifier from './Identifier';
+import Literal from './Literal';
+import Node from './Node';
+import Program from './Program';
+import TemplateLiteral from './TemplateLiteral';
+type NodeConstructor = {
+    new (node: AnyNode, scope: Context): Node<AnyNode>;
+};
+export type NodeMap = Map<AnyNode['type'], NodeConstructor>;
+declare const nodes: {
+    readonly Program: typeof Program;
+    readonly Literal: typeof Literal;
+    readonly ExpressionStatement: typeof ExpressionStatement;
+    readonly ArrayExpression: typeof ArrayExpression;
+    readonly ObjectExpression: typeof ObjectExpression;
+    readonly Identifier: typeof Identifier;
+    readonly BinaryExpression: typeof BinaryExpression;
+    readonly UnaryExpression: typeof UnaryExpression;
+    readonly LogicalExpression: typeof LogicalExpression;
+    readonly ConditionalExpression: typeof ConditionalExpression;
+    readonly IfStatement: typeof ConditionalExpression;
+    readonly TemplateLiteral: typeof TemplateLiteral;
+    readonly ArrowFunctionExpression: typeof ArrowFunctionExpression;
+    readonly CallExpression: typeof CallExpression;
+    readonly MemberExpression: typeof MemberExpression;
+    readonly ChainExpression: typeof ChainExpression;
+};
+export type NodeType = keyof typeof nodes;
+declare const _default: NodeMap;
+export default _default;

package/cjs/helpers/kscript/nodes/nodeTypes.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 expressions_1 = require("./expressions");
+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 nodes = {
+    Program: Program_1.default,
+    Literal: Literal_1.default,
+    ExpressionStatement: expressions_1.ExpressionStatement,
+    ArrayExpression: expressions_1.ArrayExpression,
+    ObjectExpression: expressions_1.ObjectExpression,
+    Identifier: Identifier_1.default,
+    BinaryExpression: expressions_1.BinaryExpression,
+    UnaryExpression: expressions_1.UnaryExpression,
+    LogicalExpression: expressions_1.LogicalExpression,
+    ConditionalExpression: expressions_1.ConditionalExpression,
+    IfStatement: expressions_1.ConditionalExpression,
+    TemplateLiteral: TemplateLiteral_1.default,
+    ArrowFunctionExpression: expressions_1.ArrowFunctionExpression,
+    CallExpression: expressions_1.CallExpression,
+    MemberExpression: expressions_1.MemberExpression,
+    ChainExpression: expressions_1.ChainExpression,
+};
+exports.default = new Map(Object.entries(nodes));

package/cjs/helpers/kscript/utils.d.ts

@@ -0,0 +1,4 @@
+import { Node } from './nodes';
+import { AnyNode } from 'acorn';
+import Context from './Context';
+export declare function construct(node: AnyNode, context: Context): Node<AnyNode>;

package/cjs/helpers/kscript/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.construct = void 0;
+const nodes_1 = require("./nodes");
+function construct(node, context) {
+    if (!context.isNodeAllowed(node.type)) {
+        throw new Error(`Blacklisted Operation: ${node.type}`);
+    }
+    const nodeClass = nodes_1.nodes.get(node.type);
+    if (!nodeClass) {
+        throw new Error(`Unknown node type: ${node.type}`);
+    }
+    return Reflect.construct(nodeClass, [node, context]);
+}
+exports.construct = construct;