更新

README.md

@@ -1,14 +1,38 @@
-## qxVm补环境框架(历史)
+# qxVm补环境框架简介
+
+- 个人微信 y2783693683
+
 - 微信公众号: y小白的笔记(https://mp.weixin.qq.com/s/GGqecHvqN54IzL3ap5c28A)
 - git: https://github.com/ylw00/qxVm
 - 基于 `node16`
 - 基于`vm2`模块纯js设计一个补环境框架
-- `没有完全补完`, 主要提供思路以及壳子的设计, 剩下的就是重复性的工作, 
 - 目前的设计思路以及实现的方式,检测点相对来说是比较少的
 - 因为是前期版本, 所以并没有加入`dom解析`,属性的方法实现
 - 内部使用`弱引用`, 不会影响内存回收问题
 - 优化实例产生的方式
 
+
+
+ ## 声明
+
+- 不会在已有的基础之上添加新的api功能
+- 框架内部的dom操作不可信, 需要重写(详情见/z_working/rs4.js)
+
+
+
+##  2023-07-26更新
+
+- 添加完善的日志功能, 替代之前的debugger功能, 使得调试更加舒服
+- 新增`QXVM_GENERATE.help` 方法, 打印帮助信息
+- 添加`默认导出函数 printLog` (runConfig.logOpen=true), 一键导出
+- 删除一些不必要的配置参数
+- 为了避免一些问题, 框架内部`qxVm`字眼`更改`为 `lwVm`
+- 隐藏环境代码, 更加简洁
+- 封装事件调用函数 `lw.callListener`  // lw.callListener("load")
+- 字符串处理 (./qxVm_sanbox/tools/updateDbugger.py)
+
+
+
 ## 调用方式(z_working目录)
 ```js
 const QXVM_GENERATE = require('../qxVm_sanbox/qxVm.sanbox');
@@ -17,7 +41,7 @@ const js_code = "function get_form (){ return '' }";  // 导出函数是一定
 const user_config = {  // 用户配置
     isTest: true,  // 是不是测试状态, 如果是, 则会固定时间戳, 随机数
     compress: false,  // 是否压缩js, 准对检测格式化的网站
-    proxy_config: { proxy: false, proxy_proto: false, print_log: true },  // 是否挂代理
+    runConfig: { proxy: false, proxy_proto: false, logOpen: true },  // 是否挂代理
     window_attribute: {},
     env: {  // 浏览器环境
         canvas: "",
@@ -42,21 +66,9 @@ console.log(result.get_form())
 - 浏览器中组成字符串, 保存到本地, 具体可以看 (https://mp.weixin.qq.com/s/lDlylUGWS2qtCGBh-1RKFQ)
 - 半自动方式可以看(qxVm_sanbox\tools\create_ptototype_js.py)
 
-## qxVm优化方向(当然新版都是已经实现的)
-- debugger改为日志打印,加入日志开关, 并且避免使用`proxy`代理
-- 加入dom解析 可以套壳jsdom, 我是使用了cheerio
-- 优化堆栈替换, 防止检测堆栈
-- 加入动态更换框架内浏览器环境的逻辑, 保证框架只加载一次
-- 加入内部指纹库, 可以随意更改指纹
-- 套壳 canvas, 实现canvas指纹生成
-- 随机浏览器环境
+## qxVm最新
 
-## qxVm(最新)
-- 暂时没开源
-- 框架加载速度 100ms左右
-- dom解析
-- form特性
-- 瑞数, 阿里,腾讯
-  
-![](https://files.mdnice.com/user/23430/b583c38d-b2e2-454b-960d-657d15d0b101.png)
+- 瑞数, 阿里, 腾讯, 
+- https://mp.weixin.qq.com/s/Py7I6RG7UT9EtdpXlV98aA
+- https://mp.weixin.qq.com/s/SSlZEMQhNxOlA3rzSNY37w
 

qxVm_sanbox/env/BASE_CONFIG/Del_attribute.js

@@ -6,5 +6,3 @@
     })
     
 })();
-
-// debugger;

qxVm_sanbox/env/BASE_CONFIG/_qxVm.BASE_CONFIG.node.js

@@ -11,6 +11,13 @@ function Get_baseConfig_node_code() {
     return code;
 };
 
+function Get_frameEnd_code(){
+    let code = ""
+    code += ReadCode("vm_frameLoadEnd.js");
+    return code;
+}
+
 module.exports = {
-    Get_baseConfig_node_code
+    Get_baseConfig_node_code, 
+    Get_frameEnd_code
 }

qxVm_sanbox/env/BASE_CONFIG/vm_frameLoadEnd.js

@@ -0,0 +1,8 @@
+/**
+ * 设置为用户的配置
+ */
+lwVm.config['logOpen'] = lwVm_module.nodeConfig.logOpen
+lwVm.config['proxy'] = lwVm_module.nodeConfig.proxy
+
+lwVm.memory.finish = true;
+lwVm.console_log('框架代码加载完毕 !!!')

qxVm_sanbox/env/BOM/Audio/AudioDestinationNode.js

@@ -1,12 +1,12 @@
 AudioDestinationNode = function AudioDestinationNode(createObj_key, channelCountMode) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {
+    lwVm.memory.private_data.set(this, {
         channelCountMode:channelCountMode,
         maxChannelCount: 1
     })
-}; qxVm.safefunction(AudioDestinationNode);
+}; lwVm.safefunction(AudioDestinationNode);
 
 ; (function () {
     const $safe_get_attribute = ['maxChannelCount'];
@@ -15,14 +15,15 @@ AudioDestinationNode = function AudioDestinationNode(createObj_key, channelCount
 
     AudioDestinationNode.prototype = {
         get maxChannelCount() {
-            debugger;
             if (!AudioDestinationNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).maxChannelCount;
+            let result = lwVm.memory.private_data.get(this).maxChannelCount;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioDestinationNode', 'maxChannelCount', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(AudioDestinationNode.prototype, "AudioDestinationNode");
-    qxVm.safeDescriptor_addConstructor(AudioDestinationNode);
-    qxVm.safe_Objattribute(AudioDestinationNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(AudioDestinationNode.prototype, "AudioDestinationNode");
+    lwVm.safeDescriptor_addConstructor(AudioDestinationNode);
+    lwVm.safe_Objattribute(AudioDestinationNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(AudioDestinationNode.prototype, AudioNode.prototype);
     Object.setPrototypeOf(AudioDestinationNode, AudioNode);

qxVm_sanbox/env/BOM/Audio/AudioListener.js

@@ -1,9 +1,9 @@
 AudioListener = function AudioListener(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(AudioListener);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(AudioListener);
 
 ; (function () {
     const $safe_get_attribute = ['forwardX', 'forwardY', 'forwardZ', 'positionX', 'positionY', 'positionZ', 'upX', 'upY', 'upZ'];
@@ -12,106 +12,119 @@ AudioListener = function AudioListener(createObj_key) {
 
     AudioListener.prototype = {
         get forwardX() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).forwardX;
+            let ele = lwVm.memory.private_data.get(this).forwardX;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).forwardX = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).forwardX = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'forwardX', arguments, result);
+            return result;
         },
         get forwardY() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).forwardY;
+            let ele = lwVm.memory.private_data.get(this).forwardY;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).forwardY = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).forwardY = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'forwardY', arguments, result);
+            return result;
         },
         get forwardZ() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).forwardZ;
+            let ele = lwVm.memory.private_data.get(this).forwardZ;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", -1, 3.4028234663852886e+38, -3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).forwardZ = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", -1, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).forwardZ = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'forwardZ', arguments, result);
+            return result;
         },
         get positionX() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).positionX;
+            let ele = lwVm.memory.private_data.get(this).positionX;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).positionX = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).positionX = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'positionX', arguments, result);
+            return result;
         },
         get positionY() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).positionY;
+            let ele = lwVm.memory.private_data.get(this).positionY;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).positionY = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).positionY = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'positionY', arguments, result);
+            return result;
         },
         get positionZ() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).positionZ;
+            let ele = lwVm.memory.private_data.get(this).positionZ;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).positionZ = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).positionZ = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'positionZ', arguments, result);
+            return result;
         },
         setOrientation() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioListener', 'setOrientation', arguments, result);
+            return result;
         },
         setPosition() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioListener', 'setPosition', arguments, result);
+            return result;
         },
         get upX() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).upX;
+            let ele = lwVm.memory.private_data.get(this).upX;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).upX = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).upX = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'upX', arguments, result);
+            return result;
         },
         get upY() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).upY;
+            let ele = lwVm.memory.private_data.get(this).upY;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 1, 3.4028234663852886e+38, -3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).upY = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 1, 3.4028234663852886e+38, -3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).upY = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'upY', arguments, result);
+            return result;
         },
         get upZ() {
-            debugger;
             if (!AudioListener.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).upZ;
+            let ele = lwVm.memory.private_data.get(this).upZ;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38);
-                qxVm.memory.private_data.get(this).upZ = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 0, 3.4028234663852886e+38);
+                lwVm.memory.private_data.get(this).upZ = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioListener', 'upZ', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(AudioListener.prototype, "AudioListener");
-    qxVm.safeDescriptor_addConstructor(AudioListener);
-    qxVm.safe_Objattribute(AudioListener, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(AudioListener.prototype, "AudioListener");
+    lwVm.safeDescriptor_addConstructor(AudioListener);
+    lwVm.safe_Objattribute(AudioListener, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
 

qxVm_sanbox/env/BOM/Audio/AudioNode.js

@@ -1,13 +1,13 @@
 AudioNode = function AudioNode(createObj_key, channelCountMode) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
 
     channelCountMode = channelCountMode || "max"
-    qxVm.memory.private_data.set(this, {
+    lwVm.memory.private_data.set(this, {
         channelCountMode:channelCountMode
     })
-}; qxVm.safefunction(AudioNode);
+}; lwVm.safefunction(AudioNode);
 
 ; (function () {
     const $safe_get_attribute = ['channelCount', 'channelCountMode', 'channelInterpretation', 'context', 'numberOfInputs', 'numberOfOutputs'];
@@ -16,68 +16,78 @@ AudioNode = function AudioNode(createObj_key, channelCountMode) {
 
     AudioNode.prototype = {
         get channelCount() {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).channelCount, 2);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).channelCount, 2);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioNode', 'channelCount', arguments, result);
+            return result;
         },
         set channelCount(value) {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).channelCount = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'AudioNode', 'channelCount', arguments);
+            lwVm.memory.private_data.get(this).channelCount = value;
         },
         get channelCountMode() {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).channelCountMode, "max");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).channelCountMode, "max");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioNode', 'channelCountMode', arguments, result);
+            return result;
         },
         set channelCountMode(value) {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).channelCountMode = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'AudioNode', 'channelCountMode', arguments);
+            lwVm.memory.private_data.get(this).channelCountMode = value + "";
         },
         get channelInterpretation() {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).channelInterpretation, "speakers");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).channelInterpretation, "speakers");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioNode', 'channelInterpretation', arguments, result);
+            return result;
         },
         set channelInterpretation(value) {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).channelInterpretation = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'AudioNode', 'channelInterpretation', arguments);
+            lwVm.memory.private_data.get(this).channelInterpretation = value + "";
         },
         connect() {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioNode', 'connect', arguments, result);
+            return result;
         },
         get context() {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             // return this;
-            let ele = qxVm.memory.private_data.get(this).context;
+            let ele = lwVm.memory.private_data.get(this).context;
             if (ele === undefined) {
-                ele = new OfflineAudioContext(qxVm.memory.$createObj_key);
-                qxVm.memory.private_data.get(this).context = ele;
+                ele = new OfflineAudioContext(lwVm.memory.$createObj_key);
+                lwVm.memory.private_data.get(this).context = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioNode', 'context', arguments, result);
+            return result;
         },
         disconnect() {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioNode', 'disconnect', arguments, result);
+            return result;
         },
         get numberOfInputs() {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).numberOfInputs, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).numberOfInputs, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioNode', 'numberOfInputs', arguments, result);
+            return result;
         },
         get numberOfOutputs() {
-            debugger;
             if (!AudioNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).numberOfOutputs, 1);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).numberOfOutputs, 1);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioNode', 'numberOfOutputs', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(AudioNode.prototype, "AudioNode");
-    qxVm.safeDescriptor_addConstructor(AudioNode);
-    qxVm.safe_Objattribute(AudioNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(AudioNode.prototype, "AudioNode");
+    lwVm.safeDescriptor_addConstructor(AudioNode);
+    lwVm.safe_Objattribute(AudioNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(AudioNode.prototype, EventTarget.prototype);
     Object.setPrototypeOf(AudioNode, EventTarget);

qxVm_sanbox/env/BOM/Audio/AudioParam.js

@@ -1,5 +1,5 @@
 AudioParam = function AudioParam(createObj_key, automationRate, defaultValue, maxValue, minValue) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
 
@@ -9,14 +9,14 @@ AudioParam = function AudioParam(createObj_key, automationRate, defaultValue, ma
     maxValue = maxValue || 3.4028234663852886e+38;
     minValue = minValue || -3.4028234663852886e+38;
     const value = defaultValue;
-    qxVm.memory.private_data.set(this, {
+    lwVm.memory.private_data.set(this, {
         automationRate: automationRate,
         defaultValue: defaultValue,
         maxValue: maxValue,
         minValue: minValue,
         value: value
     })
-}; qxVm.safefunction(AudioParam);
+}; lwVm.safefunction(AudioParam);
 
 ; (function () {
     const $safe_get_attribute = ['automationRate', 'defaultValue', 'maxValue', 'minValue', 'value'];
@@ -28,72 +28,90 @@ AudioParam = function AudioParam(createObj_key, automationRate, defaultValue, ma
 
     AudioParam.prototype = {
         get automationRate() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).automationRate, "a-rate");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).automationRate, "a-rate");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioParam', 'automationRate', arguments, result);
+            return result;
         },
         set automationRate(value) {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).automationRate = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'AudioParam', 'automationRate', arguments);
+            lwVm.memory.private_data.get(this).automationRate = value;
         },
         cancelAndHoldAtTime() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioParam', 'cancelAndHoldAtTime', arguments, result);
+            return result;
         },
         cancelScheduledValues() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioParam', 'cancelScheduledValues', arguments, result);
+            return result;
         },
         get defaultValue() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).defaultValue, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).defaultValue, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioParam', 'defaultValue', arguments, result);
+            return result;
         },
         exponentialRampToValueAtTime() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioParam', 'exponentialRampToValueAtTime', arguments, result);
+            return result;
         },
         linearRampToValueAtTime() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioParam', 'linearRampToValueAtTime', arguments, result);
+            return result;
         },
         get maxValue() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).maxValue;
+            let result = lwVm.memory.private_data.get(this).maxValue;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioParam', 'maxValue', arguments, result);
+            return result;
         },
         get minValue() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).minValue;
+            let result = lwVm.memory.private_data.get(this).minValue;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioParam', 'minValue', arguments, result);
+            return result;
         },
         setTargetAtTime() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioParam', 'setTargetAtTime', arguments, result);
+            return result;
         },
         setValueAtTime() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return new AudioParam(qxVm.memory.$createObj_key, "a-rate", 440, 22050);
+            let result = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 440, 22050);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioParam', 'setValueAtTime', arguments, result);
+            return result;
         },
         setValueCurveAtTime() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioParam', 'setValueCurveAtTime', arguments, result);
+            return result;
         },
         get value() {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).value, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).value, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioParam', 'value', arguments, result);
+            return result;
         },
         set value(value) {
-            debugger;
             if (!AudioParam.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).value = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'AudioParam', 'value', arguments);
+            lwVm.memory.private_data.get(this).value = value;
         },
     }
-    qxVm.rename(AudioParam.prototype, "AudioParam");
-    qxVm.safeDescriptor_addConstructor(AudioParam);
-    qxVm.safe_Objattribute(AudioParam, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(AudioParam.prototype, "AudioParam");
+    lwVm.safeDescriptor_addConstructor(AudioParam);
+    lwVm.safe_Objattribute(AudioParam, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
 

qxVm_sanbox/env/BOM/Audio/AudioScheduledSourceNode.js

@@ -1,9 +1,9 @@
 AudioScheduledSourceNode = function AudioScheduledSourceNode(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(AudioScheduledSourceNode);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(AudioScheduledSourceNode);
 
 ; (function () {
     const $safe_get_attribute = ['onended'];
@@ -12,27 +12,32 @@ AudioScheduledSourceNode = function AudioScheduledSourceNode(createObj_key) {
 
     AudioScheduledSourceNode.prototype = {
         get onended() {
-            debugger;
             if (!AudioScheduledSourceNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onended, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onended, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'AudioScheduledSourceNode', 'onended', arguments, result);
+            return result;
         },
         set onended(value) {
-            debugger;
             if (!AudioScheduledSourceNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onended = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'AudioScheduledSourceNode', 'onended', arguments);
+            lwVm.memory.private_data.get(this).onended = value;
         },
         start() {
-            debugger;
             if (!AudioScheduledSourceNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioScheduledSourceNode', 'start', arguments, result);
+            return result;
         },
         stop() {
-            debugger;
             if (!AudioScheduledSourceNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'AudioScheduledSourceNode', 'stop', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(AudioScheduledSourceNode.prototype, "AudioScheduledSourceNode");
-    qxVm.safeDescriptor_addConstructor(AudioScheduledSourceNode);
-    qxVm.safe_Objattribute(AudioScheduledSourceNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(AudioScheduledSourceNode.prototype, "AudioScheduledSourceNode");
+    lwVm.safeDescriptor_addConstructor(AudioScheduledSourceNode);
+    lwVm.safe_Objattribute(AudioScheduledSourceNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(AudioScheduledSourceNode.prototype, AudioNode.prototype);
     Object.setPrototypeOf(AudioScheduledSourceNode, AudioNode);

qxVm_sanbox/env/BOM/Audio/AudioWorklet.js

@@ -1,9 +1,9 @@
 AudioWorklet = function AudioWorklet(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(AudioWorklet);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(AudioWorklet);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,9 +12,9 @@ AudioWorklet = function AudioWorklet(createObj_key) {
 
     AudioWorklet.prototype = {
     }
-    qxVm.rename(AudioWorklet.prototype, "AudioWorklet");
-    qxVm.safeDescriptor_addConstructor(AudioWorklet);
-    qxVm.safe_Objattribute(AudioWorklet, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(AudioWorklet.prototype, "AudioWorklet");
+    lwVm.safeDescriptor_addConstructor(AudioWorklet);
+    lwVm.safe_Objattribute(AudioWorklet, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(AudioWorklet.prototype, Worklet.prototype);
     Object.setPrototypeOf(AudioWorklet, Worklet);

qxVm_sanbox/env/BOM/Audio/BaseAudioContext.js

@@ -1,9 +1,9 @@
 BaseAudioContext = function BaseAudioContext(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(BaseAudioContext);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(BaseAudioContext);
 
 ; (function () {
     const $safe_get_attribute = ['audioWorklet', 'currentTime', 'destination', 'listener', 'onstatechange', 'sampleRate', 'state'];
@@ -17,145 +17,186 @@ BaseAudioContext = function BaseAudioContext(createObj_key) {//构造函数
     
     BaseAudioContext.prototype = {
         get audioWorklet() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).audioWorklet;
+            let ele = lwVm.memory.private_data.get(this).audioWorklet;
             if (ele === undefined){
-                ele = new AudioWorklet(qxVm.memory.$createObj_key);
-                qxVm.memory.private_data.get(this).audioWorklet = ele;
+                ele = new AudioWorklet(lwVm.memory.$createObj_key);
+                lwVm.memory.private_data.get(this).audioWorklet = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'BaseAudioContext', 'audioWorklet', arguments, result);
+            return result;
         },
         createAnalyser() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createAnalyser', arguments, result);
+            return result;
         },
         createBiquadFilter() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createBiquadFilter', arguments, result);
+            return result;
         },
         createBuffer() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createBuffer', arguments, result);
+            return result;
         },
         createBufferSource() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createBufferSource', arguments, result);
+            return result;
         },
         createChannelMerger() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createChannelMerger', arguments, result);
+            return result;
         },
         createChannelSplitter() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createChannelSplitter', arguments, result);
+            return result;
         },
         createConstantSource() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createConstantSource', arguments, result);
+            return result;
         },
         createConvolver() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createConvolver', arguments, result);
+            return result;
         },
         createDelay() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createDelay', arguments, result);
+            return result;
         },
         createDynamicsCompressor() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = new DynamicsCompressorNode(qxVm.memory.$createObj_key);
+            let ele = new DynamicsCompressorNode(lwVm.memory.$createObj_key);
             ele.channelCountMode = "clamped-max";
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createDynamicsCompressor', arguments, result);
+            return result;
         },
         createGain() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createGain', arguments, result);
+            return result;
         },
         createIIRFilter() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createIIRFilter', arguments, result);
+            return result;
         },
         createOscillator() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return new OscillatorNode();
+            let result = new OscillatorNode();;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createOscillator', arguments, result);
+            return result;
         },
         createPanner() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createPanner', arguments, result);
+            return result;
         },
         createPeriodicWave() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createPeriodicWave', arguments, result);
+            return result;
         },
         createScriptProcessor() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createScriptProcessor', arguments, result);
+            return result;
         },
         createStereoPanner() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createStereoPanner', arguments, result);
+            return result;
         },
         createWaveShaper() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'createWaveShaper', arguments, result);
+            return result;
         },
         get currentTime() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).currentTime, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).currentTime, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'BaseAudioContext', 'currentTime', arguments, result);
+            return result;
         },
         decodeAudioData() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'BaseAudioContext', 'decodeAudioData', arguments, result);
+            return result;
         },
         get destination() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).destination;
+            let ele = lwVm.memory.private_data.get(this).destination;
             if (ele === undefined){
-                ele = new AudioDestinationNode(qxVm.memory.$createObj_key, "explicit");
-                qxVm.memory.private_data.get(this).destination = ele;
+                ele = new AudioDestinationNode(lwVm.memory.$createObj_key, "explicit");
+                lwVm.memory.private_data.get(this).destination = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'BaseAudioContext', 'destination', arguments, result);
+            return result;
         },
         get listener() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).listener;
+            let ele = lwVm.memory.private_data.get(this).listener;
             if (ele === undefined){
-                ele = new AudioListener(qxVm.memory.$createObj_key);
-                qxVm.memory.private_data.get(this).listener = ele;
+                ele = new AudioListener(lwVm.memory.$createObj_key);
+                lwVm.memory.private_data.get(this).listener = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'BaseAudioContext', 'listener', arguments, result);
+            return result;
         },
         get onstatechange() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'BaseAudioContext', 'onstatechange', arguments, result);
+            return result;
         },
         set onstatechange(value) {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onstatechange = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'BaseAudioContext', 'onstatechange', arguments);
+            lwVm.memory.private_data.get(this).onstatechange = value;
         },
         get sampleRate() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).sampleRate;
+            let result = lwVm.memory.private_data.get(this).sampleRate;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'BaseAudioContext', 'sampleRate', arguments, result);
+            return result;
         },
         get state() {
-            debugger;
             if (!BaseAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).state, "suspended");
+            return lwVm.abs(lwVm.memory.private_data.get(this).state, "suspended");
         }
     }
 
-    qxVm.rename(BaseAudioContext.prototype, "BaseAudioContext");
-    qxVm.safeDescriptor_addConstructor(BaseAudioContext);
-    qxVm.safe_Objattribute(BaseAudioContext, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(BaseAudioContext.prototype, "BaseAudioContext");
+    lwVm.safeDescriptor_addConstructor(BaseAudioContext);
+    lwVm.safe_Objattribute(BaseAudioContext, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(BaseAudioContext.prototype, EventTarget.prototype);
     Object.setPrototypeOf(BaseAudioContext, EventTarget);

qxVm_sanbox/env/BOM/Audio/DynamicsCompressorNode.js

@@ -1,9 +1,9 @@
 DynamicsCompressorNode = function DynamicsCompressorNode(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(DynamicsCompressorNode);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(DynamicsCompressorNode);
 
 ; (function () {
     const $safe_get_attribute = ['attack', 'knee', 'ratio', 'reduction', 'release', 'threshold'];
@@ -13,57 +13,67 @@ DynamicsCompressorNode = function DynamicsCompressorNode(createObj_key) {
     DynamicsCompressorNode.prototype = {
         get attack() {
             if (!DynamicsCompressorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).attack;
+            let ele = lwVm.memory.private_data.get(this).attack;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "k-rate", 0.003000000026077032, 1, 0);
-                qxVm.memory.private_data.get(this).attack = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "k-rate", 0.003000000026077032, 1, 0);
+                lwVm.memory.private_data.get(this).attack = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DynamicsCompressorNode', 'attack', arguments, result);
+            return result;
         },
         get knee() {
             if (!DynamicsCompressorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).knee;
+            let ele = lwVm.memory.private_data.get(this).knee;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "k-rate", 30, 40, 0);
-                qxVm.memory.private_data.get(this).knee = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "k-rate", 30, 40, 0);
+                lwVm.memory.private_data.get(this).knee = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DynamicsCompressorNode', 'knee', arguments, result);
+            return result;
         },
         get ratio() {
             if (!DynamicsCompressorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).ratio;
+            let ele = lwVm.memory.private_data.get(this).ratio;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "k-rate", 12, 20, 1);
-                qxVm.memory.private_data.get(this).ratio = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "k-rate", 12, 20, 1);
+                lwVm.memory.private_data.get(this).ratio = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DynamicsCompressorNode', 'ratio', arguments, result);
+            return result;
         },
         get reduction() {
             if (!DynamicsCompressorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DynamicsCompressorNode', 'reduction', arguments, result);
+            return result;
         },
         get release() {
             if (!DynamicsCompressorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).release;
+            let ele = lwVm.memory.private_data.get(this).release;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "k-rate", 0.25, 1, 0);
-                qxVm.memory.private_data.get(this).release = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "k-rate", 0.25, 1, 0);
+                lwVm.memory.private_data.get(this).release = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DynamicsCompressorNode', 'release', arguments, result);
+            return result;
         },
         get threshold() {
             if (!DynamicsCompressorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).threshold;
+            let ele = lwVm.memory.private_data.get(this).threshold;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "k-rate", -24, 0, -100);
-                qxVm.memory.private_data.get(this).threshold = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "k-rate", -24, 0, -100);
+                lwVm.memory.private_data.get(this).threshold = ele;
             }
             return ele;
         }
     }
-    qxVm.rename(DynamicsCompressorNode.prototype, "DynamicsCompressorNode");
-    qxVm.safeDescriptor_addConstructor(DynamicsCompressorNode);
-    qxVm.safe_Objattribute(DynamicsCompressorNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(DynamicsCompressorNode.prototype, "DynamicsCompressorNode");
+    lwVm.safeDescriptor_addConstructor(DynamicsCompressorNode);
+    lwVm.safe_Objattribute(DynamicsCompressorNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(DynamicsCompressorNode.prototype, AudioNode.prototype);
     Object.setPrototypeOf(DynamicsCompressorNode, AudioNode);

qxVm_sanbox/env/BOM/Audio/OfflineAudioContext.js

@@ -4,12 +4,12 @@ OfflineAudioContext = function OfflineAudioContext(numberOfChannels, length, sam
 	}
     this.numberOfChannels = numberOfChannels;
 
-    qxVm.memory.private_data.set(this, {
+    lwVm.memory.private_data.set(this, {
         numberOfChannels:numberOfChannels, 
         length:length, 
         sampleRate:sampleRate,
     })
-}; qxVm.safefunction(OfflineAudioContext);
+}; lwVm.safefunction(OfflineAudioContext);
 
 ; (function () {
     const $safe_get_attribute = ['length', 'oncomplete'];
@@ -18,27 +18,29 @@ OfflineAudioContext = function OfflineAudioContext(numberOfChannels, length, sam
 
     OfflineAudioContext.prototype = {
         get length() {
-            debugger;
             if (!OfflineAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).length;
+            let result = lwVm.memory.private_data.get(this).length;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'OfflineAudioContext', 'length', arguments, result);
+            return result;
         },
         get oncomplete() {
-            debugger;
             if (!OfflineAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).oncomplete, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).oncomplete, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'OfflineAudioContext', 'oncomplete', arguments, result);
+            return result;
         },
         set oncomplete(value) {
-            debugger;
             if (!OfflineAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).oncomplete = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'OfflineAudioContext', 'oncomplete', arguments);
+            lwVm.memory.private_data.get(this).oncomplete = value;
         },
         resume() {
-            debugger;
             if (!OfflineAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return new Promise(function () { debugger; })
+            let result = new Promise(function () { debugger; });
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'OfflineAudioContext', 'resume', arguments, result);
+            return result;
         },
         startRendering() {
-            debugger;
             if (!OfflineAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             const length = this.length;
             const sampleRate = this.sampleRate;
@@ -53,15 +55,16 @@ OfflineAudioContext = function OfflineAudioContext(numberOfChannels, length, sam
             })
         },
         suspend() {
-            debugger;
             if (!OfflineAudioContext.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return new Promise(function () { debugger; })
+            let result = new Promise(function () { debugger; });
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'OfflineAudioContext', 'suspend', arguments, result);
+            return result;
         },
     }
 
-    qxVm.rename(OfflineAudioContext.prototype, "OfflineAudioContext");
-    qxVm.safeDescriptor_addConstructor(OfflineAudioContext);
-    qxVm.safe_Objattribute(OfflineAudioContext, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(OfflineAudioContext.prototype, "OfflineAudioContext");
+    lwVm.safeDescriptor_addConstructor(OfflineAudioContext);
+    lwVm.safe_Objattribute(OfflineAudioContext, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(OfflineAudioContext.prototype, BaseAudioContext.prototype);
     Object.setPrototypeOf(OfflineAudioContext, BaseAudioContext);

qxVm_sanbox/env/BOM/Audio/OscillatorNode.js

@@ -2,8 +2,8 @@ OscillatorNode = function OscillatorNode() {
     if(new.target !== OscillatorNode){
 		throw new TypeError(`Failed to construct 'OscillatorNode': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(OscillatorNode);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(OscillatorNode);
 
 ; (function () {
     const $safe_get_attribute = ['detune', 'frequency', 'type'];
@@ -12,43 +12,47 @@ OscillatorNode = function OscillatorNode() {
 
     OscillatorNode.prototype = {
         get detune() {
-            debugger;
             if (!OscillatorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).detune;
+            let ele = lwVm.memory.private_data.get(this).detune;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 0, 153600, -153600);
-                qxVm.memory.private_data.get(this).detune = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 0, 153600, -153600);
+                lwVm.memory.private_data.get(this).detune = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'OscillatorNode', 'detune', arguments, result);
+            return result;
         },
         get frequency() {
-            debugger;
             if (!OscillatorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).detune;
+            let ele = lwVm.memory.private_data.get(this).detune;
             if (ele === undefined) {
-                ele = new AudioParam(qxVm.memory.$createObj_key, "a-rate", 440, 22050, -22050);
-                qxVm.memory.private_data.get(this).detune = ele;
+                ele = new AudioParam(lwVm.memory.$createObj_key, "a-rate", 440, 22050, -22050);
+                lwVm.memory.private_data.get(this).detune = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'OscillatorNode', 'frequency', arguments, result);
+            return result;
         },
         setPeriodicWave() {
-            debugger;
             if (!OscillatorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'OscillatorNode', 'setPeriodicWave', arguments, result);
+            return result;
         },
         get type() {
-            debugger;
             if (!OscillatorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).type, "sine");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).type, "sine");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'OscillatorNode', 'type', arguments, result);
+            return result;
         },
         set type(value) {
-            debugger;
             if (!OscillatorNode.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).type = value + "";
+            lwVm.memory.private_data.get(this).type = value + "";
         }
     }
