@typescript-guy/fn-monitor 1.0.0

package/ACKNOWLEDGEMENTS.md

@@ -0,0 +1,10 @@
+## Acknowledgements
+
+The core execution engine of this project is a modified and extended version of `sval`, a JavaScript interpreter written in JavaScript. 
+
+Original repository: https://github.com/Siubaak/sval
+
+`sval` is licensed under the MIT License. The full text of the MIT License governing this original code can be found at: 
+https://github.com/Siubaak/sval/blob/master/LICENSE
+
+*Please note: This project is an independent extension and is not affiliated with, endorsed by, or sponsored by the original `sval` project or its authors.*

package/LICENSE.md

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright (c) 2018 Siubaak
+Copyright (c) 2026 typescript-guy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,201 @@
+# @typescript-guy/fn-monitor
+
+![npm](https://img.shields.io/npm/v/@typescript-guy/fn-monitor)
+
+An augmentation of the [`sval`](https://github.com/Siubaak/sval) JS-in-JS interpreter designed to monitor functions as they execute. 
+
+This package allows developers to inspect, debug, or sandbox JavaScript functions at runtime by injecting hooks at any part of a function's lifecycle. It treats your hooks as first-class citizens within the interpreter, effectively turning your functions into white-boxes.
+
+## Installation
+
+```bash
+npm install @typescript-guy/fn-monitor
+```
+
+## Quick Start
+
+The core of the package is the `monitor` function. It accepts a configuration object and returns a new function that behaves exactly like the original, but is executed by the custom interpreter.
+
+```typescript
+import { monitor } from '@typescript-guy/fn-monitor';
+
+function add(a: number, b: number) {
+  return a + b;
+}
+
+// Create a monitored version of the function
+const monitoredAdd = monitor({
+  main: { ref: add },
+  beforeEachCall: (a, b) => console.log(`Adding ${a} and ${b}`),
+  afterEachCall: (result) => console.log(`Result: ${result}`),
+});
+
+monitoredAdd(2, 3); 
+// Logs: Adding 2 and 3
+// Logs: Result: 5
+```
+
+### Capturing External Variables
+Because monitored functions run in an isolated interpreter context, external variables must be explicitly captured:
+
+```typescript
+const multiplier = 10;
+
+const multiply = (x: number) => x * multiplier;
+
+const monitoredMultiply = monitor({
+  main: {
+    ref: multiply,
+    captures: { multiplier } // Map the variable name to its value
+  }
+});
+
+monitoredMultiply(5); // Returns 50
+```
+
+## Advanced Usage
+
+### Intercepting and Modifying the AST (Inspector Hook)
+The `inspector` hook provides a rich `visit` object, allowing you to inspect nodes, modify them before execution, and manually execute nodes to observe or change their results.
+
+```typescript
+const monitoredSum = monitor({
+  main: { ref: sumUp },
+  inspector: (visit) => {
+    // Intercept all assignment expressions
+    visit.is('AssignmentExpression', (event) => {
+      event.node.operator = "-="; // Silently change the operator
+      console.log('Assignment result:', visit.execute());
+    });
+
+    // Intercept return statements
+    visit.is('ReturnStatement', (event) => {
+      const result = visit.execute();
+      result.sum = 'INTERCEPTED'; // Modify the return value
+    });
+  }
+});
+```
+
+### Execution Timeouts & Sandboxing (`onStep` Hook)
+If you don't need deep AST inspection, use the lightweight `onStep` hook. It fires before each interpreted step without the overhead of allocating the `visit` object. This is perfect for implementing execution timeouts or simulating a sandbox.
+
+```typescript
+const timeoutTracker = { limitMs: 50, startTime: 0, stepCounter: 0 };
+
+const safeFn = monitor({
+  main: { ref: heavyComputation },
+  beforeEachCall: () => {
+    timeoutTracker.stepCounter = 0;
+    timeoutTracker.startTime = performance.now();
+  },
+  onStep: () => {
+    timeoutTracker.stepCounter++;
+    // Bitmask check: Only evaluate time every 1024 steps for performance
+    if ((timeoutTracker.stepCounter & 1023) === 0) {
+      if (performance.now() - timeoutTracker.startTime > timeoutTracker.limitMs) {
+        throw new Error('Max execution time exceeded!');
+      }
+    }
+  }
+});
+```
+
+### Embedding Functions & Extracting Source Code
+You can embed external functions directly into the interpreter's context and extract the final generated code using `sourceOut`.
+
+```typescript
+const generatedCode = { value: '' };
+
+const monitoredAsyncFn = monitor({
+  main: { ref: async (a, b) => await log(a + b) },
+  embed: {
+    log: { ref: console.log } // Embed console.log into the interpreter context
+  },
+  sourceOut: generatedCode // Populates the generated code string
+});
+
+console.log(generatedCode.value); // Prints the interpreted JS code
+```
+
+---
+
+## Full API Reference
+
+### `monitor<T>(setup: MonitorFnSetup<T>)`
+The main export. Returns the monitored function `T` augmented with an `alreadyMonitored: true` property.
+
+#### `MonitorFnSetup` Configuration
+| Property | Type | Description |
+| :--- | :--- | :--- |
+| `main` | `Metadata<T>` | **Required.** The main function to monitor and its captures. |
+| `embed` | `Record<string, Metadata<Fn>>` | Alternative to capturing. Includes external functions' source code directly in the interpreter context. |
+| `inspector` | `Inspector` | The main hook fed the interpreter's context (`visit` object) to inspect/modify nodes. |
+| `onStep` | `OnStep` | Lightweight hook called before each step. No `visit` object. Much faster than `inspector`. |
+| `sourceOut` | `{ value: string }` | Overwrites the `value` property with the generated code used in the interpreter. |
+| `beforeEachCall` | `(...args) => void` | Hook called before each execution with the passed arguments. |
+| `afterEachCall` | `(result \| Error) => void` | Hook called after each execution with the result or thrown error. |
+
+#### `Metadata<T>`
+| Property | Type | Description |
+| :--- | :--- | :--- |
+| `ref` | `T` | The reference to the function. |
+| `captures` | `Record<string, any>` | Maps variable names to their outside-scope values. Follows copy-by-value/primitive and copy-by-reference/object semantics. |
+
+### The `Visit` Object (Inspector Context)
+Passed to the `inspector` hook. It is allocated once per monitored function (not per call) to save memory. **Must only be used strictly within the inspector hook.**
+
+* **`visit.is(query, callback)`**: Registers a callback for specific AST node types (e.g., `'CallExpression'`, `'Any'`). If matched, it allocates a scope and event object.
+* **`visit.execute()`**: Manually executes the current node and returns the result. For async nodes, it returns `LAZY_NODE` (requires the inspector to be a generator to `yield`).
+* **`visit.localExeStack()`**: Returns a readonly stack of the latest evaluated child node results.
+* **`visit.perExecution`**: A setter for a callback fired on each executed node. Short-lived; exists only for the current node and its children.
+
+### Events and Queries
+The `visit.is` method accepts a `Query` (any valid ESTree node type string, plus `'Any'`). The callback receives a specific `Event` object tailored to that node type (e.g., `CallExprEvent`, `BinaryExprEvent`), which contains:
+* `node`: The AST node.
+* `scope`: The safe scope object (`ScopeForEvent`), allowing you to search local variables and check scope depth.
+
+### Utility Types
+* **`QList<T>` / `ReadonlyQList<T>`**: Custom optimized dequeue with random array access. Used internally for the execution stack.
+* **`Var`**: Represents a variable in the scope.
+* **Symbols**: `NOT_ALLOCATED`, `LAZY_NODE`.
+* **Events**: Over 30 specific event classes (e.g., `IfStmtEvent`, `ForStmtEvent`, `LiteralEvent`) extending the base `LangEvent`.
+
+---
+
+## How it Works (Architecture)
+
+Under the hood, `@typescript-guy/fn-monitor` utilizes an **AST-walker interpreter** (rather than a bytecode implementation) to evaluate functions. 
+
+* **Interpreter Isolation:** Each monitored function is assigned its own dedicated interpreter instance. While this incurs a slight memory overhead, it strictly prevents state collision between executions.
+* **Reusables Architecture:** To share interpretation context with the inspector hook performantly, the implementation leverages internal "reusable" objects. This prevents the allocation of intermediate objects mid-evaluation. To handle complex async/await state transitions safely, it uses a "copy, then overwrite" pattern.
+* **Single Parse:** A monitored function is parsed into an AST only once. The resulting nodes and scope objects are reused across all calls to maximize execution speed.
+
+---
+
+## Limitations & Important Notes
+
+Please keep the following architectural constraints in mind when using this package:
+
+1. **Debugging & Stack Traces:** Because monitored functions run in an isolated context, errors thrown within them will not map directly to their original source location in your editor. You should debug functions in their unmonitored state first. *(Note: The inspector hook itself runs in the native JS runtime, so it will still display a proper stack trace if the inspector throws an error).*
+2. **AST Mutation Persistence:** Because the AST is parsed only once, **any mutations made to a node within the inspector will persist and reflect in all subsequent calls** to that function. 
+3. **Sandboxing:** This monitor is not designed to act as a secure, impenetrable sandbox out-of-the-box. However, you can simulate a sandboxed environment by actively monitoring and intercepting nodes via the `inspector` and `onStep` hooks.
+4. **Scope Limitations:** Do not attempt to expand this into a script-level or module-level monitor. The package is strictly designed around hidden function-context assumptions.
+
+---
+
+## Acknowledgements
+
+The core execution engine of this project is a modified and extended version of [`sval`](https://github.com/Siubaak/sval), a JavaScript interpreter written in JavaScript, originally authored by Siubaak.
+
+*Please note: This project is an independent extension and is not affiliated with, endorsed by, or sponsored by the original `sval` project or its authors.*
+
+`sval` is licensed under the MIT License.
+
+## Questions & Support
+
+If you have questions about how to use `@typescript-guy/fn-monitor`, need help with a specific implementation, or want to discuss architecture:
+* **Open a [GitHub Discussion](https://github.com/The-BigMan-tech/fn-monitor/discussions)**: This is the best place for Q&A and community help.
+* **Open an [Issue](https://github.com/The-BigMan-tech/fn-monitor/issues)**: If you've found a bug or want to request a new feature.
+
+*Note: This is an open-source project maintained in my free time. I will do my best to respond, but please allow a few days for a reply. Before opening a new thread, please check existing Discussions and Issues to see if your question has already been answered!*

package/dist/custom-types.d.ts

@@ -0,0 +1,239 @@
+import { default as Scope } from './scope/index.ts';
+import { Node as EsTreeNode, Literal, VariableDeclaration, FunctionDeclaration, IfStatement, SwitchStatement, TryStatement, CatchClause, ReturnStatement, ThrowStatement, ForStatement, WhileStatement, DoWhileStatement, ForOfStatement, ForInStatement, BreakStatement, ContinueStatement, LabeledStatement, YieldExpression, BinaryExpression, CallExpression, AssignmentExpression, UpdateExpression, LogicalExpression, MemberExpression, AwaitExpression, FunctionExpression, ArrowFunctionExpression, ConditionalExpression, NewExpression, ExpressionStatement, ArrayExpression, ObjectExpression, TemplateLiteral, SequenceExpression, UnaryExpression } from 'estree';
+import { Var } from './scope/variable.ts';
+import { QList, ReadonlyQList } from './q-list.ts';
+export type Fn = (...args: any[]) => any;
+export type EsNode = EsTreeNode;
+/**
+ * This is a string union of all the possible nodes the caller can query in the visit.is callback.
+ * They are all estree node types.You will see type definitions shortening this to EsNode.
+ * There are over 30 types of nodes that you can query and if any of the nodes dont match your needs,you can always use the 'Any' query which matches for every node.You can then use the estree node type to cast it to specific types
+ */
+export type Query = Literal['type'] | BinaryExpression['type'] | CallExpression['type'] | AssignmentExpression['type'] | UpdateExpression['type'] | LogicalExpression['type'] | MemberExpression['type'] | AwaitExpression['type'] | FunctionExpression['type'] | ReturnStatement['type'] | IfStatement['type'] | SwitchStatement['type'] | ThrowStatement['type'] | TryStatement['type'] | CatchClause['type'] | VariableDeclaration['type'] | FunctionDeclaration['type'] | ForStatement['type'] | WhileStatement['type'] | DoWhileStatement['type'] | ForOfStatement['type'] | ForInStatement['type'] | LabeledStatement['type'] | BreakStatement['type'] | ContinueStatement['type'] | ArrowFunctionExpression['type'] | ConditionalExpression['type'] | NewExpression['type'] | YieldExpression['type'] | ExpressionStatement['type'] | ArrayExpression['type'] | ObjectExpression['type'] | TemplateLiteral['type'] | SequenceExpression['type'] | UnaryExpression['type'] | 'Any';
+/**
+ * The type definiton that maps each node query to the event object you will get from that query
+ * Each type has its own dedicated Event class which helps to tailor intellisense
+ */
+export type EventMap = (Record<Literal['type'], LiteralEvent> & Record<BinaryExpression['type'], BinaryExprEvent> & Record<CallExpression['type'], CallExprEvent> & Record<AssignmentExpression['type'], AssignmentExprEvent> & Record<UpdateExpression['type'], UpdateExprEvent> & Record<LogicalExpression['type'], LogicalExprEvent> & Record<MemberExpression['type'], MemberExprEvent> & Record<AwaitExpression['type'], AwaitExprEvent> & Record<FunctionExpression['type'], FuncExprEvent> & Record<ReturnStatement['type'], ReturnStmtEvent> & Record<IfStatement['type'], IfStmtEvent> & Record<SwitchStatement['type'], SwitchStmtEvent> & Record<ThrowStatement['type'], ThrowStmtEvent> & Record<TryStatement['type'], TryStmtEvent> & Record<CatchClause['type'], CatchClauseEvent> & Record<VariableDeclaration['type'], VarDeclEvent> & Record<FunctionDeclaration['type'], FuncDeclEvent> & Record<ForStatement['type'], ForStmtEvent> & Record<WhileStatement['type'], WhileStmtEvent> & Record<DoWhileStatement['type'], DoWhileStmtEvent> & Record<ForOfStatement['type'], ForOfStmtEvent> & Record<ForInStatement['type'], ForInStmtEvent> & Record<LabeledStatement['type'], LabeledStmtEvent> & Record<BreakStatement['type'], BreakStmtEvent> & Record<ContinueStatement['type'], ContinueStmtEvent> & Record<ArrowFunctionExpression['type'], ArrowFnExprEvent> & Record<ConditionalExpression['type'], TernaryExprEvent> & Record<NewExpression['type'], NewExprEvent> & Record<YieldExpression['type'], YieldExprEvent> & Record<ExpressionStatement['type'], ExpressionStmtEvent> & Record<ArrayExpression['type'], ArrayExprEvent> & Record<ObjectExpression['type'], ObjectExprEvent> & Record<TemplateLiteral['type'], TemplateLiteralEvent> & Record<SequenceExpression['type'], SequenceExprEvent> & Record<UnaryExpression['type'], UnaryExprEvent> & Record<'Any', LangEvent>);
+export declare const LAZY_NODE: unique symbol;
+export declare const NOT_ALLOCATED: unique symbol;
+export declare const UNASSIGNED: unique symbol;
+export declare const SEEN: unique symbol;
+export type InspectorGenerator = Generator<typeof LAZY_NODE, undefined, any>;
+export type PerExe = () => void;
+/**
+ * The rich object that gives inspectors their ability to participate in the interpretation of the function
+ * Every monitored function has exactly one interpreter and also,exactly one visit object to themselves
+ * This means that the visit object is only alloacted once per monitored function and not per call to save memory
+ * You will shoot yourself in the foot if you attempt to take the visit object oustide of the inspector hook to use elsewhere.It can cause unexpected side effects.It is to be used strictly within that hook
+ *
+ * Because there is only one unique visit object,it uses live references to the current interpreter's state.This means that:
+ *  -The local exe stack is volatile.
+ *  -The 'is' method does not register your callback as a hook.Although that is what it will look like on the outside,its actually eagerly evaluating your callback the moment you call it and check your query against the current node.It will then discard your callback right after.
+ *  -The perExecution method does not register your callback as a hook.You use it like a setter and its short lived.It only exists for the current node and all its children
+ *  -The execute method must strictly be called within the lifetime of the inspector hook if you ever wish to call it.
+ *
+ * You dont have to worry too much about all of this if you use the visit object in the inspector hook where you know using it is safe.
+ */
+export interface Visit {
+    /**
+     * You pass in which node you are interested in as the first argument and you pass in your callback as the second.
+     * For each node that matches your query,it will fire your callback and allocate a scope object to wrap together with the node under a single event object
+     * You can mutate the node or query the scope.
+     *
+     * If you dont set a query for a particular node,the interpreter will not allocate a scope nor an event object.This is to save memory.
+     * So in the exe result,you will see a symbol called NOT_ALLOCATED.but you can use visit.is('Any',...) to force the interpreter to allocate a scope and event object for every node it visits
+     */
+    is: <T extends Query>(query: T, ifMatched: (event: EventMap[T]) => void) => void;
+    /**
+     * This is fired on each executed node.The hook itself does not get passed anything.It is actually a good place to check the local exe stack.By querying for the last element,you get to see the exe result in real time which includes the nodes,the results and each scope
+     */
+    set perExecution(perExe: PerExe);
+    /**
+     * The function that tells the interpreter to execute the current node and return the result.
+     * If its an async node like an await call,you get LAZY_NODE instead of the awaited result.You must explicitly type yield visit.execute() to get it.but it requires the inspector to be a generator instead of a regular function
+     * Once you get the result,you can read it or even modify it before it is returned to the caller
+     * The interpreter will execute the node manually if you never call this.
+     * There is no way to directly stop the interpreter from executing a node.This is to prevent a half broken state.If required,the inspector hook must throw an error
+     */
+    execute: <T extends any = any>() => T;
+    /**
+     * This is a stack data structure that contains the results of each evaluated child node for a given node.
+     * The latest results stay at the top and the oldest remain at the bottom.
+     * It is not the full execution history of the entire function.
+     */
+    localExeStack: () => Omit<ReadonlyQList<ExeResult>, 'swapSrc'>;
+}
+export interface ExeResult {
+    /**The result of the node's evaluation */
+    evaluation: unknown;
+    /**The type of the node*/
+    type: EsNode['type'];
+    /**
+     * The node itself.Unlike the scope object,the nodes are always allocated.
+     * The reality is that the interpreter always allocates a node and a scope object to process each step.
+     * But it doesnt openly pass the original scope object because mutating the scope directly isnt as safe as a specific node
+     * So it only directly passes the internal node object and allocates a safe scope object that cant be used to mutate the original scope in any way.But it is only selectively allocated
+    */
+    node: EsNode;
+    /**
+     *the safe scope created for the caller
+     */
+    scope: ScopeForEvent | typeof NOT_ALLOCATED;
+}
+/**This type describes an internal object */
+export interface Reusables {
+    node: EsNode | null;
+    currentScope: Scope | null;
+    handler: null | ((node: EsNode, scope: Scope<SvalPlus>) => any);
+    result: any | typeof UNASSIGNED | typeof SEEN;
+    currentEvent: LangEvent | typeof NOT_ALLOCATED;
+    shared: {
+        exeStack: QList<ExeResult>;
+        readonlyExeStack: ReadonlyQList<ExeResult>;
+        evalStack: {
+            value: number;
+        };
+        perExe: null | {
+            owner: EsNode;
+            fn: PerExe;
+        };
+    };
+}
+export type Inspector = (visit: Visit) => void | InspectorGenerator;
+export type OnStep = () => void;
+export interface SvalPlus {
+    inspector: Inspector | null;
+    onStep: OnStep | null;
+    reusables: Reusables;
+    visit: Visit;
+    stage: 'IDLE' | 'PRE-PROCESSING' | 'MONITORING';
+    createEventScope: () => ScopeForEvent;
+}
+export interface VariableForEvent {
+    /**The value of the variable */
+    value: () => any;
+}
+export interface ScopeForEvent {
+    /**The variables in the scope.You can check for all the local variables or use the search method to get a variable from its identifier.*/
+    variables: {
+        /**If a variable cannot be identified from the given name,you get null instead of the object */
+        search: (name: string) => VariableForEvent | null;
+        local: Record<string, Var>;
+    };
+    /**The parent scope */
+    parent: Scope | null;
+    /**The depth of the scope of the current node*/
+    depth: number;
+}
+export declare class LangEvent<NodeType extends EsNode = EsNode> {
+    node: NodeType;
+    scope: ScopeForEvent;
+    constructor(interpreter: SvalPlus);
+}
+export declare class ExpressionStmtEvent extends LangEvent<ExpressionStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ArrayExprEvent extends LangEvent<ArrayExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ObjectExprEvent extends LangEvent<ObjectExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class TemplateLiteralEvent extends LangEvent<TemplateLiteral> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class SequenceExprEvent extends LangEvent<SequenceExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class UnaryExprEvent extends LangEvent<UnaryExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class BinaryExprEvent extends LangEvent<BinaryExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class CallExprEvent extends LangEvent<CallExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class AssignmentExprEvent extends LangEvent<AssignmentExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class UpdateExprEvent extends LangEvent<UpdateExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class LogicalExprEvent extends LangEvent<LogicalExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class MemberExprEvent extends LangEvent<MemberExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class AwaitExprEvent extends LangEvent<AwaitExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class FuncExprEvent extends LangEvent<FunctionExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ArrowFnExprEvent extends LangEvent<ArrowFunctionExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class TernaryExprEvent extends LangEvent<ConditionalExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class NewExprEvent extends LangEvent<NewExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class YieldExprEvent extends LangEvent<YieldExpression> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ReturnStmtEvent extends LangEvent<ReturnStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class IfStmtEvent extends LangEvent<IfStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class SwitchStmtEvent extends LangEvent<SwitchStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ThrowStmtEvent extends LangEvent<ThrowStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class TryStmtEvent extends LangEvent<TryStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class CatchClauseEvent extends LangEvent<CatchClause> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class VarDeclEvent extends LangEvent<VariableDeclaration> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class FuncDeclEvent extends LangEvent<FunctionDeclaration> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ForStmtEvent extends LangEvent<ForStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class WhileStmtEvent extends LangEvent<WhileStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class DoWhileStmtEvent extends LangEvent<DoWhileStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ForOfStmtEvent extends LangEvent<ForOfStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ForInStmtEvent extends LangEvent<ForInStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class LabeledStmtEvent extends LangEvent<LabeledStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class BreakStmtEvent extends LangEvent<BreakStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class ContinueStmtEvent extends LangEvent<ContinueStatement> {
+    constructor(interpreter: SvalPlus);
+}
+export declare class LiteralEvent extends LangEvent<Literal> {
+    constructor(interpreter: SvalPlus);
+}
+export declare function createEvent<T extends Query>(query: Query, interpreter: SvalPlus): EventMap[T];