Full Code of bnmgh1/node-sandbox for AI

Repository: bnmgh1/node-sandbox
Branch: main
Commit: e39d2a8e5ca5
Files: 190
Total size: 3.8 MB

Directory structure:
gitextract_v2jkf5ez/

├── .idea/
│   ├── .gitignore
│   ├── inspectionProfiles/
│   │   ├── Project_Default.xml
│   │   └── profiles_settings.xml
│   ├── misc.xml
│   ├── modules.xml
│   ├── node-sandbox.iml
│   └── vcs.xml
├── LICENSE
├── README.md
├── env/
│   ├── ANGLEInstancedArrays.js
│   ├── AnalyserNode.js
│   ├── AudioContext.js
│   ├── AudioListener.js
│   ├── AudioNode.js
│   ├── AudioParam.js
│   ├── AudioScheduledSourceNode.js
│   ├── BarProp.js
│   ├── BaseAudioContext.js
│   ├── BatteryManager.js
│   ├── Blob.js
│   ├── CSSStyleDeclaration.js
│   ├── CSSStyleRule.js
│   ├── CSSStyleSheet.js
│   ├── CanvasGradient.js
│   ├── CanvasRenderingContext2D.js
│   ├── Crypto.js
│   ├── CustomElementRegistry.js
│   ├── CustomEvent.js
│   ├── DOMTokenList.js
│   ├── Database.js
│   ├── DeprecatedStorageInfo.js
│   ├── DeprecatedStorageQuota.js
│   ├── Document.js
│   ├── DocumentType.js
│   ├── DynamicsCompressorNode.js
│   ├── EXTDisjointTimerQuery.js
│   ├── Element.js
│   ├── Event.js
│   ├── External.js
│   ├── GainNode.js
│   ├── HTMLAllCollection.js
│   ├── HTMLAnchorElement.js
│   ├── HTMLAreaElement.js
│   ├── HTMLBRElement.js
│   ├── HTMLBaseElement.js
│   ├── HTMLBodyElement.js
│   ├── HTMLButtonElement.js
│   ├── HTMLCanvasElement.js
│   ├── HTMLCollection.js
│   ├── HTMLDListElement.js
│   ├── HTMLDataElement.js
│   ├── HTMLDataListElement.js
│   ├── HTMLDetailsElement.js
│   ├── HTMLDialogElement.js
│   ├── HTMLDirectoryElement.js
│   ├── HTMLDivElement.js
│   ├── HTMLElement.js
│   ├── HTMLEmbedElement.js
│   ├── HTMLFieldSetElement.js
│   ├── HTMLFontElement.js
│   ├── HTMLFormElement.js
│   ├── HTMLFrameElement.js
│   ├── HTMLFrameSetElement.js
│   ├── HTMLHRElement.js
│   ├── HTMLHeadingElement.js
│   ├── HTMLHtmlElement.js
│   ├── HTMLIFrameElement.js
│   ├── HTMLImageElement.js
│   ├── HTMLInputElement.js
│   ├── HTMLLIElement.js
│   ├── HTMLLabelElement.js
│   ├── HTMLLegendElement.js
│   ├── HTMLLinkElement.js
│   ├── HTMLMapElement.js
│   ├── HTMLMarqueeElement.js
│   ├── HTMLMediaElement.js
│   ├── HTMLMenuElement.js
│   ├── HTMLMetaElement.js
│   ├── HTMLMeterElement.js
│   ├── HTMLModElement.js
│   ├── HTMLOListElement.js
│   ├── HTMLObjectElement.js
│   ├── HTMLOptGroupElement.js
│   ├── HTMLOptionElement.js
│   ├── HTMLOutputElement.js
│   ├── HTMLParagraphElement.js
│   ├── HTMLParamElement.js
│   ├── HTMLPreElement.js
│   ├── HTMLProgressElement.js
│   ├── HTMLQuoteElement.js
│   ├── HTMLScriptElement.js
│   ├── HTMLSelectElement.js
│   ├── HTMLSlotElement.js
│   ├── HTMLSourceElement.js
│   ├── HTMLStyleElement.js
│   ├── HTMLTableCaptionElement.js
│   ├── HTMLTableCellElement.js
│   ├── HTMLTableColElement.js
│   ├── HTMLTableElement.js
│   ├── HTMLTableRowElement.js
│   ├── HTMLTableSectionElement.js
│   ├── HTMLTemplateElement.js
│   ├── HTMLTextAreaElement.js
│   ├── HTMLTimeElement.js
│   ├── HTMLTitleElement.js
│   ├── HTMLTrackElement.js
│   ├── HTMLUListElement.js
│   ├── HTMLVideoElement.js
│   ├── History.js
│   ├── IDBDatabase.js
│   ├── IDBFactory.js
│   ├── IDBObjectStore.js
│   ├── IDBOpenDBRequest.js
│   ├── IDBRequest.js
│   ├── IDBTransaction.js
│   ├── Image.js
│   ├── ImageData.js
│   ├── InputDeviceCapabilities.js
│   ├── MediaEncryptedEvent.js
│   ├── MediaQueryList.js
│   ├── MimeType.js
│   ├── MimeTypeArray.js
│   ├── MouseEvent.js
│   ├── MutationObserver.js
│   ├── MutationRecord.js
│   ├── Navigator.js
│   ├── NavigatorUAData.js
│   ├── NetworkInformation.js
│   ├── Node.js
│   ├── NodeList.js
│   ├── Notification.js
│   ├── OESVertexArrayObject.js
│   ├── OfflineAudioContext.js
│   ├── OffscreenCanvas.js
│   ├── OffscreenCanvasRenderingContext2D.js
│   ├── OscillatorNode.js
│   ├── Path2D.js
│   ├── Performance.js
│   ├── PerformanceEntry.js
│   ├── Plugin.js
│   ├── PluginArray.js
│   ├── PointerEvent.js
│   ├── RTCDataChannel.js
│   ├── RTCIceCandidate.js
│   ├── RTCPeerConnection.js
│   ├── RTCPeerConnectionIceEvent.js
│   ├── RTCSessionDescription.js
│   ├── Request.js
│   ├── Screen.js
│   ├── ScreenOrientation.js
│   ├── SpeechSynthesis.js
│   ├── SpeechSynthesisUtterance.js
│   ├── Storage.js
│   ├── StorageManager.js
│   ├── StyleMedia.js
│   ├── StyleSheet.js
│   ├── Text.js
│   ├── TextMetrics.js
│   ├── TrustedTypePolicyFactory.js
│   ├── UIEvent.js
│   ├── URL.js
│   ├── UserActivation.js
│   ├── VisualViewport.js
│   ├── WebGL2RenderingContext.js
│   ├── WebGLDebugShaders.js
│   ├── WebGLDrawBuffers.js
│   ├── WebGLLoseContext.js
│   ├── WebGLMultiDraw.js
│   ├── WebGLRenderingContext.js
│   ├── WebGLShaderPrecisionFormat.js
│   ├── WebSocket.js
│   ├── Woker.js
│   ├── XMLHttpRequest.js
│   ├── XMLHttpRequestEventTarget.js
│   └── XPathExpression.js
├── main.js
├── ret.html
├── util/
│   ├── cover_construct_function.js
│   ├── cover_function.js
│   ├── end.js
│   ├── globalMy.js
│   ├── init_env.js
│   └── pass_check.js
└── work/
    ├── ali140.js
    ├── boss.js
    ├── jrtt/
    │   ├── ac_sign.js
    │   └── jrtt.js
    ├── rsvmp.js
    └── zhihu/
        ├── x81.js
        └── zhihu.js

