@typescript-guy/fn-monitor 1.0.0

package/dist/custom-types.js

@@ -0,0 +1,341 @@
+const LAZY_NODE = Symbol("LAZY_NODE");
+const NOT_ALLOCATED = Symbol("NOT_ALLOCATED");
+const UNASSIGNED = Symbol("UNASSIGNED");
+const SEEN = Symbol("SEEN");
+class LangEvent {
+  //LangEvent is short for Language Event
+  node;
+  scope;
+  constructor(interpreter) {
+    this.node = interpreter.reusables.node;
+    this.scope = interpreter.createEventScope();
+  }
+}
+class ExpressionStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ArrayExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ObjectExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class TemplateLiteralEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class SequenceExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class UnaryExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class BinaryExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class CallExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class AssignmentExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class UpdateExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class LogicalExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class MemberExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class AwaitExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class FuncExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ArrowFnExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class TernaryExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class NewExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class YieldExprEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ReturnStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class IfStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class SwitchStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ThrowStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class TryStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class CatchClauseEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class VarDeclEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class FuncDeclEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ForStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class WhileStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class DoWhileStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ForOfStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ForInStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class LabeledStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class BreakStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class ContinueStmtEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+class LiteralEvent extends LangEvent {
+  constructor(interpreter) {
+    super(interpreter);
+  }
+}
+function createEvent(query, interpreter) {
+  let event = null;
+  switch (query) {
+    case "BinaryExpression": {
+      event = new BinaryExprEvent(interpreter);
+      break;
+    }
+    case "CallExpression": {
+      event = new CallExprEvent(interpreter);
+      break;
+    }
+    case "AssignmentExpression": {
+      event = new AssignmentExprEvent(interpreter);
+      break;
+    }
+    case "UpdateExpression": {
+      event = new UpdateExprEvent(interpreter);
+      break;
+    }
+    case "LogicalExpression": {
+      event = new LogicalExprEvent(interpreter);
+      break;
+    }
+    case "MemberExpression": {
+      event = new MemberExprEvent(interpreter);
+      break;
+    }
+    case "AwaitExpression": {
+      event = new AwaitExprEvent(interpreter);
+      break;
+    }
+    case "FunctionExpression": {
+      event = new FuncExprEvent(interpreter);
+      break;
+    }
+    case "ReturnStatement": {
+      event = new ReturnStmtEvent(interpreter);
+      break;
+    }
+    case "IfStatement": {
+      event = new IfStmtEvent(interpreter);
+      break;
+    }
+    case "SwitchStatement": {
+      event = new SwitchStmtEvent(interpreter);
+      break;
+    }
+    case "ThrowStatement": {
+      event = new ThrowStmtEvent(interpreter);
+      break;
+    }
+    case "TryStatement": {
+      event = new TryStmtEvent(interpreter);
+      break;
+    }
+    case "CatchClause": {
+      event = new CatchClauseEvent(interpreter);
+      break;
+    }
+    case "VariableDeclaration": {
+      event = new VarDeclEvent(interpreter);
+      break;
+    }
+    case "FunctionDeclaration": {
+      event = new FuncDeclEvent(interpreter);
+      break;
+    }
+    case "ForStatement": {
+      event = new ForStmtEvent(interpreter);
+      break;
+    }
+    case "WhileStatement": {
+      event = new WhileStmtEvent(interpreter);
+      break;
+    }
+    case "DoWhileStatement": {
+      event = new DoWhileStmtEvent(interpreter);
+      break;
+    }
+    case "ForOfStatement": {
+      event = new ForOfStmtEvent(interpreter);
+      break;
+    }
+    case "ForInStatement": {
+      event = new ForInStmtEvent(interpreter);
+      break;
+    }
+    case "Literal": {
+      event = new LiteralEvent(interpreter);
+      break;
+    }
+    case "LabeledStatement": {
+      event = new LabeledStmtEvent(interpreter);
+      break;
+    }
+    case "BreakStatement": {
+      event = new BreakStmtEvent(interpreter);
+      break;
+    }
+    case "ContinueStatement": {
+      event = new ContinueStmtEvent(interpreter);
+      break;
+    }
+    case "NewExpression": {
+      event = new NewExprEvent(interpreter);
+      break;
+    }
+    case "ArrowFunctionExpression": {
+      event = new ArrowFnExprEvent(interpreter);
+      break;
+    }
+    case "ConditionalExpression": {
+      event = new TernaryExprEvent(interpreter);
+      break;
+    }
+    case "YieldExpression": {
+      event = new YieldExprEvent(interpreter);
+      break;
+    }
+    case "ExpressionStatement": {
+      event = new ExpressionStmtEvent(interpreter);
+      break;
+    }
+    case "ArrayExpression": {
+      event = new ArrayExprEvent(interpreter);
+      break;
+    }
+    case "ObjectExpression": {
+      event = new ObjectExprEvent(interpreter);
+      break;
+    }
+    case "TemplateLiteral": {
+      event = new TemplateLiteralEvent(interpreter);
+      break;
+    }
+    case "SequenceExpression": {
+      event = new SequenceExprEvent(interpreter);
+      break;
+    }
+    case "UnaryExpression": {
+      event = new UnaryExprEvent(interpreter);
+      break;
+    }
+    case "Any":
+    default: {
+      event = new LangEvent(interpreter);
+      break;
+    }
+  }
+  return event;
+}
+
+export { ArrayExprEvent, ArrowFnExprEvent, AssignmentExprEvent, AwaitExprEvent, BinaryExprEvent, BreakStmtEvent, CallExprEvent, CatchClauseEvent, ContinueStmtEvent, DoWhileStmtEvent, ExpressionStmtEvent, ForInStmtEvent, ForOfStmtEvent, ForStmtEvent, FuncDeclEvent, FuncExprEvent, IfStmtEvent, LAZY_NODE, LabeledStmtEvent, LangEvent, LiteralEvent, LogicalExprEvent, MemberExprEvent, NOT_ALLOCATED, NewExprEvent, ObjectExprEvent, ReturnStmtEvent, SEEN, SequenceExprEvent, SwitchStmtEvent, TemplateLiteralEvent, TernaryExprEvent, ThrowStmtEvent, TryStmtEvent, UNASSIGNED, UnaryExprEvent, UpdateExprEvent, VarDeclEvent, WhileStmtEvent, YieldExprEvent, createEvent };

