@typescript-guy/fn-monitor 1.0.0

package/dist/evaluate_n/helper.js

@@ -0,0 +1,238 @@
+import { CLSCTOR, STRICT, STRICT_FN, NEWTARGET, SUPER, SUPERCALL, RETURN, NOCTOR } from '../share/const.js';
+import { VariableDeclaration, ClassBody, PropertyDefinition } from './declaration.js';
+import { inherits, define, callSuper } from '../share/util.js';
+import { Identifier } from './identifier.js';
+import { BlockStatement } from './statement.js';
+import Scope from '../scope/index.js';
+import evaluate from './index.js';
+import { AssignmentPattern, RestElement, ArrayPattern, ObjectPattern } from './pattern.js';
+import { createFunc as createFunc$1 } from '../evaluate/helper.js';
+
+function hoist(block, scope, options = {}) {
+  const { onlyBlock = false } = options;
+  const funcDclrList = [];
+  const funcDclrIdxs = [];
+  for (let i = 0; i < block.body.length; i++) {
+    const statement = block.body[i];
+    if (statement.type === "FunctionDeclaration") {
+      funcDclrList.push(statement);
+      funcDclrIdxs.push(i);
+    } else if (statement.type === "VariableDeclaration" && ["const", "let"].indexOf(statement.kind) !== -1) {
+      VariableDeclaration(statement, scope, { hoist: true, onlyBlock: true });
+    } else if (!onlyBlock) {
+      hoistVarRecursion(statement, scope);
+    }
+  }
+  if (funcDclrIdxs.length) {
+    for (let i = funcDclrIdxs.length - 1; i > -1; i--) {
+      block.body.splice(funcDclrIdxs[i], 1);
+    }
+    block.body = funcDclrList.concat(block.body);
+  }
+}
+function hoistVarRecursion(statement, scope) {
+  switch (statement.type) {
+    case "VariableDeclaration":
+      VariableDeclaration(statement, scope, { hoist: true });
+      break;
+    case "ForInStatement":
+    case "ForOfStatement":
+      if (statement.left.type === "VariableDeclaration") {
+        VariableDeclaration(statement.left, scope, { hoist: true });
+      }
+    case "ForStatement":
+      if (statement.type === "ForStatement" && statement.init && statement.init.type === "VariableDeclaration") {
+        VariableDeclaration(statement.init, scope, { hoist: true });
+      }
+    case "WhileStatement":
+    case "DoWhileStatement":
+      hoistVarRecursion(statement.body, scope);
+      break;
+    case "IfStatement":
+      hoistVarRecursion(statement.consequent, scope);
+      if (statement.alternate) {
+        hoistVarRecursion(statement.alternate, scope);
+      }
+      break;
+    case "BlockStatement":
+      for (let i = 0; i < statement.body.length; i++) {
+        hoistVarRecursion(statement.body[i], scope);
+      }
+      break;
+    case "SwitchStatement":
+      for (let i = 0; i < statement.cases.length; i++) {
+        for (let j = 0; j < statement.cases[i].consequent.length; j++) {
+          hoistVarRecursion(statement.cases[i].consequent[j], scope);
+        }
+      }
+      break;
+    case "TryStatement": {
+      const tryBlock = statement.block.body;
+      for (let i = 0; i < tryBlock.length; i++) {
+        hoistVarRecursion(tryBlock[i], scope);
+      }
+      const catchBlock = statement.handler && statement.handler.body.body;
+      if (catchBlock) {
+        for (let i = 0; i < catchBlock.length; i++) {
+          hoistVarRecursion(catchBlock[i], scope);
+        }
+      }
+      const finalBlock = statement.finalizer && statement.finalizer.body;
+      if (finalBlock) {
+        for (let i = 0; i < finalBlock.length; i++) {
+          hoistVarRecursion(finalBlock[i], scope);
+        }
+      }
+      break;
+    }
+  }
+}
+function pattern(node, scope, options = {}) {
+  switch (node.type) {
+    case "ObjectPattern":
+      return ObjectPattern(node, scope, options);
+    case "ArrayPattern":
+      return ArrayPattern(node, scope, options);
+    case "RestElement":
+      return RestElement(node, scope, options);
+    case "AssignmentPattern":
+      return AssignmentPattern(node, scope, options);
+    default:
+      throw new SyntaxError("Unexpected token");
+  }
+}
+function createFunc(node, scope, options = {}) {
+  if (node.generator || node.async) {
+    return createFunc$1(node, scope, options);
+  }
+  const { superClass, construct } = options;
+  const params = node.params;
+  const hasOwnUseStrict = node.body.type === "BlockStatement" && node.body.body.length > 0 && node.body.body[0].directive === "use strict";
+  const enclosingStrict = !!scope.find(STRICT)?.get();
+  const isFuncStrict = hasOwnUseStrict || enclosingStrict;
+  const tmpFunc = function(...args) {
+    const subScope = new Scope(scope, true);
+    if (hasOwnUseStrict && !enclosingStrict) {
+      subScope.const(STRICT, true);
+    }
+    if (node.type !== "ArrowFunctionExpression") {
+      subScope.let("this", this);
+      subScope.let("arguments", arguments);
+      subScope.const(NEWTARGET, new.target);
+      if (superClass) {
+        subScope.const(SUPER, superClass);
+        if (construct) subScope.let(SUPERCALL, construct);
+      } else if (construct) {
+        construct(this);
+      }
+    }
+    for (let i = 0; i < params.length; i++) {
+      const param = params[i];
+      if (param.type === "Identifier") {
+        subScope.var(param.name, args[i]);
+      } else if (param.type === "RestElement") {
+        RestElement(param, subScope, { kind: "var", feed: args.slice(i) });
+      } else {
+        pattern(param, subScope, { kind: "var", feed: args[i] });
+      }
+    }
+    let result;
+    if (node.body.type === "BlockStatement") {
+      hoist(node.body, subScope);
+      result = BlockStatement(node.body, subScope, {
+        invasived: true,
+        hoisted: true
+      });
+    } else {
+      result = evaluate(node.body, subScope);
+      if (node.type === "ArrowFunctionExpression") {
+        RETURN.RES = result;
+        result = RETURN;
+      }
+    }
+    if (result === RETURN) {
+      return result.RES;
+    } else if (new.target) {
+      return subScope.find("this").get();
+    }
+  };
+  let func = tmpFunc;
+  if (node.type === "ArrowFunctionExpression") {
+    define(func, NOCTOR, { value: true });
+  }
+  define(func, "name", {
+    value: node.id && node.id.name || "",
+    configurable: true
+  });
+  define(func, "length", {
+    value: params.length,
+    configurable: true
+  });
+  if (isFuncStrict) {
+    define(func, STRICT_FN, { value: true });
+  }
+  const source = node.loc?.source;
+  if (source) {
+    define(func, "toString", {
+      value: () => source.substring(node.start, node.end),
+      configurable: true
+    });
+  }
+  return func;
+}
+function createClass(node, scope) {
+  const superClass = evaluate(node.superClass, scope);
+  const methodBody = node.body.body;
+  const construct = function(object) {
+    for (let i = 0; i < methodBody.length; i++) {
+      const def = methodBody[i];
+      if (def.type === "PropertyDefinition" && !def.static) {
+        PropertyDefinition(def, scope, { klass: object, superClass });
+      }
+    }
+  };
+  let klass = function() {
+    const inst = superClass ? callSuper(this, superClass) : this;
+    construct(inst);
+    return inst;
+  };
+  for (let i = 0; i < methodBody.length; i++) {
+    const method = methodBody[i];
+    if (method.type === "MethodDefinition" && method.kind === "constructor") {
+      klass = createFunc(method.value, scope, { superClass, construct });
+      break;
+    }
+  }
+  if (superClass) {
+    inherits(klass, superClass);
+  }
+  ClassBody(node.body, scope, { klass, superClass });
+  define(klass, CLSCTOR, { value: true });
+  define(klass, "name", {
+    value: node.id && node.id.name || "",
+    configurable: true
+  });
+  return klass;
+}
+function ForXHandler(node, scope, options) {
+  const { value } = options;
+  const left = node.left;
+  const subScope = new Scope(scope);
+  if (left.type === "VariableDeclaration") {
+    VariableDeclaration(left, subScope, { feed: value });
+  } else if (left.type === "Identifier") {
+    const variable = Identifier(left, scope, { getVar: true });
+    variable.set(value);
+  } else {
+    pattern(left, scope, { feed: value });
+  }
+  let result;
+  if (node.body.type === "BlockStatement") {
+    result = BlockStatement(node.body, subScope, { invasived: true });
+  } else {
+    result = evaluate(node.body, subScope);
+  }
+  return result;
+}
+
+export { ForXHandler, createClass, createFunc, hoist, pattern };

