@dronedeploy/rocos-js-sdk 3.0.11 → 3.0.13

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/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';

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

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwitchStatement = exports.ExpressionStatement = exports.ReturnStatement = exports.BlockStatement = void 0;
+var BlockStatement_1 = require("./BlockStatement");
+Object.defineProperty(exports, "BlockStatement", { enumerable: true, get: function () { return __importDefault(BlockStatement_1).default; } });
+var ReturnStatement_1 = require("./ReturnStatement");
+Object.defineProperty(exports, "ReturnStatement", { enumerable: true, get: function () { return __importDefault(ReturnStatement_1).default; } });
+var ExpressionStatement_1 = require("./ExpressionStatement");
+Object.defineProperty(exports, "ExpressionStatement", { enumerable: true, get: function () { return __importDefault(ExpressionStatement_1).default; } });
+var SwitchStatement_1 = require("./SwitchStatement");
+Object.defineProperty(exports, "SwitchStatement", { enumerable: true, get: function () { return __importDefault(SwitchStatement_1).default; } });

package/cjs/services/BaseStreamService.js

@@ -44,7 +44,7 @@ class BaseStreamService {
                 this.status = msg === models_1.SubscriberStatusEnum.STOPPED || msg === models_1.SubscriberStatusEnum.ALIVE;
                 this.status$.next(msg);
             });
-            await streamRegister.addStream(stream);
+            streamRegister.addStream(stream);
             await this.initStream(stream);
         }
         return { stream, isNew };

package/cjs/services/WebRTCSignallingService.js

@@ -53,8 +53,7 @@ class WebRTCSignallingService {
                 this.status = msg === SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
                 this.status$.next(msg);
             });
-            // don't wait for these promises, they can be init after startup
-            await streamRegister.addStream(stream);
+            streamRegister.addStream(stream);
             await this.initStream(stream);
         }
         return stream;

package/esm/api/StreamRegister.d.ts

@@ -6,8 +6,8 @@ export declare class StreamRegister {
     private constructor();
     static getInstance(): StreamRegister;
     static getIdentifier($identifier: string, scope?: string): string;
-    addStream(stream: IBaseStream): Promise<void>;
+    addStream(stream: IBaseStream): void;
     getStream(identifier: string): IBaseStream | undefined;
-    removeStream(stream: IBaseStream): Promise<void>;
-    removeAllStreams(): Promise<boolean>;
+    removeStream(stream: IBaseStream): void;
+    removeAllStreams(): boolean;
 }

package/esm/api/StreamRegister.js