================================================
FILE CONTENTS
================================================

================================================
FILE: .idea/.gitignore
================================================
# Default ignored files
/shelf/
/workspace.xml
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml
# Editor-based HTTP Client requests
/httpRequests/


================================================
FILE: .idea/inspectionProfiles/Project_Default.xml
================================================
<component name="InspectionProjectProfileManager">
  <profile version="1.0">
    <option name="myName" value="Project Default" />
    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
    <inspection_tool class="PyPep8NamingInspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
      <option name="ignoredErrors">
        <list>
          <option value="N801" />
        </list>
      </option>
    </inspection_tool>
    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
      <option name="ignoredIdentifiers">
        <list>
          <option value="dict.__setitem__" />
        </list>
      </option>
    </inspection_tool>
    <inspection_tool class="TsLint" enabled="true" level="WARNING" enabled_by_default="true" />
  </profile>
</component>

================================================
FILE: .idea/inspectionProfiles/profiles_settings.xml
================================================
<component name="InspectionProjectProfileManager">
  <settings>
    <option name="USE_PROJECT_PROFILE" value="false" />
    <version value="1.0" />
  </settings>
</component>

================================================
FILE: .idea/misc.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="JavaScriptSettings">
    <option name="languageLevel" value="ES6" />
  </component>
  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.8" project-jdk-type="Python SDK" />
</project>

================================================
FILE: .idea/modules.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="ProjectModuleManager">
    <modules>
      <module fileurl="file://$PROJECT_DIR$/.idea/node-sandbox.iml" filepath="$PROJECT_DIR$/.idea/node-sandbox.iml" />
    </modules>
  </component>
</project>

================================================
FILE: .idea/node-sandbox.iml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<module type="PYTHON_MODULE" version="4">
  <component name="NewModuleRootManager">
    <content url="file://$MODULE_DIR$" />
    <orderEntry type="inheritedJdk" />
    <orderEntry type="sourceFolder" forTests="false" />
  </component>
  <component name="TestRunnerService">
    <option name="PROJECT_TEST_RUNNER" value="Nosetests" />
  </component>
</module>

================================================
FILE: .idea/vcs.xml
================================================
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
  <component name="VcsDirectoryMappings">
    <mapping directory="$PROJECT_DIR$" vcs="Git" />
  </component>
</project>

================================================
FILE: LICENSE
================================================
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.


================================================
FILE: README.md
================================================
# 魔改Node Js补环境框架

## 内置对象Utils

Utils是v8对象, 内置了几个重要函数.

1. defineProperty
作用: 重写属性描述符, 即使是configurable为false 也能强行修改然后delete掉. 暂时不支持传入get set, 只能修改成value. mode我详细解释下,
在v8底层READ_ONLY(writable)是1, DONT_ENUM(enumerable)是2, DONT_DELETE(configurable)是4, 
所以1|2|4 = 7, mode即7, 也就是所有描述符为false. 0就代表所有描述符都为true.

2. initEnv
作用: 给~~wanfeng~~globalMy下的构造函数设置原型对象.

3. initWindow
作用: 将~~wanfeng~~globalMy下的构造函数定义到window里, 因为构造函数在window里的enumerable描述符为false, 所以不能直接用赋值形式定义在window下. 而用Object.defineProperty耗时太慢了, 所以单独写个方法初始化window.

4. initWorker
作用: 和initWindow同理

5. Error_get_stack
作用: 堆栈拦截, 单js获取报错的stack时, 会先走到这里. 这个不算api~ 不重写则默认不处理.

6. defineIsTrusted
作用: 给事件对象设置isTrusted属性, get事件回调将会走到globalMy.event_get_isTrusted.

7. setImmutableProto
作用: 修改对象的__proto__将会报错

8. setUndetectable
作用: 直接将对象的type设置为undefined, 可能存在bug.
解释下我为什么又用回这个api, 是因为我需要代理document.all对象, 但是这样typeof解决不掉, 所以又用底层api去标记对象, 而不是新建一个对象的时候标记对象为undetectable. 可能存在bug, 谨慎使用, 我暂时没问题. 没需求的直接用new一个xtd对象即可.

9. setNative
作用: 就是将模块下的SetNative移植到了v8层面

10. api例子
```javascript
Utils.definePropery({}, "a", {value: 1, mode: 7});
```
```javascript
Utils.Error_get_stack = function(stack){
    console.log(stack)
};
```
```javascript
Utils.defineIsTrusted(event);
```
```javascript
Utils.setImmutableProto(this);
```

## wanfeng
接下来是内置模块, 我将其命名为wanfeng. 
所以使用的时候需要require("wanfeng")

1. setNative
作用: ~~给函数套壳, 这样的话就不用考虑函数toString检测问题了.
~~第一个参数是函数, 第二个参数是函数名称, 第三个是否是构造函数. 非构造函数则传false, new 函数将会报错.
第四个参数的函数的length. 返回壳函数.~~
之前保护这样得到的函数会导致无法被回收, 内存一直增加, 所以换了写法...现在只对函数toString进行保护, 其他需要的自行封装, 比如判断是否是new关键字调用, 以及函数长度等... (感谢零点大佬提供的代码) 

~~2. DeleteProperty
作用: 强行移除属性, 即使configurable为false也能直接删除. (感谢零点大佬提供的代码)
缺点: 目前我只用在了Promise构造函数删除caller以及arguments属性(底层自带的没有这2个属性), 强制删除可能引发bug, 所以大多时候我用v8底层函数
强制修改描述符之后再用delete关键字进行安全的删除.~~ 有bug, 还是修改描述符delete吧~

3. xtd
作用: 生成一个type为undefined的对象. (感谢泰迪大佬提供的代码)

4. ClearMemory
作用: 通知引擎进行垃圾回收.这将使 V8 尝试执行一次完整的垃圾回收, 并尝试释放未使用的内存. 这样无限创建vm虚拟机也能保持内存占用处在稳定的区间.


4. api例子
```javascript
function a(){}
/* 现在只传函数进去, 然后的话函数的name如果是a ,那么toString就会得到 function a(){ [native code] } */
wanfeng.SetNative(a);
```
```javascript
let undefined_obj = new wanfeng.xtd;
```
```javascript
wanfeng.ClearMemory();
```

## node框架使用说明

1. 以window对象为例, window 获取 window对象时, 会走到 globalMy.window_get_window 这个方法里,我们在这里写方法逻辑。

2. 以document对象为例, document 调用 createElement方法时, 会走到 globalMy.Document_createElement 这个方法里,因为是原型链上的方法,所以是Document

3. 还是以document为例, document 获取 location对象时, 会走到 globalMy.document_get_location 这个方法里, 因为location是直接属于document对象下的。