package/dist/evaluate_n/identifier.d.ts

@@ -0,0 +1,7 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export interface IdentifierOptions {
+    getVar?: boolean;
+    throwErr?: boolean;
+}
+export declare function Identifier(node: acorn.Identifier, scope: Scope, options?: IdentifierOptions): any;

package/dist/evaluate_n/identifier.js

@@ -0,0 +1,27 @@
+import { DEADZONE } from '../share/const.js';
+
+function Identifier(node, scope, options = {}) {
+  const { getVar = false, throwErr = true } = options;
+  if (node.name === "undefined") {
+    return void 0;
+  }
+  const variable = scope.find(node.name);
+  if (variable) {
+    if (getVar) {
+      return variable;
+    } else {
+      const value = variable.get();
+      if (value === DEADZONE) {
+        throw new ReferenceError(`${node.name} is not defined`);
+      } else {
+        return value;
+      }
+    }
+  } else if (throwErr) {
+    throw new ReferenceError(`${node.name} is not defined`);
+  } else {
+    return void 0;
+  }
+}
+
+export { Identifier };

package/dist/evaluate_n/index.d.ts

@@ -0,0 +1,3 @@
+import { Node } from 'acorn';
+import { default as Scope } from '../scope/index.ts';
+export default function evaluate(node: Node, scope: Scope): any;