-    qxVm.rename(OscillatorNode.prototype, "OscillatorNode");
-    qxVm.safeDescriptor_addConstructor(OscillatorNode);
-    qxVm.safe_Objattribute(OscillatorNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(OscillatorNode.prototype, "OscillatorNode");
+    lwVm.safeDescriptor_addConstructor(OscillatorNode);
+    lwVm.safe_Objattribute(OscillatorNode, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(OscillatorNode.prototype, AudioScheduledSourceNode.prototype);
     Object.setPrototypeOf(OscillatorNode, AudioScheduledSourceNode);

qxVm_sanbox/env/BOM/BarProp.js

@@ -1,8 +1,8 @@
 BarProp = function BarProp(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-}; qxVm.safefunction(BarProp);
+}; lwVm.safefunction(BarProp);
 
 ; (function () {
     const $safe_get_attribute = ['visible'];
@@ -11,19 +11,20 @@ BarProp = function BarProp(createObj_key) {
 
     BarProp.prototype = {
         get visible() {
-            debugger;
             if (!BarProp.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return true;
+            let result = true;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'BarProp', 'visible', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(BarProp.prototype, "BarProp");
-    qxVm.safeDescriptor_addConstructor(BarProp);
-    qxVm.safe_Objattribute(BarProp, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(BarProp.prototype, "BarProp");
+    lwVm.safeDescriptor_addConstructor(BarProp);
+    lwVm.safe_Objattribute(BarProp, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
-locationbar = new BarProp(qxVm.memory.$createObj_key);
-menubar = new BarProp(qxVm.memory.$createObj_key);
-personalbar = new BarProp(qxVm.memory.$createObj_key);
-scrollbars = new BarProp(qxVm.memory.$createObj_key);
-statusbar = new BarProp(qxVm.memory.$createObj_key);
-toolbar = new BarProp(qxVm.memory.$createObj_key);
+locationbar = new BarProp(lwVm.memory.$createObj_key);
+menubar = new BarProp(lwVm.memory.$createObj_key);
+personalbar = new BarProp(lwVm.memory.$createObj_key);
+scrollbars = new BarProp(lwVm.memory.$createObj_key);
+statusbar = new BarProp(lwVm.memory.$createObj_key);
+toolbar = new BarProp(lwVm.memory.$createObj_key);
 

qxVm_sanbox/env/BOM/Base64.js

@@ -1,11 +1,11 @@
 ; (function () {
-    qxVm.encrypt.base64.base64EncodeChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    qxVm.encrypt.base64.base64DecodeChars = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1];
+    lwVm.encrypt.base64.base64EncodeChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    lwVm.encrypt.base64.base64DecodeChars = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1];
 
-    const base64EncodeChars = qxVm.encrypt.base64.base64EncodeChars;
-    const base64DecodeChars = qxVm.encrypt.base64.base64DecodeChars
+    const base64EncodeChars = lwVm.encrypt.base64.base64EncodeChars;
+    const base64DecodeChars = lwVm.encrypt.base64.base64DecodeChars
 
-    qxVm.encrypt.base64.encode = function btoa(str) {
+    lwVm.encrypt.base64.encode = function btoa(str) {
         var out, i, len;
         var c1, c2, c3;
 
@@ -37,7 +37,7 @@
         return out;
     }
 
-    qxVm.encrypt.base64.decode = function atob(str) {
+    lwVm.encrypt.base64.decode = function atob(str) {
         var c1, c2, c3, c4;
         var i, len, out;
 
@@ -87,14 +87,14 @@
         return out;
     }
 
-    this.btoa = qxVm.encrypt.base64.encode;
-    this.atob = qxVm.encrypt.base64.decode;
+    this.btoa = lwVm.encrypt.base64.encode;
+    this.atob = lwVm.encrypt.base64.decode;
 
     this.btoa.prototype = undefined;
     this.atob.prototype = undefined;
 
-    qxVm.safefunction(this.btoa);
-    qxVm.safefunction(this.atob);
+    lwVm.safefunction(this.btoa);
+    lwVm.safefunction(this.atob);
 
 })();
 

qxVm_sanbox/env/BOM/CacheStorage.js

@@ -1,9 +1,9 @@
 CacheStorage = function CacheStorage(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(CacheStorage);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(CacheStorage);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,29 +12,39 @@ CacheStorage = function CacheStorage(createObj_key) {
 
     CacheStorage.prototype = {
         delete() {
-            debugger;
             if (!CacheStorage.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CacheStorage', 'delete', arguments, result);
+            return result;
         },
         has() {
-            debugger;
             if (!CacheStorage.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CacheStorage', 'has', arguments, result);
+            return result;
         },
         keys() {
-            debugger;
             if (!CacheStorage.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CacheStorage', 'keys', arguments, result);
+            return result;
         },
         match() {
-            debugger;
             if (!CacheStorage.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CacheStorage', 'match', arguments, result);
+            return result;
         },
         open() {
-            debugger;
             if (!CacheStorage.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CacheStorage', 'open', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(CacheStorage.prototype, "CacheStorage");
-    qxVm.safeDescriptor_addConstructor(CacheStorage);
-    qxVm.safe_Objattribute(CacheStorage, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(CacheStorage.prototype, "CacheStorage");
+    lwVm.safeDescriptor_addConstructor(CacheStorage);
+    lwVm.safe_Objattribute(CacheStorage, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
-caches = new CacheStorage(qxVm.memory.$createObj_key);
+caches = new CacheStorage(lwVm.memory.$createObj_key);
 

qxVm_sanbox/env/BOM/CredentialsContainer.js

@@ -1,9 +1,9 @@
 CredentialsContainer = function CredentialsContainer(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(CredentialsContainer);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(CredentialsContainer);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,24 +12,32 @@ CredentialsContainer = function CredentialsContainer(createObj_key) {
 
     CredentialsContainer.prototype = {
         create() {
-            debugger;
             if (!CredentialsContainer.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CredentialsContainer', 'create', arguments, result);
+            return result;
         },
         get() {
-            debugger;
             if (!CredentialsContainer.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CredentialsContainer', 'get', arguments, result);
+            return result;
         },
         preventSilentAccess() {
-            debugger;
             if (!CredentialsContainer.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CredentialsContainer', 'preventSilentAccess', arguments, result);
+            return result;
         },
         store() {
-            debugger;
             if (!CredentialsContainer.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CredentialsContainer', 'store', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(CredentialsContainer.prototype, "CredentialsContainer");
-    qxVm.safeDescriptor_addConstructor(CredentialsContainer);
-    qxVm.safe_Objattribute(CredentialsContainer, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(CredentialsContainer.prototype, "CredentialsContainer");
+    lwVm.safeDescriptor_addConstructor(CredentialsContainer);
+    lwVm.safe_Objattribute(CredentialsContainer, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/Crypto.js

@@ -1,9 +1,9 @@
 Crypto = function Crypto(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Crypto);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Crypto);
 // crypto = {};
 
 ; (function () {
@@ -13,24 +13,29 @@ Crypto = function Crypto(createObj_key) {
 
     Crypto.prototype = {
         getRandomValues() {
-            debugger;
             if (!Crypto.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Crypto', 'getRandomValues', arguments, result);
+            return result;
         },
         randomUUID() {
-            debugger;
             if (!Crypto.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Crypto', 'randomUUID', arguments, result);
+            return result;
         },
         get subtle() {
-            debugger;
             if (!Crypto.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).subtle, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).subtle, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Crypto', 'subtle', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(Crypto.prototype, "Crypto");
-    qxVm.safeDescriptor_addConstructor(Crypto);
-    qxVm.safe_Objattribute(Crypto, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Crypto.prototype, "Crypto");
+    lwVm.safeDescriptor_addConstructor(Crypto);
+    lwVm.safe_Objattribute(Crypto, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     // Object.setPrototypeOf(crypto, Crypto.prototype);
 })();
-crypto = new Crypto(qxVm.memory.$createObj_key)
+crypto = new Crypto(lwVm.memory.$createObj_key)
 

qxVm_sanbox/env/BOM/CustomElementRegistry.js

@@ -1,9 +1,9 @@
 CustomElementRegistry = function CustomElementRegistry(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(CustomElementRegistry);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(CustomElementRegistry);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,25 +12,33 @@ CustomElementRegistry = function CustomElementRegistry(createObj_key) {
     
     CustomElementRegistry.prototype = {
         define() {
-            debugger;
             if (!CustomElementRegistry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CustomElementRegistry', 'define', arguments, result);
+            return result;
         },
         get() {
-            debugger;
             if (!CustomElementRegistry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CustomElementRegistry', 'get', arguments, result);
+            return result;
         },
         upgrade() {
-            debugger;
             if (!CustomElementRegistry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CustomElementRegistry', 'upgrade', arguments, result);
+            return result;
         },
         whenDefined() {
-            debugger;
             if (!CustomElementRegistry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CustomElementRegistry', 'whenDefined', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(CustomElementRegistry.prototype, "CustomElementRegistry");
-    qxVm.safeDescriptor_addConstructor(CustomElementRegistry);
-    qxVm.safe_Objattribute(CustomElementRegistry, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(CustomElementRegistry.prototype, "CustomElementRegistry");
+    lwVm.safeDescriptor_addConstructor(CustomElementRegistry);
+    lwVm.safe_Objattribute(CustomElementRegistry, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
-customElements = new CustomElementRegistry(qxVm.memory.$createObj_key)
+customElements = new CustomElementRegistry(lwVm.memory.$createObj_key)
 

qxVm_sanbox/env/BOM/Database.js

@@ -2,14 +2,14 @@ openDatabase = undefined;
 
 ; (function () {
     SQLResultSetRowList = function SQLResultSetRowList(createObj_key, rows) {
-        if (createObj_key !== qxVm.memory.$createObj_key) {
+        if (createObj_key !== lwVm.memory.$createObj_key) {
             throw new TypeError("Illegal constructor");
         }
-        qxVm.memory.private_data.set(this, {
+        lwVm.memory.private_data.set(this, {
             rows: rows,
             length: rows.length
         })
-    }; qxVm.safefunction(SQLResultSetRowList);
+    }; lwVm.safefunction(SQLResultSetRowList);
 
     ; (function () {
         const $safe_get_attribute = ['length'];
@@ -17,28 +17,30 @@ openDatabase = undefined;
         const $safe_func_attribute = ['item'];
         SQLResultSetRowList.prototype = {
             item() {
-                debugger;
                 if (!SQLResultSetRowList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return qxVm.memory.private_data.get(this).rows
+            let result = lwVm.memory.private_data.get(this).rows;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'SQLResultSetRowList', 'item', arguments, result);
+            return result;
             },
             get length() {
-                debugger;
                 if (!SQLResultSetRowList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return qxVm.abs(qxVm.memory.private_data.get(this).length, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).length, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'SQLResultSetRowList', 'length', arguments, result);
+            return result;
             },
         }
-        qxVm.rename(SQLResultSetRowList.prototype, "SQLResultSetRowList");
-        qxVm.safeDescriptor_addConstructor(SQLResultSetRowList);
-        qxVm.safe_Objattribute(SQLResultSetRowList, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+        lwVm.rename(SQLResultSetRowList.prototype, "SQLResultSetRowList");
+        lwVm.safeDescriptor_addConstructor(SQLResultSetRowList);
+        lwVm.safe_Objattribute(SQLResultSetRowList, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
     })();
 
     // -----------------------------------------------------------SQLResultSet----------------------------------------------------------------
     SQLResultSet = function SQLResultSet(createObj_key) {
-        if (createObj_key !== qxVm.memory.$createObj_key) {
+        if (createObj_key !== lwVm.memory.$createObj_key) {
             throw new TypeError("Illegal constructor");
         }
-        qxVm.memory.private_data.set(this, {})
-    }; qxVm.safefunction(SQLResultSet);
+        lwVm.memory.private_data.set(this, {})
+    }; lwVm.safefunction(SQLResultSet);
 
     ; (function () {
         const $safe_get_attribute = ['insertId', 'rows', 'rowsAffected'];
@@ -47,36 +49,39 @@ openDatabase = undefined;
 
         SQLResultSet.prototype = {
             get insertId() {
-                debugger;
                 if (!SQLResultSet.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return qxVm.abs(qxVm.memory.private_data.get(this).insertId, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).insertId, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'SQLResultSet', 'insertId', arguments, result);
+            return result;
             },
             get rows() {
-                debugger;
                 if (!SQLResultSet.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
 
-                // let sql_result_row_list = new SQLResultSetRowList(qxVm.memory.$createObj_key, {"value": window.sql_values});
-                return { "value": "0" }
+                // let sql_result_row_list = new SQLResultSetRowList(lwVm.memory.$createObj_key, {"value": window.sql_values});
+            let result = { "value": "0" };
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'SQLResultSet', 'rows', arguments, result);
+            return result;
             },
             get rowsAffected() {
-                debugger;
                 if (!SQLResultSet.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return qxVm.abs(qxVm.memory.private_data.get(this).rowsAffected, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).rowsAffected, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'SQLResultSet', 'rowsAffected', arguments, result);
+            return result;
             },
         }
-        qxVm.rename(SQLResultSet.prototype, "SQLResultSet");
-        qxVm.safeDescriptor_addConstructor(SQLResultSet);
-        qxVm.safe_Objattribute(SQLResultSet, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+        lwVm.rename(SQLResultSet.prototype, "SQLResultSet");
+        lwVm.safeDescriptor_addConstructor(SQLResultSet);
+        lwVm.safe_Objattribute(SQLResultSet, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     })();
 
     // -----------------------------------------------------------SQLTransaction----------------------------------------------------------------
     SQLTransaction = function SQLTransaction(createObj_key) {
-        if (createObj_key !== qxVm.memory.$createObj_key) {
+        if (createObj_key !== lwVm.memory.$createObj_key) {
             throw new TypeError("Illegal constructor");
         }
-        qxVm.memory.private_data.set(this, {})
-    }; qxVm.safefunction(SQLTransaction);
+        lwVm.memory.private_data.set(this, {})
+    }; lwVm.safefunction(SQLTransaction);
 
     ; (function () {
         const $safe_get_attribute = [];
@@ -85,20 +90,23 @@ openDatabase = undefined;
 
         SQLTransaction.prototype = {
             executeSql(sql, arg, succrssCallback, errorCallback) {
-                debugger;
                 if (!SQLTransaction.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
                 try {
 
                 } catch (error) {
-                    return errorCallback(this, sql_result);
+            let result = errorCallback(this, sql_result);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'SQLTransaction', '} catch ', arguments, result);
+            return result;
                 }
-                let sql_result = new SQLResultSet(qxVm.memory.$createObj_key);
-                return succrssCallback(this, sql_result)
+                let sql_result = new SQLResultSet(lwVm.memory.$createObj_key);
+            let result = succrssCallback(this, sql_result);
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'SQLTransaction', '} catch ', arguments, result);
+            return result;
             }
         }
-        qxVm.rename(SQLTransaction.prototype, "SQLTransaction");
-        qxVm.safeDescriptor_addConstructor(SQLTransaction);
-        qxVm.safe_Objattribute(SQLTransaction, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+        lwVm.rename(SQLTransaction.prototype, "SQLTransaction");
+        lwVm.safeDescriptor_addConstructor(SQLTransaction);
+        lwVm.safe_Objattribute(SQLTransaction, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
     })();
 
 
@@ -108,13 +116,13 @@ openDatabase = undefined;
 
 
     Database = function Database(createObj_key, version) {
-        if (createObj_key !== qxVm.memory.$createObj_key) {
+        if (createObj_key !== lwVm.memory.$createObj_key) {
             throw new TypeError("Illegal constructor");
         }
-        qxVm.memory.private_data.set(this, {
+        lwVm.memory.private_data.set(this, {
             version: version
         })
-    }; qxVm.safefunction(Database);
+    }; lwVm.safefunction(Database);
 
     ; (function () {
         const $safe_get_attribute = ['version'];
@@ -122,44 +130,46 @@ openDatabase = undefined;
         const $safe_func_attribute = ['changeVersion', 'readTransaction', 'transaction'];
         Database.prototype = {
             changeVersion(old_version, new_version) {
-                debugger;
                 if (!Database.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                let this_info = qxVm.memory.private_data.get(this);
+                let this_info = lwVm.memory.private_data.get(this);
                 if (old_version == this_info.version) {
                     this_info.version = new_version;
                 }
             },
             readTransaction(func) {
-                debugger;
                 if (!Database.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Database', 'readTransaction', arguments, result);
+            return result;
             },
             transaction(func) {
-                debugger;
                 if (!Database.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                let sql_tran = new SQLTransaction(qxVm.memory.$createObj_key);
-                return func(sql_tran);
+                let sql_tran = new SQLTransaction(lwVm.memory.$createObj_key);
+            let result = func(sql_tran);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Database', 'transaction', arguments, result);
+            return result;
             },
             get version() {
-                debugger;
                 if (!Database.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return qxVm.abs(qxVm.memory.private_data.get(this).version, "");
+                return lwVm.abs(lwVm.memory.private_data.get(this).version, "");
             }
         }
-        qxVm.rename(Database.prototype, "Database");
-        qxVm.safeDescriptor_addConstructor(Database);
-        qxVm.safe_Objattribute(Database, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+        lwVm.rename(Database.prototype, "Database");
+        lwVm.safeDescriptor_addConstructor(Database);
+        lwVm.safe_Objattribute(Database, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     })();
 
 
     openDatabase = function openDatabase(name, version, desc, size, callback) {
-        debugger;
 
         let db = buffer_memory[name];
         if (db) {
-            return db;
+            let result = db;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Database', 'if ', arguments, result);
+            return result;
         }
-        db = new Database(qxVm.memory.$createObj_key, version);
+        db = new Database(lwVm.memory.$createObj_key, version);
         buffer_memory[name] = db;
 
         return db;

qxVm_sanbox/env/BOM/External.js

@@ -1,9 +1,9 @@
 External = function External(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(External);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(External);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,17 +12,21 @@ External = function External(createObj_key) {
 
     External.prototype = {
         AddSearchProvider() {
-            debugger;
             if (!External.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'External', 'AddSearchProvider', arguments, result);
+            return result;
         },
         IsSearchProviderInstalled() {
-            debugger;
             if (!External.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'External', 'IsSearchProviderInstalled', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(External.prototype, "External");
-    qxVm.safeDescriptor_addConstructor(External);
-    qxVm.safe_Objattribute(External, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(External.prototype, "External");
+    lwVm.safeDescriptor_addConstructor(External);
+    lwVm.safe_Objattribute(External, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
-external = new External(qxVm.memory.$createObj_key);
+external = new External(lwVm.memory.$createObj_key);
 

qxVm_sanbox/env/BOM/Geolocation.js

@@ -1,9 +1,9 @@
 Geolocation = function Geolocation(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Geolocation);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Geolocation);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,20 +12,26 @@ Geolocation = function Geolocation(createObj_key) {
     
     Geolocation.prototype = {
         clearWatch() {
-            debugger;
             if (!Geolocation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Geolocation', 'clearWatch', arguments, result);
+            return result;
         },
         getCurrentPosition() {
-            debugger;
             if (!Geolocation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Geolocation', 'getCurrentPosition', arguments, result);
+            return result;
         },
         watchPosition() {
-            debugger;
             if (!Geolocation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Geolocation', 'watchPosition', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(Geolocation.prototype, "Geolocation");
-    qxVm.safeDescriptor_addConstructor(Geolocation);
-    qxVm.safe_Objattribute(Geolocation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Geolocation.prototype, "Geolocation");
+    lwVm.safeDescriptor_addConstructor(Geolocation);
+    lwVm.safe_Objattribute(Geolocation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/Headers.js

@@ -3,8 +3,8 @@ Headers = function Headers() {//构造函数
 		throw new TypeError(`Failed to construct 'Headers': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
 
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Headers);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Headers);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -13,46 +13,64 @@ Headers = function Headers() {//构造函数
     
     Headers.prototype = {
         append() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'append', arguments, result);
+            return result;
         },
         delete() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'delete', arguments, result);
+            return result;
         },
         entries() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'entries', arguments, result);
+            return result;
         },
         forEach() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'forEach', arguments, result);
+            return result;
         },
         get() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'get', arguments, result);
+            return result;
         },
         has() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'has', arguments, result);
+            return result;
         },
         keys() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'keys', arguments, result);
+            return result;
         },
         set() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'set', arguments, result);
+            return result;
         },
         values() {
-            debugger;
             if (!Headers.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Headers', 'values', arguments, result);
+            return result;
         }
     }
 
-    qxVm.rename(Headers.prototype, "Headers");
-    qxVm.safeDescriptor_addConstructor(Headers);
-    qxVm.safe_Objattribute(Headers, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Headers.prototype, "Headers");
+    lwVm.safeDescriptor_addConstructor(Headers);
+    lwVm.safe_Objattribute(Headers, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/History.js

@@ -1,6 +1,6 @@
 History = function History() {
     throw new TypeError("Illegal constructor");
-}; qxVm.safefunction(History);
+}; lwVm.safefunction(History);
 history = {};
 
 ; (function () {
@@ -10,48 +10,60 @@ history = {};
 
     History.prototype = {
         back() {
-            debugger;
             if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'History', 'back', arguments, result);
+            return result;
         },
         forward() {
-            debugger;
             if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'History', 'forward', arguments, result);
+            return result;
         },
         go() {
-            debugger;
             if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'History', 'go', arguments, result);
+            return result;
         },
         get length() {
             if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return Object.keys(this).length;
+            let result = Object.keys(this).length;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'History', 'length', arguments, result);
+            return result;
         },
         pushState() {
-            debugger;
             if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'History', 'pushState', arguments, result);
+            return result;
         },
         replaceState() {
-            debugger;
             if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'History', 'replaceState', arguments, result);
+            return result;
         },
         get scrollRestoration() {
-            debugger;
             if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return "auto";
+            let result = "auto";;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'History', 'scrollRestoration', arguments, result);
+            return result;
         },
         set scrollRestoration(value) {
-            debugger;
-            if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'History', 'scrollRestoration', arguments);
+            lwVm.memory.private_data.get(this).scrollRestoration = value;
         },
         get state() {
-            debugger;
             if (!History.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             return {
                 idx: 0
             }
         }
-    }; qxVm.rename(History.prototype, 'History')
-    qxVm.safeDescriptor_addConstructor(History);
-    qxVm.safe_Objattribute(History, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    }; lwVm.rename(History.prototype, 'History')
+    lwVm.safeDescriptor_addConstructor(History);
+    lwVm.safe_Objattribute(History, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(history, History.prototype);
 

qxVm_sanbox/env/BOM/HttpRequest/Request.js

@@ -3,8 +3,8 @@ Request = function Request() {//构造函数
 		throw new TypeError(`Failed to construct 'Request': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
 
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Request);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Request);
 
 ; (function () {
     const $safe_get_attribute = [
@@ -16,109 +16,134 @@ Request = function Request() {//构造函数
 
     Request.prototype = {
         arrayBuffer() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'arrayBuffer', arguments, result);
+            return result;
         },
         blob() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'blob', arguments, result);
+            return result;
         },
         get bodyUsed() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).bodyUsed, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).bodyUsed, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'bodyUsed', arguments, result);
+            return result;
         },
         get cache() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).cache, "default");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).cache, "default");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'cache', arguments, result);
+            return result;
         },
         clone() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'clone', arguments, result);
+            return result;
         },
         get credentials() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).credentials, "same-origin");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).credentials, "same-origin");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'credentials', arguments, result);
+            return result;
         },
         get destination() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).destination, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).destination, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'destination', arguments, result);
+            return result;
         },
         formData() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'formData', arguments, result);
+            return result;
         },
         get headers() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).headers, new class Headers { });
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).headers, new class Headers { });;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'headers', arguments, result);
+            return result;
         },
         get integrity() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).integrity, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).integrity, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'integrity', arguments, result);
+            return result;
         },
         get isHistoryNavigation() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).isHistoryNavigation, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).isHistoryNavigation, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'isHistoryNavigation', arguments, result);
+            return result;
         },
         json() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'json', arguments, result);
+            return result;
         },
         get keepalive() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).keepalive, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).keepalive, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'keepalive', arguments, result);
+            return result;
         },
         get method() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).method, "GET");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).method, "GET");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'method', arguments, result);
+            return result;
         },
         get mode() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).mode, "cors");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).mode, "cors");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'mode', arguments, result);
+            return result;
         },
         get redirect() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).redirect, "follow");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).redirect, "follow");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'redirect', arguments, result);
+            return result;
         },
         get referrer() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).referrer, "about:client");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).referrer, "about:client");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'referrer', arguments, result);
+            return result;
         },
         get referrerPolicy() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).referrerPolicy, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).referrerPolicy, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'referrerPolicy', arguments, result);
+            return result;
         },
         get signal() { // 这个有问题
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).signal, new class AbortSignal { aborted = false; onabort = null });
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).signal, new class AbortSignal { aborted = false; onabort = null });;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'referrerPolicy', arguments, result);
+            return result;
         },
         text() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'text', arguments, result);
+            return result;
         },
         get url() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).url, location.href);
+            return lwVm.abs(lwVm.memory.private_data.get(this).url, location.href);
         }
     };
 