ps : 核心就是在node底层定义了一层拦截器, 然后最终又走到我们定义的js方法里完成调用. 底层定义的方法不需要考虑toString检测. 而且node设置属性比js的defineProperty快很多.
 
## js框架简介

1. 因为之前自己写的沙箱太垃圾, 所以没有和node框架做结合. 不过node框架初始化也快, 干脆就直接用jsdom了, 偷懒了. 

2. 创建节点对象时, 我会定义一个壳对象来映射jsdom对象达到过检测的目的. 我实现的没有很优雅, 够用就行了

## 注意事项

1. 框架默认重写Promise, 用原生的Promise就不要调用globalMy. rePromise函数即可 (原生的会更好用, 有个库可以直接将异步转同步, 注意node的setTimeout的一些检测就好了...)

2. ~~不要代理任何对象,代理对象调用方法时会直接报错,和浏览器一样的机制。建议在方法调用时打印,像我的js框架一样。~~ 现在可以代理了, 可以自己判断代理对象调用方法时要不要报错.

3. node无法使用正常的vm2模块, 改用vm模块了(不建议用execjs调, 真的很蠢... 持续调用还是建议起服务接口), vm小小的魔改了下, 去掉了一些检测点...

4. 非构造函数的原型对象, 就实现了个别, 比如WindowProperties这种的原型对象。这种会存放在Utils中, 例如Utils.WindowProperties_ptototype。

5. 如果遇到方法没有定义的话, node会挂掉噢...


## 更新说明

2023-03-15

node和js框架代码更新了些许东西, 最新的node处理了一些细节问题, 还有些小bug也解决了. 
所以要用新编译的node!! 

2023-03-29

后续js框架不更新了, 因为js框架是去年写的, 很多实现的很有问题. setTimeout以及添加事件触发事件都有问题(我现在也用原生的了~). 如果大佬们有关于node框架的一些想法或者思路可以一起探讨~

2023-05-01

增加了node的一些api, 以及去除掉模块自带的构造函数, ~~改用wanfeng.SetNative来生成壳构造函数~~改用wanfeng.SetNative保护函数toString. 这样new一份虚拟机的话, 这些构造函数就不相等了, 相互独立.

修改了vm的源码, 过了一些有问题的检测点. 比如this.hasOwnProperty("hasOwnProperty") === true, vm的this只要继承谁, 就会直接拥有这个属性. 能遍历到这个key, 但是用getOwnProperty又获取到undefined. 所以修改了点东西.

初始化这块, ~~就是将保护后的构造函数放到wanfeng这个对象里(每个vm传一个wanfeng对象进去, 不要直接传wanfeng模块, 看main.js的rsvmp函数)~~, 看init_env.js. 生成构造函数放在globalMy下, 然后wanfeng.SetNative保护一下.再调用Utils.initEnv(), Utils.initWindow()就行了.

2023-05-08

修改了wanfeng.SetNative的底层源码, 所以使用方式也改变了... wanfeng新增ClearMemory api, ~~消耗内存现在稳定了呜呜~~~ (jsdom有些内存清不掉~)

2023-05-17

将nodejs修改v8源码, 以及注册壳函数源码都放到星球里了. 后续会开源出来给大家看看, 基本都是用的v8 API在做操作. 更新了一个api setUndetectable V8对象Utils下的.

现在已经将很多模块的功能都砍掉或者移植到v8层面去做了. 主要是让wanfeng模块只在node层面做事情, 而不用传入虚拟机里.

另外这次版本升级到了19.6, 18.8版本以上提供方便的生成快照命令, 所以升级了... 

我的nodejs v8源码已经上传到星球里了, 可以学习下用v8的这些api来过一些补环境的检测~ (星球随缘更新, 只要50, 饿不死你富不了我...)

## 警告

此代码开源仅供学习使用, 如有影响请联系作者删除. 请勿用于非法用途, 否则法律后果自负.


## 赞助

By: 挽风  q/v: 1491025307. 

有好的补环境思路或者遇到了bug联系我~

ps: 和陈不不大佬的cynode不是一个框架...

我、陈不不大佬、泰迪大佬一起合作的星球 : https://t.zsxq.com/06bIUvBEM. 星球里有更轻量级的框架, 只提供api的框架, 没有固定初始化的那种.


================================================
FILE: env/ANGLEInstancedArrays.js
================================================
// prototype(无构造函数)的原型方法
globalMy.ANGLEInstancedArrays_drawArraysInstancedANGLE = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了ANGLEInstancedArrays_drawArraysInstancedANGLE, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.ANGLEInstancedArrays_drawElementsInstancedANGLE = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了ANGLEInstancedArrays_drawElementsInstancedANGLE, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.ANGLEInstancedArrays_vertexAttribDivisorANGLE = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了ANGLEInstancedArrays_vertexAttribDivisorANGLE, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};

