@typescript-guy/fn-monitor 1.0.0

package/dist/share/util.js

@@ -0,0 +1,379 @@
+const freeze = Object.freeze;
+const define = Object.defineProperty;
+const getDptor = Object.getOwnPropertyDescriptor;
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+  return hasOwnProperty.call(obj, key);
+}
+const getOwnNames = Object.getOwnPropertyNames;
+const setPrototypeOf = Object.setPrototypeOf;
+function setProto(obj, proto) {
+  setPrototypeOf ? setPrototypeOf(obj, proto) : obj.__proto__ = proto;
+}
+const getPrototypeOf = Object.getPrototypeOf;
+function getProto(obj) {
+  return getPrototypeOf ? getPrototypeOf(obj) : obj.__proto__;
+}
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+function getGetterOrSetter(method, obj, key) {
+  while (obj) {
+    const descriptor = getOwnPropertyDescriptor(obj, key);
+    const value = typeof descriptor !== "undefined" && typeof descriptor.writable === "undefined" && typeof descriptor[method] === "function" && descriptor[method];
+    if (value) {
+      return value;
+    } else {
+      obj = getProto(obj);
+    }
+  }
+}
+function getGetter(obj, key) {
+  return getGetterOrSetter("get", obj, key);
+}
+function getSetter(obj, key) {
+  return getGetterOrSetter("set", obj, key);
+}
+const create = Object.create;
+function inherits(subClass, superClass) {
+  setProto(subClass, superClass);
+  subClass.prototype = create(superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true
+    }
+  });
+}
+function callSuper(target, superClass, args = []) {
+  let supportReflect = false;
+  try {
+    supportReflect = !Boolean.prototype.valueOf.call(
+      Reflect.construct(Boolean, [], function() {
+      })
+    );
+  } catch (err) {
+  }
+  return supportReflect ? Reflect.construct(superClass, args, getProto(target).constructor) : superClass.apply(target, args);
+}
+function _assign(target) {
+  for (let i = 1; i < arguments.length; ++i) {
+    const source = arguments[i];
+    for (const key in source) {
+      if (hasOwn(source, key)) {
+        target[key] = source[key];
+      }
+    }
+  }
+  return target;
+}
+const assign = Object.assign || _assign;
+let names = [];
+let globalObj = create(null);
+const setGlobalObj = (g) => {
+  if (!g.Object) throw 0;
+  names = getOwnNames(globalObj = g).filter((n) => ["webkitStorageInfo", "GLOBAL", "root"].indexOf(n) === -1);
+};
+try {
+  setGlobalObj(window);
+} catch (err) {
+  try {
+    setGlobalObj(self);
+  } catch (err2) {
+    try {
+      setGlobalObj(global);
+    } catch (err3) {
+      try {
+        setGlobalObj(globalThis);
+      } catch (err4) {
+        try {
+          globalObj.Object = Object;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Function = Function;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Array = Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Number = Number;
+        } catch (err5) {
+        }
+        try {
+          globalObj.parseFloat = parseFloat;
+        } catch (err5) {
+        }
+        try {
+          globalObj.parseInt = parseInt;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Infinity = Infinity;
+        } catch (err5) {
+        }
+        try {
+          globalObj.NaN = NaN;
+        } catch (err5) {
+        }
+        try {
+          globalObj.undefined = void 0;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Boolean = Boolean;
+        } catch (err5) {
+        }
+        try {
+          globalObj.String = String;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Symbol = Symbol;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Date = Date;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Promise = Promise;
+        } catch (err5) {
+        }
+        try {
+          globalObj.RegExp = RegExp;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Error = Error;
+        } catch (err5) {
+        }
+        try {
+          globalObj.EvalError = EvalError;
+        } catch (err5) {
+        }
+        try {
+          globalObj.RangeError = RangeError;
+        } catch (err5) {
+        }
+        try {
+          globalObj.ReferenceError = ReferenceError;
+        } catch (err5) {
+        }
+        try {
+          globalObj.SyntaxError = SyntaxError;
+        } catch (err5) {
+        }
+        try {
+          globalObj.TypeError = TypeError;
+        } catch (err5) {
+        }
+        try {
+          globalObj.URIError = URIError;
+        } catch (err5) {
+        }
+        try {
+          globalObj.JSON = JSON;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Math = Math;
+        } catch (err5) {
+        }
+        try {
+          globalObj.console = console;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Intl = Intl;
+        } catch (err5) {
+        }
+        try {
+          globalObj.ArrayBuffer = ArrayBuffer;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Uint8Array = Uint8Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Int8Array = Int8Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Uint16Array = Uint16Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Int16Array = Int16Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Uint32Array = Uint32Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Int32Array = Int32Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Float32Array = Float32Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Float64Array = Float64Array;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Uint8ClampedArray = Uint8ClampedArray;
+        } catch (err5) {
+        }
+        try {
+          globalObj.DataView = DataView;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Map = Map;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Set = Set;
+        } catch (err5) {
+        }
+        try {
+          globalObj.WeakMap = WeakMap;
+        } catch (err5) {
+        }
+        try {
+          globalObj.WeakSet = WeakSet;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Proxy = Proxy;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Reflect = Reflect;
+        } catch (err5) {
+        }
+        try {
+          globalObj.BigInt = BigInt;
+        } catch (err5) {
+        }
+        try {
+          globalObj.decodeURI = decodeURI;
+        } catch (err5) {
+        }
+        try {
+          globalObj.decodeURIComponent = decodeURIComponent;
+        } catch (err5) {
+        }
+        try {
+          globalObj.encodeURI = encodeURI;
+        } catch (err5) {
+        }
+        try {
+          globalObj.encodeURIComponent = encodeURIComponent;
+        } catch (err5) {
+        }
+        try {
+          globalObj.escape = escape;
+        } catch (err5) {
+        }
+        try {
+          globalObj.unescape = unescape;
+        } catch (err5) {
+        }
+        try {
+          globalObj.eval = eval;
+        } catch (err5) {
+        }
+        try {
+          globalObj.isFinite = isFinite;
+        } catch (err5) {
+        }
+        try {
+          globalObj.isNaN = isNaN;
+        } catch (err5) {
+        }
+        try {
+          globalObj.SharedArrayBuffer = SharedArrayBuffer;
+        } catch (err5) {
+        }
+        try {
+          globalObj.Atomics = Atomics;
+        } catch (err5) {
+        }
+        try {
+          globalObj.WebAssembly = WebAssembly;
+        } catch (err5) {
+        }
+        try {
+          globalObj.clearInterval = clearInterval;
+        } catch (err5) {
+        }
+        try {
+          globalObj.clearTimeout = clearTimeout;
+        } catch (err5) {
+        }
+        try {
+          globalObj.setInterval = setInterval;
+        } catch (err5) {
+        }
+        try {
+          globalObj.setTimeout = setTimeout;
+        } catch (err5) {
+        }
+        try {
+          globalObj.crypto = crypto;
+        } catch (err5) {
+        }
+        try {
+          globalObj.URL = URL;
+        } catch (err5) {
+        }
+        names = getOwnNames(globalObj);
+      }
+    }
+  }
+}
+if (globalObj.Symbol) {
+  !globalObj.Symbol.iterator && (globalObj.Symbol.iterator = createSymbol("iterator"));
+  !globalObj.Symbol.asyncIterator && (globalObj.Symbol.asyncIterator = createSymbol("asynciterator"));
+}
+const win = create({});
+for (let i = 0; i < names.length; i++) {
+  const name = names[i];
+  try {
+    win[name] = globalObj[name];
+  } catch (err) {
+  }
+}
+const WINDOW = createSymbol("window");
+function createSandBox() {
+  return assign(create({ [WINDOW]: globalObj }), win);
+}
+function createSymbol(key) {
+  return key + Math.random().toString(36).substring(2);
+}
+function getAsyncIterator(obj) {
+  let iterator;
+  if (typeof Symbol === "function") {
+    iterator = obj[Symbol.asyncIterator];
+    !iterator && (iterator = obj[Symbol.iterator]);
+  }
+  if (iterator) {
+    return iterator.call(obj);
+  } else if (typeof obj.next === "function") {
+    return obj;
+  } else {
+    let i = 0;
+    return {
+      next() {
+        if (obj && i >= obj.length) obj = void 0;
+        return { value: obj && obj[i++], done: !obj };
+      }
+    };
+  }
+}
+
+export { WINDOW, _assign, assign, callSuper, create, createSandBox, createSymbol, define, freeze, getAsyncIterator, getDptor, getGetter, getOwnNames, getProto, getSetter, globalObj, hasOwn, inherits, setProto };