-    qxVm.rename(Request.prototype, "Request");
-    qxVm.safeDescriptor_addConstructor(Request);
-    qxVm.safe_Objattribute(Request, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Request.prototype, "Request");
+    lwVm.safeDescriptor_addConstructor(Request);
+    lwVm.safe_Objattribute(Request, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/HttpRequest/XMLHttpRequest.js

@@ -3,8 +3,8 @@ XMLHttpRequest = function XMLHttpRequest() {//构造函数
 		throw new TypeError(`Failed to construct 'XMLHttpRequest': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
 
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(XMLHttpRequest);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(XMLHttpRequest);
 ; (function () {
     const $attributes = {
         DONE: 4,
@@ -22,118 +22,139 @@ XMLHttpRequest = function XMLHttpRequest() {//构造函数
     
     XMLHttpRequest.prototype = {
         abort() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'abort', arguments, result);
+            return result;
         },
         getAllResponseHeaders() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'getAllResponseHeaders', arguments, result);
+            return result;
         },
         getResponseHeader() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'getResponseHeader', arguments, result);
+            return result;
         },
         get onreadystatechange() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onreadystatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onreadystatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'onreadystatechange', arguments, result);
+            return result;
         },
         set onreadystatechange(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onreadystatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequest', 'onreadystatechange', arguments);
+            lwVm.memory.private_data.get(this).onreadystatechange = value + "";
         },
         open() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'open', arguments, result);
+            return result;
         },
         overrideMimeType() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'overrideMimeType', arguments, result);
+            return result;
         },
         get readyState() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).readyState, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).readyState, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'readyState', arguments, result);
+            return result;
         },
         get response() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).response, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).response, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'response', arguments, result);
+            return result;
         },
         set response(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).response = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequest', 'response', arguments);
+            lwVm.memory.private_data.get(this).response = value + "";
         },
         get responseText() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).responseText, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).responseText, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'responseText', arguments, result);
+            return result;
         },
         get responseType() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).responseType, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).responseType, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'responseType', arguments, result);
+            return result;
         },
         set responseType(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).responseType = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequest', 'responseType', arguments);
+            lwVm.memory.private_data.get(this).responseType = value + "";
         },
         get responseURL() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).responseURL, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).responseURL, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'responseURL', arguments, result);
+            return result;
         },
         get responseXML() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).responseXML, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).responseXML, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'responseXML', arguments, result);
+            return result;
         },
         send(body) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return body
+            let result = body;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'send', arguments, result);
+            return result;
         },
         setRequestHeader() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'setRequestHeader', arguments, result);
+            return result;
         },
         get status() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).status, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).status, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'status', arguments, result);
+            return result;
         },
         get statusText() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).statusText, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).statusText, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'statusText', arguments, result);
+            return result;
         },
         get timeout() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).timeout, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).timeout, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'timeout', arguments, result);
+            return result;
         },
         set timeout(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).timeout = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequest', 'timeout', arguments);
+            lwVm.memory.private_data.get(this).timeout = value + "";
         },
         get upload() {  //  XMLHttpRequestUpload
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).upload, "");
         },
         get withCredentials() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).withCredentials, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).withCredentials, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'withCredentials', arguments, result);
+            return result;
         },
         set withCredentials(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).withCredentials = value;
+            lwVm.memory.private_data.get(this).withCredentials = value;
         }
     }
 
@@ -145,9 +166,9 @@ XMLHttpRequest = function XMLHttpRequest() {//构造函数
         }
     };
 
-    qxVm.rename(XMLHttpRequest.prototype, "XMLHttpRequest");
-    qxVm.safeDescriptor_addConstructor(XMLHttpRequest);
-    qxVm.safe_Objattribute(XMLHttpRequest, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(XMLHttpRequest.prototype, "XMLHttpRequest");
+    lwVm.safeDescriptor_addConstructor(XMLHttpRequest);
+    lwVm.safe_Objattribute(XMLHttpRequest, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(XMLHttpRequest.prototype, XMLHttpRequestEventTarget.prototype);
     Object.setPrototypeOf(XMLHttpRequest, XMLHttpRequestEventTarget);

qxVm_sanbox/env/BOM/HttpRequest/XMLHttpRequestEventTarget.js

@@ -1,9 +1,9 @@
 XMLHttpRequestEventTarget = function XMLHttpRequestEventTarget(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(XMLHttpRequestEventTarget);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(XMLHttpRequestEventTarget);
 
 ; (function () {
     const $safe_get_attribute = ['onabort', 'onerror', 'onload', 'onloadend', 'onloadstart', 'onprogress', 'ontimeout'];
@@ -12,80 +12,86 @@ XMLHttpRequestEventTarget = function XMLHttpRequestEventTarget(createObj_key) {/
 
     XMLHttpRequestEventTarget.prototype = {
         get onabort() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onabort, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onabort, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onabort', arguments, result);
+            return result;
         },
         set onabort(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onabort = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onabort', arguments);
+            lwVm.memory.private_data.get(this).onabort = value + "";
         },
         get onerror() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onerror, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onerror, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onerror', arguments, result);
+            return result;
         },
         set onerror(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onerror = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onerror', arguments);
+            lwVm.memory.private_data.get(this).onerror = value + "";
         },
         get onload() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onload, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onload, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onload', arguments, result);
+            return result;
         },
         set onload(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onload = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onload', arguments);
+            lwVm.memory.private_data.get(this).onload = value + "";
         },
         get onloadend() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onloadend, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onloadend, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onloadend', arguments, result);
+            return result;
         },
         set onloadend(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onloadend = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onloadend', arguments);
+            lwVm.memory.private_data.get(this).onloadend = value + "";
         },
         get onloadstart() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onloadstart, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onloadstart, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onloadstart', arguments, result);
+            return result;
         },
         set onloadstart(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onloadstart = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onloadstart', arguments);
+            lwVm.memory.private_data.get(this).onloadstart = value + "";
         },
         get onprogress() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onprogress, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onprogress, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onprogress', arguments, result);
+            return result;
         },
         set onprogress(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onprogress = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onprogress', arguments);
+            lwVm.memory.private_data.get(this).onprogress = value + "";
         },
         get ontimeout() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ontimeout, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ontimeout, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'ontimeout', arguments, result);
+            return result;
         },
         set ontimeout(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).ontimeout = value + "";
+            lwVm.memory.private_data.get(this).ontimeout = value + "";
         }
     }
 
-    qxVm.rename(XMLHttpRequestEventTarget.prototype, "XMLHttpRequestEventTarget");
-    qxVm.safeDescriptor_addConstructor(XMLHttpRequestEventTarget);
-    qxVm.safe_Objattribute(XMLHttpRequestEventTarget, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(XMLHttpRequestEventTarget.prototype, "XMLHttpRequestEventTarget");
+    lwVm.safeDescriptor_addConstructor(XMLHttpRequestEventTarget);
+    lwVm.safe_Objattribute(XMLHttpRequestEventTarget, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(XMLHttpRequestEventTarget.prototype, EventTarget.prototype);
     Object.setPrototypeOf(XMLHttpRequestEventTarget, EventTarget);

qxVm_sanbox/env/BOM/IDB/IDBFactory.js

@@ -1,12 +1,12 @@
 IDBFactory = function IDBFactory(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {
+    lwVm.memory.private_data.set(this, {
         name: undefined,
         version: undefined
     })
-}; qxVm.safefunction(IDBFactory);
+}; lwVm.safefunction(IDBFactory);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -15,35 +15,41 @@ IDBFactory = function IDBFactory(createObj_key) {//构造函数
 
     IDBFactory.prototype = {
         cmp(first, second) {
-            debugger;
             if (!IDBFactory.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'IDBFactory', 'cmp', arguments, result);
+            return result;
         },
         databases() {
-            debugger;
             if (!IDBFactory.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return new Promise(function () { debugger })
+            let result = new Promise(function () { debugger });
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'IDBFactory', 'databases', arguments, result);
+            return result;
         },
         deleteDatabase(name, options) {
-            debugger;
             if (!IDBFactory.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'IDBFactory', 'deleteDatabase', arguments, result);
+            return result;
         },
         open(name, version) {
-            debugger;
             if (!IDBFactory.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (!name){ throw new TypeError("Failed to execute 'open' on 'IDBFactory': 1 argument required, but only 0 present.") };
 
-            qxVm.memory.private_data.set(this, {
+            lwVm.memory.private_data.set(this, {
                 name: name,
                 version: version || 1
             })
-            return new IDBOpenDBRequest(qxVm.memory.$createObj_key, name, version)
+            let result = new IDBOpenDBRequest(lwVm.memory.$createObj_key, name, version);
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'IDBFactory', 'open', arguments, result);
+            return result;
         }
     }
 
-    qxVm.rename(IDBFactory.prototype, "IDBFactory");
-    qxVm.safeDescriptor_addConstructor(IDBFactory);
-    qxVm.safe_Objattribute(IDBFactory, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(IDBFactory.prototype, "IDBFactory");
+    lwVm.safeDescriptor_addConstructor(IDBFactory);
+    lwVm.safe_Objattribute(IDBFactory, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
-indexedDB = new IDBFactory(qxVm.memory.$createObj_key);
+indexedDB = new IDBFactory(lwVm.memory.$createObj_key);
 

qxVm_sanbox/env/BOM/IDB/IDBOpenDBRequest.js

@@ -1,12 +1,12 @@
 IDBOpenDBRequest = function IDBOpenDBRequest(createObj_key, name, version) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {
+    lwVm.memory.private_data.set(this, {
         name:name,
         version:version || 0
     })
-}; qxVm.safefunction(IDBOpenDBRequest);
+}; lwVm.safefunction(IDBOpenDBRequest);
 
 ; (function () {
     const $safe_get_attribute = ['onblocked', 'onupgradeneeded'];
@@ -15,29 +15,31 @@ IDBOpenDBRequest = function IDBOpenDBRequest(createObj_key, name, version) {
 
     IDBOpenDBRequest.prototype = {
         get onblocked() {
-            debugger;
             if (!IDBOpenDBRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onblocked, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onblocked, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'IDBOpenDBRequest', 'onblocked', arguments, result);
+            return result;
         },
         set onblocked(value) {
-            debugger;
             if (!IDBOpenDBRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onblocked = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'IDBOpenDBRequest', 'onblocked', arguments);
+            lwVm.memory.private_data.get(this).onblocked = value + "";
         },
         get onupgradeneeded() {
-            debugger;
             if (!IDBOpenDBRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onupgradeneeded, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onupgradeneeded, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'IDBOpenDBRequest', 'onupgradeneeded', arguments, result);
+            return result;
         },
         set onupgradeneeded(value) {
-            debugger;
             if (!IDBOpenDBRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onupgradeneeded = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'IDBOpenDBRequest', 'onupgradeneeded', arguments);
+            lwVm.memory.private_data.get(this).onupgradeneeded = value;
         },
     }
-    qxVm.rename(IDBOpenDBRequest.prototype, "IDBOpenDBRequest");
-    qxVm.safeDescriptor_addConstructor(IDBOpenDBRequest);
-    qxVm.safe_Objattribute(IDBOpenDBRequest, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(IDBOpenDBRequest.prototype, "IDBOpenDBRequest");
+    lwVm.safeDescriptor_addConstructor(IDBOpenDBRequest);
+    lwVm.safe_Objattribute(IDBOpenDBRequest, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
     
     Object.setPrototypeOf(IDBOpenDBRequest.prototype, IDBRequest.prototype);
     Object.setPrototypeOf(IDBOpenDBRequest, IDBRequest);

qxVm_sanbox/env/BOM/IDBFactory.js

@@ -1,9 +1,9 @@
 IDBFactory = function IDBFactory(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(IDBFactory);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(IDBFactory);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,28 +12,35 @@ IDBFactory = function IDBFactory(createObj_key) {//构造函数
 
     IDBFactory.prototype = {
         cmp(first, second) {
-            debugger;
             if (!IDBFactory.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'IDBFactory', 'cmp', arguments, result);
+            return result;
         },
         databases() {
-            debugger;
             if (!IDBFactory.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return new Promise(function () { debugger })
+            let result = new Promise(function () { debugger });
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'IDBFactory', 'databases', arguments, result);
+            return result;
         },
         deleteDatabase(name, options) {
-            debugger;
             if (!IDBFactory.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'IDBFactory', 'deleteDatabase', arguments, result);
+            return result;
         },
         open(name, version) {
-            debugger;
             if (!IDBFactory.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'IDBFactory', 'open', arguments, result);
+            return result;
         }
     }
 
-    qxVm.rename(IDBFactory.prototype, "IDBFactory");
-    qxVm.safeDescriptor_addConstructor(IDBFactory);
-    qxVm.safe_Objattribute(IDBFactory, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(IDBFactory.prototype, "IDBFactory");
+    lwVm.safeDescriptor_addConstructor(IDBFactory);
+    lwVm.safe_Objattribute(IDBFactory, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
-indexedDB = new IDBFactory(qxVm.memory.$createObj_key);
+indexedDB = new IDBFactory(lwVm.memory.$createObj_key);
 

qxVm_sanbox/env/BOM/Ink.js

@@ -1,9 +1,9 @@
 Ink = function Ink(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Ink);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Ink);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,13 +12,15 @@ Ink = function Ink(createObj_key) {
     
     Ink.prototype = {
         requestPresenter() {
-            debugger;
             if (!Ink.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Ink', 'requestPresenter', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(Ink.prototype, "Ink");
-    qxVm.safeDescriptor_addConstructor(Ink);
-    qxVm.safe_Objattribute(Ink, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Ink.prototype, "Ink");
+    lwVm.safeDescriptor_addConstructor(Ink);
+    lwVm.safe_Objattribute(Ink, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/Keyboard.js

@@ -1,9 +1,9 @@
 Keyboard = function Keyboard(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Keyboard);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Keyboard);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,21 +12,27 @@ Keyboard = function Keyboard(createObj_key) {
 
     Keyboard.prototype = {
         getLayoutMap() {
-            debugger;
             if (!Keyboard.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Keyboard', 'getLayoutMap', arguments, result);
+            return result;
         },
         lock() {
-            debugger;
             if (!Keyboard.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Keyboard', 'lock', arguments, result);
+            return result;
         },
         unlock() {
-            debugger;
             if (!Keyboard.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Keyboard', 'unlock', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(Keyboard.prototype, "Keyboard");
-    qxVm.safeDescriptor_addConstructor(Keyboard);
-    qxVm.safe_Objattribute(Keyboard, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Keyboard.prototype, "Keyboard");
+    lwVm.safeDescriptor_addConstructor(Keyboard);
+    lwVm.safe_Objattribute(Keyboard, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/Location.js

@@ -1,12 +1,12 @@
 Location = function Location() {
     throw new TypeError("TypeError", "Illegal constructor")
-}; qxVm.safefunction(Location);
+}; lwVm.safefunction(Location);
 location = {};
 
 ; (function () {
     Location.prototype = {};
-    qxVm.rename(Location.prototype, "Location");
-    qxVm.safeDescriptor_addConstructor(Location);
+    lwVm.rename(Location.prototype, "Location");
+    lwVm.safeDescriptor_addConstructor(Location);
 
 
     const $safe_get_attribute = ['hash', 'host', 'hostname', 'href', 'origin', 'pathname', 'port', 'protocol', 'search'];
@@ -26,37 +26,52 @@ location = {};
 
     location = {
         ancestorOrigins() {
-            debugger;
-            return new class DOMStringList { }
+            let result = new class DOMStringList { };
+            if (lwVm.config.log_print === true) lwVm.logAdd('Func', 'Location', 'ancestorOrigins', arguments, result);
+            return result;
         },
         assign() {
-            debugger;
+            let result = undefined;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Func', 'Location', 'assign', arguments, result);
+            return result;
         },
         get hash() {
-            return $attribute_map.hash
+            let result = $attribute_map.hash;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'hash', arguments, result);
+            return result
         },
         set hash(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'hash', arguments);
             $attribute_map.hash = value
         },
 
         get host() {
-            return $attribute_map.host
+            let result = $attribute_map.host
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'host', arguments, result);
+            return result
         },
         set host(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'host', arguments);
             $attribute_map.host = value
         },
 
         get hostname() {
-            return $attribute_map.hostname
+            let result = $attribute_map.hostname;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'hostname', arguments, result);
+            return result
         },
         set hostname(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'hostname', arguments);
             $attribute_map.hostname = value
         },
 
         get href() {
-            return $attribute_map.href
+            let result = $attribute_map.href
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'href', arguments, result);
+            return result
         },
         set href(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'href', arguments);
             let a = value.match(/([^:]+:)\/\/([^/:?#]+):?(\d+)?([^?#]*)?(\?[^#]*)?(#.*)?/);
             location.protocol = a[1] ? a[1] : "";
             location.host = a[2] ? a[2] : "";
@@ -70,46 +85,66 @@ location = {};
         },
 
         get origin() {
-            return $attribute_map.origin
+            let result = $attribute_map.origin;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'origin', arguments, result);
+            return result
         },
         set origin(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'origin', arguments);
             $attribute_map.origin = value
         },
 
         get pathname() {
-            return $attribute_map.pathname
+            let result = $attribute_map.pathname
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'pathname', arguments, result);
+            return result
         },
         set pathname(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'pathname', arguments);
             $attribute_map.pathname = value
         },
 
         get port() {
-            return $attribute_map.port
+            let result =  $attribute_map.port;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'port', arguments, result);
+            return result
         },
         set port(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'port', arguments);
             $attribute_map.port = value
         },
-
         get protocol() {
-            return $attribute_map.protocol
+            let result = $attribute_map.protocol;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'protocol', arguments, result);
+            return result;
         },
         set protocol(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'protocol', arguments);
             $attribute_map.protocol = value
         },
         reload() {
-            debugger;
+            let result = undefined;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Func', 'Location', 'reload', arguments, result);
+            return result;
         },
         replace() {
-            debugger;
+            let result = undefined;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Func', 'Location', 'replace', arguments, result);
+            return result;
         },
         get search() {
-            return $attribute_map.search
+            let result = $attribute_map.search;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Get', 'Location', 'search', arguments, result);
+            return result
         },
         set search(value) {
+            if (lwVm.config.log_print === true) lwVm.logAdd('Set', 'Location', 'search', arguments);
             $attribute_map.search = value
         },
         toString() {
-            return location.href
+            let result = location.href;
+            if (lwVm.config.log_print === true) lwVm.logAdd('Func', 'Location', 'toString', arguments, result);
+            return result
         }
     };
     // 添加两个特殊的属性
@@ -121,8 +156,8 @@ location = {};
             configurable: false,
             enumerable: true
         });
-        qxVm.safefunction(Object.getOwnPropertyDescriptor(location, key)['get']);
-        qxVm.safefunction(Object.getOwnPropertyDescriptor(location, key)['set']);
+        lwVm.safefunction(Object.getOwnPropertyDescriptor(location, key)['get']);
+        lwVm.safefunction(Object.getOwnPropertyDescriptor(location, key)['set']);
     };
 
     for (let key of $safe_func_attribute) {
@@ -132,11 +167,11 @@ location = {};
             enumerable: true,
             writable: false
         });
-        qxVm.safefunction(Object.getOwnPropertyDescriptor(location, key)['value'])
+        lwVm.safefunction(Object.getOwnPropertyDescriptor(location, key)['value'])
     }
     Object.setPrototypeOf(location, Location.prototype);
 
     // 初始化用户配置
-    location.href = qxVm.default_envs['location']['href'];
+    location.href = lwVm.default_envs['location']['href'];
 })()
 

qxVm_sanbox/env/BOM/LockManager.js

@@ -1,9 +1,9 @@
 LockManager = function LockManager(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(LockManager);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(LockManager);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,17 +12,21 @@ LockManager = function LockManager(createObj_key) {
 
     LockManager.prototype = {
         query() {
-            debugger;
             if (!LockManager.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'LockManager', 'query', arguments, result);
+            return result;
         },
         request() {
-            debugger;
             if (!LockManager.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'LockManager', 'request', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(LockManager.prototype, "LockManager");
-    qxVm.safeDescriptor_addConstructor(LockManager);
-    qxVm.safe_Objattribute(LockManager, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(LockManager.prototype, "LockManager");
+    lwVm.safeDescriptor_addConstructor(LockManager);
+    lwVm.safe_Objattribute(LockManager, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/MediaCapabilities.js

@@ -1,9 +1,9 @@
 MediaCapabilities = function MediaCapabilities(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(MediaCapabilities);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(MediaCapabilities);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,12 +12,14 @@ MediaCapabilities = function MediaCapabilities(createObj_key) {
     
     MediaCapabilities.prototype = {
         decodingInfo() {
-            debugger;
             if (!MediaCapabilities.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'MediaCapabilities', 'decodingInfo', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(MediaCapabilities.prototype, "MediaCapabilities");
-    qxVm.safeDescriptor_addConstructor(MediaCapabilities);
-    qxVm.safe_Objattribute(MediaCapabilities, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(MediaCapabilities.prototype, "MediaCapabilities");
+    lwVm.safeDescriptor_addConstructor(MediaCapabilities);
+    lwVm.safe_Objattribute(MediaCapabilities, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/MediaSession.js

@@ -1,9 +1,9 @@
 MediaSession = function MediaSession(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(MediaSession);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(MediaSession);
 
 ; (function () {
     const $safe_get_attribute = ['metadata', 'playbackState'];
@@ -12,44 +12,54 @@ MediaSession = function MediaSession(createObj_key) {
 
     MediaSession.prototype = {
         get metadata() {
-            debugger;
             if (!MediaSession.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).metadata, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).metadata, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MediaSession', 'metadata', arguments, result);
+            return result;
         },
         set metadata(value) {
-            debugger;
             if (!MediaSession.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).metadata = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'MediaSession', 'metadata', arguments);
+            lwVm.memory.private_data.get(this).metadata = value + "";
         },
         get playbackState() {
-            debugger;
             if (!MediaSession.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).playbackState, "none");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).playbackState, "none");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MediaSession', 'playbackState', arguments, result);
+            return result;
         },
         set playbackState(value) {
-            debugger;
             if (!MediaSession.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).playbackState = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'MediaSession', 'playbackState', arguments);
+            lwVm.memory.private_data.get(this).playbackState = value + "";
         },
         setActionHandler() {
-            debugger;
             if (!MediaSession.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'MediaSession', 'setActionHandler', arguments, result);
+            return result;
         },
         setCameraActive() {
-            debugger;
             if (!MediaSession.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'MediaSession', 'setCameraActive', arguments, result);
+            return result;
         },
         setMicrophoneActive() {
-            debugger;
             if (!MediaSession.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'MediaSession', 'setMicrophoneActive', arguments, result);
+            return result;
         },
         setPositionState() {
-            debugger;
             if (!MediaSession.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'MediaSession', 'setPositionState', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(MediaSession.prototype, "MediaSession");
-    qxVm.safeDescriptor_addConstructor(MediaSession);
-    qxVm.safe_Objattribute(MediaSession, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(MediaSession.prototype, "MediaSession");
+    lwVm.safeDescriptor_addConstructor(MediaSession);
+    lwVm.safe_Objattribute(MediaSession, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/Navigator.js

@@ -1,22 +1,22 @@
 // =====================================================================
 
 Navigator = function Navigator(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
+    lwVm.memory.private_data.set(this, {})
 };
-qxVm.safefunction(Navigator);
+lwVm.safefunction(Navigator);
 navigator = {};
 
 ; (function () {
 
     DeprecatedStorageQuota = function DeprecatedStorageQuota(createObj_key) {
-        if (createObj_key !== qxVm.memory.$createObj_key) {
+        if (createObj_key !== lwVm.memory.$createObj_key) {
             throw new TypeError("Illegal constructor");
         }
-        qxVm.memory.private_data.set(this, {})
-    }; qxVm.safefunction(DeprecatedStorageQuota);
+        lwVm.memory.private_data.set(this, {})
+    }; lwVm.safefunction(DeprecatedStorageQuota);
 
     ; (function () {
         const $safe_get_attribute = [];
@@ -25,17 +25,21 @@ navigator = {};
 
         DeprecatedStorageQuota.prototype = {
             queryUsageAndQuota() {
-                debugger;
                 if (!DeprecatedStorageQuota.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DeprecatedStorageQuota', 'queryUsageAndQuota', arguments, result);
+            return result;
             },
             requestQuota() {
-                debugger;
                 if (!DeprecatedStorageQuota.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DeprecatedStorageQuota', 'requestQuota', arguments, result);
+            return result;
             },
         }
-        qxVm.rename(DeprecatedStorageQuota.prototype, "DeprecatedStorageQuota");
-        qxVm.safeDescriptor_addConstructor(DeprecatedStorageQuota);
-        qxVm.safe_Objattribute(DeprecatedStorageQuota, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+        lwVm.rename(DeprecatedStorageQuota.prototype, "DeprecatedStorageQuota");
+        lwVm.safeDescriptor_addConstructor(DeprecatedStorageQuota);
+        lwVm.safe_Objattribute(DeprecatedStorageQuota, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     })();
 
@@ -45,55 +49,55 @@ navigator = {};
         appCodeName: "Mozilla",
         appName: "Netscape",
         appVersion: "5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36",
-        bluetooth: new Bluetooth(qxVm.memory.$createObj_key),
-        clipboard: new Clipboard(qxVm.memory.$createObj_key),
-        connection: new NetworkInformation(qxVm.memory.$createObj_key),
+        bluetooth: new Bluetooth(lwVm.memory.$createObj_key),
+        clipboard: new Clipboard(lwVm.memory.$createObj_key),
+        connection: new NetworkInformation(lwVm.memory.$createObj_key),
         cookieEnabled: true,
-        credentials: new CredentialsContainer(qxVm.memory.$createObj_key),
+        credentials: new CredentialsContainer(lwVm.memory.$createObj_key),
         deviceMemory: 8,
         doNotTrack: null,
-        geolocation: new Geolocation(qxVm.memory.$createObj_key),
+        geolocation: new Geolocation(lwVm.memory.$createObj_key),
         hardwareConcurrency: 16,
-        hid: new HID(qxVm.memory.$createObj_key),
-        ink: new Ink(qxVm.memory.$createObj_key),
-        keyboard: new Keyboard(qxVm.memory.$createObj_key),
+        hid: new HID(lwVm.memory.$createObj_key),
+        ink: new Ink(lwVm.memory.$createObj_key),
+        keyboard: new Keyboard(lwVm.memory.$createObj_key),
         language: "zh-CN",
         languages: ['zh-CN', 'zh'],
-        locks: new LockManager(qxVm.memory.$createObj_key),
-        managed: new NavigatorManagedData(qxVm.memory.$createObj_key),
+        locks: new LockManager(lwVm.memory.$createObj_key),
+        managed: new NavigatorManagedData(lwVm.memory.$createObj_key),
         maxTouchPoints: 0,
-        mediaCapabilities: new MediaCapabilities(qxVm.memory.$createObj_key),
-        mediaDevices: new MediaDevices(qxVm.memory.$createObj_key),
-        mediaSession: new MediaSession(qxVm.memory.$createObj_key),
-        mimeTypes: qxVm.memory.mimeTypeArray.instantiate,
+        mediaCapabilities: new MediaCapabilities(lwVm.memory.$createObj_key),
+        mediaDevices: new MediaDevices(lwVm.memory.$createObj_key),
+        mediaSession: new MediaSession(lwVm.memory.$createObj_key),
+        mimeTypes: lwVm.memory.mimeTypeArray.instantiate,
         onLine: true,
         pdfViewerEnabled: true,
-        permissions: new Permissions(qxVm.memory.$createObj_key),
+        permissions: new Permissions(lwVm.memory.$createObj_key),
         platform: "Win32",
-        plugins: qxVm.memory.pluginArray.instantiate,
-        presentation: new Presentation(qxVm.memory.$createObj_key),
+        plugins: lwVm.memory.pluginArray.instantiate,
+        presentation: new Presentation(lwVm.memory.$createObj_key),
         product: "Gecko",
         productSub: "20030107",
-        scheduling: new Scheduling(qxVm.memory.$createObj_key),
-        serial: new Serial(qxVm.memory.$createObj_key),
-        serviceWorker: new ServiceWorkerContainer(qxVm.memory.$createObj_key),
-        storage: new StorageManager(qxVm.memory.$createObj_key),
-        usb: new USB(qxVm.memory.$createObj_key),
-        userActivation: new UserActivation(qxVm.memory.$createObj_key),
+        scheduling: new Scheduling(lwVm.memory.$createObj_key),
+        serial: new Serial(lwVm.memory.$createObj_key),
+        serviceWorker: new ServiceWorkerContainer(lwVm.memory.$createObj_key),
+        storage: new StorageManager(lwVm.memory.$createObj_key),
+        usb: new USB(lwVm.memory.$createObj_key),
+        userActivation: new UserActivation(lwVm.memory.$createObj_key),
         userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36 Edg/100.0.1185.44",
-        userAgentData: new NavigatorUAData(qxVm.memory.$createObj_key),
+        userAgentData: new NavigatorUAData(lwVm.memory.$createObj_key),
         vendor: "Google Inc.",
         vendorSub: "",
-        virtualKeyboard: new VirtualKeyboard(qxVm.memory.$createObj_key),
-        wakeLock: new WakeLock(qxVm.memory.$createObj_key),
+        virtualKeyboard: new VirtualKeyboard(lwVm.memory.$createObj_key),
+        wakeLock: new WakeLock(lwVm.memory.$createObj_key),
         webdriver: false,
-        webkitPersistentStorage: new DeprecatedStorageQuota(qxVm.memory.$createObj_key),
-        webkitTemporaryStorage: new DeprecatedStorageQuota(qxVm.memory.$createObj_key),
-        xr: new XRSystem(qxVm.memory.$createObj_key)
+        webkitPersistentStorage: new DeprecatedStorageQuota(lwVm.memory.$createObj_key),
+        webkitTemporaryStorage: new DeprecatedStorageQuota(lwVm.memory.$createObj_key),
+        xr: new XRSystem(lwVm.memory.$createObj_key)
     };
 
     // 将属性更新为用户自定义属性
-    qxVm.updata_envs(qxVm.default_envs['navigator'], $attribute_map)
+    lwVm.updata_envs(lwVm.default_envs['navigator'], $attribute_map)
 
     const $safe_get_attribute = [
         'appCodeName', 'appName', 'appVersion', 'bluetooth', 'clipboard', 'connection', 'cookieEnabled', 'credentials', 'deviceMemory', 'doNotTrack',
@@ -112,60 +116,85 @@ navigator = {};
     Navigator.prototype = {
         get appCodeName() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.appCodeName;
+            let result = $attribute_map.appCodeName;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'appCodeName', arguments, result);
+            return result;
         },
         get appName() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.appName;
+            let result = $attribute_map.appName;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'appName', arguments, result);
+            return result;
         },
         get appVersion() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.appVersion;
+            let result = $attribute_map.appVersion;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'appVersion', arguments, result);
+            return result;
         },
         get bluetooth() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.bluetooth;
+            let result = $attribute_map.bluetooth;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'bluetooth', arguments, result);
+            return result;
         },
         canShare() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'canShare', arguments, result);
+            return result;
         },
         clearAppBadge() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'clearAppBadge', arguments, result);
+            return result;
         },
         get clipboard() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.clipboard;
+            let result = $attribute_map.clipboard;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'clipboard', arguments, result);
+            return result;
         },
         get connection() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.connection;
+            let result = $attribute_map.connection;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'connection', arguments, result);
+            return result;
         },
         get cookieEnabled() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.cookieEnabled;
+            let result = $attribute_map.cookieEnabled;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'cookieEnabled', arguments, result);
+            return result;
         },
         get credentials() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.credentials;
+            let result = $attribute_map.credentials;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'credentials', arguments, result);
+            return result;
         },
         get deviceMemory() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.deviceMemory;
+            let result = $attribute_map.deviceMemory;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'deviceMemory', arguments, result);
+            return result;
         },
         get doNotTrack() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.doNotTrack;
+            let result = $attribute_map.doNotTrack;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'doNotTrack', arguments, result);
+            return result;
         },
         get geolocation() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.geolocation;
+            let result = $attribute_map.geolocation;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'geolocation', arguments, result);
+            return result;
         },
         getBattery() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;;
-            return new Promise((resolve, reject) => {
+            let result = new Promise((resolve, reject) => {
                 resolve({
                     charging: true,
                     chargingTime: Infinity,
@@ -178,212 +207,310 @@ navigator = {};
 
                 })
             })
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'getBattery', arguments, result);
+            return result;
         },
         getGamepads() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'getGamepads', arguments, result);
+            return result;
         },
         getInstalledRelatedApps() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'getInstalledRelatedApps', arguments, result);
+            return result;
         },
         getUserMedia() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'getUserMedia', arguments, result);
+            return result;
         },
         javaEnabled() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'javaEnabled', arguments, result);
+            return result;
         },
         get hardwareConcurrency() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.hardwareConcurrency;
+            let result = $attribute_map.hardwareConcurrency;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'hardwareConcurrency', arguments, result);
+            return result;
         },
         get hid() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.hid;
+            let result = $attribute_map.hid;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'hid', arguments, result);
+            return result;
         },
         get ink() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.ink;
+            let result = $attribute_map.ink;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'ink', arguments, result);
+            return result;
         },
         get keyboard() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.keyboard;
+            let result = $attribute_map.keyboard;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'keyboard', arguments, result);
+            return result;
         },
         get language() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.languages;
+            let result = $attribute_map.languages;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'language', arguments, result);
+            return result;
         },
         get languages() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.languages;
+            let result = $attribute_map.languages;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'languages', arguments, result);
+            return result;
         },
         get locks() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.locks;
+            let result = $attribute_map.locks;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'locks', arguments, result);
+            return result;
         },
         get managed() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.managed;
+            let result = $attribute_map.managed;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'managed', arguments, result);
+            return result;
         },
         get maxTouchPoints() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.maxTouchPoints;
+            let result = $attribute_map.maxTouchPoints;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'maxTouchPoints', arguments, result);
+            return result;
         },
         get mediaCapabilities() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.mediaCapabilities;
+            let result = $attribute_map.mediaCapabilities;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'mediaCapabilities', arguments, result);
+            return result;
         },
         get mediaDevices() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.mediaDevices;
+            let result = $attribute_map.mediaDevices;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'mediaDevices', arguments, result);
+            return result;
         },
         get mediaSession() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.mediaSession;
+            let result = $attribute_map.mediaSession;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'mediaSession', arguments, result);
+            return result;
         },
         get mimeTypes() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.mimeTypes;
+            let result = $attribute_map.mimeTypes;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'mimeTypes', arguments, result);
+            return result;
         },
         get onLine() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.onLine;
+            let result = $attribute_map.onLine;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'onLine', arguments, result);
+            return result;
         },
         get pdfViewerEnabled() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.pdfViewerEnabled;
+            let result = $attribute_map.pdfViewerEnabled;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'pdfViewerEnabled', arguments, result);
+            return result;
         },
         get permissions() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.permissions;
+            let result = $attribute_map.permissions;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'permissions', arguments, result);
+            return result;
         },
         get platform() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.platform;
+            let result = $attribute_map.platform;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'platform', arguments, result);
+            return result;
         },
         get plugins() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.plugins;
+            let result = $attribute_map.plugins;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'plugins', arguments, result);
+            return result;
         },
         get presentation() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.presentation;
+            let result = $attribute_map.presentation;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'presentation', arguments, result);
+            return result;
         },
         get product() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.product;
+            let result = $attribute_map.product;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'product', arguments, result);
+            return result;
         },
         get productSub() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.productSub;
+            let result = $attribute_map.productSub;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'productSub', arguments, result);
+            return result;
         },
         registerProtocolHandler() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'registerProtocolHandler', arguments, result);
+            return result;
         },
         requestMIDIAccess() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'requestMIDIAccess', arguments, result);
+            return result;
         },
         requestMediaKeySystemAccess() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'requestMediaKeySystemAccess', arguments, result);
+            return result;
         },
         get scheduling() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.scheduling;
+            let result = $attribute_map.scheduling;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'scheduling', arguments, result);
+            return result;
         },
         sendBeacon() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'sendBeacon', arguments, result);
+            return result;
         },
         get serial() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
 
-            return $attribute_map.serial;
+            let result = $attribute_map.serial;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'serial', arguments, result);
+            return result;
         },
         get serviceWorker() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.serviceWorker;
+            let result = $attribute_map.serviceWorker;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'serviceWorker', arguments, result);
+            return result;
         },
         setAppBadge() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'setAppBadge', arguments, result);
+            return result;
         },
         share() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'share', arguments, result);
+            return result;
         },
         get storage() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.storage;
+            let result = $attribute_map.storage;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'storage', arguments, result);
+            return result;
         },
         unregisterProtocolHandler() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'unregisterProtocolHandler', arguments, result);
+            return result;
         },
         get usb() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return new qxVm.memory.$createObj_key();
+            let result = new lwVm.memory.$createObj_key();;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'usb', arguments, result);
+            return result;
         },
         get userActivation() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.userActivation;
+            let result = $attribute_map.userActivation;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'userActivation', arguments, result);
+            return result;
         },
         get userAgent() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.userAgent;
+            let result = $attribute_map.userAgent;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'userAgent', arguments, result);
+            return result;
         },
         get userAgentData() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.userAgentData;
+            let result = $attribute_map.userAgentData;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'userAgentData', arguments, result);
+            return result;
         },
         get vendor() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.vendor;
+            let result = $attribute_map.vendor;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'vendor', arguments, result);
+            return result;
         },
         get vendorSub() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.vendorSub;
+            let result = $attribute_map.vendorSub;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'vendorSub', arguments, result);
+            return result;
         },
         vibrate() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Navigator', 'vibrate', arguments, result);
+            return result;
         },
         get virtualKeyboard() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.virtualKeyboard;
+            let result = $attribute_map.virtualKeyboard;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'virtualKeyboard', arguments, result);
+            return result;
         },
         get wakeLock() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.wakeLock;
+            let result = $attribute_map.wakeLock;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'wakeLock', arguments, result);
+            return result;
         },
         get webdriver() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.webdriver;
+            let result = $attribute_map.webdriver;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'webdriver', arguments, result);
+            return result;
         },
         webkitGetUserMedia() {
-            debugger;
         },
         get webkitPersistentStorage() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.webkitPersistentStorage;
+            let result = $attribute_map.webkitPersistentStorage;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'webkitPersistentStorage', arguments, result);
+            return result;
         },
         get webkitTemporaryStorage() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.webkitTemporaryStorage;
+            let result = $attribute_map.webkitTemporaryStorage;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'webkitTemporaryStorage', arguments, result);
+            return result;
         },
         get xr() {
             if (!Navigator.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.xr;
+            let result = $attribute_map.xr;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Navigator', 'xr', arguments, result);
+            return result;
         },
     };
-    qxVm.rename(Navigator.prototype, "Navigator");
-    qxVm.safeDescriptor_addConstructor(Navigator);
-    qxVm.safe_Objattribute(Navigator, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Navigator.prototype, "Navigator");
+    lwVm.safeDescriptor_addConstructor(Navigator);
+    lwVm.safe_Objattribute(Navigator, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(navigator, Navigator.prototype);
 

qxVm_sanbox/env/BOM/NavigatorUAData.js

@@ -1,9 +1,9 @@
 NavigatorUAData = function NavigatorUAData(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(NavigatorUAData);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(NavigatorUAData);
 
 ; (function () {
     const $safe_get_attribute = ['brands', 'mobile', 'platform'];
@@ -12,7 +12,6 @@ NavigatorUAData = function NavigatorUAData(createObj_key) {//构造函数
 
     NavigatorUAData.prototype = {
         get brands() { // 这个属性得对象描述符不正确, 
-            debugger;
             if (!NavigatorUAData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             return [
                 { brand: ' Not;A Brand', version: '99' },
@@ -21,24 +20,32 @@ NavigatorUAData = function NavigatorUAData(createObj_key) {//构造函数
             ]
         },
         getHighEntropyValues() {
-            debugger;
             if (!NavigatorUAData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'NavigatorUAData', 'getHighEntropyValues', arguments, result);
+            return result;
         },
         get mobile() {
             if (!NavigatorUAData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return false;
+            let result = false;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'NavigatorUAData', 'mobile', arguments, result);
+            return result;
         },
         get platform() {
             if (!NavigatorUAData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return "Windows";
+            let result = "Windows";;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'NavigatorUAData', 'platform', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!NavigatorUAData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'NavigatorUAData', 'toJSON', arguments, result);
+            return result;
         },
     };
-    qxVm.rename(NavigatorUAData.prototype, "NavigatorUAData");
-    qxVm.safeDescriptor_addConstructor(NavigatorUAData);
-    qxVm.safe_Objattribute(NavigatorUAData, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(NavigatorUAData.prototype, "NavigatorUAData");
+    lwVm.safeDescriptor_addConstructor(NavigatorUAData);
+    lwVm.safe_Objattribute(NavigatorUAData, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })()
 

qxVm_sanbox/env/BOM/Performance.js

@@ -1,16 +1,16 @@
 Performance = function Performance(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Performance);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Performance);
 
 ; (function () {
     MemoryInfo = function MemoryInfo(createObj_key) {
-        if (createObj_key !== qxVm.memory.$createObj_key) {
+        if (createObj_key !== lwVm.memory.$createObj_key) {
             throw new TypeError("Illegal constructor");
         }
-    }; qxVm.safefunction(MemoryInfo);
+    }; lwVm.safefunction(MemoryInfo);
 
     ; (function () {
         const $safe_get_attribute = ['jsHeapSizeLimit', 'totalJSHeapSize', 'usedJSHeapSize'];
@@ -19,24 +19,27 @@ Performance = function Performance(createObj_key) {//构造函数
 
         MemoryInfo.prototype = {
             get jsHeapSizeLimit() {
-                debugger;
                 if (!MemoryInfo.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return 2330000000;
+            let result = 2330000000;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MemoryInfo', 'jsHeapSizeLimit', arguments, result);
+            return result;
             },
             get totalJSHeapSize() {
-                debugger;
                 if (!MemoryInfo.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return 18200000;
+            let result = 18200000;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MemoryInfo', 'totalJSHeapSize', arguments, result);
+            return result;
             },
             get usedJSHeapSize() {
-                debugger;
                 if (!MemoryInfo.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return 15200000;
+            let result = 15200000;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MemoryInfo', 'usedJSHeapSize', arguments, result);
+            return result;
             },
         }
-        qxVm.rename(MemoryInfo.prototype, "MemoryInfo");
-        qxVm.safeDescriptor_addConstructor(MemoryInfo);
-        qxVm.safe_Objattribute(MemoryInfo, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+        lwVm.rename(MemoryInfo.prototype, "MemoryInfo");
+        lwVm.safeDescriptor_addConstructor(MemoryInfo);
+        lwVm.safe_Objattribute(MemoryInfo, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
     })();
 
 
@@ -47,32 +50,42 @@ Performance = function Performance(createObj_key) {//构造函数
     // Performance.prototype.eventCounts
     Performance.prototype = {
         clearMarks() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'clearMarks', arguments, result);
+            return result;
         },
         clearMeasures() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'clearMeasures', arguments, result);
+            return result;
         },
         clearResourceTimings() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'clearResourceTimings', arguments, result);
+            return result;
         },
         get eventCounts() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).eventCounts, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).eventCounts, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Performance', 'eventCounts', arguments, result);
+            return result;
         },
         getEntries() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'getEntries', arguments, result);
+            return result;
         },
         getEntriesByName() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'getEntriesByName', arguments, result);
+            return result;
         },
         getEntriesByType(type) {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (type === undefined)
                 throw new TypeError(`Failed to execute 'getEntriesByType' on 'Performance': 1 argument required, but only 0 present.`)
@@ -81,7 +94,6 @@ Performance = function Performance(createObj_key) {//构造函数
             let ele;
             switch (type){
                 default:
-                    debugger;
                     ele = [];
                     break
             };
@@ -89,81 +101,98 @@ Performance = function Performance(createObj_key) {//构造函数
 
         },
         mark() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'mark', arguments, result);
+            return result;
         },
         measure() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'measure', arguments, result);
+            return result;
         },
         get memory() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).memory;
+            let ele = lwVm.memory.private_data.get(this).memory;
             if (!ele) {
-                ele = new MemoryInfo(qxVm.memory.$createObj_key);
-                qxVm.memory.private_data.get(this).memory = ele;
+                ele = new MemoryInfo(lwVm.memory.$createObj_key);
+                lwVm.memory.private_data.get(this).memory = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'if ', arguments, result);
+            return result;
         },
         get navigation() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).navigation;
+            let ele = lwVm.memory.private_data.get(this).navigation;
             if (!ele) {
-                ele = new PerformanceNavigation(qxVm.memory.$createObj_key);
-                qxVm.memory.private_data.get(this).navigation = ele;
+                ele = new PerformanceNavigation(lwVm.memory.$createObj_key);
+                lwVm.memory.private_data.get(this).navigation = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'if ', arguments, result);
+            return result;
         },
         now() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'now', arguments, result);
+            return result;
         },
         get onresourcetimingbufferfull() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onresourcetimingbufferfull, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onresourcetimingbufferfull, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Performance', 'onresourcetimingbufferfull', arguments, result);
+            return result;
         },
         set onresourcetimingbufferfull(value) {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onresourcetimingbufferfull = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'Performance', 'onresourcetimingbufferfull', arguments);
+            lwVm.memory.private_data.get(this).onresourcetimingbufferfull = value;
         },
         setResourceTimingBufferSize() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'setResourceTimingBufferSize', arguments, result);
+            return result;
         },
         get timeOrigin() {
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).timeOrigin;
+            let ele = lwVm.memory.private_data.get(this).timeOrigin;
             if (!ele){
                 ele = (new Date().getTime()) + parseFloat((Math.random()).toFixed(1))
-                qxVm.memory.private_data.get(this).timeOrigin = ele
+                lwVm.memory.private_data.get(this).timeOrigin = ele
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Performance', 'timeOrigin', arguments, result);
+            return result;
         },
         get timing() {
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).timing;
+            let ele = lwVm.memory.private_data.get(this).timing;
             if (!ele){
-                ele = new PerformanceTiming(qxVm.memory.$createObj_key, parseInt(this.timeOrigin));
-                qxVm.memory.private_data.get(this).timing = ele;
+                ele = new PerformanceTiming(lwVm.memory.$createObj_key, parseInt(this.timeOrigin));
+                lwVm.memory.private_data.get(this).timing = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Performance', 'timing', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'toJSON', arguments, result);
+            return result;
         }
     };
 
-    qxVm.rename(Performance.prototype, "Performance");
-    qxVm.safeDescriptor_addConstructor(Performance);
-    qxVm.safe_Objattribute(Performance, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Performance.prototype, "Performance");
+    lwVm.safeDescriptor_addConstructor(Performance);
+    lwVm.safe_Objattribute(Performance, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(Performance.prototype, EventTarget.prototype);
     Object.setPrototypeOf(Performance, EventTarget);
 })();
-performance = new Performance(qxVm.memory.$createObj_key);
+performance = new Performance(lwVm.memory.$createObj_key);
 

qxVm_sanbox/env/BOM/Performance/Performance.js

@@ -1,16 +1,16 @@
 Performance = function Performance(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Performance);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Performance);
 
 ; (function () {
     MemoryInfo = function MemoryInfo(createObj_key) {
-        if (createObj_key !== qxVm.memory.$createObj_key) {
+        if (createObj_key !== lwVm.memory.$createObj_key) {
             throw new TypeError("Illegal constructor");
         }
-    }; qxVm.safefunction(MemoryInfo);
+    }; lwVm.safefunction(MemoryInfo);
 
     ; (function () {
         const $safe_get_attribute = ['jsHeapSizeLimit', 'totalJSHeapSize', 'usedJSHeapSize'];
@@ -19,24 +19,27 @@ Performance = function Performance(createObj_key) {//构造函数
 
         MemoryInfo.prototype = {
             get jsHeapSizeLimit() {
-                debugger;
                 if (!MemoryInfo.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return 2330000000;
+            let result = 2330000000;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MemoryInfo', 'jsHeapSizeLimit', arguments, result);
+            return result;
             },
             get totalJSHeapSize() {
-                debugger;
                 if (!MemoryInfo.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return 18200000;
+            let result = 18200000;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MemoryInfo', 'totalJSHeapSize', arguments, result);
+            return result;
             },
             get usedJSHeapSize() {
-                debugger;
                 if (!MemoryInfo.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-                return 15200000;
+            let result = 15200000;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MemoryInfo', 'usedJSHeapSize', arguments, result);
+            return result;
             },
         }
-        qxVm.rename(MemoryInfo.prototype, "MemoryInfo");
-        qxVm.safeDescriptor_addConstructor(MemoryInfo);
-        qxVm.safe_Objattribute(MemoryInfo, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+        lwVm.rename(MemoryInfo.prototype, "MemoryInfo");
+        lwVm.safeDescriptor_addConstructor(MemoryInfo);
+        lwVm.safe_Objattribute(MemoryInfo, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
     })();
 
 
@@ -47,32 +50,42 @@ Performance = function Performance(createObj_key) {//构造函数
     // Performance.prototype.eventCounts
     Performance.prototype = {
         clearMarks() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'clearMarks', arguments, result);
+            return result;
         },
         clearMeasures() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'clearMeasures', arguments, result);
+            return result;
         },
         clearResourceTimings() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'clearResourceTimings', arguments, result);
+            return result;
         },
         get eventCounts() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).eventCounts, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).eventCounts, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Performance', 'eventCounts', arguments, result);
+            return result;
         },
         getEntries() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'getEntries', arguments, result);
+            return result;
         },
         getEntriesByName() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'getEntriesByName', arguments, result);
+            return result;
         },
         getEntriesByType(type) {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (type === undefined)
                 throw new TypeError(`Failed to execute 'getEntriesByType' on 'Performance': 1 argument required, but only 0 present.`)
@@ -81,7 +94,6 @@ Performance = function Performance(createObj_key) {//构造函数
             let ele;
             switch (type){
                 default:
-                    debugger;
                     ele = [];
                     break
             };
@@ -89,81 +101,98 @@ Performance = function Performance(createObj_key) {//构造函数
 
         },
         mark() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'mark', arguments, result);
+            return result;
         },
         measure() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'measure', arguments, result);
+            return result;
         },
         get memory() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).memory;
+            let ele = lwVm.memory.private_data.get(this).memory;
             if (!ele) {
-                ele = new MemoryInfo(qxVm.memory.$createObj_key);
-                qxVm.memory.private_data.get(this).memory = ele;
+                ele = new MemoryInfo(lwVm.memory.$createObj_key);
+                lwVm.memory.private_data.get(this).memory = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'if ', arguments, result);
+            return result;
         },
         get navigation() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).navigation;
+            let ele = lwVm.memory.private_data.get(this).navigation;
             if (!ele) {
-                ele = new PerformanceNavigation(qxVm.memory.$createObj_key);
-                qxVm.memory.private_data.get(this).navigation = ele;
+                ele = new PerformanceNavigation(lwVm.memory.$createObj_key);
+                lwVm.memory.private_data.get(this).navigation = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'if ', arguments, result);
+            return result;
         },
         now() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'now', arguments, result);
+            return result;
         },
         get onresourcetimingbufferfull() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onresourcetimingbufferfull, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onresourcetimingbufferfull, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Performance', 'onresourcetimingbufferfull', arguments, result);
+            return result;
         },
         set onresourcetimingbufferfull(value) {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onresourcetimingbufferfull = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'Performance', 'onresourcetimingbufferfull', arguments);
+            lwVm.memory.private_data.get(this).onresourcetimingbufferfull = value;
         },
         setResourceTimingBufferSize() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'setResourceTimingBufferSize', arguments, result);
+            return result;
         },
         get timeOrigin() {
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).timeOrigin;
+            let ele = lwVm.memory.private_data.get(this).timeOrigin;
             if (!ele){
                 ele = (new Date().getTime()) + parseFloat((Math.random()).toFixed(1))
-                qxVm.memory.private_data.get(this).timeOrigin = ele
+                lwVm.memory.private_data.get(this).timeOrigin = ele
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Performance', 'timeOrigin', arguments, result);
+            return result;
         },
         get timing() {
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            let ele = qxVm.memory.private_data.get(this).timing;
+            let ele = lwVm.memory.private_data.get(this).timing;
             if (!ele){
-                ele = new PerformanceTiming(qxVm.memory.$createObj_key, parseInt(this.timeOrigin));
-                qxVm.memory.private_data.get(this).timing = ele;
+                ele = new PerformanceTiming(lwVm.memory.$createObj_key, parseInt(this.timeOrigin));
+                lwVm.memory.private_data.get(this).timing = ele;
             }
-            return ele;
+            let result = ele;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Performance', 'timing', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!Performance.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Performance', 'toJSON', arguments, result);
+            return result;
         }
     };
 
-    qxVm.rename(Performance.prototype, "Performance");
-    qxVm.safeDescriptor_addConstructor(Performance);
-    qxVm.safe_Objattribute(Performance, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Performance.prototype, "Performance");
+    lwVm.safeDescriptor_addConstructor(Performance);
+    lwVm.safe_Objattribute(Performance, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(Performance.prototype, EventTarget.prototype);
     Object.setPrototypeOf(Performance, EventTarget);
 })();
-performance = new Performance(qxVm.memory.$createObj_key);
+performance = new Performance(lwVm.memory.$createObj_key);
 

qxVm_sanbox/env/BOM/Performance/PerformanceEntry.js

@@ -1,10 +1,10 @@
 
 PerformanceEntry = function PerformanceEntry(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(PerformanceEntry);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(PerformanceEntry);
 
 ; (function () {
     const $safe_get_attribute = ['duration', 'entryType', 'name', 'startTime'];
@@ -13,32 +13,38 @@ PerformanceEntry = function PerformanceEntry(createObj_key) {
     
     PerformanceEntry.prototype = {
         get duration() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).duration, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).duration, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceEntry', 'duration', arguments, result);
+            return result;
         },
         get entryType() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).entryType, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).entryType, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceEntry', 'entryType', arguments, result);
+            return result;
         },
         get name() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).name, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).name, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceEntry', 'name', arguments, result);
+            return result;
         },
         get startTime() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).startTime, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).startTime, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceEntry', 'startTime', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PerformanceEntry', 'toJSON', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(PerformanceEntry.prototype, "PerformanceEntry");
-    qxVm.safeDescriptor_addConstructor(PerformanceEntry);
-    qxVm.safe_Objattribute(PerformanceEntry, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(PerformanceEntry.prototype, "PerformanceEntry");
+    lwVm.safeDescriptor_addConstructor(PerformanceEntry);
+    lwVm.safe_Objattribute(PerformanceEntry, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/Performance/PerformanceNavigation.js

@@ -1,9 +1,9 @@
 PerformanceNavigation = function PerformanceNavigation(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(PerformanceNavigation);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(PerformanceNavigation);
 
 ; (function () {
     const $attributes = {
@@ -18,23 +18,27 @@ PerformanceNavigation = function PerformanceNavigation(createObj_key) {
 
     PerformanceNavigation.prototype = {
         get redirectCount() {
-            debugger;
             if (!PerformanceNavigation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceNavigation', 'redirectCount', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!PerformanceNavigation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PerformanceNavigation', 'toJSON', arguments, result);
+            return result;
         },
         get type() {
-            debugger;
             if (!PerformanceNavigation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceNavigation', 'type', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(PerformanceNavigation.prototype, "PerformanceNavigation");
-    qxVm.safeDescriptor_addConstructor(PerformanceNavigation);
-    qxVm.safe_Objattribute(PerformanceNavigation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
-    qxVm.add_capitalLetter_attribute(PerformanceNavigation, $attributes);
+    lwVm.rename(PerformanceNavigation.prototype, "PerformanceNavigation");
+    lwVm.safeDescriptor_addConstructor(PerformanceNavigation);
+    lwVm.safe_Objattribute(PerformanceNavigation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.add_capitalLetter_attribute(PerformanceNavigation, $attributes);
 
 })();

qxVm_sanbox/env/BOM/Performance/PerformancePaintTiming.js

@@ -1,9 +1,9 @@
 PerformancePaintTiming = function PerformancePaintTiming(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    // qxVm.z_sanbox.memory.private_data.set(this, {})
-}; qxVm.safefunction(PerformancePaintTiming);
+    // lwVm.z_sanbox.memory.private_data.set(this, {})
+}; lwVm.safefunction(PerformancePaintTiming);
 
 ; (function () {
     // const $safe_get_attribute = [];
@@ -12,9 +12,9 @@ PerformancePaintTiming = function PerformancePaintTiming(createObj_key) {
 
     PerformancePaintTiming.prototype = {}
 
-    qxVm.rename(PerformancePaintTiming.prototype, "PerformancePaintTiming");
-    qxVm.safeDescriptor_addConstructor(PerformancePaintTiming);
-    // qxVm.z_sanbox.safe_Objattribute(PerformancePaintTiming, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(PerformancePaintTiming.prototype, "PerformancePaintTiming");
+    lwVm.safeDescriptor_addConstructor(PerformancePaintTiming);
+    // lwVm.z_sanbox.safe_Objattribute(PerformancePaintTiming, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(PerformancePaintTiming.prototype, PerformanceEntry.prototype);
     Object.setPrototypeOf(PerformancePaintTiming, PerformanceEntry);

qxVm_sanbox/env/BOM/Performance/PerformanceTiming.js

@@ -1,9 +1,9 @@
 PerformanceTiming = function PerformanceTiming(createObj_key, timeOrigin) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {base_time: timeOrigin})
-}; qxVm.safefunction(PerformanceTiming);
+    lwVm.memory.private_data.set(this, {base_time: timeOrigin})
+}; lwVm.safefunction(PerformanceTiming);
 
 ; (function () {
     const $safe_get_attribute = [
@@ -18,87 +18,129 @@ PerformanceTiming = function PerformanceTiming(createObj_key, timeOrigin) {//构
     PerformanceTiming.prototype = {
         get connectEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'connectEnd', arguments, result);
+            return result;
         },
         get connectStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'connectStart', arguments, result);
+            return result;
         },
         get domComplete() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + parseInt(Math.random()*(500 - 10) + 100, 10);
+            let result = lwVm.memory.private_data.get(this).base_time + parseInt(Math.random()*(500 - 10) + 100, 10);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domComplete', arguments, result);
+            return result;
         },
         get domContentLoadedEventEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 106;
+            let result = lwVm.memory.private_data.get(this).base_time + 106;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domContentLoadedEventEnd', arguments, result);
+            return result;
         },
         get domContentLoadedEventStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 103;
+            let result = lwVm.memory.private_data.get(this).base_time + 103;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domContentLoadedEventStart', arguments, result);
+            return result;
         },
         get domInteractive() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 102;
+            let result = lwVm.memory.private_data.get(this).base_time + 102;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domInteractive', arguments, result);
+            return result;
         },
         get domLoading() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 79;
+            let result = lwVm.memory.private_data.get(this).base_time + 79;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domLoading', arguments, result);
+            return result;
         },
         get domainLookupEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domainLookupEnd', arguments, result);
+            return result;
         },
         get domainLookupStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domainLookupStart', arguments, result);
+            return result;
         },
         get fetchStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'fetchStart', arguments, result);
+            return result;
         },
         get loadEventEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return this.domComplete;
+            let result = this.domComplete;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'loadEventEnd', arguments, result);
+            return result;
         },
         get loadEventStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return this.domComplete;
+            let result = this.domComplete;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'loadEventStart', arguments, result);
+            return result;
         },
         get navigationStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + -8;
+            let result = lwVm.memory.private_data.get(this).base_time + -8;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'navigationStart', arguments, result);
+            return result;
         },
         get redirectEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'redirectEnd', arguments, result);
+            return result;
         },
         get redirectStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'redirectStart', arguments, result);
+            return result;
         },
         get requestStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'requestStart', arguments, result);
+            return result;
         },
         get responseEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 20;
+            let result = lwVm.memory.private_data.get(this).base_time + 20;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'responseEnd', arguments, result);
+            return result;
         },
         get responseStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'responseStart', arguments, result);
+            return result;
         },
         get secureConnectionStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'secureConnectionStart', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PerformanceTiming', 'toJSON', arguments, result);
+            return result;
         },
         get unloadEventEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'unloadEventEnd', arguments, result);
+            return result;
         },
         get unloadEventStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
@@ -106,9 +148,9 @@ PerformanceTiming = function PerformanceTiming(createObj_key, timeOrigin) {//构
         }
     };
 
-    qxVm.rename(PerformanceTiming.prototype, "PerformanceTiming");
-    qxVm.safeDescriptor_addConstructor(PerformanceTiming);
-    qxVm.safe_Objattribute(PerformanceTiming, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(PerformanceTiming.prototype, "PerformanceTiming");
+    lwVm.safeDescriptor_addConstructor(PerformanceTiming);
+    lwVm.safe_Objattribute(PerformanceTiming, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/PerformanceEntry.js

@@ -1,10 +1,10 @@
 
 PerformanceEntry = function PerformanceEntry(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(PerformanceEntry);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(PerformanceEntry);
 
 ; (function () {
     const $safe_get_attribute = ['duration', 'entryType', 'name', 'startTime'];
@@ -13,32 +13,38 @@ PerformanceEntry = function PerformanceEntry(createObj_key) {
     
     PerformanceEntry.prototype = {
         get duration() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).duration, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).duration, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceEntry', 'duration', arguments, result);
+            return result;
         },
         get entryType() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).entryType, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).entryType, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceEntry', 'entryType', arguments, result);
+            return result;
         },
         get name() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).name, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).name, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceEntry', 'name', arguments, result);
+            return result;
         },
         get startTime() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).startTime, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).startTime, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceEntry', 'startTime', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!PerformanceEntry.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PerformanceEntry', 'toJSON', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(PerformanceEntry.prototype, "PerformanceEntry");
-    qxVm.safeDescriptor_addConstructor(PerformanceEntry);
-    qxVm.safe_Objattribute(PerformanceEntry, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(PerformanceEntry.prototype, "PerformanceEntry");
+    lwVm.safeDescriptor_addConstructor(PerformanceEntry);
+    lwVm.safe_Objattribute(PerformanceEntry, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/PerformanceNavigation.js

@@ -1,9 +1,9 @@
 PerformanceNavigation = function PerformanceNavigation(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(PerformanceNavigation);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(PerformanceNavigation);
 
 ; (function () {
     const $attributes = {
@@ -18,23 +18,27 @@ PerformanceNavigation = function PerformanceNavigation(createObj_key) {
 
     PerformanceNavigation.prototype = {
         get redirectCount() {
-            debugger;
             if (!PerformanceNavigation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceNavigation', 'redirectCount', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!PerformanceNavigation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PerformanceNavigation', 'toJSON', arguments, result);
+            return result;
         },
         get type() {
-            debugger;
             if (!PerformanceNavigation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceNavigation', 'type', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(PerformanceNavigation.prototype, "PerformanceNavigation");
-    qxVm.safeDescriptor_addConstructor(PerformanceNavigation);
-    qxVm.safe_Objattribute(PerformanceNavigation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
-    qxVm.add_capitalLetter_attribute(PerformanceNavigation, $attributes);
+    lwVm.rename(PerformanceNavigation.prototype, "PerformanceNavigation");
+    lwVm.safeDescriptor_addConstructor(PerformanceNavigation);
+    lwVm.safe_Objattribute(PerformanceNavigation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.add_capitalLetter_attribute(PerformanceNavigation, $attributes);
 
 })();

qxVm_sanbox/env/BOM/PerformancePaintTiming.js

@@ -1,9 +1,9 @@
 PerformancePaintTiming = function PerformancePaintTiming(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    // qxVm.z_sanbox.memory.private_data.set(this, {})
-}; qxVm.safefunction(PerformancePaintTiming);
+    // lwVm.z_sanbox.memory.private_data.set(this, {})
+}; lwVm.safefunction(PerformancePaintTiming);
 
 ; (function () {
     // const $safe_get_attribute = [];
@@ -12,9 +12,9 @@ PerformancePaintTiming = function PerformancePaintTiming(createObj_key) {
 
     PerformancePaintTiming.prototype = {}
 
-    qxVm.rename(PerformancePaintTiming.prototype, "PerformancePaintTiming");
-    qxVm.safeDescriptor_addConstructor(PerformancePaintTiming);
-    // qxVm.z_sanbox.safe_Objattribute(PerformancePaintTiming, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(PerformancePaintTiming.prototype, "PerformancePaintTiming");
+    lwVm.safeDescriptor_addConstructor(PerformancePaintTiming);
+    // lwVm.z_sanbox.safe_Objattribute(PerformancePaintTiming, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(PerformancePaintTiming.prototype, PerformanceEntry.prototype);
     Object.setPrototypeOf(PerformancePaintTiming, PerformanceEntry);

qxVm_sanbox/env/BOM/PerformanceTiming.js

@@ -1,9 +1,9 @@
 PerformanceTiming = function PerformanceTiming(createObj_key, timeOrigin) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {base_time: timeOrigin})
-}; qxVm.safefunction(PerformanceTiming);
+    lwVm.memory.private_data.set(this, {base_time: timeOrigin})
+}; lwVm.safefunction(PerformanceTiming);
 
 ; (function () {
     const $safe_get_attribute = [
@@ -18,87 +18,129 @@ PerformanceTiming = function PerformanceTiming(createObj_key, timeOrigin) {//构
     PerformanceTiming.prototype = {
         get connectEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'connectEnd', arguments, result);
+            return result;
         },
         get connectStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'connectStart', arguments, result);
+            return result;
         },
         get domComplete() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + parseInt(Math.random()*(500 - 10) + 100, 10);
+            let result = lwVm.memory.private_data.get(this).base_time + parseInt(Math.random()*(500 - 10) + 100, 10);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domComplete', arguments, result);
+            return result;
         },
         get domContentLoadedEventEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 106;
+            let result = lwVm.memory.private_data.get(this).base_time + 106;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domContentLoadedEventEnd', arguments, result);
+            return result;
         },
         get domContentLoadedEventStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 103;
+            let result = lwVm.memory.private_data.get(this).base_time + 103;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domContentLoadedEventStart', arguments, result);
+            return result;
         },
         get domInteractive() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 102;
+            let result = lwVm.memory.private_data.get(this).base_time + 102;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domInteractive', arguments, result);
+            return result;
         },
         get domLoading() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 79;
+            let result = lwVm.memory.private_data.get(this).base_time + 79;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domLoading', arguments, result);
+            return result;
         },
         get domainLookupEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domainLookupEnd', arguments, result);
+            return result;
         },
         get domainLookupStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'domainLookupStart', arguments, result);
+            return result;
         },
         get fetchStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'fetchStart', arguments, result);
+            return result;
         },
         get loadEventEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return this.domComplete;
+            let result = this.domComplete;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'loadEventEnd', arguments, result);
+            return result;
         },
         get loadEventStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return this.domComplete;
+            let result = this.domComplete;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'loadEventStart', arguments, result);
+            return result;
         },
         get navigationStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + -8;
+            let result = lwVm.memory.private_data.get(this).base_time + -8;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'navigationStart', arguments, result);
+            return result;
         },
         get redirectEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'redirectEnd', arguments, result);
+            return result;
         },
         get redirectStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'redirectStart', arguments, result);
+            return result;
         },
         get requestStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'requestStart', arguments, result);
+            return result;
         },
         get responseEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time + 20;
+            let result = lwVm.memory.private_data.get(this).base_time + 20;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'responseEnd', arguments, result);
+            return result;
         },
         get responseStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).base_time;
+            let result = lwVm.memory.private_data.get(this).base_time;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'responseStart', arguments, result);
+            return result;
         },
         get secureConnectionStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'secureConnectionStart', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PerformanceTiming', 'toJSON', arguments, result);
+            return result;
         },
         get unloadEventEnd() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PerformanceTiming', 'unloadEventEnd', arguments, result);
+            return result;
         },
         get unloadEventStart() {
             if (!PerformanceTiming.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
@@ -106,9 +148,9 @@ PerformanceTiming = function PerformanceTiming(createObj_key, timeOrigin) {//构
         }
     };
 
-    qxVm.rename(PerformanceTiming.prototype, "PerformanceTiming");
-    qxVm.safeDescriptor_addConstructor(PerformanceTiming);
-    qxVm.safe_Objattribute(PerformanceTiming, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(PerformanceTiming.prototype, "PerformanceTiming");
+    lwVm.safeDescriptor_addConstructor(PerformanceTiming);
+    lwVm.safe_Objattribute(PerformanceTiming, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/Permissions.js

@@ -1,9 +1,9 @@
 Permissions = function Permissions(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Permissions);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Permissions);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,12 +12,14 @@ Permissions = function Permissions(createObj_key) {
     
     Permissions.prototype = {
         query() {
-            debugger;
             if (!Permissions.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Permissions', 'query', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(Permissions.prototype, "Permissions");
-    qxVm.safeDescriptor_addConstructor(Permissions);
-    qxVm.safe_Objattribute(Permissions, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Permissions.prototype, "Permissions");
+    lwVm.safeDescriptor_addConstructor(Permissions);
+    lwVm.safe_Objattribute(Permissions, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/Plugin/MimeType.js

@@ -1,6 +1,6 @@
 MimeType = function MimeType() {
     throw new TypeError("Illegal constructor");
-}; qxVm.safefunction(MimeType);
+}; lwVm.safefunction(MimeType);
 
 ; (function () {
 
@@ -23,14 +23,17 @@ MimeType = function MimeType() {
         },
         get type() {
             if (!MimeType.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MimeType', 'type', arguments, result);
+            return result;
         },
 
-    }; qxVm.rename(MimeType.prototype, 'MimeType');
-    qxVm.safeDescriptor_addConstructor(MimeType);
-    qxVm.safe_Objattribute(MimeType, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    }; lwVm.rename(MimeType.prototype, 'MimeType');
+    lwVm.safeDescriptor_addConstructor(MimeType);
+    lwVm.safe_Objattribute(MimeType, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 
-    qxVm.memory.mimeType.new = function (mimeType_data, initPlugin) {
+    lwVm.memory.mimeType.new = function (mimeType_data, initPlugin) {
         let mimetype = {};
         if (mimeType_data !== undefined) {
             mimetype.description = mimeType_data.description;

qxVm_sanbox/env/BOM/Plugin/MimeTypeArray.js

@@ -1,6 +1,6 @@
 MimeTypeArray = function MimeTypeArray() {
     throw new TypeError("Illegal constructor");
-}; qxVm.safefunction(MimeTypeArray);
+}; lwVm.safefunction(MimeTypeArray);
 
 ; (function () {
 
@@ -10,48 +10,51 @@ MimeTypeArray = function MimeTypeArray() {
 
     MimeTypeArray.prototype = {
         item(index) {
-            debugger;
-            return this[index];
+            let result = this[index];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'MimeTypeArray', 'item', arguments, result);
+            return result;
         },
         get length() {
-            debugger;
             if (!MimeTypeArray.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.mimeTypeArray.length;
+            let result = lwVm.memory.mimeTypeArray.length;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'MimeTypeArray', 'length', arguments, result);
+            return result;
         },
         namedItem(key) {
-            debugger;
-            return this[key];
+            let result = this[key];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'MimeTypeArray', 'namedItem', arguments, result);
+            return result;
         }
 
-    }; qxVm.rename(MimeTypeArray.prototype, 'MimeTypeArray');
-    qxVm.safeDescriptor_addConstructor(MimeTypeArray);
-    qxVm.safe_Objattribute(MimeTypeArray, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    }; lwVm.rename(MimeTypeArray.prototype, 'MimeTypeArray');
+    lwVm.safeDescriptor_addConstructor(MimeTypeArray);
+    lwVm.safe_Objattribute(MimeTypeArray, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
     
 
-    qxVm.memory.mimeTypeArray.instantiate = {};
-    qxVm.memory.mimeTypeArray.length = 0;
+    lwVm.memory.mimeTypeArray.instantiate = {};
+    lwVm.memory.mimeTypeArray.length = 0;
 
     ; (function add_default_mimeTypeArray() {
-        for (let plugin_index = 0; plugin_index < qxVm.memory.pluginArray.temp.length; plugin_index++) {
-            let plugin_ = qxVm.memory.pluginArray.instantiate.item(plugin_index);
+        for (let plugin_index = 0; plugin_index < lwVm.memory.pluginArray.temp.length; plugin_index++) {
+            let plugin_ = lwVm.memory.pluginArray.instantiate.item(plugin_index);
             for (let mindex = 0; mindex < plugin_.length; mindex++) {
                 let mimeType_ = plugin_.item(mindex)
-                if (qxVm.memory.mimeTypeArray.instantiate[mimeType_.type] === undefined) {
+                if (lwVm.memory.mimeTypeArray.instantiate[mimeType_.type] === undefined) {
                     
-                    Object.defineProperty(qxVm.memory.mimeTypeArray.instantiate, qxVm.memory.mimeTypeArray.length, {
+                    Object.defineProperty(lwVm.memory.mimeTypeArray.instantiate, lwVm.memory.mimeTypeArray.length, {
                         value: mimeType_, configurable: true, enumerable: true, writable: false
                     });
-                    Object.defineProperty(qxVm.memory.mimeTypeArray.instantiate, mimeType_.type, {
+                    Object.defineProperty(lwVm.memory.mimeTypeArray.instantiate, mimeType_.type, {
                         value: mimeType_, configurable: true, enumerable: false, writable: false
                     });
 
-                    qxVm.memory.mimeTypeArray.length += 1;
+                    lwVm.memory.mimeTypeArray.length += 1;
                 }
             }
         }
     })();
 
-    Object.setPrototypeOf(qxVm.memory.mimeTypeArray.instantiate, MimeTypeArray.prototype);
+    Object.setPrototypeOf(lwVm.memory.mimeTypeArray.instantiate, MimeTypeArray.prototype);
 
 })();
 

qxVm_sanbox/env/BOM/Plugin/Plugin.js

@@ -1,6 +1,6 @@
 Plugin = function Plugin() {
     throw new TypeError("Illegal constructor");
-}; qxVm.safefunction(Plugin);
+}; lwVm.safefunction(Plugin);
 
 ; (function () {
     const $safe_get_attribute = ['description', 'filename', 'length', 'name'];
@@ -11,32 +11,47 @@ Plugin = function Plugin() {
     Plugin.prototype = {
         get description() {
             if (!Plugin.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Plugin', 'description', arguments, result);
+            return result;
         },
         get filename() {
             if (!Plugin.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Plugin', 'filename', arguments, result);
+            return result;
         },
         item(index) {
             // debugger;
-            return this[index];
+            let result = this[index];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Plugin', 'item', arguments, result);
+            return result;
         },
         get length() {
             if (!Plugin.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Plugin', 'length', arguments, result);
+            return result;
         },
         get name() {
             if (!Plugin.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Plugin', 'name', arguments, result);
+            return result;
         },
         namedItem(key) {
-            debugger;
-            return this[key];
+            let result = this[key];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Plugin', 'namedItem', arguments, result);
+            return result;
         },
     }; 
-    qxVm.set_iterator(Plugin);
-    qxVm.rename(Plugin.prototype, 'Plugin');
-    qxVm.safeDescriptor_addConstructor(Plugin);
-    qxVm.safe_Objattribute(Plugin, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.set_iterator(Plugin);
+    lwVm.rename(Plugin.prototype, 'Plugin');
+    lwVm.safeDescriptor_addConstructor(Plugin);
+    lwVm.safe_Objattribute(Plugin, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
     
 
-    qxVm.memory.plugin.new = function (plugin_data) {
+    lwVm.memory.plugin.new = function (plugin_data) {
         let plugin = {};
 
         if (plugin_data !== undefined) {
@@ -46,7 +61,7 @@ Plugin = function Plugin() {
 
             for (let mtindex = 0; mtindex < plugin_data.MimeTypes.length; mtindex++) {
                 let mimeType_data = plugin_data.MimeTypes[mtindex];
-                let mimeType = qxVm.memory.mimeType.new(mimeType_data, plugin);
+                let mimeType = lwVm.memory.mimeType.new(mimeType_data, plugin);
 
                 Object.defineProperty(plugin, mtindex, {
                     value: mimeType, configurable: true, enumerable: true, writable: false
@@ -58,7 +73,9 @@ Plugin = function Plugin() {
             plugin.length = plugin_data.MimeTypes.length;
         }
         Object.setPrototypeOf(plugin, Plugin.prototype)
-        return plugin;
+            let result = plugin;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Plugin', 'namedItem', arguments, result);
+            return result;
     }
 
 })()

qxVm_sanbox/env/BOM/Plugin/PluginArray.js

@@ -1,7 +1,7 @@
 PluginArray = function PluPluginArraygin() {//构造函数
     throw new TypeError("Illegal constructor");
 };
-qxVm.safefunction(PluginArray);
+lwVm.safefunction(PluginArray);
 
 ; (function () {
     const $safe_get_attribute = ['length'];
@@ -12,44 +12,52 @@ qxVm.safefunction(PluginArray);
     PluginArray.prototype = {
         item(index) {
             if (!PluginArray.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return this[index];
+            let result = this[index];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PluginArray', 'item', arguments, result);
+            return result;
         },
         get length() {
             if (!PluginArray.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.pluginArray.temp.length;
+            let result = lwVm.memory.pluginArray.temp.length;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'PluginArray', 'length', arguments, result);
+            return result;
         },
         namedItem(key) {
             if (!PluginArray.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return this[key];
+            let result = this[key];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PluginArray', 'namedItem', arguments, result);
+            return result;
         },
         refresh() {
             if (!PluginArray.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            debugger;
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'PluginArray', 'refresh', arguments, result);
+            return result;
         }
     };
-    qxVm.set_iterator(PluginArray);
-    qxVm.rename(PluginArray.prototype, 'PluginArray');
-    qxVm.safeDescriptor_addConstructor(PluginArray);
-    qxVm.safe_Objattribute(PluginArray, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.set_iterator(PluginArray);
+    lwVm.rename(PluginArray.prototype, 'PluginArray');
+    lwVm.safeDescriptor_addConstructor(PluginArray);
+    lwVm.safe_Objattribute(PluginArray, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
     
 
-    qxVm.memory.pluginArray.instantiate = {};
+    lwVm.memory.pluginArray.instantiate = {};
     ; (function add_default_pluginArray() {
-        if (Array.isArray(qxVm.memory.pluginArray.temp) && qxVm.memory.pluginArray.temp.length > 0) {
-            for (let index = 0; index < qxVm.memory.pluginArray.temp.length; index++) {
-                let plugin_temp = qxVm.memory.plugin.new(qxVm.memory.pluginArray.temp[index]);
+        if (Array.isArray(lwVm.memory.pluginArray.temp) && lwVm.memory.pluginArray.temp.length > 0) {
+            for (let index = 0; index < lwVm.memory.pluginArray.temp.length; index++) {
+                let plugin_temp = lwVm.memory.plugin.new(lwVm.memory.pluginArray.temp[index]);
 
-                Object.defineProperty(qxVm.memory.pluginArray.instantiate, index, {
+                Object.defineProperty(lwVm.memory.pluginArray.instantiate, index, {
                     value: plugin_temp, configurable: true, enumerable: true, writable: false
                 });
-                Object.defineProperty(qxVm.memory.pluginArray.instantiate, plugin_temp.name, {
+                Object.defineProperty(lwVm.memory.pluginArray.instantiate, plugin_temp.name, {
                     value: plugin_temp, configurable: true, enumerable: false, writable: false
                 });
             }
         }
     })();
 
-    Object.setPrototypeOf(qxVm.memory.pluginArray.instantiate, PluginArray.prototype);
+    Object.setPrototypeOf(lwVm.memory.pluginArray.instantiate, PluginArray.prototype);
 
 })();
 

qxVm_sanbox/env/BOM/Presentation.js

@@ -1,9 +1,9 @@
 Presentation = function Presentation(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Presentation);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Presentation);
 
 ; (function () {
     const $safe_get_attribute = ['defaultRequest', 'receiver'];
@@ -12,23 +12,25 @@ Presentation = function Presentation(createObj_key) {
 
     Presentation.prototype = {
         get defaultRequest() {
-            debugger;
             if (!Presentation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).defaultRequest, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).defaultRequest, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Presentation', 'defaultRequest', arguments, result);
+            return result;
         },
         set defaultRequest(value) {
-            debugger;
             if (!Presentation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).defaultRequest = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'Presentation', 'defaultRequest', arguments);
+            lwVm.memory.private_data.get(this).defaultRequest = value + "";
         },
         get receiver() {
-            debugger;
             if (!Presentation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return null;
+            let result = null;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Presentation', 'receiver', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(Presentation.prototype, "Presentation");
-    qxVm.safeDescriptor_addConstructor(Presentation);
-    qxVm.safe_Objattribute(Presentation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Presentation.prototype, "Presentation");
+    lwVm.safeDescriptor_addConstructor(Presentation);
+    lwVm.safe_Objattribute(Presentation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/RTC/RTCDataChannel.js

@@ -1,9 +1,9 @@
 RTCDataChannel = function RTCDataChannel(createObj_key, label) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {label:label})
-}; qxVm.safefunction(RTCDataChannel);
+    lwVm.memory.private_data.set(this, {label:label})
+}; lwVm.safefunction(RTCDataChannel);
 
 ; (function () {
     const $safe_get_attribute = ['binaryType', 'bufferedAmount', 'bufferedAmountLowThreshold', 'id', 'label', 'maxRetransmitTime', 'maxRetransmits', 'negotiated', 'onbufferedamountlow', 'onclose', 'onerror', 'onmessage', 'onopen', 'ordered', 'protocol', 'readyState', 'reliable'];
@@ -12,143 +12,164 @@ RTCDataChannel = function RTCDataChannel(createObj_key, label) {//构造函数
     RTCDataChannel.prototype = {
 
         get binaryType() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).binaryType, "arraybuffer");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).binaryType, "arraybuffer");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'binaryType', arguments, result);
+            return result;
         },
         set binaryType(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).binaryType = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'binaryType', arguments);
+            lwVm.memory.private_data.get(this).binaryType = value + "";
         },
         get bufferedAmount() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).bufferedAmount, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).bufferedAmount, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'bufferedAmount', arguments, result);
+            return result;
         },
         set bufferedAmount(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).bufferedAmount = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'bufferedAmount', arguments);
+            lwVm.memory.private_data.get(this).bufferedAmount = value;
         },
         get bufferedAmountLowThreshold() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).bufferedAmountLowThreshold, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).bufferedAmountLowThreshold, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'bufferedAmountLowThreshold', arguments, result);
+            return result;
         },
         set bufferedAmountLowThreshold(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).bufferedAmountLowThreshold = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'bufferedAmountLowThreshold', arguments);
+            lwVm.memory.private_data.get(this).bufferedAmountLowThreshold = value;
         },
         close() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCDataChannel', 'close', arguments, result);
+            return result;
         },
         get id() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).id, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).id, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'id', arguments, result);
+            return result;
         },
         get label() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).label;
+            let result = lwVm.memory.private_data.get(this).label;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'label', arguments, result);
+            return result;
         },
         get maxRetransmitTime() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).maxRetransmitTime, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).maxRetransmitTime, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'maxRetransmitTime', arguments, result);
+            return result;
         },
         get maxRetransmits() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).maxRetransmits, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).maxRetransmits, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'maxRetransmits', arguments, result);
+            return result;
         },
         get negotiated() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).negotiated, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).negotiated, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'negotiated', arguments, result);
+            return result;
         },
         get onbufferedamountlow() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onbufferedamountlow, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onbufferedamountlow, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onbufferedamountlow', arguments, result);
+            return result;
         },
         set onbufferedamountlow(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onbufferedamountlow = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onbufferedamountlow', arguments);
+            lwVm.memory.private_data.get(this).onbufferedamountlow = value + "";
         },
         get onclose() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onclose, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onclose, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onclose', arguments, result);
+            return result;
         },
         set onclose(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onclose = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onclose', arguments);
+            lwVm.memory.private_data.get(this).onclose = value + "";
         },
         get onerror() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onerror, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onerror, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onerror', arguments, result);
+            return result;
         },
         set onerror(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onerror = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onerror', arguments);
+            lwVm.memory.private_data.get(this).onerror = value + "";
         },
         get onmessage() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onmessage, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onmessage, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onmessage', arguments, result);
+            return result;
         },
         set onmessage(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onmessage = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onmessage', arguments);
+            lwVm.memory.private_data.get(this).onmessage = value + "";
         },
         get onopen() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onopen, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onopen, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onopen', arguments, result);
+            return result;
         },
         set onopen(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onopen = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onopen', arguments);
+            lwVm.memory.private_data.get(this).onopen = value + "";
         },
         get ordered() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ordered, true);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ordered, true);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'ordered', arguments, result);
+            return result;
         },
         get protocol() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).protocol, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).protocol, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'protocol', arguments, result);
+            return result;
         },
         get readyState() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).readyState, "connecting");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).readyState, "connecting");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'readyState', arguments, result);
+            return result;
         },
         get reliable() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).reliable, true);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).reliable, true);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'reliable', arguments, result);
+            return result;
         },
         send() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCDataChannel', 'send', arguments, result);
+            return result;
         }
     };
 
-    qxVm.rename(RTCDataChannel.prototype, "RTCDataChannel");
-    qxVm.safeDescriptor_addConstructor(RTCDataChannel);
-    qxVm.safe_Objattribute(RTCDataChannel, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCDataChannel.prototype, "RTCDataChannel");
+    lwVm.safeDescriptor_addConstructor(RTCDataChannel);
+    lwVm.safe_Objattribute(RTCDataChannel, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(RTCDataChannel.prototype, EventTarget.prototype);
     Object.setPrototypeOf(RTCDataChannel, EventTarget);

qxVm_sanbox/env/BOM/RTC/RTCIceCandidate.js

@@ -1,9 +1,9 @@
 RTCIceCandidate = function RTCIceCandidate(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(RTCIceCandidate);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(RTCIceCandidate);
 
 ; (function () {
     const $safe_get_attribute = ['address', 'candidate', 'component', 'foundation', 'port', 'priority', 'protocol', 'relatedAddress', 'relatedPort', 'sdpMLineIndex', 'sdpMid', 'tcpType', 'type', 'usernameFragment'];
@@ -12,83 +12,99 @@ RTCIceCandidate = function RTCIceCandidate(createObj_key) {
 
     RTCIceCandidate.prototype = {
         get address() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).address, "192.168.0.103");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).address, "192.168.0.103");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'address', arguments, result);
+            return result;
         },
         get candidate() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).candidate, "candidate:1840965416 1 udp 2122260223 192.168.0.103 49325 typ host generation 0 ufrag o6U2 network-id 1 network-cost 10");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).candidate, "candidate:1840965416 1 udp 2122260223 192.168.0.103 49325 typ host generation 0 ufrag o6U2 network-id 1 network-cost 10");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'candidate', arguments, result);
+            return result;
         },
         get component() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).component, "rtp");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).component, "rtp");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'component', arguments, result);
+            return result;
         },
         get foundation() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).foundation, "1840965416");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).foundation, "1840965416");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'foundation', arguments, result);
+            return result;
         },
         get port() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).port, 49325);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).port, 49325);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'port', arguments, result);
+            return result;
         },
         get priority() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).priority, 2122260223);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).priority, 2122260223);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'priority', arguments, result);
+            return result;
         },
         get protocol() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).protocol, "udp");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).protocol, "udp");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'protocol', arguments, result);
+            return result;
         },
         get relatedAddress() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).relatedAddress, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).relatedAddress, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'relatedAddress', arguments, result);
+            return result;
         },
         get relatedPort() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).relatedPort, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).relatedPort, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'relatedPort', arguments, result);
+            return result;
         },
         get sdpMLineIndex() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).sdpMLineIndex, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).sdpMLineIndex, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'sdpMLineIndex', arguments, result);
+            return result;
         },
         get sdpMid() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).sdpMid, "1");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).sdpMid, "1");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'sdpMid', arguments, result);
+            return result;
         },
         get tcpType() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).tcpType, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).tcpType, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'tcpType', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCIceCandidate', 'toJSON', arguments, result);
+            return result;
         },
         get type() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).type, "host");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).type, "host");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'type', arguments, result);
+            return result;
         },
         get usernameFragment() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).usernameFragment, "o6U2");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).usernameFragment, "o6U2");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'usernameFragment', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(RTCIceCandidate.prototype, "RTCIceCandidate");
-    qxVm.safeDescriptor_addConstructor(RTCIceCandidate);
-    qxVm.safe_Objattribute(RTCIceCandidate, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCIceCandidate.prototype, "RTCIceCandidate");
+    lwVm.safeDescriptor_addConstructor(RTCIceCandidate);
+    lwVm.safe_Objattribute(RTCIceCandidate, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/RTC/RTCPeerConnection.js

@@ -3,8 +3,8 @@ RTCPeerConnection = function RTCPeerConnection() {//构造函数
 		throw new TypeError(`Failed to construct 'RTCPeerConnection': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
 
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(RTCPeerConnection);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(RTCPeerConnection);
 
 ; (function () {
     const $safe_get_attribute = [
@@ -21,280 +21,340 @@ RTCPeerConnection = function RTCPeerConnection() {//构造函数
 
     RTCPeerConnection.prototype = {
         addIceCandidate() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'addIceCandidate', arguments, result);
+            return result;
         },
         addStream() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'addStream', arguments, result);
+            return result;
         },
         addTrack() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'addTrack', arguments, result);
+            return result;
         },
         addTransceiver() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'addTransceiver', arguments, result);
+            return result;
         },
         get canTrickleIceCandidates() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).canTrickleIceCandidates, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).canTrickleIceCandidates, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'canTrickleIceCandidates', arguments, result);