================================================
FILE: env/AnalyserNode.js
================================================
globalMy.AnalyserNode_get_fftSize = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['fftSize'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_get_fftSize,result => ', result)
    }
    return result;
}
globalMy.AnalyserNode_set_fftSize = function (val) {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    globalMy.value[foundName]['fftSize'] = val;
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_set_fftSize, 传参val => ' + val + '  result => ', result)
    }
}
globalMy.AnalyserNode_get_frequencyBinCount = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['frequencyBinCount'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_get_frequencyBinCount,result => ', result)
    }
    return result;
}
globalMy.AnalyserNode_get_minDecibels = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['minDecibels'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_get_minDecibels,result => ', result)
    }
    return result;
}
globalMy.AnalyserNode_set_minDecibels = function (val) {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    globalMy.value[foundName]['minDecibels'] = val;
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_set_minDecibels, 传参val => ' + val + '  result => ', result)
    }
}
globalMy.AnalyserNode_get_maxDecibels = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['maxDecibels'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_get_maxDecibels,result => ', result)
    }
    return result;
}
globalMy.AnalyserNode_set_maxDecibels = function (val) {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    globalMy.value[foundName]['maxDecibels'] = val;
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_set_maxDecibels, 传参val => ' + val + '  result => ', result)
    }
}
globalMy.AnalyserNode_get_smoothingTimeConstant = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['smoothingTimeConstant'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_get_smoothingTimeConstant,result => ', result)
    }
    return result;
}
globalMy.AnalyserNode_set_smoothingTimeConstant = function (val) {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    globalMy.value[foundName]['smoothingTimeConstant'] = val;
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_set_smoothingTimeConstant, 传参val => ' + val + '  result => ', result)
    }
}
globalMy.AnalyserNode_getByteFrequencyData = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_getByteFrequencyData, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AnalyserNode_getByteTimeDomainData = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_getByteTimeDomainData, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AnalyserNode_getFloatFrequencyData = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_getFloatFrequencyData, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AnalyserNode_getFloatTimeDomainData = function () {
    if (!(this instanceof AnalyserNode)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AnalyserNode_getFloatTimeDomainData, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}



================================================
FILE: env/AudioContext.js
================================================
globalMy.AudioContext_get_baseLatency = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['baseLatency'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_get_baseLatency,result => ', result)
    }
    return result;
}
globalMy.AudioContext_get_outputLatency = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['outputLatency'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_get_outputLatency,result => ', result)
    }
    return result;
}
globalMy.AudioContext_close = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_close, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AudioContext_createMediaElementSource = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_createMediaElementSource, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AudioContext_createMediaStreamDestination = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_createMediaStreamDestination, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AudioContext_createMediaStreamSource = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_createMediaStreamSource, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AudioContext_getOutputTimestamp = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_getOutputTimestamp, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AudioContext_resume = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_resume, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AudioContext_suspend = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_suspend, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AudioContext_get_sinkId = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['sinkId'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_get_sinkId,result => ', result)
    }
    return result;
}
globalMy.AudioContext_get_onsinkchange = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['onsinkchange'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_get_onsinkchange,result => ', result)
    }
    return result;
}
globalMy.AudioContext_set_onsinkchange = function (val) {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    globalMy.value[foundName]['onsinkchange'] = val;
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_set_onsinkchange, 传参val => ' + val + '  result => ', result)
    }
}
globalMy.AudioContext_setSinkId = function () {
    if (!(this instanceof AudioContext)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioContext_setSinkId, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}



================================================
FILE: env/AudioListener.js
================================================
globalMy.AudioListener_get_positionX = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['positionX'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_positionX,result => ', result)
    }
    return result;
}
globalMy.AudioListener_get_positionY = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['positionY'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_positionY,result => ', result)
    }
    return result;
}
globalMy.AudioListener_get_positionZ = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['positionZ'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_positionZ,result => ', result)
    }
    return result;
}
globalMy.AudioListener_get_forwardX = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['forwardX'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_forwardX,result => ', result)
    }
    return result;
}
globalMy.AudioListener_get_forwardY = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['forwardY'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_forwardY,result => ', result)
    }
    return result;
}
globalMy.AudioListener_get_forwardZ = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['forwardZ'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_forwardZ,result => ', result)
    }
    return result;
}
globalMy.AudioListener_get_upX = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['upX'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_upX,result => ', result)
    }
    return result;
}
globalMy.AudioListener_get_upY = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['upY'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_upY,result => ', result)
    }
    return result;
}
globalMy.AudioListener_get_upZ = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['upZ'];
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_get_upZ,result => ', result)
    }
    return result;
}
globalMy.AudioListener_setOrientation = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_setOrientation, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}
globalMy.AudioListener_setPosition = function () {
    if (!(this instanceof AudioListener)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了AudioListener_setPosition, arguments => ' + JSON.stringify(arguments) + '  result => ', result)
    }
    return result;
}