package/dist/evaluate/declaration.d.ts

@@ -0,0 +1,27 @@
+import { VarKind } from '../scope/variable.ts';
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function FunctionDeclaration(node: acorn.FunctionDeclaration, scope: Scope): IterableIterator<any>;
+export interface VariableDeclarationOptions {
+    hoist?: boolean;
+    onlyBlock?: boolean;
+    feed?: any;
+}
+export declare function VariableDeclaration(node: acorn.VariableDeclaration, scope: Scope, options?: VariableDeclarationOptions): Generator<any, void, any>;
+export interface VariableDeclaratorOptions {
+    kind?: VarKind;
+}
+export declare function VariableDeclarator(node: acorn.VariableDeclarator, scope: Scope, options?: VariableDeclaratorOptions & VariableDeclarationOptions): Generator<any, void, any>;
+export declare function ClassDeclaration(node: acorn.ClassDeclaration, scope: Scope): IterableIterator<any>;
+export interface ClassOptions {
+    klass?: any;
+    superClass?: (...args: any[]) => void;
+}
+export declare function ClassBody(node: acorn.ClassBody, scope: Scope, options?: ClassOptions): Generator<any, void, any>;
+export declare function MethodDefinition(node: acorn.MethodDefinition, scope: Scope, options?: ClassOptions): Generator<any, void, any>;
+export declare function PropertyDefinition(node: acorn.PropertyDefinition, scope: Scope, options?: ClassOptions): Generator<any, void, any>;
+export declare function StaticBlock(node: acorn.StaticBlock, scope: Scope, options?: ClassOptions): Generator<any, any, any>;
+export declare function ImportDeclaration(node: acorn.ImportDeclaration, scope: Scope): Generator<never, void, unknown>;
+export declare function ExportDefaultDeclaration(node: acorn.ExportDefaultDeclaration, scope: Scope): Generator<any, void, any>;
+export declare function ExportNamedDeclaration(node: acorn.ExportNamedDeclaration, scope: Scope): Generator<any, void, any>;
+export declare function ExportAllDeclaration(node: acorn.ExportAllDeclaration, scope: Scope): Generator<never, void, unknown>;

package/dist/evaluate/declaration.js