+            return result;
         },
         close() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'close', arguments, result);
+            return result;
         },
         get connectionState() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).connectionState, "new");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).connectionState, "new");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'connectionState', arguments, result);
+            return result;
         },
         createAnswer() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'createAnswer', arguments, result);
+            return result;
         },
         createDTMFSender() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'createDTMFSender', arguments, result);
+            return result;
         },
         createDataChannel(label) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (label === undefined) { throw new TypeError(`Failed to execute 'createDataChannel' on 'RTCPeerConnection': 1 argument required, but only 0 present.`) }
-            return new RTCDataChannel(qxVm.memory.$createObj_key, label);
+            let result = new RTCDataChannel(lwVm.memory.$createObj_key, label);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'createDataChannel', arguments, result);
+            return result;
         },
         async createOffer(successCallback, failureCallback) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
 
             return new Promise(resolve=>{
                 return function(offer){
                     console.log(offer)
-                    resolve(new RTCSessionDescription(qxVm.memory.$createObj_key))
+                    resolve(new RTCSessionDescription(lwVm.memory.$createObj_key))
                 }
             })
         },
         get currentLocalDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).currentLocalDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).currentLocalDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'currentLocalDescription', arguments, result);
+            return result;
         },
         get currentRemoteDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).currentRemoteDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).currentRemoteDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'currentRemoteDescription', arguments, result);
