nv-constexpr-angle-exec 1.0.0

package/TEST/tst-proto.js

@@ -0,0 +1,84 @@
+// tst-proto.js
+const vm = require("vm");
+
+// 原始对象
+var obj = {
+    bigint: 9007199254740993n,
+    num: 123.456,
+    str: 'hello\\nworld',
+    bool: true,
+    nil: null,
+    undef: undefined
+}
+
+console.log("=== 原始对象 ===");
+console.log("obj:", obj);
+console.log("Object.getPrototypeOf(obj) === Object.prototype:", Object.getPrototypeOf(obj) === Object.prototype);
+console.log("Object.getPrototypeOf(obj):", Object.getPrototypeOf(obj));
+console.log("Object.prototype:", Object.prototype);
+console.log("");
+
+// 创建 context
+const context = { input: obj };
+vm.createContext(context);
+
+// 在 vm 中执行代码，直接返回对象
+vm.runInContext(`result = input;`, context);
+
+console.log("=== vm 执行后 ===");
+console.log("context.result:", context.result);
+console.log("Object.getPrototypeOf(context.result) === Object.prototype:", Object.getPrototypeOf(context.result) === Object.prototype);
+console.log("Object.getPrototypeOf(context.result):", Object.getPrototypeOf(context.result));
+console.log("");
+
+// 实验 2：在 vm 中创建新对象
+vm.runInContext(`newObj = { a: 1, b: 2 };`, context);
+
+console.log("=== vm 中创建的新对象 ===");
+console.log("context.newObj:", context.newObj);
+console.log("Object.getPrototypeOf(context.newObj) === Object.prototype:", Object.getPrototypeOf(context.newObj) === Object.prototype);
+console.log("Object.getPrototypeOf(context.newObj):", Object.getPrototypeOf(context.newObj));
+console.log("");
+
+// 实验 3：检查 vm context 本身的原型
+console.log("=== vm context 原型 ===");
+console.log("Object.getPrototypeOf(context):", Object.getPrototypeOf(context));
+console.log("Object.getPrototypeOf(context) === Object.prototype:", Object.getPrototypeOf(context) === Object.prototype);
+console.log("");
+
+// 实验 4：检查 vm context 的属性描述符
+console.log("=== vm context 属性描述符 ===");
+console.log("Object.getOwnPropertyDescriptor(context, 'result'):", Object.getOwnPropertyDescriptor(context, 'result'));
+console.log("");
+
+// 实验 5：尝试用 Object.create(null) 在 vm 中创建对象
+vm.runInContext(`nullProtoObj = Object.create(null); nullProtoObj.x = 1;`, context);
+
+console.log("=== vm 中 Object.create(null) 创建的对象 ===");
+console.log("context.nullProtoObj:", context.nullProtoObj);
+console.log("Object.getPrototypeOf(context.nullProtoObj):", Object.getPrototypeOf(context.nullProtoObj));
+console.log("");
+
+
+// 实验 7：检查隐藏的 [[Prototype]]
+console.log("=== 深入检查原型 ===");
+const resultProto = Object.getPrototypeOf(context.result);
+console.log("resultProto === Object.prototype:", resultProto === Object.prototype);
+console.log("resultProto == Object.prototype:", resultProto == Object.prototype);  // 宽松相等
+console.log("resultProto instanceof Object:", resultProto instanceof Object);
+console.log("Object.prototype instanceof Object:", Object.prototype instanceof Object);
+console.log("");
+
+// 实验 8：检查属性是否可枚举
+console.log("=== 检查属性枚举 ===");
+console.log("Object.keys(context.result):", Object.keys(context.result));
+console.log("Object.getOwnPropertyNames(context.result):", Object.getOwnPropertyNames(context.result));
+console.log("");
+
+// 实验 9：尝试修改原型
+try {
+    Object.setPrototypeOf(context.result, null);
+    console.log("成功将 context.result 的原型设为 null");
+} catch (e) {
+    console.log("无法修改 context.result 的原型:", e.message);
+}

package/TEST/tst-vm-proto.js

@@ -0,0 +1,38 @@
+const vm = require("vm");
+
+// 外部环境的 Object.prototype
+console.log("=== 外部环境 ===");
+console.log("Object.prototype:", Object.prototype);
+console.log("Object.prototype === Object.prototype:", Object.prototype === Object.prototype);
+
+// 创建 vm context
+const context = {};
+vm.createContext(context);
+
+// 在 vm 中获取 Object.prototype
+vm.runInContext(`
+    vmObjectPrototype = Object.prototype;
+    vmGlobalObject = globalThis;
+`, context);
+
+console.log("\n=== vm 环境 ===");
+console.log("context.vmObjectPrototype:", context.vmObjectPrototype);
+console.log("context.vmGlobalObject:", context.vmGlobalObject);
+console.log("");
+
+// 比较
+console.log("=== 比较 ===");
+console.log("Object.prototype === context.vmObjectPrototype:", Object.prototype === context.vmObjectPrototype);
+console.log("Object.prototype == context.vmObjectPrototype:", Object.prototype == context.vmObjectPrototype);
+
+// 检查 vm 中创建的对象原型
+vm.runInContext(`
+    vmObj = { a: 1 };
+    vmObjProto = Object.getPrototypeOf(vmObj);
+`, context);
+
+console.log("\n=== vm 中创建的对象 ===");
+console.log("context.vmObj:", context.vmObj);
+console.log("context.vmObjProto:", context.vmObjProto);
+console.log("context.vmObjProto === Object.prototype:", context.vmObjProto === Object.prototype);
+console.log("context.vmObjProto === context.vmObjectPrototype:", context.vmObjProto === context.vmObjectPrototype);

