@typescript-guy/fn-monitor 1.0.0

package/dist/evaluate/expression.js

@@ -0,0 +1,604 @@
+import { callSuper, WINDOW, getSetter, createSymbol, define, getGetter, assign, freeze, getDptor } from '../share/util.js';
+import { STRICT, AWAIT, PRIVATE, OPTCHAIN, CLSCTOR, STRICT_FN, SUPERCALL, IMPORT, NEWTARGET, NOCTOR, SUPER } from '../share/const.js';
+import { createFunc, pattern, createClass } from './helper.js';
+import { Prop } from '../scope/variable.js';
+import { Identifier } from './identifier.js';
+import { Literal } from './literal.js';
+import Scope from '../scope/index.js';
+import evaluate from './index.js';
+
+function* ThisExpression(node, scope) {
+  const superCall = scope.find(SUPERCALL);
+  if (superCall && superCall.get() !== true) {
+    throw new ReferenceError("Must call super constructor in derived class before accessing 'this' or returning from derived constructor");
+  } else {
+    return scope.find("this").get();
+  }
+}
+function* ArrayExpression(node, scope) {
+  let results = [];
+  for (let i = 0; i < node.elements.length; i++) {
+    const item = node.elements[i];
+    if (item === null) {
+      results.length++;
+    } else if (item.type === "SpreadElement") {
+      results = results.concat(yield* SpreadElement(item, scope));
+    } else {
+      results.push(yield* evaluate(item, scope));
+    }
+  }
+  return results;
+}
+function* ObjectExpression(node, scope) {
+  const object = {};
+  for (let i = 0; i < node.properties.length; i++) {
+    const property = node.properties[i];
+    if (property.type === "SpreadElement") {
+      assign(object, yield* SpreadElement(property, scope, { spreadProps: true }));
+    } else {
+      let key;
+      const propKey = property.key;
+      if (property.computed) {
+        key = yield* evaluate(propKey, scope);
+      } else {
+        if (propKey.type === "Identifier") {
+          key = propKey.name;
+        } else {
+          key = "" + (yield* Literal(propKey));
+        }
+      }
+      const value = yield* evaluate(property.value, scope);
+      const propKind = property.kind;
+      if (propKind === "init") {
+        object[key] = value;
+      } else if (propKind === "get") {
+        const oriDptor = getDptor(object, key);
+        define(object, key, {
+          get: value,
+          set: oriDptor && oriDptor.set,
+          enumerable: true,
+          configurable: true
+        });
+      } else {
+        const oriDptor = getDptor(object, key);
+        define(object, key, {
+          get: oriDptor && oriDptor.get,
+          set: value,
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+  }
+  return object;
+}
+function* FunctionExpression(node, scope) {
+  if (node.id && node.id.name) {
+    const tmpScope = new Scope(scope);
+    const func = createFunc(node, tmpScope);
+    tmpScope.const(node.id.name, func);
+    return func;
+  } else {
+    return createFunc(node, scope);
+  }
+}
+function* UnaryExpression(node, scope) {
+  const arg = node.argument;
+  switch (node.operator) {
+    case "+":
+      return +(yield* evaluate(arg, scope));
+    case "-":
+      return -(yield* evaluate(arg, scope));
+    case "!":
+      return !(yield* evaluate(arg, scope));
+    case "~":
+      return ~(yield* evaluate(arg, scope));
+    case "void":
+      return void (yield* evaluate(arg, scope));
+    case "typeof":
+      if (arg.type === "Identifier") {
+        return typeof (yield* Identifier(arg, scope, { throwErr: false }));
+      } else {
+        return typeof (yield* evaluate(arg, scope));
+      }
+    case "delete":
+      if (arg.type === "MemberExpression") {
+        const variable = yield* MemberExpression(arg, scope, { getVar: true });
+        return variable.del();
+      } else if (arg.type === "Identifier") {
+        throw new SyntaxError("Delete of an unqualified identifier in strict mode");
+      } else {
+        yield* evaluate(arg, scope);
+        return true;
+      }
+    /* istanbul ignore next */
+    default:
+      throw new SyntaxError(`Unexpected token ${node.operator}`);
+  }
+}
+function* UpdateExpression(node, scope) {
+  const arg = node.argument;
+  let variable;
+  if (arg.type === "Identifier") {
+    variable = yield* Identifier(arg, scope, { getVar: true });
+  } else if (arg.type === "MemberExpression") {
+    variable = yield* MemberExpression(arg, scope, { getVar: true });
+  } else {
+    throw new SyntaxError("Unexpected token");
+  }
+  const value = variable.get();
+  if (node.operator === "++") {
+    variable.set(value + 1);
+    return node.prefix ? variable.get() : value;
+  } else if (node.operator === "--") {
+    variable.set(value - 1);
+    return node.prefix ? variable.get() : value;
+  } else {
+    throw new SyntaxError(`Unexpected token ${node.operator}`);
+  }
+}
+function* BinaryExpression(node, scope) {
+  let left;
+  let right;
+  if (node.left.type === "PrivateIdentifier") {
+    left = node.left.name;
+    right = yield* evaluate(node.right, scope);
+    right = right[PRIVATE] || {};
+  } else {
+    left = yield* evaluate(node.left, scope);
+    right = yield* evaluate(node.right, scope);
+  }
+  switch (node.operator) {
+    case "==":
+      return left == right;
+    case "!=":
+      return left != right;
+    case "===":
+      return left === right;
+    case "!==":
+      return left !== right;
+    case "<":
+      return left < right;
+    case "<=":
+      return left <= right;
+    case ">":
+      return left > right;
+    case ">=":
+      return left >= right;
+    case "<<":
+      return left << right;
+    case ">>":
+      return left >> right;
+    case ">>>":
+      return left >>> right;
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "**":
+      return left ** right;
+    case "/":
+      return left / right;
+    case "%":
+      return left % right;
+    case "|":
+      return left | right;
+    case "^":
+      return left ^ right;
+    case "&":
+      return left & right;
+    case "in":
+      return left in right;
+    case "instanceof":
+      return left instanceof right;
+    /* istanbul ignore next */
+    default:
+      throw new SyntaxError(`Unexpected token ${node.operator}`);
+  }
+}
+function* AssignmentExpression(node, scope) {
+  const left = node.left;
+  let variable;
+  if (left.type === "Identifier") {
+    variable = yield* Identifier(left, scope, { getVar: true, throwErr: false });
+    if (!variable) {
+      const strictMode = scope.find(STRICT);
+      if (strictMode && strictMode.get()) {
+        throw new ReferenceError(`${left.name} is not defined`);
+      }
+      const win = scope.global().find("window").get();
+      variable = new Prop(win, left.name);
+    }
+  } else if (left.type === "MemberExpression") {
+    variable = yield* MemberExpression(left, scope, { getVar: true });
+  } else {
+    const value2 = yield* evaluate(node.right, scope);
+    return yield* pattern(left, scope, { feed: value2 });
+  }
+  const value = yield* evaluate(node.right, scope);
+  switch (node.operator) {
+    case "=":
+      variable.set(value);
+      return variable.get();
+    case "+=":
+      variable.set(variable.get() + value);
+      return variable.get();
+    case "-=":
+      variable.set(variable.get() - value);
+      return variable.get();
+    case "*=":
+      variable.set(variable.get() * value);
+      return variable.get();
+    case "/=":
+      variable.set(variable.get() / value);
+      return variable.get();
+    case "%=":
+      variable.set(variable.get() % value);
+      return variable.get();
+    case "**=":
+      variable.set(variable.get() ** value);
+      return variable.get();
+    case "<<=":
+      variable.set(variable.get() << value);
+      return variable.get();
+    case ">>=":
+      variable.set(variable.get() >> value);
+      return variable.get();
+    case ">>>=":
+      variable.set(variable.get() >>> value);
+      return variable.get();
+    case "|=":
+      variable.set(variable.get() | value);
+      return variable.get();
+    case "^=":
+      variable.set(variable.get() ^ value);
+      return variable.get();
+    case "&=":
+      variable.set(variable.get() & value);
+      return variable.get();
+    case "??=":
+      variable.set(variable.get() ?? value);
+      return variable.get();
+    case "&&=":
+      variable.set(variable.get() && value);
+      return variable.get();
+    case "||=":
+      variable.set(variable.get() || value);
+      return variable.get();
+    /* istanbul ignore next */
+    default:
+      throw new SyntaxError(`Unexpected token ${node.operator}`);
+  }
+}
+function* LogicalExpression(node, scope) {
+  switch (node.operator) {
+    case "||":
+      return (yield* evaluate(node.left, scope)) || (yield* evaluate(node.right, scope));
+    case "&&":
+      return (yield* evaluate(node.left, scope)) && (yield* evaluate(node.right, scope));
+    case "??":
+      return (yield* evaluate(node.left, scope)) ?? (yield* evaluate(node.right, scope));
+    default:
+      throw new SyntaxError(`Unexpected token ${node.operator}`);
+  }
+}
+function* MemberExpression(node, scope, options = {}) {
+  const { getObj = false, getVar = false } = options;
+  let object;
+  if (node.object.type === "Super") {
+    object = yield* Super(node.object, scope, { getProto: true });
+  } else {
+    object = yield* evaluate(node.object, scope);
+  }
+  if (object === OPTCHAIN) return OPTCHAIN;
+  if (getObj) return object;
+  let key;
+  let priv = false;
+  if (node.computed) {
+    key = yield* evaluate(node.property, scope);
+  } else if (node.property.type === "PrivateIdentifier") {
+    key = node.property.name;
+    priv = true;
+  } else {
+    key = node.property.name;
+  }
+  if (priv) {
+    object = object[PRIVATE];
+  }
+  if (getVar) {
+    const setter = getSetter(object, key);
+    if (node.object.type === "Super" && setter) {
+      const thisObject = scope.find("this").get();
+      const privateKey = createSymbol(key);
+      define(thisObject, privateKey, { set: setter });
+      return new Prop(thisObject, privateKey);
+    } else {
+      return new Prop(object, key);
+    }
+  } else {
+    const getter = getGetter(object, key);
+    if (node.object.type === "Super" && getter) {
+      const thisObject = scope.find("this").get();
+      if (node.optional && thisObject == null) {
+        return OPTCHAIN;
+      }
+      return getter.call(thisObject);
+    } else {
+      if (node.optional && object == null) {
+        return OPTCHAIN;
+      }
+      return object[key];
+    }
+  }
+}
+function* ConditionalExpression(node, scope) {
+  return (yield* evaluate(node.test, scope)) ? yield* evaluate(node.consequent, scope) : yield* evaluate(node.alternate, scope);
+}
+function getCalleeDesc(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  } else if (node.type === "MemberExpression") {
+    const memberNode = node;
+    const objDesc = getCalleeDesc(memberNode.object);
+    if (!memberNode.computed) {
+      if (memberNode.property.type === "PrivateIdentifier") {
+        return `${objDesc}.#${memberNode.property.name}`;
+      }
+      return `${objDesc}.${memberNode.property.name}`;
+    }
+    const prop = memberNode.property;
+    if (prop.type === "Literal") {
+      return `${objDesc}[${prop.raw}]`;
+    }
+    if (prop.type === "Identifier") {
+      return `${objDesc}[${prop.name}]`;
+    }
+    return objDesc;
+  } else if (node.type === "Super") {
+    return "super";
+  }
+  return "(intermediate value)";
+}
+function* CallExpression(node, scope) {
+  let func;
+  let object;
+  if (node.callee.type === "MemberExpression") {
+    object = yield* MemberExpression(node.callee, scope, { getObj: true });
+    if (object === OPTCHAIN) return OPTCHAIN;
+    if (node.callee.optional && object == null) {
+      return OPTCHAIN;
+    }
+    let key;
+    let priv = false;
+    if (node.callee.computed) {
+      key = yield* evaluate(node.callee.property, scope);
+    } else if (node.callee.property.type === "PrivateIdentifier") {
+      key = node.callee.property.name;
+      priv = true;
+    } else {
+      key = node.callee.property.name;
+    }
+    let obj = object;
+    if (priv) {
+      obj = obj[PRIVATE];
+    }
+    if (node.callee.object.type === "Super") {
+      const thisObject = scope.find("this").get();
+      func = obj[key].bind(thisObject);
+    } else {
+      func = obj[key];
+    }
+    if (node.optional && func == null) {
+      return OPTCHAIN;
+    }
+    if (typeof func !== "function") {
+      const calleeDesc = getCalleeDesc(node.callee);
+      throw new TypeError(`${calleeDesc} is not a function`);
+    } else if (CLSCTOR in func) {
+      const calleeDesc = getCalleeDesc(node.callee);
+      throw new TypeError(`Class constructor ${calleeDesc} cannot be invoked without 'new'`);
+    }
+  } else {
+    func = yield* evaluate(node.callee, scope);
+    if (func === OPTCHAIN) return OPTCHAIN;
+    if (node.optional && func == null) {
+      return OPTCHAIN;
+    }
+    if (typeof func !== "function" || node.callee.type !== "Super" && CLSCTOR in func) {
+      let name;
+      if (node.callee.type === "Identifier") {
+        name = node.callee.name;
+      } else {
+        try {
+          name = JSON.stringify(func);
+        } catch (err) {
+          name = "" + func;
+        }
+      }
+      if (typeof func !== "function") {
+        throw new TypeError(`${name} is not a function`);
+      } else {
+        throw new TypeError(`Class constructor ${name} cannot be invoked without 'new'`);
+      }
+    }
+    if (node.callee.type === "Super") {
+      object = scope.find("this").get();
+    } else {
+      const isStrictCall = !!scope.find(STRICT)?.get() || !!(func && func[STRICT_FN]);
+      object = isStrictCall ? void 0 : scope.find("this").get();
+    }
+  }
+  let args = [];
+  for (let i = 0; i < node.arguments.length; i++) {
+    const arg = node.arguments[i];
+    if (arg.type === "SpreadElement") {
+      args = args.concat(yield* SpreadElement(arg, scope));
+    } else {
+      args.push(yield* evaluate(arg, scope));
+    }
+  }
+  if (node.callee.type === "Super") {
+    const superCall = scope.find(SUPERCALL);
+    const construct = superCall.get();
+    if (construct === true) {
+      throw new ReferenceError("Super constructor may only be called once");
+    }
+    const inst = callSuper(object, func, args);
+    yield* construct(inst);
+    scope.find("this").set(inst);
+    scope.find(SUPERCALL).set(true);
+    return inst;
+  }
+  try {
+    return func.apply(object, args);
+  } catch (err) {
+    if (err instanceof TypeError && err.message === "Illegal invocation" && func.toString().indexOf("[native code]") !== -1) {
+      const win = scope.global().find("window").get();
+      if (win && win[WINDOW]) {
+        return func.apply(win[WINDOW], args);
+      }
+    }
+    throw err;
+  }
+}
+function* NewExpression(node, scope) {
+  const constructor = yield* evaluate(node.callee, scope);
+  if (typeof constructor !== "function") {
+    let name;
+    if (node.callee.type === "Identifier") {
+      name = node.callee.name;
+    } else {
+      try {
+        name = JSON.stringify(constructor);
+      } catch (err) {
+        name = "" + constructor;
+      }
+    }
+    throw new TypeError(`${name} is not a constructor`);
+  } else if (constructor[NOCTOR]) {
+    throw new TypeError(`${constructor.name || "(intermediate value)"} is not a constructor`);
+  }
+  let args = [];
+  for (let i = 0; i < node.arguments.length; i++) {
+    const arg = node.arguments[i];
+    if (arg.type === "SpreadElement") {
+      args = args.concat(yield* SpreadElement(arg, scope));
+    } else {
+      args.push(yield* evaluate(arg, scope));
+    }
+  }
+  return new constructor(...args);
+}
+function* MetaProperty(node, scope) {
+  if (node.meta.name === "new" && node.property.name === "target") {
+    return scope.find(NEWTARGET).get();
+  } else if (node.meta.name === "import" && node.property.name === "meta") {
+    return { url: "" };
+  }
+}
+function* SequenceExpression(node, scope) {
+  let result;
+  for (let i = 0; i < node.expressions.length; i++) {
+    result = yield* evaluate(node.expressions[i], scope);
+  }
+  return result;
+}
+function* ArrowFunctionExpression(node, scope) {
+  return createFunc(node, scope);
+}
+function* TemplateLiteral(node, scope) {
+  const quasis = node.quasis.slice();
+  const expressions = node.expressions.slice();
+  let result = "";
+  let temEl;
+  let expr;
+  while (temEl = quasis.shift()) {
+    result += yield* TemplateElement(temEl);
+    expr = expressions.shift();
+    if (expr) {
+      result += yield* evaluate(expr, scope);
+    }
+  }
+  return result;
+}
+function* TaggedTemplateExpression(node, scope) {
+  const tagFunc = yield* evaluate(node.tag, scope);
+  const quasis = node.quasi.quasis;
+  const str = quasis.map((v) => v.value.cooked);
+  const raw = quasis.map((v) => v.value.raw);
+  define(str, "raw", {
+    value: freeze(raw)
+  });
+  const expressions = node.quasi.expressions;
+  const args = [];
+  if (expressions) {
+    for (let i = 0; i < expressions.length; i++) {
+      args.push(yield* evaluate(expressions[i], scope));
+    }
+  }
+  return tagFunc(freeze(str), ...args);
+}
+function* TemplateElement(node, scope) {
+  return node.value.raw;
+}
+function* ClassExpression(node, scope) {
+  if (node.id && node.id.name) {
+    const tmpScope = new Scope(scope);
+    const klass = yield* createClass(node, tmpScope);
+    tmpScope.const(node.id.name, klass);
+    return klass;
+  } else {
+    return yield* createClass(node, scope);
+  }
+}
+function* Super(node, scope, options = {}) {
+  const { getProto = false } = options;
+  const superClass = scope.find(SUPER).get();
+  return getProto ? superClass.prototype : superClass;
+}
+function* SpreadElement(node, scope, options = {}) {
+  const result = yield* evaluate(node.argument, scope);
+  if (options.spreadProps) {
+    return result;
+  }
+  if (typeof Symbol === "function" && typeof result[Symbol.iterator] !== "function") {
+    throw new TypeError("Spread syntax requires ...iterable[Symbol.iterator] to be a function");
+  }
+  return [...result];
+}
+function* ChainExpression(node, scope) {
+  const result = yield* evaluate(node.expression, scope);
+  return result === OPTCHAIN ? void 0 : result;
+}
+function* ImportExpression(node, scope) {
+  const globalScope = scope.global();
+  const source = yield* evaluate(node.source, scope);
+  const module = globalScope.find(IMPORT + source);
+  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") {
+    return Promise.reject(new TypeError(`Failed to resolve module specifier "${source}"`));
+  }
+  return Promise.resolve(value);
+}
+function* YieldExpression(node, scope) {
+  const res = yield* evaluate(node.argument, scope);
+  return node.delegate ? yield* res : yield res;
+}
+function* AwaitExpression(node, scope) {
+  AWAIT.RES = yield* evaluate(node.argument, scope);
+  return yield AWAIT;
+}
+
+export { ArrayExpression, ArrowFunctionExpression, AssignmentExpression, AwaitExpression, BinaryExpression, CallExpression, ChainExpression, ClassExpression, ConditionalExpression, FunctionExpression, ImportExpression, LogicalExpression, MemberExpression, MetaProperty, NewExpression, ObjectExpression, SequenceExpression, SpreadElement, Super, TaggedTemplateExpression, TemplateElement, TemplateLiteral, ThisExpression, UnaryExpression, UpdateExpression, YieldExpression };

package/dist/evaluate/helper.d.ts

@@ -0,0 +1,18 @@
+import { default as Scope } from '../scope/index.ts';
+import { PatternOptions } from './pattern.ts';
+import * as acorn from 'acorn';
+export interface hoistOptions {
+    onlyBlock?: boolean;
+}
+export declare function hoist(block: acorn.Program | acorn.BlockStatement | acorn.StaticBlock, scope: Scope, options?: hoistOptions): Generator<any, void, any>;
+export declare function pattern(node: acorn.Pattern, scope: Scope, options?: PatternOptions): IterableIterator<any>;
+export interface CtorOptions {
+    construct?: (object: any) => Generator | void;
+    superClass?: (...args: any[]) => any;
+}
+export declare function createFunc(node: acorn.FunctionDeclaration | acorn.FunctionExpression | acorn.ArrowFunctionExpression, scope: Scope, options?: CtorOptions): any;
+export declare function createClass(node: acorn.ClassDeclaration | acorn.ClassExpression, scope: Scope): Generator<any, () => Generator<any, any, any>, any>;
+export interface ForXHandlerOptions {
+    value: any;
+}
+export declare function ForXHandler(node: acorn.ForInStatement | acorn.ForOfStatement, scope: Scope, options: ForXHandlerOptions): Generator<any, any, any>;