+            return result;
         },
         getConfiguration() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getConfiguration', arguments, result);
+            return result;
         },
         getLocalStreams() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getLocalStreams', arguments, result);
+            return result;
         },
         getReceivers() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getReceivers', arguments, result);
+            return result;
         },
         getRemoteStreams() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getRemoteStreams', arguments, result);
+            return result;
         },
         getSenders() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getSenders', arguments, result);
+            return result;
         },
         getStats() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getStats', arguments, result);
+            return result;
         },
         getTransceivers() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getTransceivers', arguments, result);
+            return result;
         },
         get iceConnectionState() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).iceConnectionState, "new");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).iceConnectionState, "new");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'iceConnectionState', arguments, result);
+            return result;
         },
         get iceGatheringState() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).iceGatheringState, "new");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).iceGatheringState, "new");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'iceGatheringState', arguments, result);
+            return result;
         },
         get localDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).localDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).localDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'localDescription', arguments, result);
+            return result;
         },
         get onaddstream() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onaddstream, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onaddstream, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onaddstream', arguments, result);
+            return result;
         },
         set onaddstream(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onaddstream = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onaddstream', arguments);
+            lwVm.memory.private_data.get(this).onaddstream = value + "";
         },
         get onconnectionstatechange() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onconnectionstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onconnectionstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onconnectionstatechange', arguments, result);
+            return result;
         },
         set onconnectionstatechange(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onconnectionstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onconnectionstatechange', arguments);
+            lwVm.memory.private_data.get(this).onconnectionstatechange = value + "";
         },
         get ondatachannel() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ondatachannel, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ondatachannel, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'ondatachannel', arguments, result);
+            return result;
         },
         set ondatachannel(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).ondatachannel = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'ondatachannel', arguments);
+            lwVm.memory.private_data.get(this).ondatachannel = value + "";
         },
         get onicecandidate() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onicecandidate, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onicecandidate, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onicecandidate', arguments, result);
+            return result;
         },
         set onicecandidate(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onicecandidate = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onicecandidate', arguments);
+            lwVm.memory.private_data.get(this).onicecandidate = value;
         },
         get onicecandidateerror() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onicecandidateerror, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onicecandidateerror, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onicecandidateerror', arguments, result);
+            return result;
         },
         set onicecandidateerror(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onicecandidateerror = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onicecandidateerror', arguments);
+            lwVm.memory.private_data.get(this).onicecandidateerror = value + "";
         },
         get oniceconnectionstatechange() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).oniceconnectionstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).oniceconnectionstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'oniceconnectionstatechange', arguments, result);
+            return result;
         },
         set oniceconnectionstatechange(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).oniceconnectionstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'oniceconnectionstatechange', arguments);
+            lwVm.memory.private_data.get(this).oniceconnectionstatechange = value + "";
         },
         get onicegatheringstatechange() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onicegatheringstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onicegatheringstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onicegatheringstatechange', arguments, result);
+            return result;
         },
         set onicegatheringstatechange(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onicegatheringstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onicegatheringstatechange', arguments);
+            lwVm.memory.private_data.get(this).onicegatheringstatechange = value + "";
         },
         get onnegotiationneeded() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onnegotiationneeded, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onnegotiationneeded, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onnegotiationneeded', arguments, result);
+            return result;
         },
         set onnegotiationneeded(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onnegotiationneeded = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onnegotiationneeded', arguments);
+            lwVm.memory.private_data.get(this).onnegotiationneeded = value + "";
         },
         get onremovestream() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onremovestream, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onremovestream, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onremovestream', arguments, result);
+            return result;
         },
         set onremovestream(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onremovestream = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onremovestream', arguments);
+            lwVm.memory.private_data.get(this).onremovestream = value + "";
         },
         get onsignalingstatechange() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onsignalingstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onsignalingstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onsignalingstatechange', arguments, result);
+            return result;
         },
         set onsignalingstatechange(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onsignalingstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onsignalingstatechange', arguments);
+            lwVm.memory.private_data.get(this).onsignalingstatechange = value + "";
         },
         get ontrack() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ontrack, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ontrack, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'ontrack', arguments, result);
+            return result;
         },
         set ontrack(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).ontrack = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'ontrack', arguments);
+            lwVm.memory.private_data.get(this).ontrack = value + "";
         },
         get pendingLocalDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).pendingLocalDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).pendingLocalDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'pendingLocalDescription', arguments, result);
+            return result;
         },
         get pendingRemoteDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).pendingRemoteDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).pendingRemoteDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'pendingRemoteDescription', arguments, result);
+            return result;
         },
         get remoteDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).remoteDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).remoteDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'remoteDescription', arguments, result);
+            return result;
         },
         removeStream() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'removeStream', arguments, result);
+            return result;
         },
         removeTrack() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'removeTrack', arguments, result);
+            return result;
         },
         restartIce() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'restartIce', arguments, result);
+            return result;
         },
         get sctp() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).sctp, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).sctp, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'sctp', arguments, result);
+            return result;
         },
         setConfiguration() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'setConfiguration', arguments, result);
+            return result;
         },
         async setLocalDescription(session) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             this.localDescription = session;
             this.pendingLocalDescription = session;
-            return Promise.resolve()
+            let result = Promise.resolve();
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'async setLocalDescription', arguments, result);
+            return result;
         },
         setRemoteDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'setRemoteDescription', arguments, result);
+            return result;
         },
         get signalingState() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).signalingState, "stable");
+            return lwVm.abs(lwVm.memory.private_data.get(this).signalingState, "stable");
         }
     };
 
-    qxVm.rename(RTCPeerConnection.prototype, "RTCPeerConnection");
-    qxVm.safeDescriptor_addConstructor(RTCPeerConnection);
-    qxVm.safe_Objattribute(RTCPeerConnection, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCPeerConnection.prototype, "RTCPeerConnection");
+    lwVm.safeDescriptor_addConstructor(RTCPeerConnection);
+    lwVm.safe_Objattribute(RTCPeerConnection, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(RTCPeerConnection.prototype, EventTarget.prototype);
     Object.setPrototypeOf(RTCPeerConnection, EventTarget);

qxVm_sanbox/env/BOM/RTC/RTCPeerConnectionIceEvent.js

@@ -1,9 +1,9 @@
 RTCPeerConnectionIceEvent = function RTCPeerConnectionIceEvent(createObj_key, type) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, { type: type })
-}; qxVm.safefunction(RTCPeerConnectionIceEvent);
+    lwVm.memory.private_data.set(this, { type: type })
+}; lwVm.safefunction(RTCPeerConnectionIceEvent);
 
 ; (function () {
     const $safe_get_attribute = ['candidate'];
@@ -12,14 +12,15 @@ RTCPeerConnectionIceEvent = function RTCPeerConnectionIceEvent(createObj_key, ty
 
     RTCPeerConnectionIceEvent.prototype = {
         get candidate() {
-            debugger;
             if (!RTCPeerConnectionIceEvent.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).candidate, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).candidate, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnectionIceEvent', 'candidate', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(RTCPeerConnectionIceEvent.prototype, "RTCPeerConnectionIceEvent");
-    qxVm.safeDescriptor_addConstructor(RTCPeerConnectionIceEvent);
-    qxVm.safe_Objattribute(RTCPeerConnectionIceEvent, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCPeerConnectionIceEvent.prototype, "RTCPeerConnectionIceEvent");
+    lwVm.safeDescriptor_addConstructor(RTCPeerConnectionIceEvent);
+    lwVm.safe_Objattribute(RTCPeerConnectionIceEvent, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(RTCPeerConnectionIceEvent.prototype, Event.prototype);
     Object.setPrototypeOf(RTCPeerConnectionIceEvent, Event);

qxVm_sanbox/env/BOM/RTC/RTCSessionDescription.js

@@ -1,9 +1,9 @@
 RTCSessionDescription = function RTCSessionDescription(createObj_key, sdp, type) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, { sdp: sdp, type: type })
-}; qxVm.safefunction(RTCSessionDescription);
+    lwVm.memory.private_data.set(this, { sdp: sdp, type: type })
+}; lwVm.safefunction(RTCSessionDescription);
 
 ; (function () {
     const $safe_get_attribute = ['sdp', 'type'];
@@ -12,34 +12,38 @@ RTCSessionDescription = function RTCSessionDescription(createObj_key, sdp, type)
 
     RTCSessionDescription.prototype = {
         get sdp() {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).sdp, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).sdp, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSessionDescription', 'sdp', arguments, result);
+            return result;
         },
         set sdp(value) {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).sdp = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCSessionDescription', 'sdp', arguments);
+            lwVm.memory.private_data.get(this).sdp = value + "";
         },
         toJSON() {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCSessionDescription', 'toJSON', arguments, result);
+            return result;
         },
         get type() {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).type, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).type, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSessionDescription', 'type', arguments, result);
+            return result;
         },
         set type(value) {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).type = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCSessionDescription', 'type', arguments);
+            lwVm.memory.private_data.get(this).type = value + "";
         },
     };
 
-    qxVm.rename(RTCSessionDescription.prototype, "RTCSessionDescription");
-    qxVm.safeDescriptor_addConstructor(RTCSessionDescription);
-    qxVm.safe_Objattribute(RTCSessionDescription, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCSessionDescription.prototype, "RTCSessionDescription");
+    lwVm.safeDescriptor_addConstructor(RTCSessionDescription);
+    lwVm.safe_Objattribute(RTCSessionDescription, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/RTCDataChannel.js

@@ -1,9 +1,9 @@
 RTCDataChannel = function RTCDataChannel(createObj_key, label) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {label:label})
-}; qxVm.safefunction(RTCDataChannel);
+    lwVm.memory.private_data.set(this, {label:label})
+}; lwVm.safefunction(RTCDataChannel);
 
 ; (function () {
     const $safe_get_attribute = ['binaryType', 'bufferedAmount', 'bufferedAmountLowThreshold', 'id', 'label', 'maxRetransmitTime', 'maxRetransmits', 'negotiated', 'onbufferedamountlow', 'onclose', 'onerror', 'onmessage', 'onopen', 'ordered', 'protocol', 'readyState', 'reliable'];
@@ -12,143 +12,164 @@ RTCDataChannel = function RTCDataChannel(createObj_key, label) {//构造函数
     RTCDataChannel.prototype = {
 
         get binaryType() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).binaryType, "arraybuffer");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).binaryType, "arraybuffer");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'binaryType', arguments, result);
+            return result;
         },
         set binaryType(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).binaryType = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'binaryType', arguments);
+            lwVm.memory.private_data.get(this).binaryType = value + "";
         },
         get bufferedAmount() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).bufferedAmount, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).bufferedAmount, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'bufferedAmount', arguments, result);
+            return result;
         },
         set bufferedAmount(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).bufferedAmount = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'bufferedAmount', arguments);
+            lwVm.memory.private_data.get(this).bufferedAmount = value;
         },
         get bufferedAmountLowThreshold() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).bufferedAmountLowThreshold, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).bufferedAmountLowThreshold, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'bufferedAmountLowThreshold', arguments, result);
