@typescript-guy/fn-monitor 1.0.0

package/dist/evaluate/statement.js

@@ -0,0 +1,323 @@
+import { BREAK, CONTINUE, RETURN, AWAIT } from '../share/const.js';
+import { hoist, ForXHandler, pattern } from './helper.js';
+import { getAsyncIterator } from '../share/util.js';
+import Scope from '../scope/index.js';
+import evaluate from './index.js';
+
+function* ExpressionStatement(node, scope) {
+  yield* evaluate(node.expression, scope);
+}
+function* BlockStatement(block, scope, options = {}) {
+  const {
+    invasived = false,
+    hoisted = false
+  } = options;
+  const subScope = invasived ? scope : new Scope(scope);
+  if (!hoisted) {
+    yield* hoist(block, subScope, { onlyBlock: true });
+  }
+  for (let i = 0; i < block.body.length; i++) {
+    const result = yield* evaluate(block.body[i], subScope);
+    if (result === BREAK) {
+      if (result.LABEL && result.LABEL === options.label) {
+        break;
+      }
+      return result;
+    }
+    if (result === CONTINUE || result === RETURN) {
+      return result;
+    }
+  }
+}
+function* EmptyStatement() {
+}
+function* DebuggerStatement() {
+  debugger;
+}
+function* ReturnStatement(node, scope) {
+  RETURN.RES = node.argument ? yield* evaluate(node.argument, scope) : void 0;
+  return RETURN;
+}
+function* BreakStatement(node) {
+  BREAK.LABEL = node.label?.name;
+  return BREAK;
+}
+function* ContinueStatement(node) {
+  CONTINUE.LABEL = node.label?.name;
+  return CONTINUE;
+}
+function* LabeledStatement(node, scope) {
+  const label = node.label.name;
+  if (node.body.type === "WhileStatement") {
+    return yield* WhileStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "DoWhileStatement") {
+    return yield* DoWhileStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "ForStatement") {
+    return yield* ForStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "ForInStatement") {
+    return yield* ForInStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "ForOfStatement") {
+    return yield* ForOfStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "BlockStatement") {
+    return yield* BlockStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "WithStatement") {
+    return yield* WithStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "IfStatement") {
+    return yield* IfStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "SwitchStatement") {
+    return yield* SwitchStatement(node.body, scope, { label });
+  }
+  if (node.body.type === "TryStatement") {
+    return yield* TryStatement(node.body, scope, { label });
+  }
+  throw new SyntaxError(`${node.body.type} cannot be labeled`);
+}
+function* WithStatement(node, scope, options = {}) {
+  const withScope = new Scope(scope);
+  withScope.with(yield* evaluate(node.object, scope));
+  const result = yield* evaluate(node.body, withScope);
+  if (result === BREAK) {
+    if (result.LABEL && result.LABEL === options.label) {
+      return;
+    }
+    return result;
+  }
+  if (result === CONTINUE || result === RETURN) {
+    return result;
+  }
+}
+function* IfStatement(node, scope, options = {}) {
+  let result;
+  if (yield* evaluate(node.test, scope)) {
+    result = yield* evaluate(node.consequent, scope);
+  } else {
+    result = yield* evaluate(node.alternate, scope);
+  }
+  if (result === BREAK) {
+    if (result.LABEL && result.LABEL === options.label) {
+      return;
+    }
+    return result;
+  }
+  if (result === CONTINUE || result === RETURN) {
+    return result;
+  }
+}
+function* SwitchStatement(node, scope, options = {}) {
+  const discriminant = yield* evaluate(node.discriminant, scope);
+  let matched = false;
+  let defaultIndex = -1;
+  for (let i = 0; i < node.cases.length; i++) {
+    const eachCase = node.cases[i];
+    if (!eachCase.test) {
+      defaultIndex = i;
+    } else if (!matched && (yield* evaluate(eachCase.test, scope)) === discriminant) {
+      matched = true;
+      defaultIndex = -1;
+    }
+    if (matched) {
+      const result = yield* SwitchCase(eachCase, scope);
+      if (result === BREAK) {
+        if (result.LABEL === options.label) {
+          break;
+        }
+        return result;
+      }
+      if (result === CONTINUE || result === RETURN) {
+        return result;
+      }
+    }
+  }
+  if (!matched && defaultIndex !== -1) {
+    for (let i = defaultIndex; i < node.cases.length; i++) {
+      const result = yield* SwitchCase(node.cases[i], scope);
+      if (result === BREAK) {
+        if (result.LABEL === options.label) {
+          break;
+        }
+        return result;
+      }
+      if (result === CONTINUE || result === RETURN) {
+        return result;
+      }
+    }
+  }
+}
+function* SwitchCase(node, scope) {
+  for (let i = 0; i < node.consequent.length; i++) {
+    const result = yield* evaluate(node.consequent[i], scope);
+    if (result === BREAK || result === CONTINUE || result === RETURN) {
+      return result;
+    }
+  }
+}
+function* ThrowStatement(node, scope) {
+  throw yield* evaluate(node.argument, scope);
+}
+function* TryStatement(node, scope, options = {}) {
+  let result;
+  try {
+    result = yield* BlockStatement(node.block, scope);
+  } catch (err) {
+    if (node.handler) {
+      const subScope = new Scope(scope);
+      const param = node.handler.param;
+      if (param) {
+        if (param.type === "Identifier") {
+          const name = param.name;
+          subScope.var(name, err);
+        } else {
+          yield* pattern(param, scope, { feed: err });
+        }
+      }
+      result = yield* CatchClause(node.handler, subScope);
+    } else {
+      throw err;
+    }
+  } finally {
+    if (node.finalizer) {
+      result = yield* BlockStatement(node.finalizer, scope);
+    }
+  }
+  if (result === BREAK) {
+    if (result.LABEL && result.LABEL === options.label) {
+      return;
+    }
+    return result;
+  }
+  if (result === CONTINUE || result === RETURN) {
+    return result;
+  }
+}
+function* CatchClause(node, scope) {
+  return yield* BlockStatement(node.body, scope, { invasived: true });
+}
+function* WhileStatement(node, scope, options = {}) {
+  while (yield* evaluate(node.test, scope)) {
+    const result = yield* evaluate(node.body, scope);
+    if (result === BREAK) {
+      if (result.LABEL === options.label) {
+        break;
+      }
+      return result;
+    } else if (result === CONTINUE) {
+      if (result.LABEL === options.label) {
+        continue;
+      }
+      return result;
+    } else if (result === RETURN) {
+      return result;
+    }
+  }
+}
+function* DoWhileStatement(node, scope, options = {}) {
+  do {
+    const result = yield* evaluate(node.body, scope);
+    if (result === BREAK) {
+      if (result.LABEL === options.label) {
+        break;
+      }
+      return result;
+    } else if (result === CONTINUE) {
+      if (result.LABEL === options.label) {
+        continue;
+      }
+      return result;
+    } else if (result === RETURN) {
+      return result;
+    }
+  } while (yield* evaluate(node.test, scope));
+}
+function* ForStatement(node, scope, options = {}) {
+  const forScope = new Scope(scope);
+  for (node.init ? yield* evaluate(node.init, forScope) : void 0; node.test ? yield* evaluate(node.test, forScope) : true; node.update ? yield* evaluate(node.update, forScope) : void 0) {
+    const subScope = new Scope(forScope);
+    let result;
+    if (node.body.type === "BlockStatement") {
+      result = yield* BlockStatement(node.body, subScope, { invasived: true });
+    } else {
+      result = yield* evaluate(node.body, subScope);
+    }
+    if (result === BREAK) {
+      if (result.LABEL === options.label) {
+        break;
+      }
+      return result;
+    } else if (result === CONTINUE) {
+      if (result.LABEL === options.label) {
+        continue;
+      }
+      return result;
+    } else if (result === RETURN) {
+      return result;
+    }
+  }
+}
+function* ForInStatement(node, scope, options = {}) {
+  for (const value in yield* evaluate(node.right, scope)) {
+    const result = yield* ForXHandler(node, scope, { value });
+    if (result === BREAK) {
+      if (result.LABEL === options.label) {
+        break;
+      }
+      return result;
+    } else if (result === CONTINUE) {
+      if (result.LABEL === options.label) {
+        continue;
+      }
+      return result;
+    } else if (result === RETURN) {
+      return result;
+    }
+  }
+}
+function* ForOfStatement(node, scope, options = {}) {
+  const right = yield* evaluate(node.right, scope);
+  if (node.await) {
+    const iterator = getAsyncIterator(right);
+    let ret;
+    for (AWAIT.RES = iterator.next(), ret = yield AWAIT; !ret.done; AWAIT.RES = iterator.next(), ret = yield AWAIT) {
+      const result = yield* ForXHandler(node, scope, { value: ret.value });
+      if (result === BREAK) {
+        if (result.LABEL === options.label) {
+          break;
+        }
+        return result;
+      } else if (result === CONTINUE) {
+        if (result.LABEL === options.label) {
+          continue;
+        }
+        return result;
+      } else if (result === RETURN) {
+        return result;
+      }
+    }
+  } else {
+    for (const value of right) {
+      const result = yield* ForXHandler(node, scope, { value });
+      if (result === BREAK) {
+        if (result.LABEL === options.label) {
+          break;
+        }
+        return result;
+      } else if (result === CONTINUE) {
+        if (result.LABEL === options.label) {
+          continue;
+        }
+        return result;
+      } else if (result === RETURN) {
+        return result;
+      }
+    }
+  }
+}
+
+export { BlockStatement, BreakStatement, CatchClause, ContinueStatement, DebuggerStatement, DoWhileStatement, EmptyStatement, ExpressionStatement, ForInStatement, ForOfStatement, ForStatement, IfStatement, LabeledStatement, ReturnStatement, SwitchCase, SwitchStatement, ThrowStatement, TryStatement, WhileStatement, WithStatement };