================================================
FILE: env/AudioNode.js
================================================
globalMy.AudioNode_get_context = function () {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['context'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_get_context,result => ', result);
  }
  return result;
};
globalMy.AudioNode_get_numberOfInputs = function () {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['numberOfInputs'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_get_numberOfInputs,result => ', result);
  }
  return result;
};
globalMy.AudioNode_get_numberOfOutputs = function () {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['numberOfOutputs'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_get_numberOfOutputs,result => ', result);
  }
  return result;
};
globalMy.AudioNode_get_channelCount = function () {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['channelCount'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_get_channelCount,result => ', result);
  }
  return result;
};
globalMy.AudioNode_set_channelCount = function (val) {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['channelCount'] = val;
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_set_channelCount, 传参val => ' + val + '  result => ', result);
  }
};
globalMy.AudioNode_get_channelCountMode = function () {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['channelCountMode'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_get_channelCountMode,result => ', result);
  }
  return result;
};
globalMy.AudioNode_set_channelCountMode = function (val) {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['channelCountMode'] = val;
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_set_channelCountMode, 传参val => ' + val + '  result => ', result);
  }
};
globalMy.AudioNode_get_channelInterpretation = function () {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['channelInterpretation'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_get_channelInterpretation,result => ', result);
  }
  return result;
};
globalMy.AudioNode_set_channelInterpretation = function (val) {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['channelInterpretation'] = val;
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_set_channelInterpretation, 传参val => ' + val + '  result => ', result);
  }
};
globalMy.AudioNode_connect = function () {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_connect, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.AudioNode_disconnect = function () {
  if (!(this instanceof AudioNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioNode_disconnect, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};

================================================
FILE: env/AudioParam.js
================================================
globalMy.AudioParam_get_value = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['value'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_get_value,result => ', result);
  }
  return result;
};
globalMy.AudioParam_set_value = function (val) {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['value'] = val;
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_set_value, 传参val => ' + val + '  result => ', result);
  }
};
globalMy.AudioParam_get_automationRate = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['automationRate'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_get_automationRate,result => ', result);
  }
  return result;
};
globalMy.AudioParam_set_automationRate = function (val) {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['automationRate'] = val;
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_set_automationRate, 传参val => ' + val + '  result => ', result);
  }
};
globalMy.AudioParam_get_defaultValue = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['defaultValue'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_get_defaultValue,result => ', result);
  }
  return result;
};
globalMy.AudioParam_get_minValue = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['minValue'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_get_minValue,result => ', result);
  }
  return result;
};
globalMy.AudioParam_get_maxValue = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['maxValue'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_get_maxValue,result => ', result);
  }
  return result;
};
globalMy.AudioParam_cancelAndHoldAtTime = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_cancelAndHoldAtTime, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.AudioParam_cancelScheduledValues = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_cancelScheduledValues, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.AudioParam_exponentialRampToValueAtTime = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_exponentialRampToValueAtTime, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.AudioParam_linearRampToValueAtTime = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_linearRampToValueAtTime, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.AudioParam_setTargetAtTime = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_setTargetAtTime, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.AudioParam_setValueAtTime = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_setValueAtTime, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.AudioParam_setValueCurveAtTime = function () {
  if (!(this instanceof AudioParam)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioParam_setValueCurveAtTime, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};

================================================
FILE: env/AudioScheduledSourceNode.js
================================================
globalMy.AudioScheduledSourceNode_get_onended = function () {
  if (!(this instanceof AudioScheduledSourceNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['onended'];
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioScheduledSourceNode_get_onended,result => ', result);
  }
  return result;
};
globalMy.AudioScheduledSourceNode_set_onended = function (val) {
  if (!(this instanceof AudioScheduledSourceNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['onended'] = val;
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioScheduledSourceNode_set_onended, 传参val => ' + val + '  result => ', result);
  }
};
globalMy.AudioScheduledSourceNode_start = function () {
  if (!(this instanceof AudioScheduledSourceNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioScheduledSourceNode_start, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.AudioScheduledSourceNode_stop = function () {
  if (!(this instanceof AudioScheduledSourceNode)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了AudioScheduledSourceNode_stop, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};

================================================
FILE: env/BarProp.js
================================================
globalMy.BarProp_get_visible = function () {
  if (!(this instanceof BarProp)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['visible'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BarProp_get_visible,result => ', result);
  }
  return result;
};

// prototype(无构造函数)的原型方法
// prototype(无构造函数)的原型方法

================================================
FILE: env/BaseAudioContext.js
================================================
// prototype(无构造函数)的原型方法
// prototype(无构造函数)的原型方法
globalMy.BaseAudioContext_get_destination = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['destination'];
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_get_destination,result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_get_currentTime = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['currentTime'];
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_get_currentTime,result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_get_sampleRate = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['sampleRate'];
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_get_sampleRate,result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_get_listener = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['listener'];
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_get_listener,result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_get_state = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['state'];
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_get_state,result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_get_onstatechange = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['onstatechange'];
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_get_onstatechange,result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_set_onstatechange = function (val) {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['onstatechange'] = val;
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_set_onstatechange, 传参val => ' + val + '  result => ', result);
  }
};
globalMy.BaseAudioContext_createAnalyser = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createAnalyser, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createBiquadFilter = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createBiquadFilter, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createBuffer = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createBuffer, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createBufferSource = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createBufferSource, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createChannelMerger = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createChannelMerger, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createChannelSplitter = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createChannelSplitter, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createConstantSource = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createConstantSource, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createConvolver = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createConvolver, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createDelay = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createDelay, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createDynamicsCompressor = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createDynamicsCompressor, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createGain = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createGain, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createIIRFilter = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createIIRFilter, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createOscillator = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createOscillator, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createPanner = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createPanner, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createPeriodicWave = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createPeriodicWave, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createScriptProcessor = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createScriptProcessor, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createStereoPanner = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createStereoPanner, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_createWaveShaper = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_createWaveShaper, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_decodeAudioData = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_decodeAudioData, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.BaseAudioContext_get_audioWorklet = function () {
  if (!(this instanceof BaseAudioContext)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['audioWorklet'];
  if (globalMy.is_log) {
    console.log('[*]  调用了BaseAudioContext_get_audioWorklet,result => ', result);
  }
  return result;
};

================================================
FILE: env/BatteryManager.js
================================================
globalMy.BatteryManager_get_charging = function () {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['charging'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_get_charging,result => ', '' + result);
  }
  return result;
};
globalMy.BatteryManager_get_chargingTime = function () {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['chargingTime'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_get_chargingTime,result => ', '' + result);
  }
  return result;
};
globalMy.BatteryManager_get_dischargingTime = function () {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['dischargingTime'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_get_dischargingTime,result => ', '' + result);
  }
  return result;
};
globalMy.BatteryManager_get_level = function () {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['level'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_get_level,result => ', '' + result);
  }
  return result;
};
globalMy.BatteryManager_get_onchargingchange = function () {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['onchargingchange'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_get_onchargingchange,result => ', '' + result);
  }
  return result;
};
globalMy.BatteryManager_set_onchargingchange = function (val) {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['onchargingchange'] = val;
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_set_onchargingchange, 传参val => ' + val + '  result => ', '' + result);
  }
};
globalMy.BatteryManager_get_onchargingtimechange = function () {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['onchargingtimechange'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_get_onchargingtimechange,result => ', '' + result);
  }
  return result;
};
globalMy.BatteryManager_set_onchargingtimechange = function (val) {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['onchargingtimechange'] = val;
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_set_onchargingtimechange, 传参val => ' + val + '  result => ', '' + result);
  }
};
globalMy.BatteryManager_get_ondischargingtimechange = function () {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['ondischargingtimechange'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_get_ondischargingtimechange,result => ', '' + result);
  }
  return result;
};
globalMy.BatteryManager_set_ondischargingtimechange = function (val) {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['ondischargingtimechange'] = val;
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_set_ondischargingtimechange, 传参val => ' + val + '  result => ', '' + result);
  }
};
globalMy.BatteryManager_get_onlevelchange = function () {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['onlevelchange'];
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_get_onlevelchange,result => ', '' + result);
  }
  return result;
};
globalMy.BatteryManager_set_onlevelchange = function (val) {
  if (!(this instanceof BatteryManager)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  var foundName = globalMy.foundName(this);
  globalMy.value[foundName]['onlevelchange'] = val;
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了BatteryManager_set_onlevelchange, 传参val => ' + val + '  result => ', '' + result);
  }
};

================================================
FILE: env/Blob.js
================================================
globalMy.Blob_get_size = function(){
                  if (!(this instanceof Blob)) {
        throw new TypeError("Illegal invocation");
      }
                let result;
                var foundName = globalMy.foundName(this);
                result = globalMy.value[foundName]['size'];
                if(globalMy.is_log){console.log('[*]  调用了Blob_get_size,result => ' , result)}
                return result;
                }
globalMy.Blob_get_type = function(){
                  if (!(this instanceof Blob)) {
        throw new TypeError("Illegal invocation");
      }
                let result;
                var foundName = globalMy.foundName(this);
                result = globalMy.value[foundName]['type'];
                if(globalMy.is_log){console.log('[*]  调用了Blob_get_type,result => ' , result)}
                return result;
                }
globalMy.Blob_arrayBuffer = function(){
                  if (!(this instanceof Blob)) {
        throw new TypeError("Illegal invocation");
      }
                let result;
                //这里写方法实体
                if(globalMy.is_log){console.log('[*]  调用了Blob_arrayBuffer, arguments => ' , JSON.stringify(arguments),  '  result => ' , result)}
                return result;
                }
globalMy.Blob_slice = function(){
                  if (!(this instanceof Blob)) {
        throw new TypeError("Illegal invocation");
      }
                let result;
                //这里写方法实体
                if(globalMy.is_log){console.log('[*]  调用了Blob_slice, arguments => ' , JSON.stringify(arguments),  '  result => ' , result)}
                return result;
                }
globalMy.Blob_stream = function(){
                  if (!(this instanceof Blob)) {
        throw new TypeError("Illegal invocation");
      }
                let result;
                //这里写方法实体
                if(globalMy.is_log){console.log('[*]  调用了Blob_stream, arguments => ' , JSON.stringify(arguments),  '  result => ' , result)}
                return result;
                }
globalMy.Blob_text = function(){
                  if (!(this instanceof Blob)) {
        throw new TypeError("Illegal invocation");
      }
                let result;
                //这里写方法实体
                if(globalMy.is_log){console.log('[*]  调用了Blob_text, arguments => ' , JSON.stringify(arguments),  '  result => ' , result)}
                return result;
                }

================================================
FILE: env/CSSStyleDeclaration.js
================================================
globalMy.CSSStyleDeclaration_get_cssText = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_get_cssText');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['cssText'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_get_cssText, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleDeclaration_set_cssText = function (val) {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_set_cssText, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['cssText'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['cssText'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_set_cssText' + '  result => ', '' + result);
  }
};
globalMy.CSSStyleDeclaration_get_length = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_get_length');
  }
  var result;
  // var foundName = globalMy.foundName(this);
  // result = globalMy.jsdom_element[foundName]['length'];
  // if (result != null && result != undefined) {
  //   switch (typeof result) {
  //     case "object":
  //       debugger;
  //       break;
  //     case "function":
  //       debugger;
  //       break;
  //     default:
  //       break;
  //   }
  // }
  result = 346;
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_get_length, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleDeclaration_get_parentRule = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_get_parentRule');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['parentRule'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_get_parentRule, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleDeclaration_get_cssFloat = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_get_cssFloat');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['cssFloat'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_get_cssFloat, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleDeclaration_set_cssFloat = function (val) {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_set_cssFloat, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['cssFloat'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['cssFloat'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_set_cssFloat' + '  result => ', '' + result);
  }
};
globalMy.CSSStyleDeclaration_getPropertyPriority = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_getPropertyPriority, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.getPropertyPriority.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_getPropertyPriority ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleDeclaration_getPropertyValue = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_getPropertyValue, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.getPropertyValue.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_getPropertyValue ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleDeclaration_item = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_item, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.item.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_item ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleDeclaration_removeProperty = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_removeProperty, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.removeProperty.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_removeProperty ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleDeclaration_setProperty = function () {
  if (!(this instanceof CSSStyleDeclaration)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_setProperty, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.setProperty.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleDeclaration_setProperty ' + '  result => ', '' + result);
  }
  return result;
};

================================================
FILE: env/CSSStyleRule.js
================================================
globalMy.CSSStyleRule_get_selectorText = function () {
  if (!(this instanceof CSSStyleRule)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_get_selectorText');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['selectorText'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_get_selectorText, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleRule_set_selectorText = function (val) {
  if (!(this instanceof CSSStyleRule)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_set_selectorText, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['selectorText'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['selectorText'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_set_selectorText' + '  result => ', '' + result);
  }
};
globalMy.CSSStyleRule_get_style = function () {
  if (!(this instanceof CSSStyleRule)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_get_style');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['style'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_get_style, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleRule_set_style = function (val) {
  if (!(this instanceof CSSStyleRule)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_set_style, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['style'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['style'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_set_style' + '  result => ', '' + result);
  }
};
globalMy.CSSStyleRule_get_styleMap = function () {
  if (!(this instanceof CSSStyleRule)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_get_styleMap');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['styleMap'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleRule_get_styleMap, result => ', '' + result);
  }
  return result;
};

================================================
FILE: env/CSSStyleSheet.js
================================================
globalMy.CSSStyleSheet_get_ownerRule = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_get_ownerRule');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['ownerRule'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_get_ownerRule, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleSheet_get_cssRules = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_get_cssRules');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['cssRules'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_get_cssRules, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleSheet_get_rules = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_get_rules');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['rules'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_get_rules, result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleSheet_addRule = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_addRule, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.addRule.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_addRule ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleSheet_deleteRule = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_deleteRule, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.deleteRule.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_deleteRule ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleSheet_insertRule = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_insertRule, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.insertRule.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_insertRule ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleSheet_removeRule = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_removeRule, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.removeRule.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_removeRule ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleSheet_replace = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_replace, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.replace.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_replace ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CSSStyleSheet_replaceSync = function () {
  if (!(this instanceof CSSStyleSheet)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_replaceSync, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.replaceSync.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CSSStyleSheet_replaceSync ' + '  result => ', '' + result);
  }
  return result;
};

================================================
FILE: env/CanvasGradient.js
================================================
globalMy.CanvasGradient_addColorStop = function () {
  if (!(this instanceof CanvasGradient)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasGradient_addColorStop, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.addColorStop.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasGradient_addColorStop ' + '  result => ', '' + result);
  }
  return result;
};

================================================
FILE: env/CanvasRenderingContext2D.js
================================================
globalMy.CanvasRenderingContext2D_get_canvas = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_canvas');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['canvas'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_canvas, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_get_globalAlpha = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_globalAlpha');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['globalAlpha'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_globalAlpha, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_globalAlpha = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_globalAlpha, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['globalAlpha'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['globalAlpha'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_globalAlpha' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_globalCompositeOperation = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_globalCompositeOperation');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['globalCompositeOperation'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_globalCompositeOperation, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_globalCompositeOperation = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_globalCompositeOperation, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['globalCompositeOperation'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['globalCompositeOperation'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_globalCompositeOperation' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_filter = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_filter');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['filter'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_filter, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_filter = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_filter, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['filter'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['filter'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_filter' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_imageSmoothingEnabled = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_imageSmoothingEnabled');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['imageSmoothingEnabled'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_imageSmoothingEnabled, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_imageSmoothingEnabled = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_imageSmoothingEnabled, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['imageSmoothingEnabled'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['imageSmoothingEnabled'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_imageSmoothingEnabled' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_imageSmoothingQuality = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_imageSmoothingQuality');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['imageSmoothingQuality'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_imageSmoothingQuality, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_imageSmoothingQuality = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_imageSmoothingQuality, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['imageSmoothingQuality'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['imageSmoothingQuality'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_imageSmoothingQuality' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_strokeStyle = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_strokeStyle');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['strokeStyle'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_strokeStyle, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_strokeStyle = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_strokeStyle, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['strokeStyle'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['strokeStyle'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_strokeStyle' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_fillStyle = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_fillStyle');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['fillStyle'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_fillStyle, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_fillStyle = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_fillStyle, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['fillStyle'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['fillStyle'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_fillStyle' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_shadowOffsetX = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_shadowOffsetX');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['shadowOffsetX'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_shadowOffsetX, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_shadowOffsetX = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_shadowOffsetX, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['shadowOffsetX'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['shadowOffsetX'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_shadowOffsetX' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_shadowOffsetY = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_shadowOffsetY');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['shadowOffsetY'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_shadowOffsetY, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_shadowOffsetY = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_shadowOffsetY, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['shadowOffsetY'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['shadowOffsetY'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_shadowOffsetY' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_shadowBlur = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_shadowBlur');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['shadowBlur'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_shadowBlur, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_shadowBlur = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_shadowBlur, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['shadowBlur'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['shadowBlur'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_shadowBlur' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_shadowColor = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_shadowColor');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['shadowColor'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_shadowColor, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_shadowColor = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_shadowColor, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['shadowColor'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['shadowColor'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_shadowColor' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_lineWidth = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_lineWidth');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['lineWidth'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_lineWidth, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_lineWidth = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_lineWidth, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['lineWidth'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['lineWidth'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_lineWidth' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_lineCap = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_lineCap');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['lineCap'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_lineCap, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_lineCap = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_lineCap, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['lineCap'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['lineCap'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_lineCap' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_lineJoin = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_lineJoin');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['lineJoin'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_lineJoin, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_lineJoin = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_lineJoin, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['lineJoin'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['lineJoin'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_lineJoin' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_miterLimit = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_miterLimit');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['miterLimit'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_miterLimit, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_miterLimit = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_miterLimit, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['miterLimit'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['miterLimit'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_miterLimit' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_lineDashOffset = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_lineDashOffset');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['lineDashOffset'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_lineDashOffset, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_lineDashOffset = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_lineDashOffset, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['lineDashOffset'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['lineDashOffset'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_lineDashOffset' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_font = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_font');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['font'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_font, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_font = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_font, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['font'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['font'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_font' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_textAlign = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_textAlign');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['textAlign'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_textAlign, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_textAlign = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_textAlign, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['textAlign'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['textAlign'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_textAlign' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_textBaseline = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_textBaseline');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['textBaseline'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_textBaseline, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_textBaseline = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_textBaseline, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['textBaseline'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['textBaseline'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_textBaseline' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_direction = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_direction');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['direction'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_direction, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_direction = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_direction, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['direction'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['direction'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_direction' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_fontKerning = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_fontKerning');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['fontKerning'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_fontKerning, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_fontKerning = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_fontKerning, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['fontKerning'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['fontKerning'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_fontKerning' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_fontStretch = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_fontStretch');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['fontStretch'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_fontStretch, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_fontStretch = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_fontStretch, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['fontStretch'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['fontStretch'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_fontStretch' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_fontVariantCaps = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_fontVariantCaps');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['fontVariantCaps'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_fontVariantCaps, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_fontVariantCaps = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_fontVariantCaps, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['fontVariantCaps'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['fontVariantCaps'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_fontVariantCaps' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_letterSpacing = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_letterSpacing');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['letterSpacing'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_letterSpacing, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_letterSpacing = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_letterSpacing, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['letterSpacing'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['letterSpacing'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_letterSpacing' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_textRendering = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_textRendering');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['textRendering'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_textRendering, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_textRendering = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_textRendering, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['textRendering'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['textRendering'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_textRendering' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_get_wordSpacing = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_wordSpacing');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['wordSpacing'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_get_wordSpacing, result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_set_wordSpacing = function (val) {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_wordSpacing, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['wordSpacing'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['wordSpacing'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_set_wordSpacing' + '  result => ', '' + result);
  }
};
globalMy.CanvasRenderingContext2D_clip = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_clip, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.clip.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_clip ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_createConicGradient = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createConicGradient, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.createConicGradient.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createConicGradient ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_createImageData = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createImageData, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.createImageData.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createImageData ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_createLinearGradient = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createLinearGradient, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.createLinearGradient.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createLinearGradient ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_createPattern = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createPattern, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.createPattern.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createPattern ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_createRadialGradient = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createRadialGradient, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.createRadialGradient.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_createRadialGradient ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_drawFocusIfNeeded = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_drawFocusIfNeeded, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.drawFocusIfNeeded.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_drawFocusIfNeeded ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_drawImage = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_drawImage, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.drawImage.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_drawImage ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_fill = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_fill, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.fill.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_fill ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_fillText = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_fillText, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.fillText.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_fillText ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_getContextAttributes = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_getContextAttributes, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.getContextAttributes.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_getContextAttributes ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_getImageData = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_getImageData, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.getImageData.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_getImageData ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_getLineDash = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_getLineDash, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.getLineDash.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_getLineDash ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_getTransform = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_getTransform, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.getTransform.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_getTransform ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_isContextLost = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_isContextLost, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.isContextLost.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_isContextLost ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_isPointInPath = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_isPointInPath, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.isPointInPath.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_isPointInPath ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_isPointInStroke = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_isPointInStroke, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.isPointInStroke.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_isPointInStroke ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_measureText = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_measureText, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.measureText.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_measureText ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_putImageData = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_putImageData, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.putImageData.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_putImageData ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_reset = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_reset, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.reset.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_reset ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_roundRect = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_roundRect, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.roundRect.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_roundRect ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_save = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_save, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.save.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_save ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_scale = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_scale, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.scale.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_scale ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_setLineDash = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_setLineDash, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.setLineDash.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_setLineDash ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_setTransform = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_setTransform, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.setTransform.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_setTransform ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_stroke = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_stroke, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.stroke.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_stroke ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_strokeText = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_strokeText, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.strokeText.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_strokeText ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_transform = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_transform, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.transform.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_transform ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_translate = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_translate, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.translate.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_translate ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_arc = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_arc, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.arc.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_arc ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_arcTo = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_arcTo, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.arcTo.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_arcTo ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_beginPath = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_beginPath, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.beginPath.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_beginPath ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_bezierCurveTo = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_bezierCurveTo, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.bezierCurveTo.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_bezierCurveTo ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_clearRect = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_clearRect, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.clearRect.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_clearRect ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_closePath = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_closePath, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.closePath.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_closePath ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_ellipse = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_ellipse, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.ellipse.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_ellipse ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_fillRect = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_fillRect, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.fillRect.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_fillRect ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_lineTo = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_lineTo, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.lineTo.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_lineTo ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_moveTo = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_moveTo, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.moveTo.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_moveTo ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_quadraticCurveTo = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_quadraticCurveTo, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.quadraticCurveTo.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_quadraticCurveTo ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_rect = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_rect, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.rect.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_rect ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_resetTransform = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_resetTransform, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.resetTransform.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_resetTransform ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_restore = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_restore, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.restore.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_restore ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_rotate = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_rotate, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.rotate.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_rotate ' + '  result => ', '' + result);
  }
  return result;
};
globalMy.CanvasRenderingContext2D_strokeRect = function () {
  if (!(this instanceof CanvasRenderingContext2D)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_strokeRect, arguments => ', arguments);
  }
  var result;
  //这里写方法实体
  var name = globalMy.foundName(this);
  var this_ = globalMy.jsdom_element[name];
  result = this_.strokeRect.apply(this_, arguments);
  if (result == undefined || result == null) {} else {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了CanvasRenderingContext2D_strokeRect ' + '  result => ', '' + result);
  }
  return result;
};

================================================
FILE: env/Crypto.js
================================================
globalMy.Crypto_getRandomValues = function () {
    if (!(this instanceof Crypto)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了Crypto_getRandomValues, arguments => ', JSON.stringify(arguments), '  result => ', result)
    }
    return result;
}
globalMy.Crypto_get_subtle = function () {
    if (!(this instanceof Crypto)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundName(this);
    result = globalMy.value[foundName]['subtle'];
    if (globalMy.is_log) {
        console.log('[*]  调用了Crypto_get_subtle,result => ', result)
    }
    return result;
}
globalMy.Crypto_randomUUID = function () {
    if (!(this instanceof Crypto)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了Crypto_randomUUID, arguments => ', JSON.stringify(arguments), '  result => ', result)
    }
    return result;
}

================================================
FILE: env/CustomElementRegistry.js
================================================
globalMy.CustomElementRegistry_define = function () {
  if (!(this instanceof CustomElementRegistry)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了CustomElementRegistry_define, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.CustomElementRegistry_get = function () {
  if (!(this instanceof CustomElementRegistry)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了CustomElementRegistry_get, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.CustomElementRegistry_upgrade = function () {
  if (!(this instanceof CustomElementRegistry)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了CustomElementRegistry_upgrade, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.CustomElementRegistry_whenDefined = function () {
  if (!(this instanceof CustomElementRegistry)) {
    throw new TypeError("Illegal invocation");
  }
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了CustomElementRegistry_whenDefined, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
// 函数实现
// SpeechSynthesis

================================================
FILE: env/CustomEvent.js
================================================
globalMy.CustomEvent_get_detail = function () {
    if (!(this instanceof CustomEvent)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundEventName(this);
    result = globalMy.event_value[foundName]['detail'];
    if (globalMy.is_log) {
        console.log('[*]  调用了CustomEvent_get_detail,result => ', result)
    }
    return result;
}
globalMy.CustomEvent_initCustomEvent = function () {
    if (!(this instanceof CustomEvent)) {
        throw new TypeError("Illegal invocation");
    }
    let result;
    var foundName = globalMy.foundEventName(this);
    //这里写方法实体
    if (globalMy.is_log) {
        console.log('[*]  调用了CustomEvent_initCustomEvent, arguments => ', arguments, '  result => ', result)
    }
    return result;
}

================================================
FILE: env/DOMTokenList.js
================================================
globalMy.DOMTokenList_entries = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_entries, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.entries.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_entries ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_keys = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_keys, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.keys.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_keys ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_values = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_values, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.values.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_values ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_forEach = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_forEach, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.forEach.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_forEach ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_get_length = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_get_length');
    }
    var result;
    var foundName = globalMy.foundName(this);
    result = globalMy.jsdom_element[foundName]['length'];
    switch (typeof result) {
        case "object":
            debugger;
            break
        case "function":
            debugger;
            break
        default:
            break

    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_get_length, result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_get_value = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_get_value');
    }
    var result;
    var foundName = globalMy.foundName(this);
    result = globalMy.jsdom_element[foundName]['value'];
    switch (typeof result) {
        case "object":
            debugger;
            break
        case "function":
            debugger;
            break
        default:
            break

    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_get_value, result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_set_value = function (val) {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_set_value, 传参val => ' + val);
    }
    var result;
    var foundName = globalMy.foundName(this);
    if (val == undefined || val == null) {
        globalMy.jsdom_element[foundName]['value'] = val;
    } else {
        switch (typeof val) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                globalMy.jsdom_element[foundName]['value'] = val;

        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_set_value' + '  result => ', '' + result)
    }
}
globalMy.DOMTokenList_add = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_add, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.add.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_add ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_contains = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_contains, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.contains.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_contains ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_item = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_item, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.item.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_item ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_remove = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_remove, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.remove.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_remove ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_replace = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_replace, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.replace.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_replace ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_supports = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_supports, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.supports.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_supports ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_toggle = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_toggle, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.toggle.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_toggle ' + '  result => ', '' + result)
    }
    return result;
}
globalMy.DOMTokenList_toString = function () {
    if (!(this instanceof DOMTokenList)) {
        throw new TypeError("Illegal invocation");
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_toString, arguments => ', arguments);
    }
    var result;
    //这里写方法实体
    var name = globalMy.foundName(this);
    var this_ = globalMy.jsdom_element[name];
    result = this_.toString.apply(this_, arguments);
    if (result == undefined || result == null) {
    } else {
        switch (typeof result) {
            case "object":
                debugger;
                break
            case "function":
                debugger;
                break
            default:
                break
        }
    }
    if (globalMy.is_log) {
        globalMy.console.log('[*]  调用了DOMTokenList_toString ' + '  result => ', '' + result)
    }
    return result;
}


================================================
FILE: env/Database.js
================================================
globalMy.Database_get_version = function () {
  let result;
  var foundName = globalMy.foundName(this);
  result = globalMy.value[foundName]['version'];
  if (globalMy.is_log) {
    console.log('[*]  调用了Database_get_version,result => ', result);
  }
  return result;
};
globalMy.Database_changeVersion = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了Database_changeVersion, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.Database_readTransaction = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了Database_readTransaction, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.Database_transaction = function () {
  let result;
  var name = globalMy.setfoundName({});
  Object.setPrototypeOf(globalMy.element[name], IDBTransaction.prototype);
  result = globalMy.element[name];
  if (globalMy.is_log) {
    console.log('[*]  调用了Database_transaction, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};

================================================
FILE: env/DeprecatedStorageInfo.js
================================================
globalMy.DeprecatedStorageInfo_queryUsageAndQuota = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了DeprecatedStorageInfo_queryUsageAndQuota, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.DeprecatedStorageInfo_requestQuota = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了DeprecatedStorageInfo_requestQuota, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};

================================================
FILE: env/DeprecatedStorageQuota.js
================================================
globalMy.DeprecatedStorageQuota_queryUsageAndQuota = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了DeprecatedStorageQuota_queryUsageAndQuota, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};
globalMy.DeprecatedStorageQuota_requestQuota = function () {
  let result;
  //这里写方法实体
  if (globalMy.is_log) {
    console.log('[*]  调用了DeprecatedStorageQuota_requestQuota, arguments => ' + JSON.stringify(arguments) + '  result => ', result);
  }
  return result;
};

// 函数实现
// SpeechSynthesis

================================================
FILE: env/Document.js
================================================
// 函数实现
// SpeechSynthesis
globalMy.Document_get_implementation = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_implementation');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['implementation'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_implementation, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_URL = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_URL');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['URL'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_URL, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_documentURI = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_documentURI');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['documentURI'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_documentURI, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_compatMode = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_compatMode');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['compatMode'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_compatMode, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_characterSet = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_characterSet');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['characterSet'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_characterSet, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_charset = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_charset');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['charset'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_charset, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_inputEncoding = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_inputEncoding');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['inputEncoding'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_inputEncoding, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_contentType = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_contentType');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['contentType'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_contentType, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_doctype = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_doctype');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['doctype'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_doctype, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_documentElement = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_documentElement');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['documentElement'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_documentElement, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_xmlEncoding = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_xmlEncoding');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['xmlEncoding'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_xmlEncoding, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_xmlVersion = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_xmlVersion');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['xmlVersion'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_xmlVersion, result => ', '' + result);
  }
  return result;
};
globalMy.Document_set_xmlVersion = function (val) {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_set_xmlVersion, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['xmlVersion'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['xmlVersion'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_set_xmlVersion' + '  result => ', '' + result);
  }
};
globalMy.Document_get_xmlStandalone = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_xmlStandalone');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['xmlStandalone'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_xmlStandalone, result => ', '' + result);
  }
  return result;
};
globalMy.Document_set_xmlStandalone = function (val) {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_set_xmlStandalone, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['xmlStandalone'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['xmlStandalone'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_set_xmlStandalone' + '  result => ', '' + result);
  }
};
globalMy.Document_get_domain = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_domain');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['domain'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_domain, result => ', '' + result);
  }
  return result;
};
globalMy.Document_set_domain = function (val) {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_set_domain, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    globalMy.jsdom_element[foundName]['domain'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['domain'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_set_domain' + '  result => ', '' + result);
  }
};
globalMy.Document_get_referrer = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_referrer');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['referrer'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_referrer, result => ', '' + result);
  }
  return result;
};
globalMy.Document_get_cookie = function () {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_cookie');
  }
  var result;
  var foundName = globalMy.foundName(this);
  result = globalMy.jsdom_element[foundName]['cookie'];
  if (result != null && result != undefined) {
    switch (typeof result) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        break;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_get_cookie, result => ', '' + result);
  }
  return result;
};
globalMy.Document_set_cookie = function (val) {
  if (!(this instanceof Document)) {
    throw new TypeError("Illegal invocation");
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_set_cookie, 传参val => ' + val);
  }
  var result;
  var foundName = globalMy.foundName(this);
  if (val == undefined || val == null) {
    debugger;
    globalMy.jsdom_element[foundName]['cookie'] = val;
  } else {
    switch (typeof val) {
      case "object":
        debugger;
        break;
      case "function":
        debugger;
        break;
      default:
        globalMy.jsdom_element[foundName]['cookie'] = val;
    }
  }
  if (globalMy.is_log) {
    globalMy.console.log('[*]  调用了Document_set_cookie' + '  result =>