+            return result;
         },
         set bufferedAmountLowThreshold(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).bufferedAmountLowThreshold = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'bufferedAmountLowThreshold', arguments);
+            lwVm.memory.private_data.get(this).bufferedAmountLowThreshold = value;
         },
         close() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCDataChannel', 'close', arguments, result);
+            return result;
         },
         get id() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).id, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).id, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'id', arguments, result);
+            return result;
         },
         get label() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).label;
+            let result = lwVm.memory.private_data.get(this).label;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'label', arguments, result);
+            return result;
         },
         get maxRetransmitTime() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).maxRetransmitTime, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).maxRetransmitTime, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'maxRetransmitTime', arguments, result);
+            return result;
         },
         get maxRetransmits() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).maxRetransmits, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).maxRetransmits, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'maxRetransmits', arguments, result);
+            return result;
         },
         get negotiated() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).negotiated, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).negotiated, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'negotiated', arguments, result);
+            return result;
         },
         get onbufferedamountlow() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onbufferedamountlow, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onbufferedamountlow, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onbufferedamountlow', arguments, result);
+            return result;
         },
         set onbufferedamountlow(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onbufferedamountlow = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onbufferedamountlow', arguments);
+            lwVm.memory.private_data.get(this).onbufferedamountlow = value + "";
         },
         get onclose() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onclose, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onclose, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onclose', arguments, result);
+            return result;
         },
         set onclose(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onclose = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onclose', arguments);
+            lwVm.memory.private_data.get(this).onclose = value + "";
         },
         get onerror() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onerror, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onerror, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onerror', arguments, result);
+            return result;
         },
         set onerror(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onerror = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onerror', arguments);
+            lwVm.memory.private_data.get(this).onerror = value + "";
         },
         get onmessage() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onmessage, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onmessage, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onmessage', arguments, result);
+            return result;
         },
         set onmessage(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onmessage = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onmessage', arguments);
+            lwVm.memory.private_data.get(this).onmessage = value + "";
         },
         get onopen() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onopen, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onopen, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'onopen', arguments, result);
+            return result;
         },
         set onopen(value) {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onopen = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCDataChannel', 'onopen', arguments);
+            lwVm.memory.private_data.get(this).onopen = value + "";
         },
         get ordered() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ordered, true);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ordered, true);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'ordered', arguments, result);
+            return result;
         },
         get protocol() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).protocol, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).protocol, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'protocol', arguments, result);
+            return result;
         },
         get readyState() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).readyState, "connecting");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).readyState, "connecting");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'readyState', arguments, result);
+            return result;
         },
         get reliable() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).reliable, true);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).reliable, true);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCDataChannel', 'reliable', arguments, result);
+            return result;
         },
         send() {
-            debugger;
             if (!RTCDataChannel.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCDataChannel', 'send', arguments, result);
+            return result;
         }
     };
 
-    qxVm.rename(RTCDataChannel.prototype, "RTCDataChannel");
-    qxVm.safeDescriptor_addConstructor(RTCDataChannel);
-    qxVm.safe_Objattribute(RTCDataChannel, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCDataChannel.prototype, "RTCDataChannel");
+    lwVm.safeDescriptor_addConstructor(RTCDataChannel);
+    lwVm.safe_Objattribute(RTCDataChannel, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(RTCDataChannel.prototype, EventTarget.prototype);
     Object.setPrototypeOf(RTCDataChannel, EventTarget);

qxVm_sanbox/env/BOM/RTCIceCandidate.js

@@ -1,9 +1,9 @@
 RTCIceCandidate = function RTCIceCandidate(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(RTCIceCandidate);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(RTCIceCandidate);
 
 ; (function () {
     const $safe_get_attribute = ['address', 'candidate', 'component', 'foundation', 'port', 'priority', 'protocol', 'relatedAddress', 'relatedPort', 'sdpMLineIndex', 'sdpMid', 'tcpType', 'type', 'usernameFragment'];
@@ -12,83 +12,99 @@ RTCIceCandidate = function RTCIceCandidate(createObj_key) {
 
     RTCIceCandidate.prototype = {
         get address() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).address, "192.168.0.103");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).address, "192.168.0.103");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'address', arguments, result);
+            return result;
         },
         get candidate() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).candidate, "candidate:1840965416 1 udp 2122260223 192.168.0.103 49325 typ host generation 0 ufrag o6U2 network-id 1 network-cost 10");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).candidate, "candidate:1840965416 1 udp 2122260223 192.168.0.103 49325 typ host generation 0 ufrag o6U2 network-id 1 network-cost 10");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'candidate', arguments, result);
+            return result;
         },
         get component() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).component, "rtp");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).component, "rtp");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'component', arguments, result);
+            return result;
         },
         get foundation() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).foundation, "1840965416");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).foundation, "1840965416");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'foundation', arguments, result);
+            return result;
         },
         get port() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).port, 49325);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).port, 49325);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'port', arguments, result);
+            return result;
         },
         get priority() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).priority, 2122260223);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).priority, 2122260223);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'priority', arguments, result);
+            return result;
         },
         get protocol() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).protocol, "udp");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).protocol, "udp");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'protocol', arguments, result);
+            return result;
         },
         get relatedAddress() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).relatedAddress, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).relatedAddress, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'relatedAddress', arguments, result);
+            return result;
         },
         get relatedPort() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).relatedPort, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).relatedPort, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'relatedPort', arguments, result);
+            return result;
         },
         get sdpMLineIndex() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).sdpMLineIndex, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).sdpMLineIndex, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'sdpMLineIndex', arguments, result);
+            return result;
         },
         get sdpMid() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).sdpMid, "1");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).sdpMid, "1");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'sdpMid', arguments, result);
+            return result;
         },
         get tcpType() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).tcpType, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).tcpType, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'tcpType', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCIceCandidate', 'toJSON', arguments, result);
+            return result;
         },
         get type() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).type, "host");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).type, "host");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'type', arguments, result);
+            return result;
         },
         get usernameFragment() {
-            debugger;
             if (!RTCIceCandidate.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).usernameFragment, "o6U2");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).usernameFragment, "o6U2");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCIceCandidate', 'usernameFragment', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(RTCIceCandidate.prototype, "RTCIceCandidate");
-    qxVm.safeDescriptor_addConstructor(RTCIceCandidate);
-    qxVm.safe_Objattribute(RTCIceCandidate, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCIceCandidate.prototype, "RTCIceCandidate");
+    lwVm.safeDescriptor_addConstructor(RTCIceCandidate);
+    lwVm.safe_Objattribute(RTCIceCandidate, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/RTCPeerConnection.js

@@ -3,8 +3,8 @@ RTCPeerConnection = function RTCPeerConnection() {//构造函数
 		throw new TypeError(`Failed to construct 'RTCPeerConnection': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
 
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(RTCPeerConnection);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(RTCPeerConnection);
 
 ; (function () {
     const $safe_get_attribute = [
@@ -21,280 +21,340 @@ RTCPeerConnection = function RTCPeerConnection() {//构造函数
 
     RTCPeerConnection.prototype = {
         addIceCandidate() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'addIceCandidate', arguments, result);
+            return result;
         },
         addStream() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'addStream', arguments, result);
+            return result;
         },
         addTrack() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'addTrack', arguments, result);
+            return result;
         },
         addTransceiver() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'addTransceiver', arguments, result);
+            return result;
         },
         get canTrickleIceCandidates() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).canTrickleIceCandidates, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).canTrickleIceCandidates, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'canTrickleIceCandidates', arguments, result);
+            return result;
         },
         close() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'close', arguments, result);
+            return result;
         },
         get connectionState() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).connectionState, "new");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).connectionState, "new");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'connectionState', arguments, result);
+            return result;
         },
         createAnswer() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'createAnswer', arguments, result);
+            return result;
         },
         createDTMFSender() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'createDTMFSender', arguments, result);
+            return result;
         },
         createDataChannel(label) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (label === undefined) { throw new TypeError(`Failed to execute 'createDataChannel' on 'RTCPeerConnection': 1 argument required, but only 0 present.`) }
-            return new RTCDataChannel(qxVm.memory.$createObj_key, label);
+            let result = new RTCDataChannel(lwVm.memory.$createObj_key, label);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'createDataChannel', arguments, result);
+            return result;
         },
         async createOffer(successCallback, failureCallback) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
 
             return new Promise(resolve=>{
                 return function(offer){
                     console.log(offer)
-                    resolve(new RTCSessionDescription(qxVm.memory.$createObj_key))
+                    resolve(new RTCSessionDescription(lwVm.memory.$createObj_key))
                 }
             })
         },
         get currentLocalDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).currentLocalDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).currentLocalDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'currentLocalDescription', arguments, result);
+            return result;
         },
         get currentRemoteDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).currentRemoteDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).currentRemoteDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'currentRemoteDescription', arguments, result);
+            return result;
         },
         getConfiguration() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getConfiguration', arguments, result);
+            return result;
         },
         getLocalStreams() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getLocalStreams', arguments, result);
+            return result;
         },
         getReceivers() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getReceivers', arguments, result);
+            return result;
         },
         getRemoteStreams() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getRemoteStreams', arguments, result);
+            return result;
         },
         getSenders() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getSenders', arguments, result);
+            return result;
         },
         getStats() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getStats', arguments, result);
+            return result;
         },
         getTransceivers() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'getTransceivers', arguments, result);
+            return result;
         },
         get iceConnectionState() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).iceConnectionState, "new");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).iceConnectionState, "new");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'iceConnectionState', arguments, result);
+            return result;
         },
         get iceGatheringState() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).iceGatheringState, "new");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).iceGatheringState, "new");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'iceGatheringState', arguments, result);
+            return result;
         },
         get localDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).localDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).localDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'localDescription', arguments, result);
+            return result;
         },
         get onaddstream() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onaddstream, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onaddstream, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onaddstream', arguments, result);
+            return result;
         },
         set onaddstream(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onaddstream = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onaddstream', arguments);
+            lwVm.memory.private_data.get(this).onaddstream = value + "";
         },
         get onconnectionstatechange() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onconnectionstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onconnectionstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onconnectionstatechange', arguments, result);
+            return result;
         },
         set onconnectionstatechange(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onconnectionstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onconnectionstatechange', arguments);
+            lwVm.memory.private_data.get(this).onconnectionstatechange = value + "";
         },
         get ondatachannel() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ondatachannel, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ondatachannel, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'ondatachannel', arguments, result);
+            return result;
         },
         set ondatachannel(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).ondatachannel = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'ondatachannel', arguments);
+            lwVm.memory.private_data.get(this).ondatachannel = value + "";
         },
         get onicecandidate() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onicecandidate, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onicecandidate, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onicecandidate', arguments, result);
+            return result;
         },
         set onicecandidate(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onicecandidate = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onicecandidate', arguments);
+            lwVm.memory.private_data.get(this).onicecandidate = value;
         },
         get onicecandidateerror() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onicecandidateerror, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onicecandidateerror, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onicecandidateerror', arguments, result);
+            return result;
         },
         set onicecandidateerror(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onicecandidateerror = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onicecandidateerror', arguments);
+            lwVm.memory.private_data.get(this).onicecandidateerror = value + "";
         },
         get oniceconnectionstatechange() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).oniceconnectionstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).oniceconnectionstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'oniceconnectionstatechange', arguments, result);
+            return result;
         },
         set oniceconnectionstatechange(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).oniceconnectionstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'oniceconnectionstatechange', arguments);
+            lwVm.memory.private_data.get(this).oniceconnectionstatechange = value + "";
         },
         get onicegatheringstatechange() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onicegatheringstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onicegatheringstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onicegatheringstatechange', arguments, result);
+            return result;
         },
         set onicegatheringstatechange(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onicegatheringstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onicegatheringstatechange', arguments);
+            lwVm.memory.private_data.get(this).onicegatheringstatechange = value + "";
         },
         get onnegotiationneeded() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onnegotiationneeded, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onnegotiationneeded, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onnegotiationneeded', arguments, result);
+            return result;
         },
         set onnegotiationneeded(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onnegotiationneeded = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onnegotiationneeded', arguments);
+            lwVm.memory.private_data.get(this).onnegotiationneeded = value + "";
         },
         get onremovestream() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onremovestream, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onremovestream, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onremovestream', arguments, result);
+            return result;
         },
         set onremovestream(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onremovestream = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onremovestream', arguments);
+            lwVm.memory.private_data.get(this).onremovestream = value + "";
         },
         get onsignalingstatechange() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onsignalingstatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onsignalingstatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'onsignalingstatechange', arguments, result);
+            return result;
         },
         set onsignalingstatechange(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onsignalingstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'onsignalingstatechange', arguments);
+            lwVm.memory.private_data.get(this).onsignalingstatechange = value + "";
         },
         get ontrack() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ontrack, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ontrack, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'ontrack', arguments, result);
+            return result;
         },
         set ontrack(value) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).ontrack = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCPeerConnection', 'ontrack', arguments);
+            lwVm.memory.private_data.get(this).ontrack = value + "";
         },
         get pendingLocalDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).pendingLocalDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).pendingLocalDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'pendingLocalDescription', arguments, result);
+            return result;
         },
         get pendingRemoteDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).pendingRemoteDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).pendingRemoteDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'pendingRemoteDescription', arguments, result);
+            return result;
         },
         get remoteDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).remoteDescription, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).remoteDescription, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'remoteDescription', arguments, result);
+            return result;
         },
         removeStream() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'removeStream', arguments, result);
+            return result;
         },
         removeTrack() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'removeTrack', arguments, result);
+            return result;
         },
         restartIce() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'restartIce', arguments, result);
+            return result;
         },
         get sctp() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).sctp, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).sctp, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnection', 'sctp', arguments, result);
+            return result;
         },
         setConfiguration() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'setConfiguration', arguments, result);
+            return result;
         },
         async setLocalDescription(session) {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             this.localDescription = session;
             this.pendingLocalDescription = session;
-            return Promise.resolve()
+            let result = Promise.resolve();
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'async setLocalDescription', arguments, result);
+            return result;
         },
         setRemoteDescription() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCPeerConnection', 'setRemoteDescription', arguments, result);
+            return result;
         },
         get signalingState() {
-            debugger;
             if (!RTCPeerConnection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).signalingState, "stable");
+            return lwVm.abs(lwVm.memory.private_data.get(this).signalingState, "stable");
         }
     };
 
-    qxVm.rename(RTCPeerConnection.prototype, "RTCPeerConnection");
-    qxVm.safeDescriptor_addConstructor(RTCPeerConnection);
-    qxVm.safe_Objattribute(RTCPeerConnection, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCPeerConnection.prototype, "RTCPeerConnection");
+    lwVm.safeDescriptor_addConstructor(RTCPeerConnection);
+    lwVm.safe_Objattribute(RTCPeerConnection, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(RTCPeerConnection.prototype, EventTarget.prototype);
     Object.setPrototypeOf(RTCPeerConnection, EventTarget);

qxVm_sanbox/env/BOM/RTCPeerConnectionIceEvent.js

@@ -1,9 +1,9 @@
 RTCPeerConnectionIceEvent = function RTCPeerConnectionIceEvent(createObj_key, type) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, { type: type })
-}; qxVm.safefunction(RTCPeerConnectionIceEvent);
+    lwVm.memory.private_data.set(this, { type: type })
+}; lwVm.safefunction(RTCPeerConnectionIceEvent);
 
 ; (function () {
     const $safe_get_attribute = ['candidate'];
@@ -12,14 +12,15 @@ RTCPeerConnectionIceEvent = function RTCPeerConnectionIceEvent(createObj_key, ty
 
     RTCPeerConnectionIceEvent.prototype = {
         get candidate() {
-            debugger;
             if (!RTCPeerConnectionIceEvent.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).candidate, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).candidate, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCPeerConnectionIceEvent', 'candidate', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(RTCPeerConnectionIceEvent.prototype, "RTCPeerConnectionIceEvent");
-    qxVm.safeDescriptor_addConstructor(RTCPeerConnectionIceEvent);
-    qxVm.safe_Objattribute(RTCPeerConnectionIceEvent, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCPeerConnectionIceEvent.prototype, "RTCPeerConnectionIceEvent");
+    lwVm.safeDescriptor_addConstructor(RTCPeerConnectionIceEvent);
+    lwVm.safe_Objattribute(RTCPeerConnectionIceEvent, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(RTCPeerConnectionIceEvent.prototype, Event.prototype);
     Object.setPrototypeOf(RTCPeerConnectionIceEvent, Event);

qxVm_sanbox/env/BOM/RTCSctpTransport.js

@@ -1,9 +1,9 @@
 RTCSctpTransport = function RTCSctpTransport(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(RTCSctpTransport);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(RTCSctpTransport);
 
 ; (function () {
     const $safe_get_attribute = ['maxChannels', 'maxMessageSize', 'onstatechange', 'state', 'transport'];
@@ -12,39 +12,44 @@ RTCSctpTransport = function RTCSctpTransport(createObj_key) {
 
     RTCSctpTransport.prototype = {
         get maxChannels() {
-            debugger;
             if (!RTCSctpTransport.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).maxChannels, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).maxChannels, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSctpTransport', 'maxChannels', arguments, result);
+            return result;
         },
         get maxMessageSize() {
-            debugger;
             if (!RTCSctpTransport.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).maxMessageSize, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).maxMessageSize, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSctpTransport', 'maxMessageSize', arguments, result);
+            return result;
         },
         get onstatechange() {
-            debugger;
             if (!RTCSctpTransport.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onstatechange, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onstatechange, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSctpTransport', 'onstatechange', arguments, result);
+            return result;
         },
         set onstatechange(value) {
-            debugger;
             if (!RTCSctpTransport.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onstatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCSctpTransport', 'onstatechange', arguments);
+            lwVm.memory.private_data.get(this).onstatechange = value + "";
         },
         get state() {
-            debugger;
             if (!RTCSctpTransport.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).state, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).state, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSctpTransport', 'state', arguments, result);
+            return result;
         },
         get transport() {
-            debugger;
             if (!RTCSctpTransport.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).transport, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).transport, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSctpTransport', 'transport', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(RTCSctpTransport.prototype, "RTCSctpTransport");
-    qxVm.safeDescriptor_addConstructor(RTCSctpTransport);
-    qxVm.safe_Objattribute(RTCSctpTransport, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCSctpTransport.prototype, "RTCSctpTransport");
+    lwVm.safeDescriptor_addConstructor(RTCSctpTransport);
+    lwVm.safe_Objattribute(RTCSctpTransport, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(RTCSctpTransport.prototype, EventTarget.prototype);
     Object.setPrototypeOf(RTCSctpTransport, EventTarget);

qxVm_sanbox/env/BOM/RTCSessionDescription.js

@@ -1,9 +1,9 @@
 RTCSessionDescription = function RTCSessionDescription(createObj_key, sdp, type) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, { sdp: sdp, type: type })
-}; qxVm.safefunction(RTCSessionDescription);
+    lwVm.memory.private_data.set(this, { sdp: sdp, type: type })
+}; lwVm.safefunction(RTCSessionDescription);
 
 ; (function () {
     const $safe_get_attribute = ['sdp', 'type'];
@@ -12,34 +12,38 @@ RTCSessionDescription = function RTCSessionDescription(createObj_key, sdp, type)
 
     RTCSessionDescription.prototype = {
         get sdp() {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).sdp, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).sdp, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSessionDescription', 'sdp', arguments, result);
+            return result;
         },
         set sdp(value) {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).sdp = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCSessionDescription', 'sdp', arguments);
+            lwVm.memory.private_data.get(this).sdp = value + "";
         },
         toJSON() {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'RTCSessionDescription', 'toJSON', arguments, result);
+            return result;
         },
         get type() {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).type, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).type, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'RTCSessionDescription', 'type', arguments, result);
+            return result;
         },
         set type(value) {
-            debugger;
             if (!RTCSessionDescription.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).type = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'RTCSessionDescription', 'type', arguments);
+            lwVm.memory.private_data.get(this).type = value + "";
         },
     };
 
-    qxVm.rename(RTCSessionDescription.prototype, "RTCSessionDescription");
-    qxVm.safeDescriptor_addConstructor(RTCSessionDescription);
-    qxVm.safe_Objattribute(RTCSessionDescription, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(RTCSessionDescription.prototype, "RTCSessionDescription");
+    lwVm.safeDescriptor_addConstructor(RTCSessionDescription);
+    lwVm.safe_Objattribute(RTCSessionDescription, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/Request.js

@@ -3,8 +3,8 @@ Request = function Request() {//构造函数
 		throw new TypeError(`Failed to construct 'Request': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
 
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Request);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Request);
 
 ; (function () {
     const $safe_get_attribute = [
@@ -16,109 +16,134 @@ Request = function Request() {//构造函数
 
     Request.prototype = {
         arrayBuffer() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'arrayBuffer', arguments, result);
+            return result;
         },
         blob() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'blob', arguments, result);
+            return result;
         },
         get bodyUsed() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).bodyUsed, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).bodyUsed, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'bodyUsed', arguments, result);
+            return result;
         },
         get cache() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).cache, "default");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).cache, "default");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'cache', arguments, result);
+            return result;
         },
         clone() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'clone', arguments, result);
+            return result;
         },
         get credentials() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).credentials, "same-origin");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).credentials, "same-origin");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'credentials', arguments, result);
+            return result;
         },
         get destination() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).destination, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).destination, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'destination', arguments, result);
+            return result;
         },
         formData() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'formData', arguments, result);
+            return result;
         },
         get headers() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).headers, new class Headers { });
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).headers, new class Headers { });;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'headers', arguments, result);
+            return result;
         },
         get integrity() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).integrity, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).integrity, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'integrity', arguments, result);
+            return result;
         },
         get isHistoryNavigation() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).isHistoryNavigation, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).isHistoryNavigation, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'isHistoryNavigation', arguments, result);
+            return result;
         },
         json() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'json', arguments, result);
+            return result;
         },
         get keepalive() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).keepalive, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).keepalive, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'keepalive', arguments, result);
+            return result;
         },
         get method() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).method, "GET");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).method, "GET");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'method', arguments, result);
+            return result;
         },
         get mode() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).mode, "cors");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).mode, "cors");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'mode', arguments, result);
+            return result;
         },
         get redirect() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).redirect, "follow");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).redirect, "follow");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'redirect', arguments, result);
+            return result;
         },
         get referrer() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).referrer, "about:client");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).referrer, "about:client");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'referrer', arguments, result);
+            return result;
         },
         get referrerPolicy() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).referrerPolicy, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).referrerPolicy, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'referrerPolicy', arguments, result);
+            return result;
         },
         get signal() { // 这个有问题
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).signal, new class AbortSignal { aborted = false; onabort = null });
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).signal, new class AbortSignal { aborted = false; onabort = null });;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Request', 'referrerPolicy', arguments, result);
+            return result;
         },
         text() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Request', 'text', arguments, result);
+            return result;
         },
         get url() {
-            debugger;
             if (!Request.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).url, location.href);
+            return lwVm.abs(lwVm.memory.private_data.get(this).url, location.href);
         }
     };
 