@@ -0,0 +1,289 @@
+import { IMPORT, EXPORTS, PRIVATE, DEADZONE, NOINIT } from '../share/const.js';
+import { assign, hasOwn, define, getDptor } from '../share/util.js';
+import { createClass, createFunc, pattern } from './helper.js';
+import { BlockStatement } from './statement.js';
+import Scope from '../scope/index.js';
+import evaluate from './index.js';
+
+function* FunctionDeclaration(node, scope) {
+  scope.func(node.id.name, createFunc(node, scope));
+}
+function* VariableDeclaration(node, scope, options = {}) {
+  for (let i = 0; i < node.declarations.length; i++) {
+    yield* VariableDeclarator(node.declarations[i], scope, assign({ kind: node.kind }, options));
+  }
+}
+function* VariableDeclarator(node, scope, options = {}) {
+  const { kind = "var", hoist = false, onlyBlock = false, feed } = options;
+  if (hoist) {
+    if (onlyBlock || kind === "var") {
+      if (node.id.type === "Identifier") {
+        scope[kind](node.id.name, onlyBlock ? DEADZONE : kind === "var" ? NOINIT : void 0);
+      } else {
+        yield* pattern(node.id, scope, { kind, hoist, onlyBlock });
+      }
+    }
+  } else {
+    const hasFeed = "feed" in options;
+    const value = hasFeed ? feed : yield* evaluate(node.init, scope);
+    if (node.id.type === "Identifier") {
+      const name = node.id.name;
+      if (kind === "var" && !node.init && !hasFeed) {
+        scope.var(name, NOINIT);
+      } else {
+        scope[kind](name, value);
+      }
+      if (node.init && ["ClassExpression", "FunctionExpression", "ArrowFunctionExpression"].indexOf(node.init.type) !== -1 && !value.name) {
+        define(value, "name", {
+          value: name,
+          configurable: true
+        });
+      }
+    } else {
+      yield* pattern(node.id, scope, { kind, feed: value });
+    }
+  }
+}
+function* ClassDeclaration(node, scope) {
+  scope.func(node.id.name, yield* createClass(node, scope));
+}
+function* ClassBody(node, scope, options = {}) {
+  const { klass, superClass } = options;
+  for (let i = 0; i < node.body.length; i++) {
+    const def = node.body[i];
+    if (def.type === "MethodDefinition") {
+      yield* MethodDefinition(def, scope, { klass, superClass });
+    } else if (def.type === "PropertyDefinition" && def.static) {
+      yield* PropertyDefinition(def, scope, { klass, superClass });
+    } else if (def.type === "StaticBlock") {
+      yield* StaticBlock(def, scope, { klass});
+    }
+  }
+}
+function* MethodDefinition(node, scope, options = {}) {
+  const { klass, superClass } = options;
+  let key;
+  let priv = false;
+  if (node.computed) {
+    key = yield* evaluate(node.key, scope);
+  } else if (node.key.type === "Identifier") {
+    key = node.key.name;
+  } else if (node.key.type === "PrivateIdentifier") {
+    key = node.key.name;
+    priv = true;
+  } else {
+    throw new SyntaxError("Unexpected token");
+  }
+  let obj = node.static ? klass : klass.prototype;
+  if (priv) {
+    if (!obj[PRIVATE]) {
+      define(obj, PRIVATE, { value: {} });
+    }
+    obj = obj[PRIVATE];
+  }
+  const value = createFunc(node.value, scope, { superClass });
+  switch (node.kind) {
+    case "constructor":
+      break;
+    case "method":
+      define(obj, key, {
+        value,
+        writable: true,
+        configurable: true
+      });
+      break;
+    case "get": {
+      const oriDptor = getDptor(obj, key);
+      define(obj, key, {
+        get: value,
+        set: oriDptor && oriDptor.set,
+        configurable: true
+      });
+      break;
+    }
+    case "set": {
+      const oriDptor = getDptor(obj, key);
+      define(obj, key, {
+        get: oriDptor && oriDptor.get,
+        set: value,
+        configurable: true
+      });
+      break;
+    }
+    default:
+      throw new SyntaxError("Unexpected token");
+  }
+}
+function* PropertyDefinition(node, scope, options = {}) {
+  const { klass, superClass } = options;
+  let key;
+  let priv = false;
+  if (node.computed) {
+    key = yield* evaluate(node.key, scope);
+  } else if (node.key.type === "Identifier") {
+    key = node.key.name;
+  } else if (node.key.type === "PrivateIdentifier") {
+    key = node.key.name;
+    priv = true;
+  } else {
+    throw new SyntaxError("Unexpected token");
+  }
+  const subScope = new Scope(scope, true);
+  subScope.const("this", klass);
+  let obj = klass;
+  if (priv) {
+    if (!obj[PRIVATE]) {
+      define(obj, PRIVATE, { value: {} });
+    }
+    obj = obj[PRIVATE];
+  }
+  if (!node.value) {
+    obj[key] = void 0;
+  } else if (node.value.type === "FunctionExpression" || node.value.type === "ArrowFunctionExpression") {
+    obj[key] = createFunc(node.value, subScope, { superClass });
+  } else {
+    obj[key] = yield* evaluate(node.value, subScope);
+  }
+}
+function* StaticBlock(node, scope, options = {}) {
+  const { klass } = options;
+  const subScope = new Scope(scope, true);
+  subScope.const("this", klass);
+  return yield* BlockStatement(node, subScope, { invasived: true });
+}
+function* ImportDeclaration(node, scope) {
+  const globalScope = scope.global();
+  const module = globalScope.find(IMPORT + node.source.value);
+  let value;
+  if (module) {
+    const result = module.get();
+    if (result) {
+      if (typeof result === "function") {
+        value = result();
+      } else if (typeof result === "object") {
+        value = result;
+      }
+    }
+  }
+  if (!value || typeof value !== "object") {
+    throw new TypeError(`Failed to resolve module specifier "${node.source.value}"`);
+  }
+  for (let i = 0; i < node.specifiers.length; i++) {
+    const spec = node.specifiers[i];
+    let name;
+    if (spec.type === "ImportSpecifier") {
+      name = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+    } else if (spec.type === "ImportDefaultSpecifier") {
+      name = "default";
+    } else if (spec.type === "ImportNamespaceSpecifier") {
+      name = "*";
+    }
+    if (name !== "*" && !hasOwn(value, name)) {
+      throw new SyntaxError(`The requested module "${node.source.value}" does not provide an export named "${name}"`);
+    }
+    scope.var(spec.local.name, name === "*" ? assign({}, value) : value[name]);
+  }
+}
+function* ExportDefaultDeclaration(node, scope) {
+  const globalScope = scope.global();
+  let value;
+  if (node.declaration.type === "FunctionDeclaration") {
+    value = createFunc(node.declaration, scope);
+    scope.func(node.declaration.id.name, value);
+  } else if (node.declaration.type === "ClassDeclaration") {
+    value = yield* createClass(node.declaration, scope);
+    scope.func(node.declaration.id.name, value);
+  } else {
+    value = yield* evaluate(node.declaration, scope);
+  }
+  const variable = globalScope.find(EXPORTS);
+  if (variable) {
+    const exports = variable.get();
+    if (exports && typeof exports === "object") {
+      exports.default = value;
+    }
+  }
+}
+function* ExportNamedDeclaration(node, scope) {
+  const globalScope = scope.global();
+  if (node.declaration) {
+    if (node.declaration.type === "FunctionDeclaration") {
+      const value = createFunc(node.declaration, scope);
+      scope.func(node.declaration.id.name, value);
+      const variable = globalScope.find(EXPORTS);
+      if (variable) {
+        const exports = variable.get();
+        if (exports && typeof exports === "object") {
+          exports[node.declaration.id.name] = value;
+        }
+      }
+    } else if (node.declaration.type === "ClassDeclaration") {
+      const value = yield* createClass(node.declaration, scope);
+      scope.func(node.declaration.id.name, value);
+      const variable = globalScope.find(EXPORTS);
+      if (variable) {
+        const exports = variable.get();
+        if (exports && typeof exports === "object") {
+          exports[node.declaration.id.name] = value;
+        }
+      }
+    } else if (node.declaration.type === "VariableDeclaration") {
+      yield* VariableDeclaration(node.declaration, scope);
+      const variable = globalScope.find(EXPORTS);
+      if (variable) {
+        const exports = variable.get();
+        if (exports && typeof exports === "object") {
+          for (let i = 0; i < node.declaration.declarations.length; i++) {
+            const name = node.declaration.declarations[i].id.name;
+            const item = scope.find(name);
+            if (item) {
+              exports[name] = item.get();
+            }
+          }
+        }
+      }
+    }
+  } else if (node.specifiers) {
+    const variable = globalScope.find(EXPORTS);
+    if (variable) {
+      const exports = variable.get();
+      if (exports && typeof exports === "object") {
+        for (let i = 0; i < node.specifiers.length; i++) {
+          const spec = node.specifiers[i];
+          const name = spec.local.type === "Identifier" ? spec.local.name : spec.local.value;
+          const item = scope.find(name);
+          if (item) {
+            exports[spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value] = item.get();
+          }
+        }
+      }
+    }
+  }
+}
+function* ExportAllDeclaration(node, scope) {
+  const globalScope = scope.global();
+  const module = globalScope.find(IMPORT + node.source.value);
+  let value;
+  if (module) {
+    const result = module.get();
+    if (result) {
+      if (typeof result === "function") {
+        value = result();
+      } else if (typeof result === "object") {
+        value = result;
+      }
+    }
+  }
+  if (!value || typeof value !== "object") {
+    throw new TypeError(`Failed to resolve module specifier "${node.source.value}"`);
+  }
+  const variable = globalScope.find(EXPORTS);
+  if (variable) {
+    const exports = variable.get();
+    if (exports && typeof exports === "object") {
+      assign(exports, value);
+    }
+  }
+}
+
+export { ClassBody, ClassDeclaration, ExportAllDeclaration, ExportDefaultDeclaration, ExportNamedDeclaration, FunctionDeclaration, ImportDeclaration, MethodDefinition, PropertyDefinition, StaticBlock, VariableDeclaration, VariableDeclarator };