package/dist/evaluate_n/index.js

@@ -0,0 +1,76 @@
+import { assign } from '../share/util.js';
+import * as declaration from './declaration.js';
+import * as expression from './expression.js';
+import * as identifier from './identifier.js';
+import * as statement from './statement.js';
+import * as literal from './literal.js';
+import * as pattern from './pattern.js';
+import * as program from './program.js';
+import { UNASSIGNED, SEEN } from '../custom-types.js';
+import { useModifiedEvaluator, captureReusables, callMonitor, isGenerator, refreshExeStack, pushHandler, callPerExe, cleanStack } from '../helper-functions.js';
+import ansis from 'ansis';
+
+let evaluateOps;
+function evaluate(node, scope) {
+  if (!node) return;
+  if (!evaluateOps) {
+    evaluateOps = assign(
+      {},
+      declaration,
+      expression,
+      identifier,
+      statement,
+      literal,
+      pattern,
+      program
+    );
+  }
+  const handler = evaluateOps[node.type];
+  if (!handler) throw new Error(`${node.type} isn't implemented`);
+  const interpreter = scope.interpreter;
+  if (interpreter.onStep) {
+    interpreter.onStep();
+  }
+  if (!useModifiedEvaluator(scope)) {
+    return handler(node, scope);
+  }
+  const parentReusables = captureReusables(interpreter);
+  try {
+    interpreter.reusables.shared.evalStack.value += 1;
+    const feedback = callMonitor(node, scope, handler);
+    if (isGenerator(feedback)) {
+      const next = feedback.next();
+      const executedManually = interpreter.reusables.result !== UNASSIGNED;
+      const result = executedManually ? interpreter.reusables.result : handler(node, scope);
+      const manuallyExecutedResult = interpreter.reusables.result;
+      interpreter.reusables.result = SEEN;
+      if (!next.done) {
+        if (next.value !== manuallyExecutedResult) {
+          throw new Error(ansis.red(`For an eager node,inspectors that are generators can only yield the result of that node to be consistent but saw: ${String(next.value)} instead of: ${String(manuallyExecutedResult)}.`));
+        }
+        const next2 = feedback.next(result);
+        if (!next2.done) {
+          throw new Error(ansis.red(`In Eager Node:inspectors that are generators can only yield once.`));
+        }
+      }
+      const wasCleared = refreshExeStack(interpreter);
+      const pushedManually = executedManually && !wasCleared;
+      pushHandler(interpreter, result, pushedManually);
+      callPerExe(interpreter);
+      return result;
+    } else {
+      const executedManually = interpreter.reusables.result !== UNASSIGNED;
+      const result = executedManually ? interpreter.reusables.result : handler(node, scope);
+      interpreter.reusables.result = SEEN;
+      const wasCleared = refreshExeStack(interpreter);
+      const pushedManually = executedManually && !wasCleared;
+      pushHandler(interpreter, result, pushedManually);
+      callPerExe(interpreter);
+      return result;
+    }
+  } finally {
+    cleanStack(interpreter, parentReusables);
+  }
+}
+
+export { evaluate as default };