-    qxVm.rename(Request.prototype, "Request");
-    qxVm.safeDescriptor_addConstructor(Request);
-    qxVm.safe_Objattribute(Request, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Request.prototype, "Request");
+    lwVm.safeDescriptor_addConstructor(Request);
+    lwVm.safe_Objattribute(Request, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/Scheduler.js

@@ -1,9 +1,9 @@
 Scheduler = function Scheduler(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Scheduler);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Scheduler);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,13 +12,15 @@ Scheduler = function Scheduler(createObj_key) {
 
     Scheduler.prototype = {
         postTask() {
-            debugger;
             if (!Scheduler.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Scheduler', 'postTask', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(Scheduler.prototype, "Scheduler");
-    qxVm.safeDescriptor_addConstructor(Scheduler);
-    qxVm.safe_Objattribute(Scheduler, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Scheduler.prototype, "Scheduler");
+    lwVm.safeDescriptor_addConstructor(Scheduler);
+    lwVm.safe_Objattribute(Scheduler, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
-scheduler = new Scheduler(qxVm.memory.$createObj_key)
+scheduler = new Scheduler(lwVm.memory.$createObj_key)
 

qxVm_sanbox/env/BOM/Scheduling.js

@@ -1,9 +1,9 @@
 Scheduling = function Scheduling(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Scheduling);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Scheduling);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,12 +12,14 @@ Scheduling = function Scheduling(createObj_key) {
 
     Scheduling.prototype = {
         isInputPending() {
-            debugger;
             if (!Scheduling.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Scheduling', 'isInputPending', arguments, result);
+            return result;
         }
     }
-    qxVm.rename(Scheduling.prototype, "Scheduling");
-    qxVm.safeDescriptor_addConstructor(Scheduling);
-    qxVm.safe_Objattribute(Scheduling, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Scheduling.prototype, "Scheduling");
+    lwVm.safeDescriptor_addConstructor(Scheduling);
+    lwVm.safe_Objattribute(Scheduling, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/BOM/Screen.js

@@ -1,10 +1,10 @@
 Screen = function Screen(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
+    lwVm.memory.private_data.set(this, {})
 };
-qxVm.safefunction(Screen);
+lwVm.safefunction(Screen);
 screen = {};
 ; (function () {
     const $attribute_map = {
@@ -14,12 +14,12 @@ screen = {};
         availWidth: 2560,
         colorDepth: 24,
         height: 1440,
-        orientation: new ScreenOrientation(qxVm.memory.$createObj_key),
+        orientation: new ScreenOrientation(lwVm.memory.$createObj_key),
         pixelDepth: 24,
         width: 2560
     };
     // 将属性更新为用户自定义属性
-    qxVm.updata_envs(qxVm.default_envs['screen'], $attribute_map)
+    lwVm.updata_envs(lwVm.default_envs['screen'], $attribute_map)
 
     const $safe_get_attribute = [
         'availHeight', 'availLeft', 'availTop', 'availWidth', 'colorDepth', 'height', 'orientation', 'pixelDepth', 'width'
@@ -30,44 +30,60 @@ screen = {};
     Screen.prototype = {
         get availHeight() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.availHeight;
+            let result = $attribute_map.availHeight;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Screen', 'availHeight', arguments, result);
+            return result;
         },
         get availLeft() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.availLeft;
+            let result = $attribute_map.availLeft;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Screen', 'availLeft', arguments, result);
+            return result;
         },
         get availTop() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.availTop;
+            let result = $attribute_map.availTop;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Screen', 'availTop', arguments, result);
+            return result;
         },
         get availWidth() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.availWidth;
+            let result = $attribute_map.availWidth;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Screen', 'availWidth', arguments, result);
+            return result;
         },
         get colorDepth() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.colorDepth;
+            let result = $attribute_map.colorDepth;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Screen', 'colorDepth', arguments, result);
+            return result;
         },
         get height() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.height;
+            let result = $attribute_map.height;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Screen', 'height', arguments, result);
+            return result;
         },
         get orientation() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.orientation
+            let result = $attribute_map.orientation;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Screen', 'orientation', arguments, result);
+            return result;
         },
         get pixelDepth() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return $attribute_map.pixelDepth;
+            let result = $attribute_map.pixelDepth;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Screen', 'pixelDepth', arguments, result);
+            return result;
         },
         get width() {
             if (!Screen.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             return $attribute_map.width;
         }
     };
-    qxVm.rename(Screen.prototype, "Screen");
-    qxVm.safeDescriptor_addConstructor(Screen);
-    qxVm.safe_Objattribute(Screen, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Screen.prototype, "Screen");
+    lwVm.safeDescriptor_addConstructor(Screen);
+    lwVm.safe_Objattribute(Screen, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(screen, Screen.prototype);
 

qxVm_sanbox/env/BOM/Storage.js

@@ -1,6 +1,6 @@
 Storage = function Storage() {//构造函数
     throw new TypeError("Illegal constructor");
-}; qxVm.safefunction(Storage);
+}; lwVm.safefunction(Storage);
 
 localStorage = {};
 sessionStorage = {};
@@ -13,35 +13,36 @@ sessionStorage = {};
 
     Storage.prototype = {
         clear() {
-            debugger;
             var temp = Object.keys(this)
             for (var i = 0; temp.length > i; i++) {
                 delete this[temp[i]];
             }
         },
         getItem(k) {
-            debugger;
-            return this[k] ? this[k] : null;
+            let result = this[k] ? this[k] : null;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Storage', 'getItem', arguments, result);
+            return result;
         },
         key(index) {
-            debugger;
-            return Object.keys(this)[index];
+            let result = Object.keys(this)[index];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Storage', 'key', arguments, result);
+            return result;
         },
         get length() {
             if (!Storage.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return Object.keys(this).length;
+            let result = Object.keys(this).length;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'Storage', 'length', arguments, result);
+            return result;
         },
         removeItem(k) {
-            debugger;
             delete this[k];
         },
         setItem(k, v) {
-            debugger;
             this[k] = v;
         }
-    }; qxVm.rename(Storage.prototype, "Storage");
-    qxVm.safeDescriptor_addConstructor(Storage);
-    qxVm.safe_Objattribute(Storage, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    }; lwVm.rename(Storage.prototype, "Storage");
+    lwVm.safeDescriptor_addConstructor(Storage);
+    lwVm.safe_Objattribute(Storage, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(localStorage, Storage.prototype);
     Object.setPrototypeOf(sessionStorage, Storage.prototype);

qxVm_sanbox/env/BOM/UserActivation.js

@@ -1,9 +1,9 @@
 UserActivation = function UserActivation(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(UserActivation);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(UserActivation);
 
 ; (function () {
     const $safe_get_attribute = ['hasBeenActive', 'isActive'];
@@ -12,19 +12,19 @@ UserActivation = function UserActivation(createObj_key) {
 
     UserActivation.prototype = {
         get hasBeenActive() {
-            debugger;
             if (!UserActivation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return true;
+            let result = true;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'UserActivation', 'hasBeenActive', arguments, result);
+            return result;
         },
         get isActive() {
-            debugger;
             if (!UserActivation.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             return false;
         }
     }
-    qxVm.rename(UserActivation.prototype, "UserActivation");
-    qxVm.safeDescriptor_addConstructor(UserActivation);
-    qxVm.safe_Objattribute(UserActivation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(UserActivation.prototype, "UserActivation");
+    lwVm.safeDescriptor_addConstructor(UserActivation);
+    lwVm.safe_Objattribute(UserActivation, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/BOM/WakeLock.js

@@ -1,9 +1,9 @@
 WakeLock = function WakeLock(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(WakeLock);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(WakeLock);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,12 +12,14 @@ WakeLock = function WakeLock(createObj_key) {
 
     WakeLock.prototype = {
         request() {
-            debugger;
             if (!WakeLock.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'WakeLock', 'request', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(WakeLock.prototype, "WakeLock");
-    qxVm.safeDescriptor_addConstructor(WakeLock);
-    qxVm.safe_Objattribute(WakeLock, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(WakeLock.prototype, "WakeLock");
+    lwVm.safeDescriptor_addConstructor(WakeLock);
+    lwVm.safe_Objattribute(WakeLock, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
 

qxVm_sanbox/env/BOM/Window.js

@@ -3,7 +3,7 @@
 Window = function Window() {
     throw new TypeError("Illegal constructor");
 }; 
-qxVm.safefunction(Window);
+lwVm.safefunction(Window);
 window = this;
 
 ; (function () {
@@ -11,10 +11,10 @@ window = this;
     let WindowProperties = (function () {
         let WindowProperties = function WindowProperties() {
             throw new TypeError("Illegal constructor");
-        }; qxVm.safefunction(WindowProperties);
+        }; lwVm.safefunction(WindowProperties);
 
         delete WindowProperties.prototype.constructor;
-        qxVm.rename(WindowProperties.prototype, "WindowProperties");
+        lwVm.rename(WindowProperties.prototype, "WindowProperties");
         Object.setPrototypeOf(WindowProperties.prototype, EventTarget.prototype);
         return WindowProperties;
     })();
@@ -24,8 +24,8 @@ window = this;
         PERSISTENT: 1
     };
 
-    qxVm.rename(Window.prototype, "Window");
-    qxVm.add_capitalLetter_attribute(Window, $attributes);
+    lwVm.rename(Window.prototype, "Window");
+    lwVm.add_capitalLetter_attribute(Window, $attributes);
 
     Object.setPrototypeOf(WindowProperties.prototype, EventTarget.prototype);
     Object.setPrototypeOf(Window.prototype, WindowProperties.prototype);

qxVm_sanbox/env/BOM/Worklet.js

@@ -1,9 +1,9 @@
 Worklet = function Worklet(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(Worklet);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(Worklet);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,12 +12,14 @@ Worklet = function Worklet(createObj_key) {
 
     Worklet.prototype = {
         addModule() {
-            debugger;
             if (!Worklet.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'Worklet', 'addModule', arguments, result);
+            return result;
         }
     }
-    qxVm.rename(Worklet.prototype, "Worklet");
-    qxVm.safeDescriptor_addConstructor(Worklet);
-    qxVm.safe_Objattribute(Worklet, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(Worklet.prototype, "Worklet");
+    lwVm.safeDescriptor_addConstructor(Worklet);
+    lwVm.safe_Objattribute(Worklet, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
 

qxVm_sanbox/env/BOM/XMLHttpRequest.js

@@ -3,8 +3,8 @@ XMLHttpRequest = function XMLHttpRequest() {//构造函数
 		throw new TypeError(`Failed to construct 'XMLHttpRequest': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
 
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(XMLHttpRequest);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(XMLHttpRequest);
 ; (function () {
     const $attributes = {
         DONE: 4,
@@ -22,118 +22,139 @@ XMLHttpRequest = function XMLHttpRequest() {//构造函数
     
     XMLHttpRequest.prototype = {
         abort() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'abort', arguments, result);
+            return result;
         },
         getAllResponseHeaders() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'getAllResponseHeaders', arguments, result);
+            return result;
         },
         getResponseHeader() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'getResponseHeader', arguments, result);
+            return result;
         },
         get onreadystatechange() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onreadystatechange, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onreadystatechange, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'onreadystatechange', arguments, result);
+            return result;
         },
         set onreadystatechange(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onreadystatechange = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequest', 'onreadystatechange', arguments);
+            lwVm.memory.private_data.get(this).onreadystatechange = value + "";
         },
         open() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'open', arguments, result);
+            return result;
         },
         overrideMimeType() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'overrideMimeType', arguments, result);
+            return result;
         },
         get readyState() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).readyState, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).readyState, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'readyState', arguments, result);
+            return result;
         },
         get response() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).response, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).response, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'response', arguments, result);
+            return result;
         },
         set response(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).response = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequest', 'response', arguments);
+            lwVm.memory.private_data.get(this).response = value + "";
         },
         get responseText() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).responseText, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).responseText, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'responseText', arguments, result);
+            return result;
         },
         get responseType() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).responseType, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).responseType, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'responseType', arguments, result);
+            return result;
         },
         set responseType(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).responseType = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequest', 'responseType', arguments);
+            lwVm.memory.private_data.get(this).responseType = value + "";
         },
         get responseURL() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).responseURL, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).responseURL, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'responseURL', arguments, result);
+            return result;
         },
         get responseXML() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).responseXML, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).responseXML, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'responseXML', arguments, result);
+            return result;
         },
         send(body) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return body
+            let result = body;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'send', arguments, result);
+            return result;
         },
         setRequestHeader() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'XMLHttpRequest', 'setRequestHeader', arguments, result);
+            return result;
         },
         get status() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).status, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).status, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'status', arguments, result);
+            return result;
         },
         get statusText() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).statusText, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).statusText, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'statusText', arguments, result);
+            return result;
         },
         get timeout() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).timeout, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).timeout, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'timeout', arguments, result);
+            return result;
         },
         set timeout(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).timeout = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequest', 'timeout', arguments);
+            lwVm.memory.private_data.get(this).timeout = value + "";
         },
         get upload() {  //  XMLHttpRequestUpload
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).upload, "");
         },
         get withCredentials() {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).withCredentials, false);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).withCredentials, false);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequest', 'withCredentials', arguments, result);
+            return result;
         },
         set withCredentials(value) {
-            debugger;
             if (!XMLHttpRequest.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).withCredentials = value;
+            lwVm.memory.private_data.get(this).withCredentials = value;
         }
     }
 
@@ -145,9 +166,9 @@ XMLHttpRequest = function XMLHttpRequest() {//构造函数
         }
     };
 
-    qxVm.rename(XMLHttpRequest.prototype, "XMLHttpRequest");
-    qxVm.safeDescriptor_addConstructor(XMLHttpRequest);
-    qxVm.safe_Objattribute(XMLHttpRequest, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(XMLHttpRequest.prototype, "XMLHttpRequest");
+    lwVm.safeDescriptor_addConstructor(XMLHttpRequest);
+    lwVm.safe_Objattribute(XMLHttpRequest, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(XMLHttpRequest.prototype, XMLHttpRequestEventTarget.prototype);
     Object.setPrototypeOf(XMLHttpRequest, XMLHttpRequestEventTarget);

qxVm_sanbox/env/BOM/XMLHttpRequestEventTarget.js

@@ -1,9 +1,9 @@
 XMLHttpRequestEventTarget = function XMLHttpRequestEventTarget(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(XMLHttpRequestEventTarget);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(XMLHttpRequestEventTarget);
 
 ; (function () {
     const $safe_get_attribute = ['onabort', 'onerror', 'onload', 'onloadend', 'onloadstart', 'onprogress', 'ontimeout'];
@@ -12,80 +12,86 @@ XMLHttpRequestEventTarget = function XMLHttpRequestEventTarget(createObj_key) {/
 
     XMLHttpRequestEventTarget.prototype = {
         get onabort() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onabort, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onabort, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onabort', arguments, result);
+            return result;
         },
         set onabort(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onabort = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onabort', arguments);
+            lwVm.memory.private_data.get(this).onabort = value + "";
         },
         get onerror() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onerror, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onerror, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onerror', arguments, result);
+            return result;
         },
         set onerror(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onerror = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onerror', arguments);
+            lwVm.memory.private_data.get(this).onerror = value + "";
         },
         get onload() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onload, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onload, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onload', arguments, result);
+            return result;
         },
         set onload(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onload = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onload', arguments);
+            lwVm.memory.private_data.get(this).onload = value + "";
         },
         get onloadend() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onloadend, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onloadend, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onloadend', arguments, result);
+            return result;
         },
         set onloadend(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onloadend = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onloadend', arguments);
+            lwVm.memory.private_data.get(this).onloadend = value + "";
         },
         get onloadstart() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onloadstart, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onloadstart, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onloadstart', arguments, result);
+            return result;
         },
         set onloadstart(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onloadstart = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onloadstart', arguments);
+            lwVm.memory.private_data.get(this).onloadstart = value + "";
         },
         get onprogress() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).onprogress, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).onprogress, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'onprogress', arguments, result);
+            return result;
         },
         set onprogress(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).onprogress = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'XMLHttpRequestEventTarget', 'onprogress', arguments);
+            lwVm.memory.private_data.get(this).onprogress = value + "";
         },
         get ontimeout() {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ontimeout, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ontimeout, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'XMLHttpRequestEventTarget', 'ontimeout', arguments, result);
+            return result;
         },
         set ontimeout(value) {
-            debugger;
             if (!XMLHttpRequestEventTarget.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).ontimeout = value + "";
+            lwVm.memory.private_data.get(this).ontimeout = value + "";
         }
     }
 
-    qxVm.rename(XMLHttpRequestEventTarget.prototype, "XMLHttpRequestEventTarget");
-    qxVm.safeDescriptor_addConstructor(XMLHttpRequestEventTarget);
-    qxVm.safe_Objattribute(XMLHttpRequestEventTarget, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(XMLHttpRequestEventTarget.prototype, "XMLHttpRequestEventTarget");
+    lwVm.safeDescriptor_addConstructor(XMLHttpRequestEventTarget);
+    lwVm.safe_Objattribute(XMLHttpRequestEventTarget, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(XMLHttpRequestEventTarget.prototype, EventTarget.prototype);
     Object.setPrototypeOf(XMLHttpRequestEventTarget, EventTarget);

qxVm_sanbox/env/BOM/chrome.js

@@ -15,34 +15,24 @@ chrome = {
             SORTING_CODE: "SORTING_CODE"
         },
         getAddressComponents() {
-            debugger;
         },
         getAddressComponents() {
-            debugger;
         },
         getAddressList() {
-            debugger;
         },
         getCountryList() {
-            debugger;
         },
         getCreditCardList() {
-            debugger;
         },
         getUpiIdList() {
-            debugger;
         },
         logServerCardLinkClicked() {
-            debugger;
         },
         maskCreditCard() {
-            debugger;
         },
         migrateCreditCards() {
-            debugger;
         },
         get onPersonalDataChanged() {
-            debugger;
             return {
                 addListener() { debugger; },
                 dispatch() { debugger; },
@@ -52,29 +42,21 @@ chrome = {
             }
         },
         set onPersonalDataChanged(value) {
-            debugger;
         },
         removeEntry() {
-            debugger;
         },
         saveAddress() {
-            debugger;
         },
         saveCreditCard() {
-            debugger;
         },
         setCreditCardFIDOAuthEnabledState() {
-            debugger;
         },
         validatePhoneNumbers() {
-            debugger;
         }
     },
     csi: function csi() {
-        debugger;
     },
     getVariableValue() {
-        debugger;
     },
     inputMethodPrivate: {
         AutoCapitalizeType: {
@@ -120,154 +102,104 @@ chrome = {
             UNDERLINE: "underline",
         },
         addWordToDictionary() {
-            debugger;
         },
         fetchAllDictionaryWords() {
-            debugger;
         },
         finishComposingText() {
-            debugger;
         },
         getAutocorrectCharacterBounds() {
-            debugger;
         },
         getAutocorrectRange() {
-            debugger;
         },
         getCompositionBounds() {
-            debugger;
         },
         getCurrentInputMethod() {
-            debugger;
         },
         getEncryptSyncEnabled() {
-            debugger;
         },
         getInputMethodConfig() {
-            debugger;
         },
         getInputMethods() {
-            debugger;
         },
         getSettings() {
-            debugger;
         },
         getSurroundingText() {
-            debugger;
         },
         getTextFieldBounds() {
-            debugger;
         },
         hideInputView() {
-            debugger;
         },
         notifyImeMenuItemActivated() {
-            debugger;
         },
         onAutocorrect() {
-            debugger;
         },
         get onChanged() {
-            debugger;
         },
         set onChanged(value) {
-            debugger;
         },
         get onCompositionBoundsChanged() {
-            debugger;
         },
         set onCompositionBoundsChanged(value) {
-            debugger;
         },
         get onDictionaryChanged() {
-            debugger;
         },
         set onDictionaryChanged(value) {
-            debugger;
         },
         get onDictionaryLoaded() {
-            debugger;
         },
         set onDictionaryLoaded(value) {
-            debugger;
         },
         get onFocus() {
-            debugger;
         },
         set onFocus(value) {
-            debugger;
         },
         get onImeMenuActivationChanged() {
-            debugger;
         },
         set onImeMenuActivationChanged(value) {
-            debugger;
         },
         get onImeMenuItemsChanged() {
-            debugger;
         },
         set onImeMenuItemsChanged(value) {
-            debugger;
         },
         get onImeMenuListChanged() {
-            debugger;
         },
         set onImeMenuListChanged(value) {
-            debugger;
         },
         get onInputMethodOptionsChanged() {
-            debugger;
         },
         set onInputMethodOptionsChanged(value) {
-            debugger;
         },
         get onScreenProjectionChanged() {
-            debugger;
         },
         set onScreenProjectionChanged(value) {
-            debugger;
         },
         get onSettingsChanged() {
-            debugger;
         },
         set onSettingsChanged(value) {
-            debugger;
         },
         get onSuggestionsChanged() {
-            debugger;
         },
         set onSuggestionsChanged(value) {
-            debugger;
         },
         openOptionsPage() {
-            debugger;
         },
         reset() {
-            debugger;
         },
         setAutocorrectRange() {
-            debugger;
         },
         setComposingRange() {
-            debugger;
         },
         setCompositionRange() {
-            debugger;
         },
         setCurrentInputMethod() {
-            debugger;
         },
         setSelectionRange() {
-            debugger;
         },
         setSettings() {
-            debugger;
         },
         setXkbLayout() {
-            debugger;
         },
         showInputView() {
-            debugger;
         },
     },
     languageSettingsPrivate: {
@@ -278,96 +210,68 @@ chrome = {
             UP: "UP",
         },
         addInputMethod() {
-            debugger;
         },
         addSpellcheckWord() {
-            debugger;
         },
         disableLanguage() {
-            debugger;
         },
         enableLanguage() {
-            debugger;
         },
         getAlwaysTranslateLanguages() {
-            debugger;
         },
         getInputMethodLists() {
-            debugger;
         },
         getLanguageList() {
-            debugger;
         },
         getNeverTranslateLanguages() {
-            debugger;
         },
         getSpellcheckDictionaryStatuses() {
-            debugger;
         },
         getSpellcheckWords() {
-            debugger;
         },
         getTranslateTargetLanguage() {
-            debugger;
         },
         moveLanguage() {
-            debugger;
         },
         onCustomDictionaryChanged: {
             addListener() {
-                debugger;
             },
             dispatch() {
-                debugger;
             },
             hasListener() {
-                debugger;
             },
             hasListeners() {
-                debugger;
             },
             removeListener() {
-                debugger;
             }
         },
         get onInputMethodAdded() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
         set onInputMethodAdded(value) {
-            debugger;
         },
         get onInputMethodRemoved() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
@@ -376,43 +280,31 @@ chrome = {
         },
         onSpellcheckDictionariesChanged: {
             addListener() {
-                debugger;
             },
             dispatch() {
-                debugger;
             },
             hasListener() {
-                debugger;
             },
             hasListeners() {
-                debugger;
             },
             removeListener() {
-                debugger;
             }
         },
         removeInputMethod() {
-            debugger;
         },
         removeSpellcheckWord() {
-            debugger;
         },
         retryDownloadDictionary() {
-            debugger;
         },
         setEnableTranslationForLanguage() {
-            debugger;
         },
         setLanguageAlwaysTranslateState() {
-            debugger;
         },
         setTranslateTargetLanguage() {
-            debugger;
         },
 
     },
     loadTimes: function loadTimes() {
-        debugger;
     },
     management: {
         ExtensionDisabledReason: {
@@ -441,83 +333,60 @@ chrome = {
             OPEN_FULL_SCREEN: "OPEN_FULL_SCREEN",
         },
         createAppShortcut() {
-            debugger;
         },
         generateAppForLink() {
-            debugger;
         },
         get() {
-            debugger;
         },
         getAll() {
-            debugger;
         },
         getPermissionWarningsById() {
-            debugger;
         },
         launchApp() {
-            debugger;
         },
         get onDisabled() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
         set onDisabled(value) {
-            debugger;
         },
         get onEnabled() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
         set onEnabled(value) {
-            debugger;
         },
         get onInstalled() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
@@ -527,19 +396,14 @@ chrome = {
         get onUninstalled() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
@@ -547,13 +411,10 @@ chrome = {
             debugger
         },
         setEnabled() {
-            debugger;
         },
         setLaunchType() {
-            debugger;
         },
         uninstall() {
-            debugger;
         }
     },
     metricsPrivate: {
@@ -562,52 +423,36 @@ chrome = {
             HISTOGRAM_LOG: "histogram-log"
         },
         getFieldTrial() {
-            debugger;
         },
         getHistogram() {
-            debugger;
         },
         getVariationParams() {
-            debugger;
         },
         recordBoolean() {
-            debugger;
         },
         recordCount() {
-            debugger;
         },
         recordEnumerationValue() {
-            debugger;
         },
         recordLongTime() {
-            debugger;
         },
         recordMediumCount() {
-            debugger;
         },
         recordMediumTime() {
-            debugger;
         },
         recordPercentage() {
-            debugger;
         },
         recordSmallCount() {
-            debugger;
         },
         recordSparseHashable() {
-            debugger;
         },
         recordSparseValue() {
-            debugger;
         },
         recordTime() {
-            debugger;
         },
         recordUserAction() {
-            debugger;
         },
         recordValue() {
-            debugger;
         }
     },
     passwordsPrivate: {
@@ -639,69 +484,48 @@ chrome = {
             VIEW: "VIEW"
         },
         addPassword() {
-            debugger;
         },
         cancelExportPasswords() {
-            debugger;
         },
         changeInsecureCredential() {
-            debugger;
         },
         changeSavedPassword() {
-            debugger;
         },
         exportPasswords() {
-            debugger;
         },
         getCompromisedCredentials() {
-            debugger;
         },
         getPasswordCheckStatus() {
-            debugger;
         },
         getPasswordExceptionList() {
-            debugger;
         },
         getPlaintextInsecurePassword() {
-            debugger;
         },
         getSavedPasswordList() {
-            debugger;
         },
         getUrlCollection() {
-            debugger;
         },
         getWeakCredentials() {
-            debugger;
         },
         importPasswords() {
-            debugger;
         },
         isAccountStoreDefault() {
-            debugger;
         },
         isOptedInForAccountStorage() {
-            debugger;
         },
         movePasswordsToAccount() {
-            debugger;
         },
         get onAccountStorageOptInStateChanged() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
@@ -710,37 +534,27 @@ chrome = {
         },
         onCompromisedCredentialsChanged: {
             addListener() {
-                debugger;
             },
             dispatch() {
-                debugger;
             },
             hasListener() {
-                debugger;
             },
             hasListeners() {
-                debugger;
             },
             removeListener() {
-                debugger;
             }
         },
         get onPasswordExceptionsListChanged() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
@@ -750,19 +564,14 @@ chrome = {
         get onPasswordsFileExportProgress() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
@@ -772,19 +581,14 @@ chrome = {
         get onSavedPasswordsListChanged() {
             return {
                 addListener() {
-                    debugger;
                 },
                 dispatch() {
-                    debugger;
                 },
                 hasListener() {
-                    debugger;
                 },
                 hasListeners() {
-                    debugger;
                 },
                 removeListener() {
-                    debugger;
                 }
             }
         },
@@ -793,56 +597,39 @@ chrome = {
         },
         onWeakCredentialsChanged: {
             addListener() {
-                debugger;
             },
             dispatch() {
-                debugger;
             },
             hasListener() {
-                debugger;
             },
             hasListeners() {
-                debugger;
             },
             removeListener() {
-                debugger;
             }
         },
         optInForAccountStorage() {
-            debugger;
         },
         recordPasswordsPageAccessInSettings() {
-            debugger;
         },
         removeInsecureCredential() {
-            debugger;
         },
         removePasswordException() {
-            debugger;
         },
         removePasswordExceptions() {
-            debugger;
         },
         removeSavedPassword() {
-            debugger;
         },
         removeSavedPasswords() {
-            debugger;
         },
         requestExportProgressStatus() {
-            debugger;
         },
         requestPlaintextPassword() {
-            debugger;
         },
         startPasswordCheck() {
-            debugger;
         },
         stopPasswordCheck() {
-            debugger;
         },
         undoRemoveSavedPasswordOrException() {
-            debugger;
         }
     },
     runtime: {
@@ -889,11 +676,9 @@ chrome = {
             return undefined;
         },
         set id(value) {
-            debugger;
         }
     },
     send() {
-        debugger;
     },
     settingsPrivate: {
         ControlledBy: {
@@ -919,36 +704,26 @@ chrome = {
             URL: "URL"
         },
         getAllPrefs() {
-            debugger;
         },
         getDefaultZoom() {
-            debugger;
         },
         getPref() {
-            debugger;
         },
         onPrefsChanged: {
             addListener() {
-                debugger;
             },
             dispatch() {
-                debugger;
             },
             hasListener() {
-                debugger;
             },
             hasListeners() {
-                debugger;
             },
             removeListener() {
-                debugger;
             }
         },
         setDefaultZoom() {
-            debugger;
         },
         setPref() {
-            debugger;
         }
     }
 }

qxVm_sanbox/env/BOM/timer.js

@@ -1,35 +1,35 @@
 ; (function () {
     let timer = {
         setTimeout(callback, ...arg) {
-            const timer_obj = qxVm_module.node_func.setTimeout(callback, ...arg);
-            const timer_id = parseInt(Object.keys(qxVm.memory.timer_map).sort((a, b) => {
+            const timer_obj = lwVm_module.node_func.setTimeout(callback, ...arg);
+            const timer_id = parseInt(Object.keys(lwVm.memory.timer_map).sort((a, b) => {
                 return a - b;
             }).pop()) + 1;
-            qxVm.memory.timer_map[timer_id] = timer_obj
+            lwVm.memory.timer_map[timer_id] = timer_obj
             return timer_id;
         },
         setInterval(callback, ...arg) {
-            const timer_obj = qxVm_module.node_func.setInterval(callback, ...arg);
-            const timer_id = parseInt(Object.keys(qxVm.memory.timer_map).sort((a, b) => {
+            const timer_obj = lwVm_module.node_func.setInterval(callback, ...arg);
+            const timer_id = parseInt(Object.keys(lwVm.memory.timer_map).sort((a, b) => {
                 return a - b;
             }).pop()) + 1;
-            qxVm.memory.timer_map[timer_id] = timer_obj
+            lwVm.memory.timer_map[timer_id] = timer_obj
             return timer_id;
         },
         clearTimeout(timer_id) {
-            const timer_obj = qxVm.memory.timer_map[timer_id];
-            return qxVm_module.node_func.clearTimeout(timer_obj)
+            const timer_obj = lwVm.memory.timer_map[timer_id];
+            return lwVm_module.node_func.clearTimeout(timer_obj)
         },
         clearInterval(timer_id) {
-            const timer_obj = qxVm.memory.timer_map[timer_id];
-            return qxVm_module.node_func.clearInterval(timer_obj)
+            const timer_obj = lwVm.memory.timer_map[timer_id];
+            return lwVm_module.node_func.clearInterval(timer_obj)
         }
     };
     for (const key in timer) {
         if (Object.hasOwnProperty.call(timer, key)) {
             const timer_obj = timer[key];
             
-            qxVm.safefunction(timer_obj);
+            lwVm.safefunction(timer_obj);
 
             Object.defineProperty(window, timer_obj.name, {
                 value: timer_obj,

qxVm_sanbox/env/BOM/window.attributes.js

@@ -292,9 +292,9 @@ self = window;
             }
             Object.defineProperty(window, key, desc);
 
-            qxVm.safefunction(Object.getOwnPropertyDescriptor(window, key)['get'], `get ${key}`, true);
+            lwVm.safefunction(Object.getOwnPropertyDescriptor(window, key)['get'], `get ${key}`, true);
             if (set === true) {
-                qxVm.safefunction(Object.getOwnPropertyDescriptor(window, key)['set'], `set ${key}`, true);
+                lwVm.safefunction(Object.getOwnPropertyDescriptor(window, key)['set'], `set ${key}`, true);
             }
         }
     };
@@ -310,7 +310,7 @@ self = window;
             Object.defineProperty(window, key, {
                 value: value, configurable: configurable, enumerable: enumerable, writable: writable
             });
-            qxVm.safefunction(Object.getOwnPropertyDescriptor(window, key)['value'])
+            lwVm.safefunction(Object.getOwnPropertyDescriptor(window, key)['value'])
         }
     }
 

qxVm_sanbox/env/DOM/Attr.js

@@ -1,6 +1,6 @@
 Attr = function Attr() {//构造函数
     throw new TypeError("Illegal constructor");
-}; qxVm.safefunction(Attr);
+}; lwVm.safefunction(Attr);
 
 ; (function () {
     const $safe_get_attribute = [
@@ -11,42 +11,35 @@ Attr = function Attr() {//构造函数
 
     Attr.prototype = {
         get localName(){
-            debugger;
             if (!Attr.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             
         },
         get name(){
-            debugger;
             if (!Attr.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             
         },
         get namespaceURI(){
-            debugger;
             if (!Attr.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
         },
         get ownerElement(){
-            debugger;
             if (!Attr.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
         },
         get prefix(){
-            debugger;
             if (!Attr.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
         },
         get specified(){
-            debugger;
             if (!Attr.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
         },
         get value(){
-            debugger;
             if (!Attr.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
         },
         set value(value){
         }
     };
-    qxVm.rename(Attr.prototype, "Attr");
-    qxVm.safeDescriptor_addConstructor(Attr);
+    lwVm.rename(Attr.prototype, "Attr");
+    lwVm.safeDescriptor_addConstructor(Attr);
     // debugger;
-    qxVm.safe_Objattribute(Attr, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.safe_Objattribute(Attr, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 
     Object.setPrototypeOf(Attr.prototype, Node.prototype);

qxVm_sanbox/env/DOM/CDATASection.js

@@ -1,9 +1,9 @@
 CDATASection = function CDATASection(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(CDATASection);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(CDATASection);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -11,9 +11,9 @@ CDATASection = function CDATASection(createObj_key) {
     const $safe_func_attribute = [];
 
     CDATASection.prototype = { }
-    qxVm.rename(CDATASection.prototype, "CDATASection");
-    qxVm.safeDescriptor_addConstructor(CDATASection);
-    qxVm.safe_Objattribute(CDATASection, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(CDATASection.prototype, "CDATASection");
+    lwVm.safeDescriptor_addConstructor(CDATASection);
+    lwVm.safe_Objattribute(CDATASection, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(CDATASection.prototype, Text.prototype);
     Object.setPrototypeOf(CDATASection, Text);

qxVm_sanbox/env/DOM/CSS.js

@@ -1,103 +1,71 @@
 CSS = {
     Hz() {
-        debugger;
     },
     Q() {
-        debugger;
     },
     ch() {
-        debugger;
     },
     cm() {
-        debugger;
     },
     deg() {
-        debugger;
     },
     dpcm() {
-        debugger;
     },
     dpi() {
-        debugger;
     },
     dppx() {
-        debugger;
     },
     em() {
-        debugger;
     },
     escape() {
-        debugger;
     },
     ex() {
-        debugger;
     },
     fr() {
-        debugger;
     },
     grad() {
-        debugger;
     },
     in() {
-        debugger;
     },
     kHz() {
-        debugger;
     },
     mm() {
-        debugger;
     },
     ms() {
-        debugger;
     },
     number() {
-        debugger;
     },
     pc() {
-        debugger;
     },
     percent() {
-        debugger;
     },
     pt() {
-        debugger;
     },
     px() {
-        debugger;
     },
     rad() {
-        debugger;
     },
     registerProperty() {
-        debugger;
     },
     rem() {
-        debugger;
     },
     s() {
-        debugger;
     },
     supports() {
-        debugger;
         return true;
     },
     turn() {
-        debugger;
     },
     vh() {
-        debugger;
     },
     vmax() {
-        debugger;
     },
     vmin() {
-        debugger;
     },
     vw() {
-        debugger;
     }
 };
-qxVm.rename(CSS, 'CSS');
+lwVm.rename(CSS, 'CSS');
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -107,6 +75,6 @@ qxVm.rename(CSS, 'CSS');
         'px', 'rad', 'registerProperty', 'rem', 's', 'supports', 'turn', 'vh', 'vmax', 'vmin', 'vw'
     ];
 
-    qxVm.safe_Objattribute(CSS, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute, true);
+    lwVm.safe_Objattribute(CSS, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute, true);
 })();
 

qxVm_sanbox/env/DOM/CSSStyleDeclaration.js

@@ -1,9 +1,9 @@
 CSSStyleDeclaration = function CSSStyleDeclaration(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(CSSStyleDeclaration);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(CSSStyleDeclaration);
 
 ; (function () {
     const $safe_get_attribute = ['cssFloat', 'cssText', 'length', 'parentRule'];
@@ -12,60 +12,74 @@ CSSStyleDeclaration = function CSSStyleDeclaration(createObj_key) {//构造函
     CSSStyleDeclaration.prototype = {
 
         get cssFloat() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).cssFloat, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).cssFloat, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CSSStyleDeclaration', 'cssFloat', arguments, result);
+            return result;
         },
         set cssFloat(value) {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).cssFloat = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CSSStyleDeclaration', 'cssFloat', arguments);
+            lwVm.memory.private_data.get(this).cssFloat = value + "";
         },
         get cssText() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).cssText, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).cssText, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CSSStyleDeclaration', 'cssText', arguments, result);
+            return result;
         },
         set cssText(value) {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).cssText = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CSSStyleDeclaration', 'cssText', arguments);
+            lwVm.memory.private_data.get(this).cssText = value + "";
         },
         getPropertyPriority() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CSSStyleDeclaration', 'getPropertyPriority', arguments, result);
+            return result;
         },
         getPropertyValue() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CSSStyleDeclaration', 'getPropertyValue', arguments, result);
+            return result;
         },
         item() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CSSStyleDeclaration', 'item', arguments, result);
+            return result;
         },
         get length() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).length, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).length, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CSSStyleDeclaration', 'length', arguments, result);
+            return result;
         },
         get parentRule() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).parentRule, null);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).parentRule, null);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CSSStyleDeclaration', 'parentRule', arguments, result);
+            return result;
         },
         removeProperty() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CSSStyleDeclaration', 'removeProperty', arguments, result);
+            return result;
         },
         setProperty() {
-            debugger;
             if (!CSSStyleDeclaration.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CSSStyleDeclaration', 'setProperty', arguments, result);
+            return result;
         }
     }
 
-    qxVm.rename(CSSStyleDeclaration.prototype, "CSSStyleDeclaration");
-    qxVm.safeDescriptor_addConstructor(CSSStyleDeclaration);
-    qxVm.safe_Objattribute(CSSStyleDeclaration, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(CSSStyleDeclaration.prototype, "CSSStyleDeclaration");
+    lwVm.safeDescriptor_addConstructor(CSSStyleDeclaration);
+    lwVm.safe_Objattribute(CSSStyleDeclaration, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/DOM/CanvasRenderingContext2D.js

@@ -1,9 +1,9 @@
 CanvasRenderingContext2D = function CanvasRenderingContext2D(createObj_key, canvas) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {canvas: canvas})
-}; qxVm.safefunction(CanvasRenderingContext2D);
+    lwVm.memory.private_data.set(this, {canvas: canvas})
+}; lwVm.safefunction(CanvasRenderingContext2D);
 
 ; (function () {
     const $safe_get_attribute = [
@@ -26,124 +26,162 @@ CanvasRenderingContext2D = function CanvasRenderingContext2D(createObj_key, canv
 
     CanvasRenderingContext2D.prototype = {
         arc(x, y, radius, startAngle, endAngle, anticlockwise) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'arc', arguments, result);
+            return result;
         },
         arcTo(x1, y1, x2, y2, radius) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'arcTo', arguments, result);
+            return result;
         },
         beginPath() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'beginPath', arguments, result);
+            return result;
         },
         bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'bezierCurveTo', arguments, result);
+            return result;
         },
         get canvas() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.memory.private_data.get(this).canvas;
+            let result = lwVm.memory.private_data.get(this).canvas;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'canvas', arguments, result);
+            return result;
         },
         clearRect(x, y, width, height) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'clearRect', arguments, result);
+            return result;
         },
         clip() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'clip', arguments, result);
+            return result;
         },
         closePath() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'closePath', arguments, result);
+            return result;
         },
         createImageData(width, height) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'createImageData', arguments, result);
+            return result;
         },
         createLinearGradient(x0, y0, x1, y1) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'createLinearGradient', arguments, result);
+            return result;
         },
         createPattern(image, repetition) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'createPattern', arguments, result);
+            return result;
         },
         createRadialGradient(x0, y0, r0, x1, y1, r1) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'createRadialGradient', arguments, result);
+            return result;
         },
         get direction() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).direction, "ltr");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).direction, "ltr");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'direction', arguments, result);
+            return result;
         },
         set direction(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).direction = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'direction', arguments);
+            lwVm.memory.private_data.get(this).direction = value + "";
         },
         drawFocusIfNeeded(path, element) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'drawFocusIfNeeded', arguments, result);
+            return result;
         },
         drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'drawImage', arguments, result);
+            return result;
         },
         ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, counterclockwise) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'ellipse', arguments, result);
+            return result;
         },
         fill(path, fillRule) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'fill', arguments, result);
+            return result;
         },
         fillRect(x, y, width, height) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'fillRect', arguments, result);
+            return result;
         },
         get fillStyle() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).fillStyle, "#000000");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).fillStyle, "#000000");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'fillStyle', arguments, result);
+            return result;
         },
         set fillStyle(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
 
             // if (value.slice(0, 1) !== "#" || value.length !== 7) {
             //     return
             // }
-            qxVm.memory.private_data.get(this).fillStyle = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'fillStyle', arguments);
+            lwVm.memory.private_data.get(this).fillStyle = value + "";
         },
         fillText(text, x, y, maxWidth) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'fillText', arguments, result);
+            return result;
         },
         get filter() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).filter, "none");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).filter, "none");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'filter', arguments, result);
+            return result;
         },
         set filter(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).filter = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'filter', arguments);
+            lwVm.memory.private_data.get(this).filter = value + "";
         },
         get font() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).font, "10px sans-serif");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).font, "10px sans-serif");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'font', arguments, result);
+            return result;
         },
         set font(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).font = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'font', arguments);
+            lwVm.memory.private_data.get(this).font = value + "";
         },
         getContextAttributes() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             return {
                 alpha: true,
@@ -152,16 +190,18 @@ CanvasRenderingContext2D = function CanvasRenderingContext2D(createObj_key, canv
             }
         },
         getImageData(sx, sy, sw, sh) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'getImageData', arguments, result);
+            return result;
         },
         getLineDash() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return [];
+            let result = [];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'getLineDash', arguments, result);
+            return result;
         },
         getTransform() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             return new (class DOMMatrix {
                 a = 1;
@@ -191,287 +231,336 @@ CanvasRenderingContext2D = function CanvasRenderingContext2D(createObj_key, canv
             })
         },
         get globalAlpha() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).globalAlpha, 1);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).globalAlpha, 1);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'globalAlpha', arguments, result);
+            return result;
         },
         set globalAlpha(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).globalAlpha = value === 1 ? 1 : 0;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'globalAlpha', arguments);
+            lwVm.memory.private_data.get(this).globalAlpha = value === 1 ? 1 : 0;
         },
         get globalCompositeOperation() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).globalCompositeOperation, "source-over");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).globalCompositeOperation, "source-over");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'globalCompositeOperation', arguments, result);
+            return result;
         },
         set globalCompositeOperation(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).globalCompositeOperation = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'globalCompositeOperation', arguments);
+            lwVm.memory.private_data.get(this).globalCompositeOperation = value + "";
         },
         get imageSmoothingEnabled() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).imageSmoothingEnabled, true);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).imageSmoothingEnabled, true);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'imageSmoothingEnabled', arguments, result);
+            return result;
         },
         set imageSmoothingEnabled(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).imageSmoothingEnabled = value === 0 ? false : true;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'imageSmoothingEnabled', arguments);
+            lwVm.memory.private_data.get(this).imageSmoothingEnabled = value === 0 ? false : true;
         },
         get imageSmoothingQuality() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).imageSmoothingQuality, "low");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).imageSmoothingQuality, "low");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'imageSmoothingQuality', arguments, result);
+            return result;
         },
         set imageSmoothingQuality(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).imageSmoothingQuality = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'imageSmoothingQuality', arguments);
+            lwVm.memory.private_data.get(this).imageSmoothingQuality = value + "";
         },
         isPointInPath(path, x, y, fillRule) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'isPointInPath', arguments, result);
+            return result;
         },
         isPointInStroke(path, x, y) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'isPointInStroke', arguments, result);
+            return result;
         },
         get lineCap() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).lineCap, "butt");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).lineCap, "butt");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'lineCap', arguments, result);
+            return result;
         },
         set lineCap(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).lineCap = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'lineCap', arguments);
+            lwVm.memory.private_data.get(this).lineCap = value + "";
         },
         get lineDashOffset() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).lineDashOffset, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).lineDashOffset, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'lineDashOffset', arguments, result);
+            return result;
         },
         set lineDashOffset(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (value === true) {
-                qxVm.memory.private_data.get(this).lineDashOffset = 1;
+                lwVm.memory.private_data.get(this).lineDashOffset = 1;
             }else{
                 if (!isNaN(parseFloat(value)) && isFinite(value)){
-                    qxVm.memory.private_data.get(this).lineDashOffset =  parseInt(value);
+                    lwVm.memory.private_data.get(this).lineDashOffset =  parseInt(value);
                 }
             }
         },
         get lineJoin() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).lineJoin, "miter");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).lineJoin, "miter");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'lineJoin', arguments, result);
+            return result;
         },
         set lineJoin(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).lineJoin = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'lineJoin', arguments);
+            lwVm.memory.private_data.get(this).lineJoin = value + "";
         },
         lineTo(x, y) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'lineTo', arguments, result);
+            return result;
         },
         get lineWidth() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).lineWidth, 1);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).lineWidth, 1);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'lineWidth', arguments, result);
+            return result;
         },
         set lineWidth(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (value === true) {
-                qxVm.memory.private_data.get(this).lineWidth = 1;
+                lwVm.memory.private_data.get(this).lineWidth = 1;
             }else{
                 if (!isNaN(parseFloat(value)) && isFinite(value)){
-                    qxVm.memory.private_data.get(this).lineWidth =  parseInt(value);
+                    lwVm.memory.private_data.get(this).lineWidth =  parseInt(value);
                 }
             }
         },
         measureText(text) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'measureText', arguments, result);
+            return result;
         },
         get miterLimit() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).miterLimit, 10);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).miterLimit, 10);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'miterLimit', arguments, result);
+            return result;
         },
         set miterLimit(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (value === true) {
-                qxVm.memory.private_data.get(this).miterLimit = 1;
+                lwVm.memory.private_data.get(this).miterLimit = 1;
             }else{
                 if (!isNaN(parseFloat(value)) && isFinite(value)){
-                    qxVm.memory.private_data.get(this).miterLimit =  parseInt(value);
+                    lwVm.memory.private_data.get(this).miterLimit =  parseInt(value);
                 }
             }
         },
         moveTo(x, y) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'moveTo', arguments, result);
+            return result;
         },
         putImageData(imageData, dx, dy, dirtyX, dirtyY, dirtyWidth, dirtyHeight) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'putImageData', arguments, result);
+            return result;
         },
         quadraticCurveTo(cpx, cpy, x, y) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'quadraticCurveTo', arguments, result);
+            return result;
         },
         rect(x, y, width, height) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'rect', arguments, result);
+            return result;
         },
         resetTransform() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'resetTransform', arguments, result);
+            return result;
         },
         restore() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'restore', arguments, result);
+            return result;
         },
         rotate(angle) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'rotate', arguments, result);
+            return result;
         },
         save() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'save', arguments, result);
+            return result;
         },
         scale(x, y) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'scale', arguments, result);
+            return result;
         },
         setLineDash(segments) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'setLineDash', arguments, result);
+            return result;
         },
         setTransform(a, b, c, d, e, f) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'setTransform', arguments, result);
+            return result;
         },
         get shadowBlur() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).shadowBlur, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).shadowBlur, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'shadowBlur', arguments, result);
+            return result;
         },
         set shadowBlur(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (value === true) {
-                qxVm.memory.private_data.get(this).shadowBlur = 1;
+                lwVm.memory.private_data.get(this).shadowBlur = 1;
             }else{
                 if (!isNaN(parseFloat(value)) && isFinite(value)){
-                    qxVm.memory.private_data.get(this).shadowBlur =  parseInt(value);
+                    lwVm.memory.private_data.get(this).shadowBlur =  parseInt(value);
                 }
             }
         },
         get shadowColor() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).shadowColor, "rgba(0, 0, 0, 0)");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).shadowColor, "rgba(0, 0, 0, 0)");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'shadowColor', arguments, result);
+            return result;
         },
         set shadowColor(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).shadowColor = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'shadowColor', arguments);
+            lwVm.memory.private_data.get(this).shadowColor = value + "";
         },
         get shadowOffsetX() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).shadowOffsetX, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).shadowOffsetX, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'shadowOffsetX', arguments, result);
+            return result;
         },
         set shadowOffsetX(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (value === true) {
-                qxVm.memory.private_data.get(this).shadowOffsetX = 1;
+                lwVm.memory.private_data.get(this).shadowOffsetX = 1;
             }else{
                 if (!isNaN(parseFloat(value)) && isFinite(value)){
-                    qxVm.memory.private_data.get(this).shadowOffsetX =  parseInt(value);
+                    lwVm.memory.private_data.get(this).shadowOffsetX =  parseInt(value);
                 }
             }
         },
         get shadowOffsetY() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).shadowOffsetY, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).shadowOffsetY, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'shadowOffsetY', arguments, result);
+            return result;
         },
         set shadowOffsetY(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (value === true) {
-                qxVm.memory.private_data.get(this).shadowOffsetY = 1;
+                lwVm.memory.private_data.get(this).shadowOffsetY = 1;
             }else{
                 if (!isNaN(parseFloat(value)) && isFinite(value)){
-                    qxVm.memory.private_data.get(this).shadowOffsetY =  parseInt(value);
+                    lwVm.memory.private_data.get(this).shadowOffsetY =  parseInt(value);
                 }
             }
         },
         stroke(path) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'stroke', arguments, result);
+            return result;
         },
         strokeRect(x, y, width, height) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'strokeRect', arguments, result);
+            return result;
         },
         get strokeStyle() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).strokeStyle, "#000000");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).strokeStyle, "#000000");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'strokeStyle', arguments, result);
+            return result;
         },
         set strokeStyle(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).strokeStyle = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'strokeStyle', arguments);
+            lwVm.memory.private_data.get(this).strokeStyle = value + "";
         },
         strokeText(text, x, y, maxWidth) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'strokeText', arguments, result);
+            return result;
         },
         get textAlign() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).textAlign, "start");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).textAlign, "start");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'textAlign', arguments, result);
+            return result;
         },
         set textAlign(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).textAlign = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CanvasRenderingContext2D', 'textAlign', arguments);
+            lwVm.memory.private_data.get(this).textAlign = value + "";
         },
         get textBaseline() {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).textBaseline, "alphabetic");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).textBaseline, "alphabetic");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CanvasRenderingContext2D', 'textBaseline', arguments, result);
+            return result;
         },
         set textBaseline(value) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
             if (["top", "hanging", "middle", "alphabetic", "ideographic", "bottom"].includes(value)){
-                qxVm.memory.private_data.get(this).textBaseline = value + "";
+                lwVm.memory.private_data.get(this).textBaseline = value + "";
             }
         },
         transform(a, b, c, d, e, f) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'transform', arguments, result);
+            return result;
         },
         translate(x, y) {
-            debugger;
             if (!CanvasRenderingContext2D.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CanvasRenderingContext2D', 'translate', arguments, result);
+            return result;
         }
     };
 
-    qxVm.rename(CanvasRenderingContext2D.prototype, "CanvasRenderingContext2D");
-    qxVm.safeDescriptor_addConstructor(CanvasRenderingContext2D);
-    qxVm.safe_Objattribute(CanvasRenderingContext2D, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(CanvasRenderingContext2D.prototype, "CanvasRenderingContext2D");
+    lwVm.safeDescriptor_addConstructor(CanvasRenderingContext2D);
+    lwVm.safe_Objattribute(CanvasRenderingContext2D, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/DOM/CharacterData.js

@@ -1,9 +1,9 @@
 CharacterData = function (createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(CharacterData);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(CharacterData);
 
 ; (function () {
     const $safe_get_attribute = ['data', 'length', 'nextElementSibling', 'previousElementSibling'];
@@ -12,71 +12,93 @@ CharacterData = function (createObj_key) {//构造函数
 
     CharacterData.prototype = {
         after() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'after', arguments, result);
+            return result;
         },
         appendData() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'appendData', arguments, result);
+            return result;
         },
         before() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'before', arguments, result);
+            return result;
         },
         get data() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).data, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).data, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CharacterData', 'data', arguments, result);
+            return result;
         },
         set data(value) {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).data = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'CharacterData', 'data', arguments);
+            lwVm.memory.private_data.get(this).data = value + "";
         },
         deleteData() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'deleteData', arguments, result);
+            return result;
         },
         insertData() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'insertData', arguments, result);
+            return result;
         },
         get length() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).length, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).length, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CharacterData', 'length', arguments, result);
+            return result;
         },
         get nextElementSibling() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).nextElementSibling, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).nextElementSibling, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CharacterData', 'nextElementSibling', arguments, result);
+            return result;
         },
         get previousElementSibling() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).previousElementSibling, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).previousElementSibling, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'CharacterData', 'previousElementSibling', arguments, result);
+            return result;
         },
         remove() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'remove', arguments, result);
+            return result;
         },
         replaceData() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'replaceData', arguments, result);
+            return result;
         },
         replaceWith() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'replaceWith', arguments, result);
+            return result;
         },
         substringData() {
-            debugger;
             if (!CharacterData.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'CharacterData', 'substringData', arguments, result);
+            return result;
         }
     };
 
-    qxVm.rename(CharacterData.prototype, "CharacterData");
-    qxVm.safeDescriptor_addConstructor(CharacterData);
-    qxVm.safe_Objattribute(CharacterData, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(CharacterData.prototype, "CharacterData");
+    lwVm.safeDescriptor_addConstructor(CharacterData);
+    lwVm.safe_Objattribute(CharacterData, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.defineProperties(CharacterData.prototype, {
         [Symbol.unscopables]: {

qxVm_sanbox/env/DOM/DOMParser.js

@@ -3,8 +3,8 @@ DOMParser = function DOMParser() {
 		throw new TypeError(`Failed to construct 'DOMParser': Please use the 'new' operator, this DOM object constructor cannot be called as a function.`)
 	}
     
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(DOMParser);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(DOMParser);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -13,12 +13,14 @@ DOMParser = function DOMParser() {
 
     DOMParser.prototype = {
         parseFromString() {
-            debugger;
             if (!DOMParser.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMParser', 'parseFromString', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(DOMParser.prototype, "DOMParser");
-    qxVm.safeDescriptor_addConstructor(DOMParser);
-    qxVm.safe_Objattribute(DOMParser, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(DOMParser.prototype, "DOMParser");
+    lwVm.safeDescriptor_addConstructor(DOMParser);
+    lwVm.safe_Objattribute(DOMParser, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();

qxVm_sanbox/env/DOM/DOMRect.js

@@ -1,9 +1,9 @@
 DOMRect = function DOMRect(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(DOMRect);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(DOMRect);
 
 ; (function () {
     const $safe_get_attribute = ['height', 'width', 'x', 'y'];
@@ -12,49 +12,53 @@ DOMRect = function DOMRect(createObj_key) {
 
     DOMRect.prototype = {
         get height() {
-            debugger;
             if (!DOMRect.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).height, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).height, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRect', 'height', arguments, result);
+            return result;
         },
         set height(value) {
-            debugger;
             if (!DOMRect.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).height = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'DOMRect', 'height', arguments);
+            lwVm.memory.private_data.get(this).height = value;
         },
         get width() {
-            debugger;
             if (!DOMRect.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).width, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).width, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRect', 'width', arguments, result);
+            return result;
         },
         set width(value) {
-            debugger;
             if (!DOMRect.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).width = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'DOMRect', 'width', arguments);
+            lwVm.memory.private_data.get(this).width = value;
         },
         get x() {
-            debugger;
             if (!DOMRect.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).x, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).x, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRect', 'x', arguments, result);
+            return result;
         },
         set x(value) {
-            debugger;
             if (!DOMRect.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).x = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'DOMRect', 'x', arguments);
+            lwVm.memory.private_data.get(this).x = value;
         },
         get y() {
-            debugger;
             if (!DOMRect.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).y, 0);
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).y, 0);;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRect', 'y', arguments, result);
+            return result;
         },
         set y(value) {
-            debugger;
             if (!DOMRect.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).y = value;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'DOMRect', 'y', arguments);
+            lwVm.memory.private_data.get(this).y = value;
         },
     }
-    qxVm.rename(DOMRect.prototype, "DOMRect");
-    qxVm.safeDescriptor_addConstructor(DOMRect);
-    qxVm.safe_Objattribute(DOMRect, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(DOMRect.prototype, "DOMRect");
+    lwVm.safeDescriptor_addConstructor(DOMRect);
+    lwVm.safe_Objattribute(DOMRect, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(DOMRect.prototype, DOMRectReadOnly.prototype);
     Object.setPrototypeOf(DOMRect, DOMRectReadOnly);

qxVm_sanbox/env/DOM/DOMRectReadOnly.js

@@ -1,9 +1,9 @@
 DOMRectReadOnly = function DOMRectReadOnly(createObj_key) {
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(DOMRectReadOnly);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(DOMRectReadOnly);
 
 ; (function () {
     const $safe_get_attribute = ['bottom', 'height', 'left', 'right', 'top', 'width', 'x', 'y'];
@@ -12,52 +12,62 @@ DOMRectReadOnly = function DOMRectReadOnly(createObj_key) {
 
     DOMRectReadOnly.prototype = {
         get bottom() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRectReadOnly', 'bottom', arguments, result);
+            return result;
         },
         get height() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRectReadOnly', 'height', arguments, result);
+            return result;
         },
         get left() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRectReadOnly', 'left', arguments, result);
+            return result;
         },
         get right() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRectReadOnly', 'right', arguments, result);
+            return result;
         },
         toJSON() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMRectReadOnly', 'toJSON', arguments, result);
+            return result;
         },
         get top() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRectReadOnly', 'top', arguments, result);
+            return result;
         },
         get width() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRectReadOnly', 'width', arguments, result);
+            return result;
         },
         get x() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRectReadOnly', 'x', arguments, result);
+            return result;
         },
         get y() {
-            debugger;
             if (!DOMRectReadOnly.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return 0;
+            let result = 0;;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMRectReadOnly', 'y', arguments, result);
+            return result;
         },
     }
-    qxVm.rename(DOMRectReadOnly.prototype, "DOMRectReadOnly");
-    qxVm.safeDescriptor_addConstructor(DOMRectReadOnly);
-    qxVm.safe_Objattribute(DOMRectReadOnly, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(DOMRectReadOnly.prototype, "DOMRectReadOnly");
+    lwVm.safeDescriptor_addConstructor(DOMRectReadOnly);
+    lwVm.safe_Objattribute(DOMRectReadOnly, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 })();
 

qxVm_sanbox/env/DOM/DOMTokenList.js

@@ -1,9 +1,9 @@
 DOMTokenList = function DOMTokenList(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(DOMTokenList);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(DOMTokenList);
 
 ; (function () {
     const $safe_get_attribute = ['length', 'value'];
@@ -12,73 +12,99 @@ DOMTokenList = function DOMTokenList(createObj_key) {//构造函数
     
     DOMTokenList.prototype = {
         add() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'add', arguments, result);
+            return result;
         },
         contains() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'contains', arguments, result);
+            return result;
         },
         entries() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'entries', arguments, result);
+            return result;
         },
         forEach() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'forEach', arguments, result);
+            return result;
         },
         item() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'item', arguments, result);
+            return result;
         },
         keys() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'keys', arguments, result);
+            return result;
         },
         get length() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).length, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).length, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMTokenList', 'length', arguments, result);
+            return result;
         },
         remove() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'remove', arguments, result);
+            return result;
         },
         replace() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'replace', arguments, result);
+            return result;
         },
         supports() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'supports', arguments, result);
+            return result;
         },
         toString() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'toString', arguments, result);
+            return result;
         },
         toggle() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'toggle', arguments, result);
+            return result;
         },
         get value() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).value, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).value, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'DOMTokenList', 'value', arguments, result);
+            return result;
         },
         set value(value) {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).value = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'DOMTokenList', 'value', arguments);
+            lwVm.memory.private_data.get(this).value = value + "";
         },
         values() {
-            debugger;
             if (!DOMTokenList.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'DOMTokenList', 'values', arguments, result);
+            return result;
         }
     };
 
-    qxVm.rename(DOMTokenList.prototype, "DOMTokenList");
-    qxVm.safeDescriptor_addConstructor(DOMTokenList);
-    qxVm.safe_Objattribute(DOMTokenList, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(DOMTokenList.prototype, "DOMTokenList");
+    lwVm.safeDescriptor_addConstructor(DOMTokenList);
+    lwVm.safe_Objattribute(DOMTokenList, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
 })();
 

qxVm_sanbox/env/DOM/HTMLCollection.js

@@ -1,8 +1,8 @@
 HTMLCollection = function HTMLCollection(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     };
-}; qxVm.safefunction(HTMLCollection);
+}; lwVm.safefunction(HTMLCollection);
 
 ; (function () {
     const $safe_get_attribute = ['length'];
@@ -11,27 +11,31 @@ HTMLCollection = function HTMLCollection(createObj_key) {//构造函数
 
     HTMLCollection.prototype = {
         item(index) {
-            debugger;
             if (!HTMLCollection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return this[index];
+            let result = this[index];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'HTMLCollection', 'item', arguments, result);
+            return result;
         },
         get length() {
             if (!HTMLCollection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return Object.keys(this).length
+            let result = Object.keys(this).length;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLCollection', 'length', arguments, result);
+            return result;
         },
         namedItem(name) {
-            debugger;
             if (!HTMLCollection.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return this[name];
+            let result = this[name];;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'HTMLCollection', 'namedItem', arguments, result);
+            return result;
         }
     };
-    qxVm.set_iterator(HTMLCollection);
-    qxVm.rename(HTMLCollection.prototype, "HTMLCollection");
-    qxVm.safeDescriptor_addConstructor(HTMLCollection);
-    qxVm.safe_Objattribute(HTMLCollection, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.set_iterator(HTMLCollection);
+    lwVm.rename(HTMLCollection.prototype, "HTMLCollection");
+    lwVm.safeDescriptor_addConstructor(HTMLCollection);
+    lwVm.safe_Objattribute(HTMLCollection, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     // 创建一个放到框架内存(模拟全局变量), 便于后续得其他引用操作
-    qxVm.memory.htmlCollection = new HTMLCollection(qxVm.memory.$createObj_key);
+    lwVm.memory.htmlCollection = new HTMLCollection(lwVm.memory.$createObj_key);
 
 })();
 

qxVm_sanbox/env/DOM/HTMLDocument.js

@@ -1,9 +1,9 @@
 HTMLDocument = function HTMLDocument(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(HTMLDocument);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(HTMLDocument);
 
 ; (function () {
     const $safe_get_attribute = [];
@@ -12,9 +12,9 @@ HTMLDocument = function HTMLDocument(createObj_key) {//构造函数
 
 
     HTMLDocument.prototype = {};
-    qxVm.rename(HTMLDocument.prototype, "HTMLDocument");
-    qxVm.safeDescriptor_addConstructor(HTMLDocument);
-    qxVm.safe_Objattribute(HTMLDocument, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(HTMLDocument.prototype, "HTMLDocument");
+    lwVm.safeDescriptor_addConstructor(HTMLDocument);
+    lwVm.safe_Objattribute(HTMLDocument, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(HTMLDocument.prototype, Document.prototype); // 指定属性原型的原型链
     Object.setPrototypeOf(HTMLDocument, Document);  // 指定属性的原型链

qxVm_sanbox/env/DOM/HTMLElements/HTMLAnchorElement.js

@@ -1,9 +1,9 @@
 HTMLAnchorElement = function HTMLAnchorElement(createObj_key) {//构造函数
-    if (createObj_key !== qxVm.memory.$createObj_key) {
+    if (createObj_key !== lwVm.memory.$createObj_key) {
         throw new TypeError("Illegal constructor");
     }
-    qxVm.memory.private_data.set(this, {})
-}; qxVm.safefunction(HTMLAnchorElement);
+    lwVm.memory.private_data.set(this, {})
+}; lwVm.safefunction(HTMLAnchorElement);
 
 ; (function () {
     const $safe_get_attribute = ['charset', 'coords', 'download', 'hash', 'host', 'hostname', 'href', 'hrefTranslate', 'hreflang', 'name', 'origin', 'password', 'pathname', 'ping', 'port', 'protocol', 'referrerPolicy', 'rel', 'relList', 'rev', 'search', 'shape', 'target', 'text', 'type', 'username'];
@@ -12,244 +12,296 @@ HTMLAnchorElement = function HTMLAnchorElement(createObj_key) {//构造函数
 
     HTMLAnchorElement.prototype = {
         get charset() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).charset, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).charset, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'charset', arguments, result);
+            return result;
         },
         set charset(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).charset = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'charset', arguments);
+            lwVm.memory.private_data.get(this).charset = value + "";
         },
         get coords() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).coords, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).coords, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'coords', arguments, result);
+            return result;
         },
         set coords(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).coords = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'coords', arguments);
+            lwVm.memory.private_data.get(this).coords = value + "";
         },
         get download() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).download, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).download, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'download', arguments, result);
+            return result;
         },
         set download(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).download = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'download', arguments);
+            lwVm.memory.private_data.get(this).download = value + "";
         },
         get hash() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).hash, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).hash, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'hash', arguments, result);
+            return result;
         },
         set hash(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).hash = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'hash', arguments);
+            lwVm.memory.private_data.get(this).hash = value + "";
         },
         get host() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).host, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).host, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'host', arguments, result);
+            return result;
         },
         set host(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).host = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'host', arguments);
+            lwVm.memory.private_data.get(this).host = value + "";
         },
         get hostname() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).hostname, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).hostname, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'hostname', arguments, result);
+            return result;
         },
         set hostname(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).hostname = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'hostname', arguments);
+            lwVm.memory.private_data.get(this).hostname = value + "";
         },
         get href() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).href, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).href, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'href', arguments, result);
+            return result;
         },
         set href(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).href = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'href', arguments);
+            lwVm.memory.private_data.get(this).href = value + "";
         },
         get hrefTranslate() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).hrefTranslate, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).hrefTranslate, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'hrefTranslate', arguments, result);
+            return result;
         },
         set hrefTranslate(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).hrefTranslate = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'hrefTranslate', arguments);
+            lwVm.memory.private_data.get(this).hrefTranslate = value + "";
         },
         get hreflang() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).hreflang, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).hreflang, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'hreflang', arguments, result);
+            return result;
         },
         set hreflang(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).hreflang = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'hreflang', arguments);
+            lwVm.memory.private_data.get(this).hreflang = value + "";
         },
         get name() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).name, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).name, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'name', arguments, result);
+            return result;
         },
         set name(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).name = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'name', arguments);
+            lwVm.memory.private_data.get(this).name = value + "";
         },
         get origin() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).origin, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).origin, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'origin', arguments, result);
+            return result;
         },
         get password() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).password, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).password, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'password', arguments, result);
+            return result;
         },
         set password(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).password = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'password', arguments);
+            lwVm.memory.private_data.get(this).password = value + "";
         },
         get pathname() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).pathname, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).pathname, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'pathname', arguments, result);
+            return result;
         },
         set pathname(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).pathname = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'pathname', arguments);
+            lwVm.memory.private_data.get(this).pathname = value + "";
         },
         get ping() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).ping, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).ping, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'ping', arguments, result);
+            return result;
         },
         set ping(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).ping = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'ping', arguments);
+            lwVm.memory.private_data.get(this).ping = value + "";
         },
         get port() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).port, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).port, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'port', arguments, result);
+            return result;
         },
         set port(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).port = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'port', arguments);
+            lwVm.memory.private_data.get(this).port = value + "";
         },
         get protocol() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).protocol, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).protocol, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'protocol', arguments, result);
+            return result;
         },
         set protocol(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).protocol = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'protocol', arguments);
+            lwVm.memory.private_data.get(this).protocol = value + "";
         },
         get referrerPolicy() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).referrerPolicy, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).referrerPolicy, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'referrerPolicy', arguments, result);
+            return result;
         },
         set referrerPolicy(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).referrerPolicy = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'referrerPolicy', arguments);
+            lwVm.memory.private_data.get(this).referrerPolicy = value + "";
         },
         get rel() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).rel, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).rel, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'rel', arguments, result);
+            return result;
         },
         set rel(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).rel = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'rel', arguments);
+            lwVm.memory.private_data.get(this).rel = value + "";
         },
         get relList() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).relList, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).relList, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'relList', arguments, result);
+            return result;
         },
         set relList(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).relList = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'relList', arguments);
+            lwVm.memory.private_data.get(this).relList = value + "";
         },
         get rev() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).rev, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).rev, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'rev', arguments, result);
+            return result;
         },
         set rev(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).rev = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'rev', arguments);
+            lwVm.memory.private_data.get(this).rev = value + "";
         },
         get search() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).search, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).search, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'search', arguments, result);
+            return result;
         },
         set search(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).search = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'search', arguments);
+            lwVm.memory.private_data.get(this).search = value + "";
         },
         get shape() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).shape, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).shape, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'shape', arguments, result);
+            return result;
         },
         set shape(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).shape = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'shape', arguments);
+            lwVm.memory.private_data.get(this).shape = value + "";
         },
         get target() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).target, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).target, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'target', arguments, result);
+            return result;
         },
         set target(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).target = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'target', arguments);
+            lwVm.memory.private_data.get(this).target = value + "";
         },
         get text() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).text, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).text, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'text', arguments, result);
+            return result;
         },
         set text(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).text = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'text', arguments);
+            lwVm.memory.private_data.get(this).text = value + "";
         },
         toString() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
+            let result = undefined;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Func', 'HTMLAnchorElement', 'toString', arguments, result);
+            return result;
         },
         get type() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).type, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).type, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'type', arguments, result);
+            return result;
         },
         set type(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).type = value + "";
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Set', 'HTMLAnchorElement', 'type', arguments);
+            lwVm.memory.private_data.get(this).type = value + "";
         },
         get username() {
-            debugger;
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            return qxVm.abs(qxVm.memory.private_data.get(this).username, "");
+            let result = lwVm.abs(lwVm.memory.private_data.get(this).username, "");;
+            if (lwVm.config.logOpen=== true) lwVm.logAdd('Get', 'HTMLAnchorElement', 'username', arguments, result);
+            return result;
         },
         set username(value) {
             if (!HTMLAnchorElement.prototype.isPrototypeOf(this)) { throw new TypeError("Illegal constructor"); };
-            qxVm.memory.private_data.get(this).username = value + "";
+            lwVm.memory.private_data.get(this).username = value + "";
         }
     }
 
-    qxVm.rename(HTMLAnchorElement.prototype, "HTMLAnchorElement");
-    qxVm.safeDescriptor_addConstructor(HTMLAnchorElement);
-    qxVm.safe_Objattribute(HTMLAnchorElement, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
+    lwVm.rename(HTMLAnchorElement.prototype, "HTMLAnchorElement");
+    lwVm.safeDescriptor_addConstructor(HTMLAnchorElement);
+    lwVm.safe_Objattribute(HTMLAnchorElement, $safe_get_attribute, $safe_set_attribute, $safe_func_attribute);
 
     Object.setPrototypeOf(HTMLAnchorElement.prototype, HTMLElement.prototype);
     Object.setPrototypeOf(HTMLAnchorElement, HTMLElement);
@@ -257,6 +309,6 @@ HTMLAnchorElement = function HTMLAnchorElement(createObj_key) {//构造函数
 })();
 
 
-qxVm.memory.htmlElements["a"] = function () {
-    return new HTMLAnchorElement(qxVm.memory.$createObj_key);
+lwVm.memory.htmlElements["a"] = function () {
+    return new HTMLAnchorElement(lwVm.memory.$createObj_key);
 }