package/dist/sval.d.ts

@@ -0,0 +1,15 @@
+import { Options, Node } from 'acorn';
+export interface SvalOptions {
+    ecmaVer?: Options['ecmaVersion'];
+    sourceType?: Options['sourceType'];
+    sandBox?: boolean;
+}
+export default class Sval {
+    private options;
+    private scope;
+    exports: Record<string, any>;
+    constructor(options?: SvalOptions);
+    import(nameOrModules: string | Record<string, any>, mod?: any): void;
+    parse(code: string, parser?: (code: string, options: Options) => Node): Node;
+    run(code: string | Node): void;
+}

package/dist/sval.js

@@ -0,0 +1,104 @@
+import { createSandBox, globalObj, getOwnNames } from './share/util.js';
+import { parse } from 'acorn';
+import { EXPORTS, STRICT, IMPORT } from './share/const.js';
+import Scope from './scope/index.js';
+import { runAsync } from './share/async.js';
+import { hoist } from './evaluate/helper.js';
+import { hoist as hoist$1 } from './evaluate_n/helper.js';
+import evaluate from './evaluate/index.js';
+import evaluate$1 from './evaluate_n/index.js';
+
+const latestVer = 15;
+function improveSyntaxError(err, code) {
+  if (typeof err.pos !== "number" || !err.message.startsWith("Unexpected token")) return err;
+  const pos = err.pos;
+  const ch = pos < code.length ? code[pos] : void 0;
+  let ident = null;
+  if (ch !== void 0 && /[a-zA-Z_$]/.test(ch)) {
+    const m = code.slice(pos).match(/^[a-zA-Z_$][a-zA-Z0-9_$]*/);
+    if (m) ident = m[0];
+  } else if (ch === void 0 || ch === "(") {
+    let end = pos;
+    while (end > 0 && /\s/.test(code[end - 1])) end--;
+    if (end > 0 && /[a-zA-Z0-9_$]/.test(code[end - 1])) {
+      let start = end;
+      while (start > 0 && /[a-zA-Z0-9_$]/.test(code[start - 1])) start--;
+      const candidate = code.slice(start, end);
+      if (/^[a-zA-Z_$]/.test(candidate)) ident = candidate;
+    }
+  }
+  if (ident) return new SyntaxError(`Unexpected identifier '${ident}'`);
+  return err;
+}
+class Sval {
+  options = { ecmaVersion: "latest" };
+  scope = new Scope(null, true, this);
+  exports = {};
+  constructor(options = {}) {
+    let { ecmaVer = "latest", sandBox = true, sourceType = "script" } = options;
+    if (typeof ecmaVer === "number") {
+      ecmaVer -= ecmaVer < 2015 ? 0 : 2009;
+    }
+    if (ecmaVer !== "latest" && ecmaVer !== 3 && (ecmaVer < 5 || ecmaVer > latestVer)) {
+      throw new Error(`unsupported ecmaVer`);
+    }
+    this.options.ecmaVersion = ecmaVer;
+    this.options.sourceType = sourceType;
+    this.options.ranges = true;
+    this.options.locations = true;
+    this.options.preserveParens = false;
+    if (sandBox) {
+      const win = createSandBox();
+      this.scope.let("globalThis", win);
+      this.scope.let("window", win);
+      this.scope.let("self", win);
+      this.scope.let("this", sourceType === "module" ? void 0 : win);
+    } else {
+      this.scope.let("globalThis", globalObj);
+      this.scope.let("window", globalObj);
+      this.scope.let("self", globalObj);
+      this.scope.let("this", sourceType === "module" ? void 0 : globalObj);
+    }
+    this.scope.const(sourceType === "module" ? EXPORTS : "exports", this.exports = {});
+    if (sourceType === "module") {
+      this.scope.const(STRICT, true);
+    }
+  }
+  import(nameOrModules, mod) {
+    if (typeof nameOrModules === "string") {
+      nameOrModules = { [nameOrModules]: mod };
+    }
+    if (typeof nameOrModules !== "object") return;
+    const names = getOwnNames(nameOrModules);
+    for (let i = 0; i < names.length; i++) {
+      const name = names[i];
+      const modName = this.options.sourceType === "module" ? IMPORT + name : name;
+      this.scope.var(modName, nameOrModules[name]);
+    }
+  }
+  parse(code, parser) {
+    if (typeof parser === "function") {
+      return parser(code, this.options);
+    }
+    try {
+      return parse(code, this.options);
+    } catch (err) {
+      throw improveSyntaxError(err, code);
+    }
+  }
+  run(code) {
+    const ast = typeof code === "string" ? this.parse(code) : code;
+    const scope = this.scope;
+    if (this.options.sourceType === "module" && (this.options.ecmaVersion === "latest" || this.options.ecmaVersion >= 13)) {
+      runAsync((function* () {
+        yield* hoist(ast, scope);
+        yield* evaluate(ast, scope);
+      })());
+    } else {
+      hoist$1(ast, scope);
+      evaluate$1(ast, scope);
+    }
+  }
+}
+
+export { Sval as default };

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "@typescript-guy/fn-monitor",
+    "version": "1.0.0",
+    "description": "An augmentation of the sval JS-in-JS interpreter to monitor functions as they execute.",
+    "type": "module",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist/**/*.js",
+        "dist/**/*.d.ts",
+        "ACKNOWLEDGEMENTS.md"
+    ],
+    "author": "typescript-guy",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/The-BigMan-tech/fn-monitor.git"
+    },
+    "keywords": [
+        "javascript",
+        "typescript",
+        "function",
+        "monitor",
+        "interpreter"
+    ],
+    "scripts": {
+        "start": "vite",
+        "build": "vite build",
+        "test": "vitest run --coverage",
+        "publish:public": "npm publish --registry=https://registry.npmjs.org/ --access public"
+    },
+    "dependencies": {
+        "@types/estree": "^1.0.8",
+        "acorn": "^8.14.0",
+        "ansis": "^4.3.1",
+        "js-beautify": "^1.15.4",
+        "js-sha256": "^0.11.1",
+        "lru-cache": "^11.3.5",
+        "meriyah": "^7.1.0"
+    },
+    "devDependencies": {
+        "@swc/core": "^1.11.24",
+        "@types/js-beautify": "^1.14.3",
+        "@types/node": "^22.15.3",
+        "@vitest/coverage-v8": "^3.1.2",
+        "happy-dom": "^20.0.11",
+        "rollup": "^4.62.2",
+        "rollup-plugin-dts": "^6.4.1",
+        "tsx": "^4.23.1",
+        "vite": "^6.3.4",
+        "vite-plugin-dts": "^4.5.3",
+        "vitest": "^3.1.2"
+    }
+}