@@ -14,10 +14,10 @@ export class StreamRegister {
     static getIdentifier($identifier, scope) {
         return `${$identifier}-${scope ?? ''}`;
     }
-    async addStream(stream) {
+    addStream(stream) {
         try {
             if (this.teleStreams.has(stream.identifier)) {
-                await this.removeStream(stream);
+                this.removeStream(stream);
             }
             this.teleStreams.set(stream.identifier, stream);
         }
@@ -34,9 +34,9 @@ export class StreamRegister {
     getStream(identifier) {
         return this.teleStreams.get(identifier);
     }
-    async removeStream(stream) {
+    removeStream(stream) {
         try {
-            await stream.stopStream();
+            stream.stopStream();
             this.teleStreams.delete(stream.identifier);
         }
         catch (e) {
@@ -49,10 +49,10 @@ export class StreamRegister {
             }
         }
     }
-    async removeAllStreams() {
+    removeAllStreams() {
         try {
             for (const [, stream] of this.teleStreams.entries()) {
-                await this.removeStream(stream);
+                this.removeStream(stream);
             }
         }
         catch (e) {

package/esm/api/streams/telemetry/TelemetryStreamAbstract.js

@@ -100,6 +100,14 @@ export class TelemetryStreamAbstract {
         const before = this.getSubscriptions();
         this.subscriptions.delete(params.uniqueId);
         const after = this.getSubscriptions();
+        // Do this before we send the telemetry request so that new subscriptions don't get this stream from the register while it is closing
+        if (!this.subscriptions.size) {
+            this.logger.info('No subscriptions remaining closing stream', params.uniqueId);
+            this.stopStream();
+            // self remove when no subscriptions are left
+            StreamRegister.getInstance().removeStream(this);
+            this.logger.info('Stream closed');
+        }
         // assign the current values from state after change
         this.callsignsLookup = new CallsignsLookup(Object.keys(after));
         this.sources = arrayUnique(Object.values(after).reduce((a, v) => a.concat(v), []));
@@ -113,13 +121,6 @@ export class TelemetryStreamAbstract {
                 this.logger.error(`Failed to unsubscribe: ${err}`);
             }
         }
-        if (!this.subscriptions.size) {
-            this.logger.info('No subscriptions remaining closing stream', params.uniqueId);
-            this.stopStream();
-            // self remove when no subscriptions a re left
-            void StreamRegister.getInstance().removeStream(this);
-            this.logger.info('Stream closed');
-        }
     }
     sendAcknowledgment(uid, status, noRetry) {
         return this.sendAcknowledgmentInternal(uid, status, noRetry);

package/esm/helpers/kscript/Context.d.ts

@@ -7,19 +7,20 @@ import type { NodeType } from './nodes';
  * If the set is null, all properties are allowed.
  */
 export type PrototypeWhitelist = Map<unknown, Set<string> | null>;
-export type Scope = Map<string, unknown> | Record<string, unknown>;
+export type Scope = Record<string, unknown> | Map<string, unknown>;
 export interface ContextOptions {
     nodeBlacklist?: Set<NodeType>;
     prototypeWhitelist?: PrototypeWhitelist;
     functionCallsAllowed?: boolean;
 }
 export default class Context {
-    readonly scope: Map<string, unknown>;
-    readonly isFunctionCallAllowed: boolean;
-    private readonly options;
-    constructor(scope?: Scope, options?: ContextOptions);
-    isNodeAllowed(nodeType: AnyNode['type']): boolean;
-    newChildContext(scope: Scope): Context;
+    private readonly parent;
+    private readonly scope;
+    private readonly config;
+    static create(scope?: Scope, options?: ContextOptions): Context;
+    private static buildMap;
+    private constructor();
+    newChild(scope?: Scope): Context;
     /** Returns true if the property is allowed to be accessed on the prototype.
      *
      * - If the prototype is not in the whitelist, the property is allowed only if it is an own property.
@@ -30,5 +31,10 @@ export default class Context {
      * @param ownProperty Whether the property is owned by the object it is being accessed on.
      */
     isPrototypeAllowed(prototype: unknown, property: string, ownProperty: boolean): boolean;
-    private static buildMap;
+    isNodeAllowed(nodeType: AnyNode['type']): boolean;
+    get isFunctionCallAllowed(): boolean;
+    private getDescriptor;
+    get(key: string): unknown;
+    set(key: string, value: unknown): void;
+    declare(key: string, value: unknown, constant: boolean): void;
 }

package/esm/helpers/kscript/Context.js

@@ -1,26 +1,27 @@
 export default class Context {
-    constructor(scope, options) {
+    static create(scope, options) {
+        return new Context(null, {
+            functionCallsAllowed: true,
+            nodeBlacklist: new Set(),
+            prototypeWhitelist: new Map(),
+            ...(options ?? {}),
+        }, scope);
+    }
+    static buildMap(obj) {
+        const entries = obj instanceof Map ? Array.from(obj.entries()) : Object.entries(obj);
+        return new Map(entries.map(([key, value]) => [key, { value, constant: false }]));
+    }
+    constructor(parent, config, scope) {
+        this.parent = parent;
         this.scope = scope ? Context.buildMap(scope) : new Map();
-        this.options = {
-            nodeBlacklist: options?.nodeBlacklist ?? new Set(),
-            prototypeWhitelist: options?.prototypeWhitelist ?? new Map(),
-            functionCallsAllowed: options?.functionCallsAllowed ?? true,
+        this.config = {
+            nodeBlacklist: config.nodeBlacklist ?? new Set(),
+            prototypeWhitelist: config.prototypeWhitelist ?? new Map(),
+            functionCallsAllowed: config.functionCallsAllowed ?? true,
         };
-        this.isFunctionCallAllowed = this.options.functionCallsAllowed;
-    }
-    isNodeAllowed(nodeType) {
-        return !this.options.nodeBlacklist.has(nodeType);
     }
-    newChildContext(scope) {
-        let newEntries;
-        if (scope instanceof Map) {
-            newEntries = [...scope.entries()];
-        }
-        else {
-            newEntries = Object.entries(scope);
-        }
-        const newScope = new Map([...this.scope.entries(), ...newEntries]);
-        return new Context(newScope, this.options);
+    newChild(scope) {
+        return new Context(this, this.config, scope);
     }
     /** Returns true if the property is allowed to be accessed on the prototype.
      *
@@ -32,7 +33,7 @@ export default class Context {
      * @param ownProperty Whether the property is owned by the object it is being accessed on.
      */
     isPrototypeAllowed(prototype, property, ownProperty) {
-        const whitelist = this.options.prototypeWhitelist.get(prototype);
+        const whitelist = this.config.prototypeWhitelist.get(prototype);
         // If the object owns the property, and it's not in the whitelist, it's allowed.
         // This prevents direct calls to non-whitelisted properties on allowed prototypes
         // e.g. Object.prototype.hasOwnProperty.call(obj, 'toString')
@@ -43,7 +44,43 @@ export default class Context {
             return true;
         return whitelist.has(property);
     }
-    static buildMap(obj) {
-        return obj instanceof Map ? obj : new Map(Object.entries(obj));
+    isNodeAllowed(nodeType) {
+        return !this.config.nodeBlacklist.has(nodeType);
+    }
+    get isFunctionCallAllowed() {
+        return this.config.functionCallsAllowed;
+    }
+    getDescriptor(key, searchParents = true) {
+        if (this.scope.has(key)) {
+            return this.scope.get(key);
+        }
+        if (searchParents && this.parent) {
+            return this.parent.getDescriptor(key);
+        }
+        return undefined;
+    }
+    get(key) {
+        const descriptor = this.getDescriptor(key);
+        if (descriptor) {
+            return descriptor.value;
+        }
+        return undefined;
+    }
+    set(key, value) {
+        const descriptor = this.getDescriptor(key);
+        if (!descriptor) {
+            throw new Error(`no variable with name ${key}`);
+        }
+        if (descriptor.constant) {
+            throw new Error(`cannot reassign to constant variable ${key}`);
+        }
+        descriptor.value = value;
+    }
+    declare(key, value, constant) {
+        const descriptor = this.getDescriptor(key, false);
+        if (descriptor) {
+            throw new Error(`variable ${key} already declared`);
+        }
+        this.scope.set(key, { value, constant });
     }
 }

package/esm/helpers/kscript/kscript.js

@@ -18,7 +18,7 @@ const parse = (code) => {
 };
 export const compile = (code, scope, options) => {
     const program = parse(code);
-    const context = new Context(scope ?? SAFE_GLOBALS, {
+    const context = Context.create(scope ?? SAFE_GLOBALS, {
         prototypeWhitelist: SAFE_PROTOTYPES,
         ...options,
     });
@@ -47,6 +47,7 @@ export const SAFE_GLOBALS = new Map(Object.entries({
     Number,
     Object,
     Array,
+    Boolean,
     Symbol,
     Error,
     JSON,
@@ -56,6 +57,57 @@ export const SAFE_GLOBALS = new Map(Object.entries({
 }));
 export const SAFE_PROTOTYPES = new Map([
     [Number.prototype, new Set(['toString', 'toFixed', 'toExponential', 'toPrecision'])],
+    [
+        Date.prototype,
+        new Set([
+            'toString',
+            'toDateString',
+            'toTimeString',
+            'toISOString',
+            'toUTCString',
+            'toGMTString',
+            'getDate',
+            'setDate',
+            'getDay',
+            'getFullYear',
+            'setFullYear',
+            'getHours',
+            'setHours',
+            'getMilliseconds',
+            'setMilliseconds',
+            'getMinutes',
+            'setMinutes',
+            'getMonth',
+            'setMonth',
+            'getSeconds',
+            'setSeconds',
+            'getTime',
+            'setTime',
+            'getTimezoneOffset',
+            'getUTCDate',
+            'setUTCDate',
+            'getUTCDay',
+            'getUTCFullYear',
+            'setUTCFullYear',
+            'getUTCHours',
+            'setUTCHours',
+            'getUTCMilliseconds',
+            'setUTCMilliseconds',
+            'getUTCMinutes',
+            'setUTCMinutes',
+            'getUTCMonth',
+            'setUTCMonth',
+            'getUTCSeconds',
+            'setUTCSeconds',
+            'valueOf',
+            'getYear',
+            'setYear',
+            'toJSON',
+            'toLocaleString',
+            'toLocaleDateString',
+            'toLocaleTimeString',
+        ]),
+    ],
     [
         String.prototype,
         new Set([

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

@@ -10,6 +10,6 @@ export default class IdentifierNode extends Node {
     }
     validate() { }
     run() {
-        return this.scope.get(this.node.name);
+        return this.context.get(this.node.name);
     }
 }

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

@@ -3,7 +3,6 @@ import type Context from '../Context';
 export default abstract class Node<T extends AnyNode = AnyNode> {
     protected context: Context;
     protected node: T;
-    protected scope: Context['scope'];
     protected constructor(node: AnyNode, context: Context, expectedType: T['type'] | T['type'][]);
     /** Runs the node. */
     abstract run(): unknown;

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

@@ -7,6 +7,5 @@ export default class Node {
             throw new Error(`Expected node type to be ${expectedTypes.join(' or ')}, but got ${node.type}`);
         }
         this.node = node;
-        this.scope = context.scope;
     }
 }

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

@@ -9,16 +9,19 @@ export default class ProgramNode extends Node {
         super(node, scope, 'Program');
     }
     validate(validateChildren = false) {
-        if (this.node.body.length !== 1) {
-            throw new Error('Only a single statement is supported in the sandbox');
-        }
         if (!validateChildren) {
             return;
         }
-        construct(this.node.body[0], this.context).validate(true);
+        for (const child of this.node.body) {
+            construct(child, this.context).validate(true);
+        }
     }
     run() {
         this.validate();
-        return construct(this.node.body[0], this.context).run();
+        let result;
+        for (const child of this.node.body) {
+            result = construct(child, this.context).run();
+        }
+        return result;
     }
 }

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

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

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

@@ -0,0 +1,37 @@
+import Node from './Node';
+import { construct } from '../utils';
+export default class VariableDeclarationNode extends Node {
+    constructor(node, context) {
+        super(node, context, 'VariableDeclaration');
+    }
+    validate(validateChildren = false) {
+        if (this.node.kind === 'var') {
+            throw new Error('var is not supported. use let or const instead');
+        }
+        for (const declaration of this.node.declarations) {
+            if (declaration.id.type !== 'Identifier') {
+                throw new Error('variable name must be an identifier');
+            }
+        }
+        if (!validateChildren) {
+            return;
+        }
+        for (const declaration of this.node.declarations) {
+            construct(declaration.id, this.context).validate(true);
+            if (declaration.init) {
+                construct(declaration.init, this.context).validate(true);
+            }
+        }
+    }
+    run() {
+        this.validate();
+        for (const declaration of this.node.declarations) {
+            const id = declaration.id.name;
+            let init;
+            if (declaration.init) {
+                init = construct(declaration.init, this.context).run();
+            }
+            this.context.declare(id, init, this.node.kind === 'const');
+        }
+    }
+}