package/dist/evaluate/expression.d.ts

@@ -0,0 +1,40 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function ThisExpression(node: acorn.ThisExpression, scope: Scope): Generator<never, any, unknown>;
+export declare function ArrayExpression(node: acorn.ArrayExpression, scope: Scope): Generator<any, any[], any>;
+export declare function ObjectExpression(node: acorn.ObjectExpression, scope: Scope): Generator<any, {
+    [key: string]: any;
+}, any>;
+export declare function FunctionExpression(node: acorn.FunctionExpression, scope: Scope): Generator<never, any, unknown>;
+export declare function UnaryExpression(node: acorn.UnaryExpression, scope: Scope): Generator<any, number | boolean | "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function", any>;
+export declare function UpdateExpression(node: acorn.UpdateExpression, scope: Scope): Generator<any, any, any>;
+export declare function BinaryExpression(node: acorn.BinaryExpression, scope: Scope): Generator<any, any, any>;
+export declare function AssignmentExpression(node: acorn.AssignmentExpression, scope: Scope): Generator<any, any, any>;
+export declare function LogicalExpression(node: acorn.LogicalExpression, scope: Scope): Generator<any, any, any>;
+export interface MemberExpressionOptions {
+    getObj?: boolean;
+    getVar?: boolean;
+}
+export declare function MemberExpression(node: acorn.MemberExpression, scope: Scope, options?: MemberExpressionOptions): Generator<any, any, any>;
+export declare function ConditionalExpression(node: acorn.ConditionalExpression, scope: Scope): Generator<any, any, any>;
+export declare function CallExpression(node: acorn.CallExpression, scope: Scope): Generator<any, any, any>;
+export declare function NewExpression(node: acorn.NewExpression, scope: Scope): Generator<any, any, any>;
+export declare function MetaProperty(node: acorn.MetaProperty, scope: Scope): Generator<never, any, unknown>;
+export declare function SequenceExpression(node: acorn.SequenceExpression, scope: Scope): Generator<any, any, any>;
+export declare function ArrowFunctionExpression(node: acorn.ArrowFunctionExpression, scope: Scope): Generator<never, any, unknown>;
+export declare function TemplateLiteral(node: acorn.TemplateLiteral, scope: Scope): Generator<any, string, any>;
+export declare function TaggedTemplateExpression(node: acorn.TaggedTemplateExpression, scope: Scope): Generator<any, any, any>;
+export declare function TemplateElement(node: acorn.TemplateElement, scope: Scope): Generator<never, string, unknown>;
+export declare function ClassExpression(node: acorn.ClassExpression, scope: Scope): Generator<any, () => Generator<any, any, any>, any>;
+export interface SuperOptions {
+    getProto?: boolean;
+}
+export declare function Super(node: acorn.Super, scope: Scope, options?: SuperOptions): Generator<never, any, unknown>;
+export interface SpreadOptions {
+    spreadProps?: boolean;
+}
+export declare function SpreadElement(node: acorn.SpreadElement, scope: Scope, options?: SpreadOptions): Generator<any, any, any>;
+export declare function ChainExpression(node: acorn.ChainExpression, scope: Scope): Generator<any, any, any>;
+export declare function ImportExpression(node: acorn.ImportExpression, scope: Scope): Generator<any, Promise<any>, any>;
+export declare function YieldExpression(node: acorn.YieldExpression, scope: Scope): any;
+export declare function AwaitExpression(node: acorn.AwaitExpression, scope: Scope): any;