package/dist/evaluate_n/literal.d.ts

@@ -0,0 +1,3 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function Literal(node: acorn.Literal, scope: Scope): string | number | bigint | boolean | RegExp;

package/dist/evaluate_n/literal.js

@@ -0,0 +1,8 @@
+function Literal(node, scope) {
+  if (node.regex) {
+    return new RegExp(node.regex.pattern, node.regex.flags);
+  }
+  return node.value;
+}
+
+export { Literal };

package/dist/evaluate_n/pattern.d.ts

@@ -0,0 +1,13 @@
+import { VarKind } from '../scope/variable.ts';
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export interface PatternOptions {
+    kind?: VarKind;
+    hoist?: boolean;
+    onlyBlock?: boolean;
+    feed?: any;
+}
+export declare function ObjectPattern(node: acorn.ObjectPattern, scope: Scope, options?: PatternOptions): void;
+export declare function ArrayPattern(node: acorn.ArrayPattern, scope: Scope, options?: PatternOptions): any[];
+export declare function RestElement(node: acorn.RestElement, scope: Scope, options?: PatternOptions): void;
+export declare function AssignmentPattern(node: acorn.AssignmentPattern, scope: Scope, options?: PatternOptions): void;

package/dist/evaluate_n/pattern.js

@@ -0,0 +1,118 @@
+import { DEADZONE, NOINIT } from '../share/const.js';
+import { Identifier } from './identifier.js';
+import { assign } from '../share/util.js';
+import { pattern } from './helper.js';
+import evaluate from './index.js';
+
+function ObjectPattern(node, scope, options = {}) {
+  const { kind = "var", hoist = false, onlyBlock = false, feed = {} } = options;
+  const fedKeys = [];
+  for (let i = 0; i < node.properties.length; i++) {
+    const property = node.properties[i];
+    if (hoist) {
+      if (onlyBlock || kind === "var") {
+        if (property.type === "Property") {
+          const value = property.value;
+          if (value.type === "Identifier") {
+            scope[kind](value.name, onlyBlock ? DEADZONE : kind === "var" ? NOINIT : void 0);
+          } else {
+            pattern(value, scope, { kind, hoist, onlyBlock });
+          }
+        } else {
+          RestElement(property, scope, { kind, hoist, onlyBlock });
+        }
+      }
+    } else if (property.type === "Property") {
+      let key;
+      if (property.computed) {
+        key = evaluate(property.key, scope);
+      } else {
+        key = property.key.name;
+      }
+      fedKeys.push(key);
+      const value = property.value;
+      if (value.type === "Identifier") {
+        scope[kind](value.name, feed[key]);
+      } else {
+        pattern(value, scope, { kind, feed: feed[key] });
+      }
+    } else {
+      const rest = assign({}, feed);
+      for (let i2 = 0; i2 < fedKeys.length; i2++) delete rest[fedKeys[i2]];
+      RestElement(property, scope, { kind, feed: rest });
+    }
+  }
+}
+function ArrayPattern(node, scope, options = {}) {
+  const { kind, hoist = false, onlyBlock = false, feed = [] } = options;
+  const result = [];
+  for (let i = 0; i < node.elements.length; i++) {
+    const element = node.elements[i];
+    if (!element) continue;
+    if (hoist) {
+      if (onlyBlock || kind === "var") {
+        if (element.type === "Identifier") {
+          scope[kind](element.name, onlyBlock ? DEADZONE : kind === "var" ? NOINIT : void 0);
+        } else {
+          pattern(element, scope, { kind, hoist, onlyBlock });
+        }
+      }
+    } else if (element.type === "Identifier") {
+      if (kind) {
+        scope[kind](element.name, feed[i]);
+      } else {
+        const variable = Identifier(element, scope, { getVar: true });
+        variable.set(feed[i]);
+        result.push(variable.get());
+      }
+    } else if (element.type === "RestElement") {
+      RestElement(element, scope, { kind, feed: feed.slice(i) });
+    } else {
+      pattern(element, scope, { kind, feed: feed[i] });
+    }
+  }
+  if (result.length) {
+    return result;
+  }
+}
+function RestElement(node, scope, options = {}) {
+  const { kind, hoist = false, onlyBlock = false, feed = [] } = options;
+  const arg = node.argument;
+  if (hoist) {
+    if (onlyBlock || kind === "var") {
+      if (arg.type === "Identifier") {
+        scope[kind](arg.name, onlyBlock ? DEADZONE : kind === "var" ? NOINIT : void 0);
+      } else {
+        pattern(arg, scope, { kind, hoist, onlyBlock });
+      }
+    }
+  } else if (arg.type === "Identifier") {
+    if (kind) {
+      scope[kind](arg.name, feed);
+    } else {
+      const variable = Identifier(arg, scope, { getVar: true });
+      variable.set(feed);
+    }
+  } else {
+    pattern(arg, scope, { kind, feed });
+  }
+}
+function AssignmentPattern(node, scope, options = {}) {
+  const { kind = "var", hoist = false, onlyBlock = false, feed = evaluate(node.right, scope) } = options;
+  const left = node.left;
+  if (hoist) {
+    if (onlyBlock || kind === "var") {
+      if (left.type === "Identifier") {
+        scope[kind](left.name, onlyBlock ? DEADZONE : kind === "var" ? NOINIT : void 0);
+      } else {
+        pattern(left, scope, { kind, hoist, onlyBlock });
+      }
+    }
+  } else if (left.type === "Identifier") {
+    scope[kind](left.name, feed);
+  } else {
+    pattern(left, scope, { kind, feed });
+  }
+}
+
+export { ArrayPattern, AssignmentPattern, ObjectPattern, RestElement };