package/TEST/tst.js

@@ -0,0 +1,220 @@
+const run    = require('../index');
+const codify = require('nv-constexpr-simple-codify');
+
+console.log("========== AngleExec 测试 ==========\n");
+
+// ============ 测试 1: 基础支持类型 ============
+console.log("测试 1: 基础支持类型");
+const basicEnv = {
+    bigint: 9007199254740993n,
+    num: 123.456,
+    str: "hello\\nworld",
+    bool: true,
+    nil: null,
+    undef: undefined
+};
+
+const [ok1, result1] = run(basicEnv, `({ bigint, num, str, bool, nil, undef })`);
+console.log("Result:", ok1, result1);
+console.log("");
+
+// ============ 测试 2: TypedArrays ============
+console.log("测试 2: TypedArrays");
+const typedArrayEnv = {
+    uint8: new Uint8Array([1, 2, 255]),
+    int32: new Int32Array([-2147483648, 2147483647]),
+    float64: new Float64Array([1.7976931348623157e+308, -Infinity, NaN])
+};
+
+const [ok2, result2] = run(typedArrayEnv, `({ uint8, int32, float64 })`);
+console.log("Result:", ok2, result2);
+console.log("");
+
+// ============ 测试 3: Date 和 RegExp ============
+console.log("测试 3: Date 和 RegExp");
+const dateRegexEnv = {
+    date: new Date('2024-01-15T12:30:45.123Z'),
+    regex: /test\/pattern/gi
+};
+
+const [ok3, result3] = run(dateRegexEnv, `({ date, regex })`);
+console.log("Result:", ok3, result3);
+console.log("");
+
+// ============ 测试 4: 嵌套结构 ============
+console.log("测试 4: 嵌套结构");
+const nestedEnv = {
+    nested: {
+        level2: {
+            value: 789n,
+            arr: [1n, 2n, 3n]
+        }
+    }
+};
+
+const [ok4, result4] = run(nestedEnv, `({ nested })`);
+console.log("Result:", ok4, result4);
+console.log("");
+
+
+// ============ 测试 16: 不支持的类型 - BigInt too large for int64 (testing copy v8 bigint.cc scenario) ============
+console.log("测试 16: BigInt 超出 int64 范围 (理论上支持，但需要 v8 bigint.cc)");
+const hugeBigIntEnv = { huge: 1844674407370955161612345678901234567890n };
+
+const [ok16, result16] = run(hugeBigIntEnv, `huge`);
+console.log("Result:", ok16, result16);
+console.log("Note: This is supported by codify, but C++ may need v8 bigint.cc for such large values");
+console.log("");
+
+// ============ 测试 17: 复杂嵌套 + 多种类型 ============
+console.log("测试 17: 复杂嵌套 + 多种类型");
+const complexEnv = {
+    meta: {
+        created: new Date(),
+        version: 1.0,
+        enabled: true
+    },
+    data: {
+        buffer: new ArrayBuffer(8),
+        view: new DataView(new ArrayBuffer(16)),
+        numbers: new Float32Array([1.5, -2.5, 0.0])
+    },
+    items: [
+        { id: 1, value: 10n },
+        { id: 2, value: 20n }
+    ]
+};
+
+// 填充 buffer
+new Uint8Array(complexEnv.data.buffer).set([0, 32, 64, 96, 128, 160, 192, 224]);
+new Uint8Array(complexEnv.data.view.buffer).set(new Array(16).fill(0));
+
+const [ok17, result17] = run(complexEnv, `({ meta, data, items })`);
+console.log("Result:", ok17, result17);
+console.log("");
+
+// ============ 测试 18: 空数组和空对象 ============
+console.log("测试 18: 空数组和空对象");
+const emptyEnv = {
+    emptyArr: [],
+    emptyObj: {}
+};
+
+const [ok18, result18] = run(emptyEnv, `({ emptyArr, emptyObj })`);
+console.log("Result:", ok18, result18);
+console.log("");
+
+// ============ 测试 19: 只有 undefined 和 null ============
+console.log("测试 19: 只有 undefined 和 null");
+const nullishEnv = {
+    undef: undefined,
+    nil: null
+};
+
+const [ok19, result19] = run(nullishEnv, `({ undef, nil })`);
+console.log("Result:", ok19, result19);
+console.log("");
+
+
+
+
+
+// ============ 测试 5: 循环引用 ============
+console.log("测试 5: 循环引用");
+const circObj = { a: 1 };
+circObj.self = circObj;
+const circEnv = { circ: circObj };
+
+console.log("is_supported:", codify.is_supported(circEnv))
+
+
+const [ok5, result5] = run(circEnv, `circ`);
+console.log("Result:", ok5, result5);
+console.log("");
+
+// ============ 测试 6: 不支持的类型 - Set ============
+console.log("测试 6: 不支持的类型 - Set");
+const setEnv = { mySet: new Set([1, 2, 3]) };
+
+const [ok6, result6] = run(setEnv, `mySet`);
+console.log("Result:", ok6, result6);
+console.log("");
+
+// ============ 测试 7: 不支持的类型 - Map ============
+console.log("测试 7: 不支持的类型 - Map");
+const mapEnv = { myMap: new Map([['a', 1], ['b', 2]]) };
+
+const [ok7, result7] = run(mapEnv, `myMap`);
+console.log("Result:", ok7, result7);
+console.log("");
+
+// ============ 测试 8: 不支持的类型 - Promise ============
+console.log("测试 8: 不支持的类型 - Promise");
+const promiseEnv = { myPrms: Promise.resolve(42) };
+
+const [ok8, result8] = run(promiseEnv, `myPrms`);
+console.log("Result:", ok8, result8);
+console.log("");
+
+// ============ 测试 9: 不支持的类型 - Function ============
+console.log("测试 9: 不支持的类型 - Function");
+const funcEnv = { myFunc: function() { return 1; } };
+
+const [ok9, result9] = run(funcEnv, `myFunc`);
+console.log("Result:", ok9, result9);
+console.log("");
+
+// ============ 测试 10: 不支持的类型 - Symbol ============
+console.log("测试 10: 不支持的类型 - Symbol");
+const symbolEnv = { mySym: Symbol("test") };
+
+const [ok10, result10] = run(symbolEnv, `mySym`);
+console.log("Result:", ok10, result10);
+console.log("");
+
+// ============ 测试 11: 不支持的类型 - Generator ============
+console.log("测试 11: 不支持的类型 - Generator");
+function* gen() { yield 1; }
+const genEnv = { myGen: gen() };
+
+const [ok11, result11] = run(genEnv, `myGen`);
+console.log("Result:", ok11, result11);
+console.log("");
+
+// ============ 测试 12: 不支持的类型 - WeakMap ============
+console.log("测试 12: 不支持的类型 - WeakMap");
+const weakMapEnv = { myWeakMap: new WeakMap() };
+
+const [ok12, result12] = run(weakMapEnv, `myWeakMap`);
+console.log("Result:", ok12, result12);
+console.log("");
+
+// ============ 测试 13: 不支持的类型 - WeakSet ============
+console.log("测试 13: 不支持的类型 - WeakSet");
+const weakSetEnv = { myWeakSet: new WeakSet() };
+
+const [ok13, result13] = run(weakSetEnv, `myWeakSet`);
+console.log("Result:", ok13, result13);
+console.log("");
+
+// ============ 测试 14: 不支持的类型 - WeakRef ============
+console.log("测试 14: 不支持的类型 - WeakRef");
+const weakRefEnv = { myWeakRef: new WeakRef({}) };
+
+const [ok14, result14] = run(weakRefEnv, `myWeakRef`);
+console.log("Result:", ok14, result14);
+console.log("");
+
+// ============ 测试 15: 不支持的类型 - Iterator ============
+console.log("测试 15: 不支持的类型 - Iterator");
+const iterEnv = { myIter: [1, 2, 3][Symbol.iterator]() };
+
+const [ok15, result15] = run(iterEnv, `myIter`);
+console.log("Result:", ok15, result15);
+console.log("");
+
+
+console.log("========== 测试完成 ==========");
+
+
+

package/index.js

@@ -0,0 +1,33 @@
+const vm  = require("vm");
+const codify = require("nv-constexpr-simple-codify");
+
+
+class AngleExec {
+    context = { ___recv___:null};
+    constructor(env) {
+         Object.assign(this.context,env);
+         vm.createContext(this.context);
+    }
+    run(code) {
+        this.context.___recv___ = null;
+        vm.runInContext(`___recv___ = ${code};`, this.context);
+        var r = this.context.___recv___;
+        var [cond,reason] = codify.is_supported(r,true);
+        if(cond) {
+	    return [true, codify(r)]
+	} else     {
+	    return [false,reason]
+	}
+    }
+}
+
+const creat     = (env) => new AngleExec(env)
+const  run      = (env,code)=>{
+   var ctx = creat(env);
+   return ctx.run(code);
+}
+module.exports  = run;
+module.exports.creat = creat;
+module.exports.AngleExec = AngleExec;
+
+

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "nv-constexpr-angle-exec",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "nv-constexpr-simple-codify": "^1.0.5"
+  }
+}