package/dist/evaluate_n/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): any;
+export interface VariableDeclarationOptions {
+    hoist?: boolean;
+    onlyBlock?: boolean;
+    feed?: any;
+}
+export declare function VariableDeclaration(node: acorn.VariableDeclaration, scope: Scope, options?: VariableDeclarationOptions): void;
+export interface VariableDeclaratorOptions {
+    kind?: VarKind;
+}
+export declare function VariableDeclarator(node: acorn.VariableDeclarator, scope: Scope, options?: VariableDeclaratorOptions & VariableDeclarationOptions): void;
+export declare function ClassDeclaration(node: acorn.ClassDeclaration, scope: Scope): any;
+export interface ClassOptions {
+    klass?: any;
+    superClass?: (...args: any[]) => void;
+}
+export declare function ClassBody(node: acorn.ClassBody, scope: Scope, options?: ClassOptions): void;
+export declare function MethodDefinition(node: acorn.MethodDefinition, scope: Scope, options?: ClassOptions): void;
+export declare function PropertyDefinition(node: acorn.PropertyDefinition, scope: Scope, options?: ClassOptions): void;
+export declare function StaticBlock(node: acorn.StaticBlock, scope: Scope, options?: ClassOptions): any;
+export declare function ImportDeclaration(node: acorn.ImportDeclaration, scope: Scope): void;
+export declare function ExportDefaultDeclaration(node: acorn.ExportDefaultDeclaration, scope: Scope): void;
+export declare function ExportNamedDeclaration(node: acorn.ExportNamedDeclaration, scope: Scope): void;
+export declare function ExportAllDeclaration(node: acorn.ExportAllDeclaration, scope: Scope): void;