package/dist/evaluate_n/program.d.ts

@@ -0,0 +1,3 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function Program(program: acorn.Program, scope: Scope): void;

package/dist/evaluate_n/program.js

@@ -0,0 +1,20 @@
+import { STRICT } from '../share/const.js';
+import evaluate from './index.js';
+
+function Program(program, scope) {
+  for (let i = 0; i < program.body.length; i++) {
+    const stmt = program.body[i];
+    if (stmt.type === "ExpressionStatement" && stmt.directive) {
+      if (stmt.directive === "use strict" && !scope.find(STRICT)) {
+        scope.const(STRICT, true);
+      }
+    } else {
+      break;
+    }
+  }
+  for (let i = 0; i < program.body.length; i++) {
+    evaluate(program.body[i], scope);
+  }
+}
+
+export { Program };

package/dist/evaluate_n/statement.d.ts

@@ -0,0 +1,35 @@
+import { default as Scope } from '../scope/index.ts';
+import * as acorn from 'acorn';
+export declare function ExpressionStatement(node: acorn.ExpressionStatement, scope: Scope): void;
+export interface LabelOptions {
+    label?: string;
+}
+export interface BlockOptions {
+    invasived?: boolean;
+    hoisted?: boolean;
+}
+export declare function BlockStatement(block: acorn.BlockStatement | acorn.StaticBlock, scope: Scope, options?: BlockOptions & LabelOptions): any;
+export declare function EmptyStatement(): any;
+export declare function DebuggerStatement(): any;
+export declare function ReturnStatement(node: acorn.ReturnStatement, scope: Scope): {
+    RES: any;
+};
+export declare function BreakStatement(node: acorn.BreakStatement): {
+    LABEL: string;
+};
+export declare function ContinueStatement(node: acorn.ContinueStatement): {
+    LABEL: string;
+};
+export declare function LabeledStatement(node: acorn.LabeledStatement, scope: Scope): any;
+export declare function WithStatement(node: acorn.WithStatement, scope: Scope, options?: LabelOptions): any;
+export declare function IfStatement(node: acorn.IfStatement, scope: Scope, options?: LabelOptions): any;
+export declare function SwitchStatement(node: acorn.SwitchStatement, scope: Scope, options?: LabelOptions): any;
+export declare function SwitchCase(node: acorn.SwitchCase, scope: Scope): any;
+export declare function ThrowStatement(node: acorn.ThrowStatement, scope: Scope): void;
+export declare function TryStatement(node: acorn.TryStatement, scope: Scope, options?: LabelOptions): any;
+export declare function CatchClause(node: acorn.CatchClause, scope: Scope): any;
+export declare function WhileStatement(node: acorn.WhileStatement, scope: Scope, options?: LabelOptions): any;
+export declare function DoWhileStatement(node: acorn.DoWhileStatement, scope: Scope, options?: LabelOptions): any;
+export declare function ForStatement(node: acorn.ForStatement, scope: Scope, options?: LabelOptions): any;
+export declare function ForInStatement(node: acorn.ForInStatement, scope: Scope, options?: LabelOptions): any;
+export declare function ForOfStatement(node: acorn.ForOfStatement, scope: Scope, options?: LabelOptions): any;