package/dist/evaluate_n/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++) {
+    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 {
+        pattern(node.id, scope, { kind, hoist, onlyBlock });
+      }
+    }
+  } else {
+    const hasFeed = "feed" in options;
+    const value = hasFeed ? feed : 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 {
+      pattern(node.id, scope, { kind, feed: value });
+    }
+  }
+}
+function ClassDeclaration(node, scope) {
+  scope.func(node.id.name, 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") {
+      MethodDefinition(def, scope, { klass, superClass });
+    } else if (def.type === "PropertyDefinition" && def.static) {
+      PropertyDefinition(def, scope, { klass, superClass });
+    } else if (def.type === "StaticBlock") {
+      StaticBlock(def, scope, { klass});
+    }
+  }
+}
+function MethodDefinition(node, scope, options = {}) {
+  const { klass, superClass } = options;
+  let key;
+  let priv = false;
+  if (node.computed) {
+    key = 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 = 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] = evaluate(node.value, subScope);
+  }
+}
+function StaticBlock(node, scope, options = {}) {
+  const { klass } = options;
+  const subScope = new Scope(scope, true);
+  subScope.const("this", klass);
+  return 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 = createClass(node.declaration, scope);
+    scope.func(node.declaration.id.name, value);
+  } else {
+    value = 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 = 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") {
+      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_n/expression.d.ts

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