├── .gitignore
├── README.md
├── __tests__
    ├── fixtures
    │   ├── captured-errors.js
    │   └── tracekit-resource-spec.js
    ├── tracekit-computestacktrace-spec.js
    ├── tracekit-handler-spec.js
    ├── tracekit-parser-spec.js
    └── tracekit-spec.js
├── dist
    ├── errorWatch.esm.js
    ├── errorWatch.js
    ├── errorWatch.min.js
    └── errorWatch.min.js.map
├── package-lock.json
├── package.json
├── ref
    ├── supplement.js
    └── tracekit.js
├── rollup.config.js
└── src
    ├── .babelrc
    ├── computeStackTrace.js
    ├── config.js
    ├── index.js
    ├── report.js
    ├── resourceError.js
    ├── tryCatch.js
    ├── utils.js
    └── wrap.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules/
2 | 
3 | *.DS_Store
4 | *.idea
5 | *.vscode
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # 前端错误解析
  2 | 
  3 | 根据 [TraceKit](https://github.com/csnover/TraceKit) 改造。
  4 | 改动点：
  5 | 
  6 | 1. 使用 `es6` 对源文件进行改写，根据功能拆分成小文件便于维护；
  7 | 1. 使用 `rollup` ，方便打成 `UMD`、`ES` 包，压缩代码；
  8 | 1. 增加资源加载错误上报；
  9 | 1. 测试套件由 `jasmine` 改成了 `Jest`。
 10 | 
 11 | ## 安装
 12 | 
 13 | ```bash
 14 | npm i error-watch
 15 | ```
 16 | 
 17 | ## 使用
 18 | 
 19 | - es6
 20 | 
 21 | ```javaScript
 22 | import ErrorWatch from 'error-watch';
 23 | 
 24 | /**
 25 | * 错误监控回调函数
 26 | * @param stack {Object|null} 依次根据 Error 对象属性 stacktrace、stack、message和调用链 callers 来解析出错误行列等信息
 27 | * @param isWindowError {Boolean} 是否触发 window 监听事件，手动 try/catch 获取 err 解析为 false
 28 | * @param error {Error|null} 原始 err
 29 | */
 30 | function receiveError(stack, isWindowError, error) {
 31 |   const data = encodeURIComponent(JSON.stringify({
 32 |     ...stack, // 错误解析的对象
 33 |     // isWindowError
 34 |     url: window.location.href, // 报错页面
 35 |   }));
 36 |   // img 上报
 37 |   // 注意分析数据有可能过大，需要考虑 ajax？
 38 |   new Image().src = 'https://your-websize.com/api/handleError?data=' + data;
 39 | }
 40 | 
 41 | // 监听错误
 42 | ErrorWatch.report.subscribe(receiveError);
 43 | ```
 44 | 
 45 | - 脚本直接引入
 46 | 
 47 | ```html
 48 | <script src="./dist/errorWatch.min.js"></script>
 49 | <scritp>
 50 | ErrorWatch.report.subscribe(function() {
 51 | 	// code here
 52 | });
 53 | </script>
 54 | ```
 55 | 
 56 | ### 错误回调处理函数，传入三个参数
 57 | 
 58 | - stack，成功是个 `Object` 否则是 `null`，可以用来结合 `SourceMap` 定位错误。
 59 | ```json
 60 | {
 61 |   "mode": "stack",
 62 |   "name": "ReferenceError",
 63 |   "message": "thisIsAbug is not defined",
 64 |   "stack": [
 65 |     {
 66 |       "url": "http://localhost:7001/public/js/traceKit.min.js",
 67 |       "func": "Object.makeError",
 68 |       "args": [],
 69 |       "line": 1,
 70 |       "column": 9435,
 71 |       "context": null
 72 |     },
 73 |     {
 74 |       "url": "http://localhost:7001/public/demo.html",
 75 |       "func": "?",
 76 |       "args": [],
 77 |       "line": 49,
 78 |       "column": 12,
 79 |       "context": null
 80 |     }
 81 |   ]
 82 | }
 83 | ```
 84 | 
 85 | - isWindowError，可选上报，区分自动还是手动。由于 try/catch 吐出来的 error 信息丰富，对于定位错误帮助较大，可以为业务逻辑自定义错误。
 86 | ```javascript
 87 | try {
 88 |   /*
 89 |    * your code
 90 |    */
 91 |   throw new Error('oops');
 92 | } catch (e) {
 93 |   ErrorWatch.report(e);
 94 | }
 95 | ```
 96 | 
 97 | - error，原始错误对象，上述的 stack 如果内部解析成功，则例如 stack.stack 已翻译成数组，会抛弃原始的 stack。
 98 | 如果需要可以这么做。
 99 | 
100 | ```javascript
101 | {
102 |   ...stack,
103 |   errorStack: error && error.stack,
104 | }
105 | ```
106 | 
107 | - 完整实例
108 | 
109 | ```json
110 | {
111 |   "mode": "stack",
112 |   "name": "ReferenceError",
113 |   "message": "thisIsAbug is not defined",
114 |   "stack": [
115 |     {
116 |       "url": "http://localhost:7001/public/js/traceKit.min.js",
117 |       "func": "Object.makeError",
118 |       "args": [],
119 |       "line": 1,
120 |       "column": 9435,
121 |       "context": null
122 |     },
123 |     {
124 |       "url": "http://localhost:7001/public/demo.html",
125 |       "func": "?",
126 |       "args": [],
127 |       "line": 49,
128 |       "column": 12,
129 |       "context": null
130 |     }
131 |   ],
132 |   "errorStack": "ReferenceError: thisIsAbug is not defined\n    at Object.makeError (http://localhost:7001/public/js/traceKit.min.js:1:9435)\n    at http://localhost:7001/public/demo.html:49:12",
133 |   "url": "http://localhost:7001/public/demo.html"
134 | }
135 | ```
136 | 
137 | ### 资源加载错误上报信息
138 | - stack，根据 `mode` 是 `resource`，来区分资源加载错误。
139 | ````json
140 | {
141 |     "message": "img is load error",
142 |     "mode": "resource",
143 |     "name": "http://domain/404.jpg",
144 |     "stack": null,
145 |     "url": "http://localhost:7001/public/demo.html"
146 | }
147 | ````
148 | ### 建议
149 | - 尽量不用匿名函数，都给它加个名字，便于错误定位。
150 | ```javascript
151 | Api.foo = function Api_foo() {
152 | };
153 | const bar = function barFn() {
154 | };
155 | ```
156 | - Script error. 跨域脚本无法拿到错误信息。
157 | 1. 跨源资源共享机制 `CORS` ：`Access-Control-Allow-Origin: Your-allow-origin`
158 | 1. 脚本属性 `crossOrigin` ：`<script src="xxx.js" crossOrigin="anonymous"></script>`
159 | 
160 | ## npm scripts
161 | 
162 | - `npm run build` 根据 `rollup.config.js` 配置文件进行打包。
163 | - `npm test` 单元测试。
164 | 
165 | ## 阅读源码
166 | 
167 | 阅读源码前，可以参考下关于JS错误知识的一些讨论 [错误监控原理分析](https://github.com/Godiswill/blog/issues/7)。
168 | 


--------------------------------------------------------------------------------
/__tests__/fixtures/captured-errors.js:
--------------------------------------------------------------------------------
  1 | /* exported CapturedExceptions */
  2 | const CapturedExceptions = {};
  3 | 
  4 | CapturedExceptions.OPERA_854 = {
  5 |     message: "Statement on line 44: Type mismatch (usually a non-object value used where an object is required)\n" +
  6 |     "Backtrace:\n" +
  7 |     "  Line 44 of linked script http://path/to/file.js\n" +
  8 |     "    this.undef();\n" +
  9 |     "  Line 31 of linked script http://path/to/file.js\n" +
 10 |     "    ex = ex || this.createException();\n" +
 11 |     "  Line 18 of linked script http://path/to/file.js\n" +
 12 |     "    var p = new printStackTrace.implementation(), result = p.run(ex);\n" +
 13 |     "  Line 4 of inline#1 script in http://path/to/file.js\n" +
 14 |     "    printTrace(printStackTrace());\n" +
 15 |     "  Line 7 of inline#1 script in http://path/to/file.js\n" +
 16 |     "    bar(n - 1);\n" +
 17 |     "  Line 11 of inline#1 script in http://path/to/file.js\n" +
 18 |     "    bar(2);\n" +
 19 |     "  Line 15 of inline#1 script in http://path/to/file.js\n" +
 20 |     "    foo();\n" +
 21 |     "",
 22 |     'opera#sourceloc': 44
 23 | };
 24 | 
 25 | CapturedExceptions.OPERA_902 = {
 26 |     message: "Statement on line 44: Type mismatch (usually a non-object value used where an object is required)\n" +
 27 |     "Backtrace:\n" +
 28 |     "  Line 44 of linked script http://path/to/file.js\n" +
 29 |     "    this.undef();\n" +
 30 |     "  Line 31 of linked script http://path/to/file.js\n" +
 31 |     "    ex = ex || this.createException();\n" +
 32 |     "  Line 18 of linked script http://path/to/file.js\n" +
 33 |     "    var p = new printStackTrace.implementation(), result = p.run(ex);\n" +
 34 |     "  Line 4 of inline#1 script in http://path/to/file.js\n" +
 35 |     "    printTrace(printStackTrace());\n" +
 36 |     "  Line 7 of inline#1 script in http://path/to/file.js\n" +
 37 |     "    bar(n - 1);\n" +
 38 |     "  Line 11 of inline#1 script in http://path/to/file.js\n" +
 39 |     "    bar(2);\n" +
 40 |     "  Line 15 of inline#1 script in http://path/to/file.js\n" +
 41 |     "    foo();\n" +
 42 |     "",
 43 |     'opera#sourceloc': 44
 44 | };
 45 | 
 46 | CapturedExceptions.OPERA_927 = {
 47 |     message: "Statement on line 43: Type mismatch (usually a non-object value used where an object is required)\n" +
 48 |     "Backtrace:\n" +
 49 |     "  Line 43 of linked script http://path/to/file.js\n" +
 50 |     "    bar(n - 1);\n" +
 51 |     "  Line 31 of linked script http://path/to/file.js\n" +
 52 |     "    bar(2);\n" +
 53 |     "  Line 18 of linked script http://path/to/file.js\n" +
 54 |     "    foo();\n" +
 55 |     "",
 56 |     'opera#sourceloc': 43
 57 | };
 58 | 
 59 | CapturedExceptions.OPERA_964 = {
 60 |     message: "Statement on line 42: Type mismatch (usually non-object value supplied where object required)\n" +
 61 |     "Backtrace:\n" +
 62 |     "  Line 42 of linked script http://path/to/file.js\n" +
 63 |     "                this.undef();\n" +
 64 |     "  Line 27 of linked script http://path/to/file.js\n" +
 65 |     "            ex = ex || this.createException();\n" +
 66 |     "  Line 18 of linked script http://path/to/file.js: In function printStackTrace\n" +
 67 |     "        var p = new printStackTrace.implementation(), result = p.run(ex);\n" +
 68 |     "  Line 4 of inline#1 script in http://path/to/file.js: In function bar\n" +
 69 |     "             printTrace(printStackTrace());\n" +
 70 |     "  Line 7 of inline#1 script in http://path/to/file.js: In function bar\n" +
 71 |     "           bar(n - 1);\n" +
 72 |     "  Line 11 of inline#1 script in http://path/to/file.js: In function foo\n" +
 73 |     "           bar(2);\n" +
 74 |     "  Line 15 of inline#1 script in http://path/to/file.js\n" +
 75 |     "         foo();\n" +
 76 |     "",
 77 |     'opera#sourceloc': 42,
 78 |     stacktrace: "  ...  Line 27 of linked script http://path/to/file.js\n" +
 79 |     "            ex = ex || this.createException();\n" +
 80 |     "  Line 18 of linked script http://path/to/file.js: In function printStackTrace\n" +
 81 |     "        var p = new printStackTrace.implementation(), result = p.run(ex);\n" +
 82 |     "  Line 4 of inline#1 script in http://path/to/file.js: In function bar\n" +
 83 |     "             printTrace(printStackTrace());\n" +
 84 |     "  Line 7 of inline#1 script in http://path/to/file.js: In function bar\n" +
 85 |     "           bar(n - 1);\n" +
 86 |     "  Line 11 of inline#1 script in http://path/to/file.js: In function foo\n" +
 87 |     "           bar(2);\n" +
 88 |     "  Line 15 of inline#1 script in http://path/to/file.js\n" +
 89 |     "         foo();\n" +
 90 |     ""
 91 | };
 92 | 
 93 | CapturedExceptions.OPERA_10 = {
 94 |     message: "Statement on line 42: Type mismatch (usually non-object value supplied where object required)",
 95 |     'opera#sourceloc': 42,
 96 |     stacktrace: "  Line 42 of linked script http://path/to/file.js\n" +
 97 |     "                this.undef();\n" +
 98 |     "  Line 27 of linked script http://path/to/file.js\n" +
 99 |     "            ex = ex || this.createException();\n" +
100 |     "  Line 18 of linked script http://path/to/file.js: In function printStackTrace\n" +
101 |     "        var p = new printStackTrace.implementation(), result = p.run(ex);\n" +
102 |     "  Line 4 of inline#1 script in http://path/to/file.js: In function bar\n" +
103 |     "             printTrace(printStackTrace());\n" +
104 |     "  Line 7 of inline#1 script in http://path/to/file.js: In function bar\n" +
105 |     "           bar(n - 1);\n" +
106 |     "  Line 11 of inline#1 script in http://path/to/file.js: In function foo\n" +
107 |     "           bar(2);\n" +
108 |     "  Line 15 of inline#1 script in http://path/to/file.js\n" +
109 |     "         foo();\n" +
110 |     ""
111 | };
112 | 
113 | CapturedExceptions.OPERA_11 = {
114 |     message: "'this.undef' is not a function",
115 |     stack: "<anonymous function: run>([arguments not available])@http://path/to/file.js:27\n" +
116 |     "bar([arguments not available])@http://domain.com:1234/path/to/file.js:18\n" +
117 |     "foo([arguments not available])@http://domain.com:1234/path/to/file.js:11\n" +
118 |     "<anonymous function>@http://path/to/file.js:15\n" +
119 |     "Error created at <anonymous function>@http://path/to/file.js:15",
120 |     stacktrace: "Error thrown at line 42, column 12 in <anonymous function: createException>() in http://path/to/file.js:\n" +
121 |     "    this.undef();\n" +
122 |     "called from line 27, column 8 in <anonymous function: run>(ex) in http://path/to/file.js:\n" +
123 |     "    ex = ex || this.createException();\n" +
124 |     "called from line 18, column 4 in printStackTrace(options) in http://path/to/file.js:\n" +
125 |     "    var p = new printStackTrace.implementation(), result = p.run(ex);\n" +
126 |     "called from line 4, column 5 in bar(n) in http://path/to/file.js:\n" +
127 |     "    printTrace(printStackTrace());\n" +
128 |     "called from line 7, column 4 in bar(n) in http://path/to/file.js:\n" +
129 |     "    bar(n - 1);\n" +
130 |     "called from line 11, column 4 in foo() in http://path/to/file.js:\n" +
131 |     "    bar(2);\n" +
132 |     "called from line 15, column 3 in http://path/to/file.js:\n" +
133 |     "    foo();"
134 | };
135 | 
136 | CapturedExceptions.OPERA_12 = {
137 |     message: "Cannot convert 'x' to object",
138 |     stack: "<anonymous function>([arguments not available])@http://localhost:8000/ExceptionLab.html:48\n" +
139 |     "dumpException3([arguments not available])@http://localhost:8000/ExceptionLab.html:46\n" +
140 |     "<anonymous function>([arguments not available])@http://localhost:8000/ExceptionLab.html:1",
141 |     stacktrace: "Error thrown at line 48, column 12 in <anonymous function>(x) in http://localhost:8000/ExceptionLab.html:\n" +
142 |     "    x.undef();\n" +
143 |     "called from line 46, column 8 in dumpException3() in http://localhost:8000/ExceptionLab.html:\n" +
144 |     "    dumpException((function(x) {\n" +
145 |     "called from line 1, column 0 in <anonymous function>(event) in http://localhost:8000/ExceptionLab.html:\n" +
146 |     "    dumpException3();"
147 | };
148 | 
149 | CapturedExceptions.OPERA_25 = {
150 |     message: "Cannot read property 'undef' of null",
151 |     name: "TypeError",
152 |     stack: "TypeError: Cannot read property 'undef' of null\n" +
153 |     "    at http://path/to/file.js:47:22\n" +
154 |     "    at foo (http://path/to/file.js:52:15)\n" +
155 |     "    at bar (http://path/to/file.js:108:168)"
156 | };
157 | 
158 | CapturedExceptions.CHROME_15 = {
159 |     'arguments': ["undef"],
160 |     message: "Object #<Object> has no method 'undef'",
161 |     stack: "TypeError: Object #<Object> has no method 'undef'\n" +
162 |     "    at bar (http://path/to/file.js:13:17)\n" +
163 |     "    at bar (http://path/to/file.js:16:5)\n" +
164 |     "    at foo (http://path/to/file.js:20:5)\n" +
165 |     "    at http://path/to/file.js:24:4"
166 | };
167 | 
168 | CapturedExceptions.CHROME_36 = {
169 |     message: "Default error",
170 |     name: "Error",
171 |     stack: "Error: Default error\n" +
172 |     "    at dumpExceptionError (http://localhost:8080/file.js:41:27)\n" +
173 |     "    at HTMLButtonElement.onclick (http://localhost:8080/file.js:107:146)\n" +
174 |     "    at I.e.fn.(anonymous function) [as index] (http://localhost:8080/file.js:10:3651)"
175 | };
176 | 
177 | // can be generated when Webpack is built with { devtool: eval }
178 | CapturedExceptions.CHROME_XX_WEBPACK = {
179 |     message: "Cannot read property 'error' of undefined",
180 |     name: "TypeError",
181 |     stack: "TypeError: Cannot read property 'error' of undefined\n" +
182 |     "   at TESTTESTTEST.eval(webpack:///./src/components/test/test.jsx?:295:108)\n" +
183 |     "   at TESTTESTTEST.render(webpack:///./src/components/test/test.jsx?:272:32)\n" +
184 |     "   at TESTTESTTEST.tryRender(webpack:///./~/react-transform-catch-errors/lib/index.js?:34:31)\n" +
185 |     "   at TESTTESTTEST.proxiedMethod(webpack:///./~/react-proxy/modules/createPrototypeProxy.js?:44:30)"
186 | };
187 | 
188 | CapturedExceptions.FIREFOX_3 = {
189 |     fileName: "http://127.0.0.1:8000/js/stacktrace.js",
190 |     lineNumber: 44,
191 |     message: "this.undef is not a function",
192 |     name: "TypeError",
193 |     stack: "()@http://127.0.0.1:8000/js/stacktrace.js:44\n" +
194 |     "(null)@http://127.0.0.1:8000/js/stacktrace.js:31\n" +
195 |     "printStackTrace()@http://127.0.0.1:8000/js/stacktrace.js:18\n" +
196 |     "bar(1)@http://127.0.0.1:8000/js/file.js:13\n" +
197 |     "bar(2)@http://127.0.0.1:8000/js/file.js:16\n" +
198 |     "foo()@http://127.0.0.1:8000/js/file.js:20\n" +
199 |     "@http://127.0.0.1:8000/js/file.js:24\n" +
200 |     ""
201 | };
202 | 
203 | CapturedExceptions.FIREFOX_7 = {
204 |     fileName: "file:///G:/js/stacktrace.js",
205 |     lineNumber: 44,
206 |     stack: "()@file:///G:/js/stacktrace.js:44\n" +
207 |     "(null)@file:///G:/js/stacktrace.js:31\n" +
208 |     "printStackTrace()@file:///G:/js/stacktrace.js:18\n" +
209 |     "bar(1)@file:///G:/js/file.js:13\n" +
210 |     "bar(2)@file:///G:/js/file.js:16\n" +
211 |     "foo()@file:///G:/js/file.js:20\n" +
212 |     "@file:///G:/js/file.js:24\n" +
213 |     ""
214 | };
215 | 
216 | CapturedExceptions.FIREFOX_14 = {
217 |     message: "x is null",
218 |     stack: "@http://path/to/file.js:48\n" +
219 |     "dumpException3@http://path/to/file.js:52\n" +
220 |     "onclick@http://path/to/file.js:1\n" +
221 |     "",
222 |     fileName: "http://path/to/file.js",
223 |     lineNumber: 48
224 | };
225 | 
226 | CapturedExceptions.FIREFOX_31 = {
227 |     message: "Default error",
228 |     name: "Error",
229 |     stack: "foo@http://path/to/file.js:41:13\n" +
230 |     "bar@http://path/to/file.js:1:1\n" +
231 |     ".plugin/e.fn[c]/<@http://path/to/file.js:1:1\n" +
232 |     "",
233 |     fileName: "http://path/to/file.js",
234 |     lineNumber: 41,
235 |     columnNumber: 12
236 | };
237 | 
238 | CapturedExceptions.FIREFOX_43_EVAL = {
239 |     columnNumber: 30,
240 |     fileName: 'http://localhost:8080/file.js line 25 > eval line 2 > eval',
241 |     lineNumber: 1,
242 |     message: 'message string',
243 |     stack: 'baz@http://localhost:8080/file.js line 26 > eval line 2 > eval:1:30\n' +
244 |     'foo@http://localhost:8080/file.js line 26 > eval:2:96\n' +
245 |     '@http://localhost:8080/file.js line 26 > eval:4:18\n' +
246 |     'speak@http://localhost:8080/file.js:26:17\n' +
247 |     '@http://localhost:8080/file.js:33:9'
248 | };
249 | 
250 | // Internal errors sometimes thrown by Firefox
251 | // More here: https://developer.mozilla.org/en-US/docs/Mozilla/Errors
252 | //
253 | // Note that such errors are instanceof "Exception", not "Error"
254 | CapturedExceptions.FIREFOX_44_NS_EXCEPTION = {
255 |     message: "",
256 |     name: "NS_ERROR_FAILURE",
257 |     stack: "[2]</Bar.prototype._baz/</<@http://path/to/file.js:703:28\n" +
258 |     "App.prototype.foo@file:///path/to/file.js:15:2\n" +
259 |     "bar@file:///path/to/file.js:20:3\n" +
260 |     "@file:///path/to/index.html:23:1\n" + // inside <script> tag
261 |     "",
262 |     fileName: "http://path/to/file.js",
263 |     columnNumber: 0,
264 |     lineNumber: 703,
265 |     result: 2147500037
266 | };
267 | 
268 | CapturedExceptions.FIREFOX_50_RESOURCE_URL = {
269 |     stack: 'render@resource://path/data/content/bundle.js:5529:16\n' +
270 |     'dispatchEvent@resource://path/data/content/vendor.bundle.js:18:23028\n' +
271 |     'wrapped@resource://path/data/content/bundle.js:7270:25',
272 |     fileName: 'resource://path/data/content/bundle.js',
273 |     lineNumber: 5529,
274 |     columnNumber: 16,
275 |     message: 'this.props.raw[this.state.dataSource].rows is undefined',
276 |     name: 'TypeError'
277 | };
278 | 
279 | CapturedExceptions.SAFARI_6 = {
280 |     message: "'null' is not an object (evaluating 'x.undef')",
281 |     stack: "@http://path/to/file.js:48\n" +
282 |     "dumpException3@http://path/to/file.js:52\n" +
283 |     "onclick@http://path/to/file.js:82\n" +
284 |     "[native code]",
285 |     line: 48,
286 |     sourceURL: "http://path/to/file.js"
287 | };
288 | 
289 | CapturedExceptions.SAFARI_7 = {
290 |     message: "'null' is not an object (evaluating 'x.undef')",
291 |     name: "TypeError",
292 |     stack: "http://path/to/file.js:48:22\n" +
293 |     "foo@http://path/to/file.js:52:15\n" +
294 |     "bar@http://path/to/file.js:108:107",
295 |     line: 47,
296 |     sourceURL: "http://path/to/file.js"
297 | };
298 | 
299 | CapturedExceptions.SAFARI_8 = {
300 |     message: "null is not an object (evaluating 'x.undef')",
301 |     name: "TypeError",
302 |     stack: "http://path/to/file.js:47:22\n" +
303 |     "foo@http://path/to/file.js:52:15\n" +
304 |     "bar@http://path/to/file.js:108:23",
305 |     line: 47,
306 |     column: 22,
307 |     sourceURL: "http://path/to/file.js"
308 | };
309 | 
310 | CapturedExceptions.SAFARI_8_EVAL = {
311 |     message: "Can't find variable: getExceptionProps",
312 |     name: "ReferenceError",
313 |     stack: "eval code\n" +
314 |     "eval@[native code]\n" +
315 |     "foo@http://path/to/file.js:58:21\n" +
316 |     "bar@http://path/to/file.js:109:91",
317 |     line: 1,
318 |     column: 18
319 | };
320 | 
321 | CapturedExceptions.IE_9 = {
322 |     message: "Unable to get property 'undef' of undefined or null reference",
323 |     description: "Unable to get property 'undef' of undefined or null reference"
324 | };
325 | 
326 | CapturedExceptions.IE_10 = {
327 |     message: "Unable to get property 'undef' of undefined or null reference",
328 |     stack: "TypeError: Unable to get property 'undef' of undefined or null reference\n" +
329 |     "   at Anonymous function (http://path/to/file.js:48:13)\n" +
330 |     "   at foo (http://path/to/file.js:46:9)\n" +
331 |     "   at bar (http://path/to/file.js:82:1)",
332 |     description: "Unable to get property 'undef' of undefined or null reference",
333 |     number: -2146823281
334 | };
335 | 
336 | CapturedExceptions.IE_11 = {
337 |     message: "Unable to get property 'undef' of undefined or null reference",
338 |     name: "TypeError",
339 |     stack: "TypeError: Unable to get property 'undef' of undefined or null reference\n" +
340 |     "   at Anonymous function (http://path/to/file.js:47:21)\n" +
341 |     "   at foo (http://path/to/file.js:45:13)\n" +
342 |     "   at bar (http://path/to/file.js:108:1)",
343 |     description: "Unable to get property 'undef' of undefined or null reference",
344 |     number: -2146823281
345 | };
346 | 
347 | CapturedExceptions.IE_11_EVAL = {
348 |     message: "'getExceptionProps' is undefined",
349 |     name: "ReferenceError",
350 |     stack: "ReferenceError: 'getExceptionProps' is undefined\n" +
351 |     "   at eval code (eval code:1:1)\n" +
352 |     "   at foo (http://path/to/file.js:58:17)\n" +
353 |     "   at bar (http://path/to/file.js:109:1)",
354 |     description: "'getExceptionProps' is undefined",
355 |     number: -2146823279
356 | };
357 | 
358 | CapturedExceptions.CHROME_48_BLOB = {
359 |     message: "Error: test",
360 |     name: "Error",
361 |     stack: "Error: test\n" +
362 |     "    at Error (native)\n" +
363 |     "    at s (blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379:31:29146)\n" +
364 |     "    at Object.d [as add] (blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379:31:30039)\n" +
365 |     "    at blob:http%3A//localhost%3A8080/d4eefe0f-361a-4682-b217-76587d9f712a:15:10978\n" +
366 |     "    at blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379:1:6911\n" +
367 |     "    at n.fire (blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379:7:3019)\n" +
368 |     "    at n.handle (blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379:7:2863)"
369 | };
370 | 
371 | CapturedExceptions.CHROME_48_EVAL = {
372 |     message: 'message string',
373 |     name: 'Error',
374 |     stack: 'Error: message string\n' +
375 |     'at baz (eval at foo (eval at speak (http://localhost:8080/file.js:21:17)), <anonymous>:1:30)\n' +
376 |     'at foo (eval at speak (http://localhost:8080/file.js:21:17), <anonymous>:2:96)\n' +
377 |     'at eval (eval at speak (http://localhost:8080/file.js:21:17), <anonymous>:4:18)\n' +
378 |     'at Object.speak (http://localhost:8080/file.js:21:17)\n' +
379 |     'at http://localhost:8080/file.js:31:13\n'
380 | };
381 | 
382 | CapturedExceptions.PHANTOMJS_1_19 = {
383 |     stack: "Error: foo\n" +
384 |     "    at file:///path/to/file.js:878\n" +
385 |     "    at foo (http://path/to/file.js:4283)\n" +
386 |     "    at http://path/to/file.js:4287"
387 | };
388 | 
389 | CapturedExceptions.ANDROID_REACT_NATIVE = {
390 |     message: 'Error: test',
391 |     name: 'Error',
392 |     stack: 'Error: test\n' +
393 |     'at render(/home/username/sample-workspace/sampleapp.collect.react/src/components/GpsMonitorScene.js:78:24)\n' +
394 |     'at _renderValidatedComponentWithoutOwnerOrContext(/home/username/sample-workspace/sampleapp.collect.react/node_modules/react-native/Libraries/Renderer/src/renderers/shared/stack/reconciler/ReactCompositeComponent.js:1050:29)\n' +
395 |     'at _renderValidatedComponent(/home/username/sample-workspace/sampleapp.collect.react/node_modules/react-native/Libraries/Renderer/src/renderers/shared/stack/reconciler/ReactCompositeComponent.js:1075:15)\n' +
396 |     'at renderedElement(/home/username/sample-workspace/sampleapp.collect.react/node_modules/react-native/Libraries/Renderer/src/renderers/shared/stack/reconciler/ReactCompositeComponent.js:484:29)\n' +
397 |     'at _currentElement(/home/username/sample-workspace/sampleapp.collect.react/node_modules/react-native/Libraries/Renderer/src/renderers/shared/stack/reconciler/ReactCompositeComponent.js:346:40)\n' +
398 |     'at child(/home/username/sample-workspace/sampleapp.collect.react/node_modules/react-native/Libraries/Renderer/src/renderers/shared/stack/reconciler/ReactReconciler.js:68:25)\n' +
399 |     'at children(/home/username/sample-workspace/sampleapp.collect.react/node_modules/react-native/Libraries/Renderer/src/renderers/shared/stack/reconciler/ReactMultiChild.js:264:10)\n' +
400 |     'at this(/home/username/sample-workspace/sampleapp.collect.react/node_modules/react-native/Libraries/Renderer/src/renderers/native/ReactNativeBaseComponent.js:74:41)\n'
401 | };
402 | 
403 | CapturedExceptions.ANDROID_REACT_NATIVE_PROD = {
404 |     message: 'Error: test',
405 |     name: 'Error',
406 |     stack: 'value@index.android.bundle:12:1917\n' +
407 |     'onPress@index.android.bundle:12:2336\n' +
408 |     'touchableHandlePress@index.android.bundle:258:1497\n' +
409 |     '[native code]\n' +
410 |     '_performSideEffectsForTransition@index.android.bundle:252:8508\n' +
411 |     '[native code]\n' +
412 |     '_receiveSignal@index.android.bundle:252:7291\n' +
413 |     '[native code]\n' +
414 |     'touchableHandleResponderRelease@index.android.bundle:252:4735\n' +
415 |     '[native code]\n' +
416 |     'u@index.android.bundle:79:142\n' +
417 |     'invokeGuardedCallback@index.android.bundle:79:459\n' +
418 |     'invokeGuardedCallbackAndCatchFirstError@index.android.bundle:79:580\n' +
419 |     'c@index.android.bundle:95:365\n' +
420 |     'a@index.android.bundle:95:567\n' +
421 |     'v@index.android.bundle:146:501\n' +
422 |     'g@index.android.bundle:146:604\n' +
423 |     'forEach@[native code]\n' +
424 |     'i@index.android.bundle:149:80\n' +
425 |     'processEventQueue@index.android.bundle:146:1432\n' +
426 |     's@index.android.bundle:157:88\n' +
427 |     'handleTopLevel@index.android.bundle:157:174\n' +
428 |     'index.android.bundle:156:572\n' +
429 |     'a@index.android.bundle:93:276\n' +
430 |     'c@index.android.bundle:93:60\n' +
431 |     'perform@index.android.bundle:177:596\n' +
432 |     'batchedUpdates@index.android.bundle:188:464\n' +
433 |     'i@index.android.bundle:176:358\n' +
434 |     'i@index.android.bundle:93:90\n' +
435 |     'u@index.android.bundle:93:150\n' +
436 |     '_receiveRootNodeIDEvent@index.android.bundle:156:544\n' +
437 |     'receiveTouches@index.android.bundle:156:918\n' +
438 |     'value@index.android.bundle:29:3016\n' +
439 |     'index.android.bundle:29:955\n' +
440 |     'value@index.android.bundle:29:2417\n' +
441 |     'value@index.android.bundle:29:927\n' +
442 |     '[native code]'
443 | };
444 | 
445 | module.exports = CapturedExceptions;
446 | 


--------------------------------------------------------------------------------
/__tests__/fixtures/tracekit-resource-spec.js:
--------------------------------------------------------------------------------
  1 | // 'use strict';
  2 | //
  3 | // describe('Resource Error', function () {
  4 | //   const ErrorWatch = require('../dist/errorWatch');
  5 | //
  6 | //   describe('load img', function () {
  7 | //     let cb = null;
  8 | //     let img = null;
  9 | //     beforeEach(function () {
 10 | //       img = document.createElement('img');
 11 | //       document.body.appendChild(img);
 12 | //       console.log('step1');
 13 | //     });
 14 | //     it('img should load error', function (done) {
 15 | //       function h1(stack, isWindowError, error) {
 16 | //         expect(stack.message).toBe(`img is load error`);
 17 | //         expect(stack.name).toMatch(`xxx.png`);
 18 | //         expect(stack.mode).toBe('resource');
 19 | //         expect(stack.stack).toBe(null);
 20 | //         done();
 21 | //       }
 22 | //       cb = h1;
 23 | //       ErrorWatch.report.subscribe(cb);
 24 | //       img.src = 'xxx.png';
 25 | //       console.log('step2');
 26 | //     });
 27 | //
 28 | //     afterEach(function () {
 29 | //       ErrorWatch.report.unsubscribe(cb);
 30 | //       img.remove();
 31 | //       img = null;
 32 | //       console.log('step3');
 33 | //     });
 34 | //   });
 35 | //
 36 | //   describe('load script', function () {
 37 | //     let cb = null;
 38 | //     let script = null;
 39 | //     beforeEach(function () {
 40 | //       script = document.createElement('script');
 41 | //       document.body.appendChild(script);
 42 | //       console.log('step4');
 43 | //     });
 44 | //     it('script should load error', function (done) {
 45 | //       function h2(stack, isWindowError, error) {
 46 | //         expect(stack.message).toBe(`script is load error`);
 47 | //         expect(stack.name).toMatch(`aaa.js`);
 48 | //         expect(stack.mode).toBe('resource');
 49 | //         expect(stack.stack).toBe(null);
 50 | //         done();
 51 | //       }
 52 | //       cb = h2;
 53 | //       ErrorWatch.report.subscribe(cb);
 54 | //       script.src = 'aaa.js';
 55 | //       console.log('step5');
 56 | //     });
 57 | //
 58 | //     afterEach(function () {
 59 | //       ErrorWatch.report.unsubscribe(cb);
 60 | //       script.remove();
 61 | //       script = null;
 62 | //       console.log('step6');
 63 | //     });
 64 | //   });
 65 | //
 66 | //   describe('uninstallResourceError', function () {
 67 | //     let cb = null;
 68 | //     let script = null;
 69 | //     let timerCallback = jest.fn();
 70 | //
 71 | //     beforeEach(function () {
 72 | //       script = document.createElement('script');
 73 | //       document.body.appendChild(script);
 74 | //
 75 | //       console.log('step7');
 76 | //     });
 77 | //
 78 | //     afterEach(function() {
 79 | //       // ErrorWatch.report.unsubscribe(cb);
 80 | //       script.remove();
 81 | //       console.log('step9');
 82 | //     });
 83 | //
 84 | //     it('not toHaveBeenCalled', function (done) {
 85 | //       function h3(stack, isWindowError, error) {
 86 | //         timerCallback();
 87 | //       }
 88 | //       cb = h3;
 89 | //       ErrorWatch.report.subscribe(cb);
 90 | //       ErrorWatch.report.unsubscribe(cb);
 91 | //       script.onerror = function() {
 92 | //         expect(timerCallback.mock.calls.length).toBe(0);
 93 | //         done();
 94 | //       };
 95 | //       script.src = 'bbb.js';
 96 | //       console.log('step8');
 97 | //     });
 98 | //   });
 99 | //
100 | //
101 | // });
102 | 


--------------------------------------------------------------------------------
/__tests__/tracekit-computestacktrace-spec.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | describe('computeStackTrace', () => {
 4 |   describe('domain regex', () => {
 5 |     const regex = /(.*)\:\/\/([^\/]+)\/{0,1}([\s\S]*)/;
 6 | 
 7 |     it('should return subdomains properly', () => {
 8 |       const url = 'https://subdomain.yoursite.com/assets/main.js';
 9 |       const domain = 'subdomain.yoursite.com';
10 |       expect(regex.exec(url)[2]).toBe(domain);
11 |     });
12 |     it('should return domains correctly with any protocol', () => {
13 |       const url = 'http://yoursite.com/assets/main.js';
14 |       const domain = 'yoursite.com';
15 | 
16 |       expect(regex.exec(url)[2]).toBe(domain);
17 |     });
18 |     it('should return the correct domain when directories match the domain', () => {
19 |       const url = 'https://mysite.com/mysite/main.js';
20 |       const domain = 'mysite.com';
21 | 
22 |       expect(regex.exec(url)[2]).toBe(domain);
23 |     });
24 |   });
25 | });
26 | 


--------------------------------------------------------------------------------
/__tests__/tracekit-handler-spec.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | describe('Handler', function () {
 4 |   const ErrorWatch = require('../dist/errorWatch');
 5 | 
 6 |   it('it should not go into an infinite loop', done => {
 7 |     let stacks = [];
 8 | 
 9 |     function handler(stackInfo) {
10 |       stacks.push(stackInfo);
11 |     }
12 | 
13 |     function throwException() {
14 |       throw new Error('Boom!');
15 |     }
16 | 
17 |     ErrorWatch.report.subscribe(handler);
18 |     expect(function () {
19 |       ErrorWatch.wrap(throwException)();
20 |     }).toThrow();
21 | 
22 |     setTimeout(function () {
23 |       ErrorWatch.report.unsubscribe(handler);
24 |       expect(stacks.length).toBe(1);
25 |       done();
26 |     }, 1000);
27 |   }, 2000);
28 | 
29 |   it('should get extra arguments (isWindowError and exception)', done => {
30 |     const handler = jest.fn();
31 |     const exception = new Error('Boom!');
32 | 
33 |     function throwException() {
34 |       throw exception;
35 |     }
36 | 
37 |     ErrorWatch.report.subscribe(handler);
38 |     expect(function () {
39 |       ErrorWatch.wrap(throwException)();
40 |     }).toThrow();
41 | 
42 |     setTimeout(function () {
43 |       ErrorWatch.report.unsubscribe(handler);
44 | 
45 |       expect(handler.mock.calls.length).toEqual(1);
46 | 
47 |       var isWindowError = handler.mock.calls[0][1];
48 |       expect(isWindowError).toEqual(false);
49 | 
50 |       var e = handler.mock.calls[0][2];
51 |       expect(e).toEqual(exception);
52 | 
53 |       done();
54 |     }, 1000);
55 |   }, 2000);
56 | 
57 |   // NOTE: This will not pass currently because errors are rethrown.
58 |   /* it('it should call report handler once', function (done){
59 |       var handlerCalledCount = 0;
60 |       ErrorWatch.report.subscribe(function(stackInfo) {
61 |           handlerCalledCount++;
62 |       });
63 | 
64 |       function handleAndReportException() {
65 |           try {
66 |               a++;
67 |           } catch (ex) {
68 |               ErrorWatch.report(ex);
69 |           }
70 |       }
71 | 
72 |       expect(handleAndReportException).not.toThrow();
73 |       setTimeout(function () {
74 |           expect(handlerCalledCount).toBe(1);
75 |           done();
76 |       }, 1000);
77 |   }, 2000); */
78 | });
79 | 


--------------------------------------------------------------------------------
/__tests__/tracekit-parser-spec.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | describe('Parser', function () {
  4 |   const ErrorWatch = require('../dist/errorWatch');
  5 |   const CapturedExceptions = require('./fixtures/captured-errors');
  6 | 
  7 |   function foo() {
  8 |     return bar();
  9 |   }
 10 | 
 11 |   function bar() {
 12 |     return baz();
 13 |   }
 14 | 
 15 |   function baz() {
 16 |     return ErrorWatch.computeStackTrace.ofCaller();
 17 |   }
 18 | 
 19 |   it('should get the order of functions called right', function () {
 20 |     const trace = foo();
 21 |     const expected = ['baz', 'bar', 'foo'];
 22 | 
 23 |     for (let i = 1; i <= 3; i++) {
 24 |       expect(trace.stack[i].func).toBe(expected[i - 1]);
 25 |     }
 26 |   });
 27 | 
 28 |   it('should parse Safari 6 error', function () {
 29 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.SAFARI_6);
 30 |     expect(stackFrames).toBeTruthy();
 31 |     expect(stackFrames.stack.length).toBe(4);
 32 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 48, column: null, context: null });
 33 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'dumpException3', args: [], line: 52, column: null, context: null });
 34 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'onclick', args: [], line: 82, column: null, context: null });
 35 |     expect(stackFrames.stack[3]).toEqual({ url: '[native code]', func: '?', args: [], line: null, column: null, context: null });
 36 |   });
 37 | 
 38 |   it('should parse Safari 7 error', function () {
 39 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.SAFARI_7);
 40 |     expect(stackFrames).toBeTruthy();
 41 |     expect(stackFrames.stack.length).toBe(3);
 42 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 48, column: 22, context: null });
 43 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 52, column: 15, context: null });
 44 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 108, column: 107, context: null });
 45 |   });
 46 | 
 47 |   it('should parse Safari 8 error', function () {
 48 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.SAFARI_8);
 49 |     expect(stackFrames).toBeTruthy();
 50 |     expect(stackFrames.stack.length).toBe(3);
 51 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 47, column: 22, context: null });
 52 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 52, column: 15, context: null });
 53 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 108, column: 23, context: null });
 54 |   });
 55 | 
 56 |   it('should parse Safari 8 eval error', function () {
 57 |     // TODO: Take into account the line and column properties on the error object and use them for the first stack trace.
 58 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.SAFARI_8_EVAL);
 59 |     expect(stackFrames).toBeTruthy();
 60 |     expect(stackFrames.stack.length).toBe(3);
 61 |     expect(stackFrames.stack[0]).toEqual({ url: '[native code]', func: 'eval', args: [], line: null, column: null, context: null });
 62 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 58, column: 21, context: null });
 63 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 109, column: 91, context: null });
 64 |   });
 65 | 
 66 |   it('should parse Firefox 3 error', function () {
 67 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.FIREFOX_3);
 68 |     expect(stackFrames).toBeTruthy();
 69 |     expect(stackFrames.stack.length).toBe(7);
 70 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://127.0.0.1:8000/js/stacktrace.js', func: '?', args: [], line: 44, column: null, context: null });
 71 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://127.0.0.1:8000/js/stacktrace.js', func: '?', args: ['null'], line: 31, column: null, context: null });
 72 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://127.0.0.1:8000/js/stacktrace.js', func: 'printStackTrace', args: [], line: 18, column: null, context: null });
 73 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://127.0.0.1:8000/js/file.js', func: 'bar', args: ['1'], line: 13, column: null, context: null });
 74 |     expect(stackFrames.stack[4]).toEqual({ url: 'http://127.0.0.1:8000/js/file.js', func: 'bar', args: ['2'], line: 16, column: null, context: null });
 75 |     expect(stackFrames.stack[5]).toEqual({ url: 'http://127.0.0.1:8000/js/file.js', func: 'foo', args: [], line: 20, column: null, context: null });
 76 |     expect(stackFrames.stack[6]).toEqual({ url: 'http://127.0.0.1:8000/js/file.js', func: '?', args: [], line: 24, column: null, context: null });
 77 |   });
 78 | 
 79 |   it('should parse Firefox 7 error', function () {
 80 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.FIREFOX_7);
 81 |     expect(stackFrames).toBeTruthy();
 82 |     expect(stackFrames.stack.length).toBe(7);
 83 |     expect(stackFrames.stack[0]).toEqual({ url: 'file:///G:/js/stacktrace.js', func: '?', args: [], line: 44, column: null, context: null });
 84 |     expect(stackFrames.stack[1]).toEqual({ url: 'file:///G:/js/stacktrace.js', func: '?', args: ['null'], line: 31, column: null, context: null });
 85 |     expect(stackFrames.stack[2]).toEqual({ url: 'file:///G:/js/stacktrace.js', func: 'printStackTrace', args: [], line: 18, column: null, context: null });
 86 |     expect(stackFrames.stack[3]).toEqual({ url: 'file:///G:/js/file.js', func: 'bar', args: ['1'], line: 13, column: null, context: null });
 87 |     expect(stackFrames.stack[4]).toEqual({ url: 'file:///G:/js/file.js', func: 'bar', args: ['2'], line: 16, column: null, context: null });
 88 |     expect(stackFrames.stack[5]).toEqual({ url: 'file:///G:/js/file.js', func: 'foo', args: [], line: 20, column: null, context: null });
 89 |     expect(stackFrames.stack[6]).toEqual({ url: 'file:///G:/js/file.js', func: '?', args: [], line: 24, column: null, context: null });
 90 |   });
 91 | 
 92 |   it('should parse Firefox 14 error', function () {
 93 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.FIREFOX_14);
 94 |     expect(stackFrames).toBeTruthy();
 95 |     expect(stackFrames.stack.length).toBe(3);
 96 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 48, column: null, context: null });
 97 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'dumpException3', args: [], line: 52, column: null, context: null });
 98 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'onclick', args: [], line: 1, column: null, context: null });
 99 |   });
100 | 
101 |   it('should parse Firefox 31 error', function () {
102 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.FIREFOX_31);
103 |     expect(stackFrames).toBeTruthy();
104 |     expect(stackFrames.stack.length).toBe(3);
105 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 41, column: 13, context: null });
106 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 1, column: 1, context: null });
107 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: '.plugin/e.fn[c]/<', args: [], line: 1, column: 1, context: null });
108 |   });
109 | 
110 |   it('should parse Firefox 44 ns exceptions', function () {
111 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.FIREFOX_44_NS_EXCEPTION);
112 |     expect(stackFrames).toBeTruthy();
113 |     expect(stackFrames.stack.length).toBe(4);
114 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '[2]</Bar.prototype._baz/</<', args: [], line: 703, column: 28, context: null });
115 |     expect(stackFrames.stack[1]).toEqual({ url: 'file:///path/to/file.js', func: 'App.prototype.foo', args: [], line: 15, column: 2, context: null });
116 |     expect(stackFrames.stack[2]).toEqual({ url: 'file:///path/to/file.js', func: 'bar', args: [], line: 20, column: 3, context: null });
117 |     expect(stackFrames.stack[3]).toEqual({ url: 'file:///path/to/index.html', func: '?', args: [], line: 23, column: 1, context: null });
118 |   });
119 | 
120 |   it('should parse Chrome error with no location', function () {
121 |     const stackFrames = ErrorWatch.computeStackTrace({ stack: "error\n at Array.forEach (native)" });
122 |     expect(stackFrames.stack.length).toBe(1);
123 |     expect(stackFrames.stack[0]).toEqual({ url: null, func: 'Array.forEach', args: ['native'], line: null, column: null, context: null });
124 |   });
125 | 
126 |   it('should parse Chrome 15 error', function () {
127 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.CHROME_15);
128 |     expect(stackFrames).toBeTruthy();
129 |     expect(stackFrames.stack.length).toBe(4);
130 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 13, column: 17, context: null });
131 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 16, column: 5, context: null });
132 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 20, column: 5, context: null });
133 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 24, column: 4, context: null });
134 |   });
135 | 
136 |   it('should parse Chrome 36 error with port numbers', function () {
137 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.CHROME_36);
138 |     expect(stackFrames).toBeTruthy();
139 |     expect(stackFrames.stack.length).toBe(3);
140 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://localhost:8080/file.js', func: 'dumpExceptionError', args: [], line: 41, column: 27, context: null });
141 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://localhost:8080/file.js', func: 'HTMLButtonElement.onclick', args: [], line: 107, column: 146, context: null });
142 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://localhost:8080/file.js', func: 'I.e.fn.(anonymous function) [as index]', args: [], line: 10, column: 3651, context: null });
143 |   });
144 | 
145 |   it('should parse Chrome error with webpack URLs', function () {
146 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.CHROME_XX_WEBPACK);
147 |     expect(stackFrames).toBeTruthy();
148 |     expect(stackFrames.stack.length).toBe(4);
149 |     expect(stackFrames.stack[0]).toEqual({ url: 'webpack:///./src/components/test/test.jsx?', func: 'TESTTESTTEST.eval', args: [], line: 295, column: 108, context: null });
150 |     expect(stackFrames.stack[1]).toEqual({ url: 'webpack:///./src/components/test/test.jsx?', func: 'TESTTESTTEST.render', args: [], line: 272, column: 32, context: null });
151 |     expect(stackFrames.stack[2]).toEqual({ url: 'webpack:///./~/react-transform-catch-errors/lib/index.js?', func: 'TESTTESTTEST.tryRender', args: [], line: 34, column: 31, context: null });
152 |     expect(stackFrames.stack[3]).toEqual({ url: 'webpack:///./~/react-proxy/modules/createPrototypeProxy.js?', func: 'TESTTESTTEST.proxiedMethod', args: [], line: 44, column: 30, context: null });
153 |   });
154 | 
155 |   it('should parse nested eval() from Chrome', function () {
156 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.CHROME_48_EVAL);
157 |     expect(stackFrames).toBeTruthy();
158 |     expect(stackFrames.stack.length).toBe(5);
159 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://localhost:8080/file.js', func: 'baz', args: [], line: 21, column: 17, context: null });
160 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://localhost:8080/file.js', func: 'foo', args: [], line: 21, column: 17, context: null });
161 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://localhost:8080/file.js', func: 'eval', args: [], line: 21, column: 17, context: null });
162 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://localhost:8080/file.js', func: 'Object.speak', args: [], line: 21, column: 17, context: null });
163 |     expect(stackFrames.stack[4]).toEqual({ url: 'http://localhost:8080/file.js', func: '?', args: [], line: 31, column: 13, context: null });
164 |   });
165 | 
166 |   it('should parse Chrome error with blob URLs', function () {
167 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.CHROME_48_BLOB);
168 |     expect(stackFrames).toBeTruthy();
169 |     expect(stackFrames.stack.length).toBe(7);
170 |     expect(stackFrames.stack[1]).toEqual({ url: 'blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379', func: 's', args: [], line: 31, column: 29146, context: null });
171 |     expect(stackFrames.stack[2]).toEqual({ url: 'blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379', func: 'Object.d [as add]', args: [], line: 31, column: 30039, context: null });
172 |     expect(stackFrames.stack[3]).toEqual({ url: 'blob:http%3A//localhost%3A8080/d4eefe0f-361a-4682-b217-76587d9f712a', func: '?', args: [], line: 15, column: 10978, context: null });
173 |     expect(stackFrames.stack[4]).toEqual({ url: 'blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379', func: '?', args: [], line: 1, column: 6911, context: null });
174 |     expect(stackFrames.stack[5]).toEqual({ url: 'blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379', func: 'n.fire', args: [], line: 7, column: 3019, context: null });
175 |     expect(stackFrames.stack[6]).toEqual({ url: 'blob:http%3A//localhost%3A8080/abfc40e9-4742-44ed-9dcd-af8f99a29379', func: 'n.handle', args: [], line: 7, column: 2863, context: null });
176 |   });
177 | 
178 |   it('should parse empty IE 9 error', function () {
179 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.IE_9);
180 |     expect(stackFrames).toBeTruthy();
181 |     stackFrames.stack && expect(stackFrames.stack.length).toBe(0);
182 |   });
183 | 
184 |   it('should parse IE 10 error', function () {
185 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.IE_10);
186 |     expect(stackFrames).toBeTruthy();
187 |     expect(stackFrames.stack.length).toBe(3);
188 |     // TODO: func should be normalized
189 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: 'Anonymous function', args: [], line: 48, column: 13, context: null });
190 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 46, column: 9, context: null });
191 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 82, column: 1, context: null });
192 |   });
193 | 
194 |   it('should parse IE 11 error', function () {
195 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.IE_11);
196 |     expect(stackFrames).toBeTruthy();
197 |     expect(stackFrames.stack.length).toBe(3);
198 |     // TODO: func should be normalized
199 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: 'Anonymous function', args: [], line: 47, column: 21, context: null });
200 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 45, column: 13, context: null });
201 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 108, column: 1, context: null });
202 |   });
203 | 
204 | 
205 |   it('should parse IE 11 eval error', function () {
206 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.IE_11_EVAL);
207 |     expect(stackFrames).toBeTruthy();
208 |     expect(stackFrames.stack.length).toBe(3);
209 |     expect(stackFrames.stack[0]).toEqual({ url: 'eval code', func: 'eval code', args: [], line: 1, column: 1, context: null });
210 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 58, column: 17, context: null });
211 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 109, column: 1, context: null });
212 |   });
213 | 
214 |   it('should parse Opera 8.54 error', function () {
215 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.OPERA_854);
216 |     expect(stackFrames).toBeTruthy();
217 |     expect(stackFrames.stack.length).toBe(7);
218 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 44, column: null, context: ['    this.undef();'] });
219 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 31, column: null, context: ['    ex = ex || this.createException();'] });
220 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 18, column: null, context: ['    var p = new printStackTrace.implementation(), result = p.run(ex);'] });
221 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 4, column: null, context: ['    printTrace(printStackTrace());'] });
222 |     expect(stackFrames.stack[4]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 7, column: null, context: ['    bar(n - 1);'] });
223 |     expect(stackFrames.stack[5]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 11, column: null, context: ['    bar(2);'] });
224 |     expect(stackFrames.stack[6]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 15, column: null, context: ['    foo();'] });
225 |   });
226 | 
227 |   it('should parse Opera 9.02 error', function () {
228 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.OPERA_902);
229 |     expect(stackFrames).toBeTruthy();
230 |     expect(stackFrames.stack.length).toBe(7);
231 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 44, column: null, context: ['    this.undef();'] });
232 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 31, column: null, context: ['    ex = ex || this.createException();'] });
233 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 18, column: null, context: ['    var p = new printStackTrace.implementation(), result = p.run(ex);'] });
234 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 4, column: null, context: ['    printTrace(printStackTrace());'] });
235 |     expect(stackFrames.stack[4]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 7, column: null, context: ['    bar(n - 1);'] });
236 |     expect(stackFrames.stack[5]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 11, column: null, context: ['    bar(2);'] });
237 |     expect(stackFrames.stack[6]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 15, column: null, context: ['    foo();'] });
238 |   });
239 | 
240 |   it('should parse Opera 9.27 error', function () {
241 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.OPERA_927);
242 |     expect(stackFrames).toBeTruthy();
243 |     expect(stackFrames.stack.length).toBe(3);
244 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 43, column: null, context: ['    bar(n - 1);'] });
245 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 31, column: null, context: ['    bar(2);'] });
246 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 18, column: null, context: ['    foo();'] });
247 |   });
248 | 
249 |   it('should parse Opera 9.64 error', function () {
250 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.OPERA_964);
251 |     expect(stackFrames).toBeTruthy();
252 |     expect(stackFrames.stack.length).toBe(6);
253 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 27, column: null, context: ['            ex = ex || this.createException();'] });
254 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'printStackTrace', args: [], line: 18, column: null, context: ['        var p = new printStackTrace.implementation(), result = p.run(ex);'] });
255 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 4, column: null, context: ['             printTrace(printStackTrace());'] });
256 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 7, column: null, context: ['           bar(n - 1);'] });
257 |     expect(stackFrames.stack[4]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 11, column: null, context: ['           bar(2);'] });
258 |     expect(stackFrames.stack[5]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 15, column: null, context: ['         foo();'] });
259 |   });
260 | 
261 |   it('should parse Opera 10 error', function () {
262 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.OPERA_10);
263 |     expect(stackFrames).toBeTruthy();
264 |     expect(stackFrames.stack.length).toBe(7);
265 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 42, column: null, context: ['                this.undef();'] });
266 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 27, column: null, context: ['            ex = ex || this.createException();'] });
267 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'printStackTrace', args: [], line: 18, column: null, context: ['        var p = new printStackTrace.implementation(), result = p.run(ex);'] });
268 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 4, column: null, context: ['             printTrace(printStackTrace());'] });
269 |     expect(stackFrames.stack[4]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 7, column: null, context: ['           bar(n - 1);'] });
270 |     expect(stackFrames.stack[5]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 11, column: null, context: ['           bar(2);'] });
271 |     expect(stackFrames.stack[6]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 15, column: null, context: ['         foo();'] });
272 |   });
273 | 
274 |   it('should parse Opera 11 error', function () {
275 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.OPERA_11);
276 |     expect(stackFrames).toBeTruthy();
277 |     expect(stackFrames.stack.length).toBe(7);
278 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: 'createException', args: [], line: 42, column: 12, context: ['    this.undef();'] });
279 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'run', args: ['ex'], line: 27, column: 8, context: ['    ex = ex || this.createException();'] });
280 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'printStackTrace', args: ['options'], line: 18, column: 4, context: ['    var p = new printStackTrace.implementation(), result = p.run(ex);'] });
281 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: ['n'], line: 4, column: 5, context: ['    printTrace(printStackTrace());'] });
282 |     expect(stackFrames.stack[4]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: ['n'], line: 7, column: 4, context: ['    bar(n - 1);'] });
283 |     expect(stackFrames.stack[5]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 11, column: 4, context: ['    bar(2);'] });
284 |     expect(stackFrames.stack[6]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 15, column: 3, context: ['    foo();'] });
285 |   });
286 | 
287 |   it('should parse Opera 12 error', function () {
288 |     // TODO: Improve anonymous function name.
289 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.OPERA_12);
290 |     expect(stackFrames).toBeTruthy();
291 |     expect(stackFrames.stack.length).toBe(3);
292 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://localhost:8000/ExceptionLab.html', func: '<anonymous function>', args: ['x'], line: 48, column: 12, context: ['    x.undef();'] });
293 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://localhost:8000/ExceptionLab.html', func: 'dumpException3', args: [], line: 46, column: 8, context: ['    dumpException((function(x) {'] });
294 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://localhost:8000/ExceptionLab.html', func: '<anonymous function>', args: ['event'], line: 1, column: 0, context: ['    dumpException3();'] });
295 |   });
296 | 
297 |   it('should parse Opera 25 error', function () {
298 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.OPERA_25);
299 |     expect(stackFrames).toBeTruthy();
300 |     expect(stackFrames.stack.length).toBe(3);
301 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 47, column: 22, context: null });
302 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 52, column: 15, context: null });
303 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: 'bar', args: [], line: 108, column: 168, context: null });
304 |   });
305 | 
306 |   it('should parse PhantomJS 1.19 error', function () {
307 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.PHANTOMJS_1_19);
308 |     expect(stackFrames).toBeTruthy();
309 |     expect(stackFrames.stack.length).toBe(3);
310 |     expect(stackFrames.stack[0]).toEqual({ url: 'file:///path/to/file.js', func: '?', args: [], line: 878, column: null, context: null });
311 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://path/to/file.js', func: 'foo', args: [], line: 4283, column: null, context: null });
312 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://path/to/file.js', func: '?', args: [], line: 4287, column: null, context: null });
313 |   });
314 | 
315 |   it('should parse Firefox errors with resource: URLs', function () {
316 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.FIREFOX_50_RESOURCE_URL);
317 |     expect(stackFrames).toBeTruthy();
318 |     expect(stackFrames.stack.length).toBe(3);
319 |     expect(stackFrames.stack[0]).toEqual({ url: 'resource://path/data/content/bundle.js', func: 'render', args: [], line: 5529, column: 16, context: null });
320 |   });
321 | 
322 |   it('should parse Firefox errors with eval URLs', function () {
323 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.FIREFOX_43_EVAL);
324 |     expect(stackFrames).toBeTruthy();
325 |     expect(stackFrames.stack.length).toBe(5);
326 |     expect(stackFrames.stack[0]).toEqual({ url: 'http://localhost:8080/file.js', func: 'baz', args: [], line: 26, column: null, context: null });
327 |     expect(stackFrames.stack[1]).toEqual({ url: 'http://localhost:8080/file.js', func: 'foo', args: [], line: 26, column: null, context: null });
328 |     expect(stackFrames.stack[2]).toEqual({ url: 'http://localhost:8080/file.js', func: '?', args: [], line: 26, column: null, context: null });
329 |     expect(stackFrames.stack[3]).toEqual({ url: 'http://localhost:8080/file.js', func: 'speak', args: [], line: 26, column: 17, context: null });
330 |     expect(stackFrames.stack[4]).toEqual({ url: 'http://localhost:8080/file.js', func: '?', args: [], line: 33, column: 9, context: null });
331 |   });
332 | 
333 |   it('should parse React Native errors on Android', function () {
334 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.ANDROID_REACT_NATIVE);
335 |     expect(stackFrames).toBeTruthy();
336 |     expect(stackFrames.stack.length).toBe(8);
337 |     expect(stackFrames.stack[0]).toEqual({ url: '/home/username/sample-workspace/sampleapp.collect.react/src/components/GpsMonitorScene.js', func: 'render', args: [], line: 78, column: 24, context: null });
338 |     expect(stackFrames.stack[7]).toEqual({ url: '/home/username/sample-workspace/sampleapp.collect.react/node_modules/react-native/Libraries/Renderer/src/renderers/native/ReactNativeBaseComponent.js', func: 'this', args: [], line: 74, column: 41, context: null });
339 |   });
340 | 
341 |   it('should parse React Native errors on Android Production', function () {
342 |     const stackFrames = ErrorWatch.computeStackTrace(CapturedExceptions.ANDROID_REACT_NATIVE_PROD);
343 |     expect(stackFrames).toBeTruthy();
344 |     expect(stackFrames.stack.length).toBe(37);
345 |     expect(stackFrames.stack[0]).toEqual({ url: 'index.android.bundle', func: 'value', args: [], line: 12, column: 1917, context: null });
346 |     expect(stackFrames.stack[35]).toEqual({ url: 'index.android.bundle', func: 'value', args: [], line: 29, column: 927, context: null });
347 |     expect(stackFrames.stack[36]).toEqual({ url: '[native code]', func: '?', args: [], line: null, column: null, context: null });
348 |   });
349 | });
350 | 


--------------------------------------------------------------------------------
/__tests__/tracekit-spec.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | describe('ErrorWatch', function () {
  4 |   const ErrorWatch = require('../dist/errorWatch');
  5 | 
  6 |   describe('General', function () {
  7 |     it('should not remove anonymous functions from the stack', function () {
  8 |       // mock up an error object with a stack trace that includes both
  9 |       // named functions and anonymous functions
 10 |       const stack_str = '' +
 11 |         '  Error: \n' +
 12 |         '    at new <anonymous> (http://example.com/js/test.js:63:1)\n' +   // stack[0]
 13 |         '    at namedFunc0 (http://example.com/js/script.js:10:2)\n' +      // stack[1]
 14 |         '    at http://example.com/js/test.js:65:10\n' +                    // stack[2]
 15 |         '    at namedFunc2 (http://example.com/js/script.js:20:5)\n' +      // stack[3]
 16 |         '    at http://example.com/js/test.js:67:5\n' +                     // stack[4]
 17 |         '    at namedFunc4 (http://example.com/js/script.js:100001:10002)'; // stack[5]
 18 |       const mock_err = { stack: stack_str };
 19 |       const stackFrames = ErrorWatch.computeStackTrace.computeStackTraceFromStackProp(mock_err);
 20 | 
 21 |       // Make sure ErrorWatch didn't remove the anonymous functions
 22 |       // from the stack like it used to :)
 23 |       expect(stackFrames).toBeTruthy();
 24 |       expect(stackFrames.stack[0].func).toEqual('new <anonymous>');
 25 |       expect(stackFrames.stack[0].url).toEqual('http://example.com/js/test.js');
 26 |       expect(stackFrames.stack[0].line).toBe(63);
 27 |       expect(stackFrames.stack[0].column).toBe(1);
 28 | 
 29 |       expect(stackFrames.stack[1].func).toEqual('namedFunc0');
 30 |       expect(stackFrames.stack[1].url).toEqual('http://example.com/js/script.js');
 31 |       expect(stackFrames.stack[1].line).toBe(10);
 32 |       expect(stackFrames.stack[1].column).toBe(2);
 33 | 
 34 |       expect(stackFrames.stack[2].func).toEqual('?');
 35 |       expect(stackFrames.stack[2].url).toEqual('http://example.com/js/test.js');
 36 |       expect(stackFrames.stack[2].line).toBe(65);
 37 |       expect(stackFrames.stack[2].column).toBe(10);
 38 | 
 39 |       expect(stackFrames.stack[3].func).toEqual('namedFunc2');
 40 |       expect(stackFrames.stack[3].url).toEqual('http://example.com/js/script.js');
 41 |       expect(stackFrames.stack[3].line).toBe(20);
 42 |       expect(stackFrames.stack[3].column).toBe(5);
 43 | 
 44 |       expect(stackFrames.stack[4].func).toEqual('?');
 45 |       expect(stackFrames.stack[4].url).toEqual('http://example.com/js/test.js');
 46 |       expect(stackFrames.stack[4].line).toBe(67);
 47 |       expect(stackFrames.stack[4].column).toBe(5);
 48 | 
 49 |       expect(stackFrames.stack[5].func).toEqual('namedFunc4');
 50 |       expect(stackFrames.stack[5].url).toEqual('http://example.com/js/script.js');
 51 |       expect(stackFrames.stack[5].line).toBe(100001);
 52 |       expect(stackFrames.stack[5].column).toBe(10002);
 53 |     });
 54 | 
 55 |     it('should handle eval/anonymous strings in Chrome 46', function () {
 56 |       const stack_str = '' +
 57 |         'ReferenceError: baz is not defined\n' +
 58 |         '   at bar (http://example.com/js/test.js:19:7)\n' +
 59 |         '   at foo (http://example.com/js/test.js:23:7)\n' +
 60 |         '   at eval (eval at <anonymous> (http://example.com/js/test.js:26:5)).toBe(<anonymous>:1:26)\n';
 61 | 
 62 |       const mock_err = { stack: stack_str };
 63 |       const stackFrames = ErrorWatch.computeStackTrace.computeStackTraceFromStackProp(mock_err);
 64 |       expect(stackFrames).toBeTruthy();
 65 |       expect(stackFrames.stack[0].func).toEqual('bar');
 66 |       expect(stackFrames.stack[0].url).toEqual('http://example.com/js/test.js');
 67 |       expect(stackFrames.stack[0].line).toBe(19);
 68 |       expect(stackFrames.stack[0].column).toBe(7);
 69 | 
 70 |       expect(stackFrames.stack[1].func).toEqual('foo');
 71 |       expect(stackFrames.stack[1].url).toEqual('http://example.com/js/test.js');
 72 |       expect(stackFrames.stack[1].line).toBe(23);
 73 |       expect(stackFrames.stack[1].column).toBe(7);
 74 | 
 75 |       expect(stackFrames.stack[2].func).toEqual('eval');
 76 |       // TODO: fix nested evals
 77 |       expect(stackFrames.stack[2].url).toEqual('http://example.com/js/test.js');
 78 |       expect(stackFrames.stack[2].line).toBe(26);
 79 |       expect(stackFrames.stack[2].column).toBe(5);
 80 |     });
 81 |   });
 82 | 
 83 |   describe('.computeStackTrace', function () {
 84 |     it('should handle a native error object', function () {
 85 |       const ex = new Error('test');
 86 |       const stack = ErrorWatch.computeStackTrace(ex);
 87 |       expect(stack.name).toEqual('Error');
 88 |       expect(stack.message).toEqual('test');
 89 |     });
 90 | 
 91 |     it('should handle a native error object stack from Chrome', function () {
 92 |       const stackStr = '' +
 93 |         'Error: foo\n' +
 94 |         '    at <anonymous>:2:11\n' +
 95 |         '    at Object.InjectedScript._evaluateOn (<anonymous>:904:140)\n' +
 96 |         '    at Object.InjectedScript._evaluateAndWrap (<anonymous>:837:34)\n' +
 97 |         '    at Object.InjectedScript.evaluate (<anonymous>:693:21)';
 98 |       const mockErr = {
 99 |         name: 'Error',
100 |         message: 'foo',
101 |         stack: stackStr
102 |       };
103 |       const stackFrames = ErrorWatch.computeStackTrace(mockErr);
104 |       expect(stackFrames).toBeTruthy();
105 |       expect(stackFrames.stack[0].url).toEqual('<anonymous>');
106 |     });
107 |   });
108 | 
109 |   describe('error notifications', function () {
110 |     const testMessage = '__mocha_ignore__';
111 |     const testLineNo = 1337;
112 | 
113 |     let subscriptionHandler;
114 |     let oldOnErrorHandler;
115 | 
116 |     // ErrorWatch waits 2000ms for window.onerror to fire, so give the tests
117 |     // some extra time.
118 |     //this.timeout(3000);
119 | 
120 |     beforeEach(function () {
121 | 
122 |       // Prevent the onerror call that's part of our tests from getting to
123 |       // mocha's handler, which would treat it as a test failure.
124 |       //
125 |       // We set this up here and don't ever restore the old handler, because
126 |       // we can't do that without clobbering ErrorWatch's handler, which can only
127 |       // be installed once.
128 |       oldOnErrorHandler = window.onerror;
129 |       window.onerror = function (message, url, lineNo, error) {
130 |         if (message === testMessage || lineNo === testLineNo) {
131 |           return true;
132 |         }
133 |         return oldOnErrorHandler.apply(this, arguments);
134 |       };
135 |     });
136 | 
137 |     afterEach(function () {
138 |       window.onerror = oldOnErrorHandler;
139 |       if (subscriptionHandler) {
140 |         ErrorWatch.report.unsubscribe(subscriptionHandler);
141 |         subscriptionHandler = null;
142 |       }
143 |     });
144 | 
145 |     describe('with undefined arguments', function () {
146 |       it('should pass undefined:undefined', function (done) {
147 |         // this is probably not good behavior;  just writing this test to verify
148 |         // that it doesn't change unintentionally
149 |         subscriptionHandler = function (stack, isWindowError, error) {
150 |           expect(stack.name).toBe(undefined);
151 |           expect(stack.message).toBe(undefined);
152 |           done();
153 |         };
154 |         ErrorWatch.report.subscribe(subscriptionHandler);
155 |         window.onerror(undefined, undefined, testLineNo);
156 |       });
157 |     });
158 | 
159 |     describe('when no 5th argument (error object)', function () {
160 |       it('should separate name, message for default error types (e.g. ReferenceError)', function (done) {
161 |         subscriptionHandler = function (stack, isWindowError, error) {
162 |           expect(stack.name).toEqual('ReferenceError');
163 |           expect(stack.message).toEqual('foo is undefined');
164 |           done();
165 |         };
166 |         ErrorWatch.report.subscribe(subscriptionHandler);
167 |         window.onerror('ReferenceError: foo is undefined', 'http://example.com', testLineNo);
168 |       });
169 | 
170 |       it('should separate name, message for default error types (e.g. Uncaught ReferenceError)', function (done) {
171 |         subscriptionHandler = function (stack, isWindowError, error) {
172 |           expect(stack.name).toEqual('ReferenceError');
173 |           expect(stack.message).toEqual('foo is undefined');
174 |           done();
175 |         };
176 |         ErrorWatch.report.subscribe(subscriptionHandler);
177 |         // should work with/without 'Uncaught'
178 |         window.onerror('Uncaught ReferenceError: foo is undefined', 'http://example.com', testLineNo);
179 |       });
180 | 
181 |       it('should separate name, message for default error types on Opera Mini', function (done) {
182 |         subscriptionHandler = function (stack, isWindowError, error) {
183 |           expect(stack.name).toEqual('ReferenceError');
184 |           expect(stack.message).toEqual('Undefined variable: foo');
185 |           done();
186 |         };
187 |         ErrorWatch.report.subscribe(subscriptionHandler);
188 |         window.onerror('Uncaught exception: ReferenceError: Undefined variable: foo', 'http://example.com', testLineNo);
189 |       });
190 | 
191 |       it('should ignore unknown error types', function (done) {
192 |         // TODO: should we attempt to parse this?
193 |         subscriptionHandler = function (stack, isWindowError, error) {
194 |           expect(stack.name).toBe(undefined);
195 |           expect(stack.message).toEqual('CustomError: woo scary');
196 |           done();
197 |         };
198 |         ErrorWatch.report.subscribe(subscriptionHandler);
199 |         window.onerror('CustomError: woo scary', 'http://example.com', testLineNo);
200 |       });
201 | 
202 |       it('should ignore arbitrary messages passed through onerror', function (done) {
203 |         subscriptionHandler = function (stack, isWindowError, error) {
204 |           expect(stack.name).toBe(undefined);
205 |           expect(stack.message).toEqual('all work and no play makes homer: something something');
206 |           done();
207 |         };
208 |         ErrorWatch.report.subscribe(subscriptionHandler);
209 |         window.onerror('all work and no play makes homer: something something', 'http://example.com', testLineNo);
210 |       });
211 |     });
212 | 
213 |     function testErrorNotification(collectWindowErrors, callOnError, numReports, done) {
214 |       let numDone = 0;
215 |       // ErrorWatch's collectWindowErrors flag shouldn't affect direct calls
216 |       // to ErrorWatch.report, so we parameterize it for the tests.
217 |       ErrorWatch.collectWindowErrors = collectWindowErrors;
218 | 
219 |       subscriptionHandler = function (stack, isWindowError, error) {
220 |         numDone++;
221 |         if (numDone == numReports) {
222 |           done();
223 |         }
224 |       };
225 |       ErrorWatch.report.subscribe(subscriptionHandler);
226 | 
227 |       // ErrorWatch.report always throws an exception in order to trigger
228 |       // window.onerror so it can gather more stack data. Mocha treats
229 |       // uncaught exceptions as errors, so we catch it via assert.throws
230 |       // here (and manually call window.onerror later if appropriate).
231 |       //
232 |       // We test multiple reports because ErrorWatch has special logic for when
233 |       // report() is called a second time before either a timeout elapses or
234 |       // window.onerror is called (which is why we always call window.onerror
235 |       // only once below, after all calls to report()).
236 |       for (let i = 0; i < numReports; i++) {
237 |         const e = new Error('testing');
238 |         expect(function () {
239 |           ErrorWatch.report(e);
240 |         }).toThrow(e);
241 |       }
242 |       // The call to report should work whether or not window.onerror is
243 |       // triggered, so we parameterize it for the tests. We only call it
244 |       // once, regardless of numReports, because the case we want to test for
245 |       // multiple reports is when window.onerror is *not* called between them.
246 |       if (callOnError) {
247 |         window.onerror(testMessage);
248 |       }
249 |     }
250 | 
251 |     [false, true].forEach(function (collectWindowErrors) {
252 |       [false, true].forEach(function (callOnError) {
253 |         [1, 2].forEach(function (numReports) {
254 |           it('it should receive arguments from report() when' +
255 |             ' collectWindowErrors is ' + collectWindowErrors +
256 |             ' and callOnError is ' + callOnError +
257 |             ' and numReports is ' + numReports, function (done) {
258 |             testErrorNotification(collectWindowErrors, callOnError, numReports, done);
259 |           });
260 |         });
261 |       });
262 |     });
263 |   });
264 | 
265 |   describe('globalHandlers', function () {
266 |     let oldOnErrorHandler;
267 |     let oldOnUnhandledRejectionHandler;
268 | 
269 |     let onErrorHandler;
270 |     let onUnhandledRejectionHandler;
271 | 
272 |     beforeEach(function () {
273 |       oldOnErrorHandler = window.onerror;
274 |       oldOnUnhandledRejectionHandler = window.onunhandledrejection;
275 | 
276 |       onErrorHandler = function (){};
277 |       onUnhandledRejectionHandler = function (){};
278 | 
279 |       window.onerror = onErrorHandler;
280 |       window.onunhandledrejection = onUnhandledRejectionHandler;
281 |     });
282 | 
283 |     afterEach(function () {
284 |       window.onerror = oldOnErrorHandler;
285 |       window.onunhandledrejection = oldOnUnhandledRejectionHandler;
286 |     });
287 | 
288 |     describe('cleanup after unsubscribing', function () {
289 |       let testHandler;
290 | 
291 |       beforeEach(function () {
292 |         testHandler = function () {
293 |           return true;
294 |         };
295 |       });
296 | 
297 |       it('should should restore original `window.onerror` once unsubscribed', function () {
298 |         expect(window.onerror).toBe(onErrorHandler);
299 | 
300 |         ErrorWatch.report.subscribe(testHandler);
301 |         expect(window.onerror).not.toBe(onErrorHandler);
302 | 
303 |         ErrorWatch.report.unsubscribe(testHandler);
304 |         expect(window.onerror).toBe(onErrorHandler);
305 |       });
306 | 
307 |       it('should should restore original `window.onunhandledrejection` once unsubscribed', function () {
308 |         expect(window.onunhandledrejection).toBe(onUnhandledRejectionHandler);
309 | 
310 |         ErrorWatch.report.subscribe(testHandler);
311 |         expect(window.onunhandledrejection).not.toBe(onUnhandledRejectionHandler);
312 | 
313 |         ErrorWatch.report.unsubscribe(testHandler);
314 |         expect(window.onunhandledrejection).toBe(onUnhandledRejectionHandler);
315 |       });
316 |     });
317 |   });
318 | });
319 | 


--------------------------------------------------------------------------------
/dist/errorWatch.esm.js:
--------------------------------------------------------------------------------
   1 | //Default options:
   2 | const collectWindowErrors = true; // 是否通知 window 全局错误，开启，关掉了这个脚本就没意义了
   3 | const collectSourceErrors = true; // 是否在捕获阶段获取资源加载错误，默认开启
   4 | const linesOfContext = 11;        // 5 lines before, the offending line, 5 lines after，没啥用
   5 | const reportFuncName = 'ErrorWatch.report';
   6 | 
   7 | /**
   8 |  * A better form of hasOwnProperty<br/>
   9 |  * Example: `_has(MainHostObject, property) === true/false`
  10 |  *
  11 |  * @param {Object} object to check property
  12 |  * @param {string} key to check
  13 |  * @return {Boolean} true if the object has the key and it is not inherited
  14 |  */
  15 | function _has(object, key) {
  16 |   return Object.prototype.hasOwnProperty.call(object, key);
  17 | }
  18 | 
  19 | /**
  20 |  * Returns true if the parameter is undefined<br/>
  21 |  * Example: `_isUndefined(val) === true/false`
  22 |  *
  23 |  * @param {*} what Value to check
  24 |  * @return {Boolean} true if undefined and false otherwise
  25 |  */
  26 | function _isUndefined(what) {
  27 |   return typeof what === 'undefined';
  28 | }
  29 | 
  30 | /**
  31 |  * An object representing a single stack frame.
  32 |  * @typedef {Object} StackFrame
  33 |  * @property {string} url The JavaScript or HTML file URL.
  34 |  * @property {string} func The function name, or empty for anonymous functions (if guessing did not work).
  35 |  * @property {string[]?} args The arguments passed to the function, if known.
  36 |  * @property {number=} line The line number, if known.
  37 |  * @property {number=} column The column number, if known.
  38 |  * @property {string[]} context An array of source code lines; the middle element corresponds to the correct line#.
  39 |  * @memberof ErrorWatch
  40 |  */
  41 | 
  42 | const UNKNOWN_FUNCTION = '?';
  43 | 
  44 | let sourceCache = {};
  45 | 
  46 | /**
  47 |  * Attempts to retrieve source code via XMLHttpRequest, which is used
  48 |  * to look up anonymous function names.
  49 |  * @param {string} url URL of source code.
  50 |  * @return {string} Source contents.
  51 |  * @memberof ErrorWatch.computeStackTrace
  52 |  */
  53 | function loadSource(url) {
  54 |   { //Only attempt request if remoteFetching is on.
  55 |     return '';
  56 |   }
  57 | }
  58 | 
  59 | /**
  60 |  * Retrieves source code from the source code cache.
  61 |  * @param {string} url URL of source code.
  62 |  * @return {Array.<string>} Source contents.
  63 |  * @memberof ErrorWatch.computeStackTrace
  64 |  */
  65 | function getSource(url) {
  66 |   if (typeof url !== 'string') {
  67 |     return [];
  68 |   }
  69 | 
  70 |   if (!_has(sourceCache, url)) {
  71 |     // URL needs to be able to fetched within the acceptable domain.  Otherwise,
  72 |     // cross-domain errors will be triggered.
  73 |     /*
  74 |         Regex matches:
  75 |         0 - Full Url
  76 |         1 - Protocol
  77 |         2 - Domain
  78 |         3 - Port (Useful for internal applications)
  79 |         4 - Path
  80 |     */
  81 |     let source = '',
  82 |         domain = '';
  83 |     try { domain = window.document.domain; } catch (e) { }
  84 |     const match = /(.*)\:\/\/([^:\/]+)([:\d]*)\/{0,1}([\s\S]*)/.exec(url);
  85 |     if (match && match[2] === domain) {
  86 |       source = loadSource();
  87 |     }
  88 |     sourceCache[url] = source ? source.split('\n') : [];
  89 |   }
  90 | 
  91 |   return sourceCache[url];
  92 | }
  93 | 
  94 | /**
  95 |  * Tries to use an externally loaded copy of source code to determine
  96 |  * the name of a function by looking at the name of the variable it was
  97 |  * assigned to, if any.
  98 |  * @param {string} url URL of source code.
  99 |  * @param {(string|number)} lineNo Line number in source code.
 100 |  * @return {string} The function name, if discoverable.
 101 |  * @memberof ErrorWatch.computeStackTrace
 102 |  */
 103 | function guessFunctionName(url, lineNo) {
 104 |   const reFunctionArgNames = /function ([^(]*)\(([^)]*)\)/,
 105 |     reGuessFunction = /['"]?([0-9A-Za-z$_]+)['"]?\s*[:=]\s*(function|eval|new Function)/,
 106 |     maxLines = 10,
 107 |     source = getSource(url);
 108 |   let line = '', m;
 109 | 
 110 |   if (!source.length) {
 111 |     return UNKNOWN_FUNCTION;
 112 |   }
 113 | 
 114 |   // Walk backwards from the first line in the function until we find the line which
 115 |   // matches the pattern above, which is the function definition
 116 |   for (let i = 0; i < maxLines; ++i) {
 117 |     line = source[lineNo - i] + line;
 118 | 
 119 |     if (!_isUndefined(line)) { // 这里有个bug，永远为 true
 120 |       if ((m = reGuessFunction.exec(line))) {
 121 |         return m[1];
 122 |       } else if ((m = reFunctionArgNames.exec(line))) {
 123 |         return m[1];
 124 |       }
 125 |     }
 126 |   }
 127 | 
 128 |   return UNKNOWN_FUNCTION;
 129 | }
 130 | 
 131 | /**
 132 |  * Retrieves the surrounding lines from where an exception occurred.
 133 |  * @param {string} url URL of source code.
 134 |  * @param {(string|number)} line Line number in source code to center around for context.
 135 |  * @return {?Array.<string>} Lines of source code.
 136 |  * @memberof ErrorWatch.computeStackTrace
 137 |  */
 138 | function gatherContext(url, line) {
 139 |   const source = getSource(url);
 140 | 
 141 |   if (!source.length) {
 142 |     return null;
 143 |   }
 144 | 
 145 |   let context = [],
 146 |     // linesBefore & linesAfter are inclusive with the offending line.
 147 |     // if linesOfContext is even, there will be one extra line
 148 |     //   *before* the offending line.
 149 |     linesBefore = Math.floor(linesOfContext / 2),
 150 |     // Add one extra line if linesOfContext is odd
 151 |     linesAfter = linesBefore + (linesOfContext % 2),
 152 |     start = Math.max(0, line - linesBefore - 1),
 153 |     end = Math.min(source.length, line + linesAfter - 1);
 154 | 
 155 |   line -= 1; // convert to 0-based index
 156 | 
 157 |   for (let i = start; i < end; ++i) {
 158 |     if (!_isUndefined(source[i])) {
 159 |       context.push(source[i]);
 160 |     }
 161 |   }
 162 | 
 163 |   return context.length > 0 ? context : null;
 164 | }
 165 | 
 166 | /**
 167 |  * Escapes special characters, except for whitespace, in a string to be
 168 |  * used inside a regular expression as a string literal.
 169 |  * @param {string} text The string.
 170 |  * @return {string} The escaped string literal.
 171 |  * @memberof ErrorWatch.computeStackTrace
 172 |  */
 173 | function escapeRegExp(text) {
 174 |   return text.replace(/[\-\[\]{}()*+?.,\\\^$|#]/g, '\\$&');
 175 | }
 176 | 
 177 | /**
 178 |  * Escapes special characters in a string to be used inside a regular
 179 |  * expression as a string literal. Also ensures that HTML entities will
 180 |  * be matched the same as their literal friends.
 181 |  * @param {string} body The string.
 182 |  * @return {string} The escaped string.
 183 |  * @memberof ErrorWatch.computeStackTrace
 184 |  */
 185 | function escapeCodeAsRegExpForMatchingInsideHTML(body) {
 186 |   return escapeRegExp(body).replace('<', '(?:<|&lt;)').replace('>', '(?:>|&gt;)').replace('&', '(?:&|&amp;)').replace('"', '(?:"|&quot;)').replace(/\s+/g, '\\s+');
 187 | }
 188 | 
 189 | /**
 190 |  * Determines where a code fragment occurs in the source code.
 191 |  * @param {RegExp} re The function definition.
 192 |  * @param {Array.<string>} urls A list of URLs to search.
 193 |  * @return {?Object.<string, (string|number)>} An object containing
 194 |  * the url, line, and column number of the defined function.
 195 |  * @memberof ErrorWatch.computeStackTrace
 196 |  */
 197 | function findSourceInUrls(re, urls) {
 198 |   let source, m;
 199 |   for (let i = 0, j = urls.length; i < j; ++i) {
 200 |     if ((source = getSource(urls[i])).length) {
 201 |       source = source.join('\n');
 202 |       if ((m = re.exec(source))) {
 203 | 
 204 |         return {
 205 |           'url': urls[i],
 206 |           'line': source.substring(0, m.index).split('\n').length,
 207 |           'column': m.index - source.lastIndexOf('\n', m.index) - 1
 208 |         };
 209 |       }
 210 |     }
 211 |   }
 212 | 
 213 |   return null;
 214 | }
 215 | 
 216 | /**
 217 |  * Determines at which column a code fragment occurs on a line of the
 218 |  * source code.
 219 |  * @param {string} fragment The code fragment.
 220 |  * @param {string} url The URL to search.
 221 |  * @param {(string|number)} line The line number to examine.
 222 |  * @return {?number} The column number.
 223 |  * @memberof ErrorWatch.computeStackTrace
 224 |  */
 225 | function findSourceInLine(fragment, url, line) {
 226 |   const source = getSource(url),
 227 |     re = new RegExp('\\b' + escapeRegExp(fragment) + '\\b');
 228 |   let m;
 229 | 
 230 |   line -= 1;
 231 | 
 232 |   if (source && source.length > line && (m = re.exec(source[line]))) {
 233 |     return m.index;
 234 |   }
 235 | 
 236 |   return null;
 237 | }
 238 | 
 239 | /**
 240 |  * Determines where a function was defined within the source code.
 241 |  * @param {(Function|string)} func A function reference or serialized
 242 |  * function definition.
 243 |  * @return {?Object.<string, (string|number)>} An object containing
 244 |  * the url, line, and column number of the defined function.
 245 |  * @memberof ErrorWatch.computeStackTrace
 246 |  */
 247 | function findSourceByFunctionBody(func) {
 248 |   if (_isUndefined(window && window.document)) {
 249 |     return null;
 250 |   }
 251 | 
 252 |   const urls = [window.location.href],
 253 |     scripts = window.document.getElementsByTagName('script'),
 254 |     code = '' + func,
 255 |     codeRE = /^function(?:\s+([\w$]+))?\s*\(([\w\s,]*)\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,
 256 |     eventRE = /^function on([\w$]+)\s*\(event\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/;
 257 |   let body,
 258 |     re,
 259 |     parts,
 260 |     result;
 261 | 
 262 |   for (let i = 0; i < scripts.length; ++i) {
 263 |     const script = scripts[i];
 264 |     if (script.src) {
 265 |       urls.push(script.src);
 266 |     }
 267 |   }
 268 | 
 269 |   if (!(parts = codeRE.exec(code))) {
 270 |     re = new RegExp(escapeRegExp(code).replace(/\s+/g, '\\s+'));
 271 |   }
 272 | 
 273 |   // not sure if this is really necessary, but I don’t have a test
 274 |   // corpus large enough to confirm that and it was in the original.
 275 |   else {
 276 |     const name = parts[1] ? '\\s+' + parts[1] : '',
 277 |       args = parts[2].split(',').join('\\s*,\\s*');
 278 | 
 279 |     body = escapeRegExp(parts[3]).replace(/;$/, ';?'); // semicolon is inserted if the function ends with a comment.replace(/\s+/g, '\\s+');
 280 |     re = new RegExp('function' + name + '\\s*\\(\\s*' + args + '\\s*\\)\\s*{\\s*' + body + '\\s*}');
 281 |   }
 282 | 
 283 |   // look for a normal function definition
 284 |   if ((result = findSourceInUrls(re, urls))) {
 285 |     return result;
 286 |   }
 287 | 
 288 |   // look for an old-school event handler function
 289 |   if ((parts = eventRE.exec(code))) {
 290 |     const event = parts[1];
 291 |     body = escapeCodeAsRegExpForMatchingInsideHTML(parts[2]);
 292 | 
 293 |     // look for a function defined in HTML as an onXXX handler
 294 |     re = new RegExp('on' + event + '=[\\\'"]\\s*' + body + '\\s*[\\\'"]', 'i');
 295 | 
 296 |     if ((result = findSourceInUrls(re, urls[0]))) {
 297 |       return result;
 298 |     }
 299 | 
 300 |     // look for ???
 301 |     re = new RegExp(body);
 302 | 
 303 |     if ((result = findSourceInUrls(re, urls))) {
 304 |       return result;
 305 |     }
 306 |   }
 307 | 
 308 |   return null;
 309 | }
 310 | 
 311 | // Contents of Exception in various browsers.
 312 | //
 313 | // SAFARI:
 314 | // ex.message = Can't find variable: qq
 315 | // ex.line = 59
 316 | // ex.sourceId = 580238192
 317 | // ex.sourceURL = http://...
 318 | // ex.expressionBeginOffset = 96
 319 | // ex.expressionCaretOffset = 98
 320 | // ex.expressionEndOffset = 98
 321 | // ex.name = ReferenceError
 322 | //
 323 | // FIREFOX:
 324 | // ex.message = qq is not defined
 325 | // ex.fileName = http://...
 326 | // ex.lineNumber = 59
 327 | // ex.columnNumber = 69
 328 | // ex.stack = ...stack trace... (see the example below)
 329 | // ex.name = ReferenceError
 330 | //
 331 | // CHROME:
 332 | // ex.message = qq is not defined
 333 | // ex.name = ReferenceError
 334 | // ex.type = not_defined
 335 | // ex.arguments = ['aa']
 336 | // ex.stack = ...stack trace...
 337 | //
 338 | // INTERNET EXPLORER:
 339 | // ex.message = ...
 340 | // ex.name = ReferenceError
 341 | //
 342 | // OPERA:
 343 | // ex.message = ...message... (see the example below)
 344 | // ex.name = ReferenceError
 345 | // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)
 346 | // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'
 347 | 
 348 | /**
 349 |  * Computes stack trace information from the stack property.
 350 |  * Chrome and Gecko use this property.
 351 |  * @param {Error} ex
 352 |  * @return {?ErrorWatch.StackTrace} Stack trace information.
 353 |  * @memberof ErrorWatch.computeStackTrace
 354 |  */
 355 | function computeStackTraceFromStackProp(ex) {
 356 |   if (!ex.stack) {
 357 |     return null;
 358 |   }
 359 | 
 360 |   const chrome = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,
 361 |     gecko = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i,
 362 |     winjs = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
 363 | 
 364 |     geckoEval = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i,
 365 |     chromeEval = /\((\S*)(?::(\d+))(?::(\d+))\)/,
 366 | 
 367 |     lines = ex.stack.split('\n'),
 368 |     reference = /^(.*) is undefined$/.exec(ex.message);
 369 |   let stack = [],
 370 |     // Used to additionally parse URL/line/column from eval frames
 371 |     isEval,
 372 |     submatch,
 373 |     parts,
 374 |     element;
 375 | 
 376 |   for (let i = 0, j = lines.length; i < j; ++i) {
 377 |     if ((parts = chrome.exec(lines[i]))) {
 378 |       const isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line
 379 |       isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
 380 |       if (isEval && (submatch = chromeEval.exec(parts[2]))) {
 381 |         // throw out eval line/column and use top-most line/column number
 382 |         parts[2] = submatch[1]; // url
 383 |         parts[3] = submatch[2]; // line
 384 |         parts[4] = submatch[3]; // column
 385 |       }
 386 |       element = {
 387 |         'url': !isNative ? parts[2] : null,
 388 |         'func': parts[1] || UNKNOWN_FUNCTION,
 389 |         'args': isNative ? [parts[2]] : [],
 390 |         'line': parts[3] ? +parts[3] : null,
 391 |         'column': parts[4] ? +parts[4] : null
 392 |       };
 393 |     } else if ( parts = winjs.exec(lines[i]) ) {
 394 |       element = {
 395 |         'url': parts[2],
 396 |         'func': parts[1] || UNKNOWN_FUNCTION,
 397 |         'args': [],
 398 |         'line': +parts[3],
 399 |         'column': parts[4] ? +parts[4] : null
 400 |       };
 401 |     } else if ((parts = gecko.exec(lines[i]))) {
 402 |       isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
 403 |       if (isEval && (submatch = geckoEval.exec(parts[3]))) {
 404 |         // throw out eval line/column and use top-most line number
 405 |         parts[3] = submatch[1];
 406 |         parts[4] = submatch[2];
 407 |         parts[5] = null; // no column when eval
 408 |       } else if (i === 0 && !parts[5] && !_isUndefined(ex.columnNumber)) {
 409 |         // FireFox uses this awesome columnNumber property for its top frame
 410 |         // Also note, Firefox's column number is 0-based and everything else expects 1-based,
 411 |         // so adding 1
 412 |         // NOTE: this hack doesn't work if top-most frame is eval
 413 |         stack[0].column = ex.columnNumber + 1;
 414 |       }
 415 |       element = {
 416 |         'url': parts[3],
 417 |         'func': parts[1] || UNKNOWN_FUNCTION,
 418 |         'args': parts[2] ? parts[2].split(',') : [],
 419 |         'line': parts[4] ? +parts[4] : null,
 420 |         'column': parts[5] ? +parts[5] : null
 421 |       };
 422 |     } else {
 423 |       continue;
 424 |     }
 425 | 
 426 |     if (!element.func && element.line) {
 427 |       element.func = guessFunctionName(element.url, element.line);
 428 |     }
 429 | 
 430 |     element.context = element.line ? gatherContext(element.url, element.line) : null;
 431 |     stack.push(element);
 432 |   }
 433 | 
 434 |   if (!stack.length) {
 435 |     return null;
 436 |   }
 437 | 
 438 |   if (stack[0] && stack[0].line && !stack[0].column && reference) {
 439 |     stack[0].column = findSourceInLine(reference[1], stack[0].url, stack[0].line);
 440 |   }
 441 | 
 442 |   return {
 443 |     'mode': 'stack',
 444 |     'name': ex.name,
 445 |     'message': ex.message,
 446 |     'stack': stack
 447 |   };
 448 | }
 449 | 
 450 | /**
 451 |  * Computes stack trace information from the stacktrace property.
 452 |  * Opera 10+ uses this property.
 453 |  * @param {Error} ex
 454 |  * @return {?ErrorWatch.StackTrace} Stack trace information.
 455 |  * @memberof ErrorWatch.computeStackTrace
 456 |  */
 457 | function computeStackTraceFromStacktraceProp(ex) {
 458 |   // Access and store the stacktrace property before doing ANYTHING
 459 |   // else to it because Opera is not very good at providing it
 460 |   // reliably in other circumstances.
 461 |   const stacktrace = ex.stacktrace;
 462 |   if (!stacktrace) {
 463 |     return;
 464 |   }
 465 | 
 466 |   const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i,
 467 |     opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^\)]+))\((.*)\))? in (.*):\s*$/i,
 468 |     lines = stacktrace.split('\n');
 469 |   let stack = [],
 470 |     parts;
 471 | 
 472 |   for (let line = 0; line < lines.length; line += 2) {
 473 |     let element = null;
 474 |     if ((parts = opera10Regex.exec(lines[line]))) {
 475 |       element = {
 476 |         'url': parts[2],
 477 |         'line': +parts[1],
 478 |         'column': null,
 479 |         'func': parts[3],
 480 |         'args':[]
 481 |       };
 482 |     } else if ((parts = opera11Regex.exec(lines[line]))) {
 483 |       element = {
 484 |         'url': parts[6],
 485 |         'line': +parts[1],
 486 |         'column': +parts[2],
 487 |         'func': parts[3] || parts[4],
 488 |         'args': parts[5] ? parts[5].split(',') : []
 489 |       };
 490 |     }
 491 | 
 492 |     if (element) {
 493 |       if (!element.func && element.line) {
 494 |         element.func = guessFunctionName(element.url, element.line);
 495 |       }
 496 |       if (element.line) {
 497 |         try {
 498 |           element.context = gatherContext(element.url, element.line);
 499 |         } catch (exc) {}
 500 |       }
 501 | 
 502 |       if (!element.context) {
 503 |         element.context = [lines[line + 1]];
 504 |       }
 505 | 
 506 |       stack.push(element);
 507 |     }
 508 |   }
 509 | 
 510 |   if (!stack.length) {
 511 |     return null;
 512 |   }
 513 | 
 514 |   return {
 515 |     'mode': 'stacktrace',
 516 |     'name': ex.name,
 517 |     'message': ex.message,
 518 |     'stack': stack
 519 |   };
 520 | }
 521 | 
 522 | /**
 523 |  * NOT TESTED.
 524 |  * Computes stack trace information from an error message that includes
 525 |  * the stack trace.
 526 |  * Opera 9 and earlier use this method if the option to show stack
 527 |  * traces is turned on in opera:config.
 528 |  * @param {Error} ex
 529 |  * @return {?ErrorWatch.StackTrace} Stack information.
 530 |  * @memberof ErrorWatch.computeStackTrace
 531 |  */
 532 | function computeStackTraceFromOperaMultiLineMessage(ex) {
 533 |   // TODO: Clean this function up
 534 |   // Opera includes a stack trace into the exception message. An example is:
 535 |   //
 536 |   // Statement on line 3: Undefined variable: undefinedFunc
 537 |   // Backtrace:
 538 |   //   Line 3 of linked script file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.js: In function zzz
 539 |   //         undefinedFunc(a);
 540 |   //   Line 7 of inline#1 script in file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.html: In function yyy
 541 |   //           zzz(x, y, z);
 542 |   //   Line 3 of inline#1 script in file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.html: In function xxx
 543 |   //           yyy(a, a, a);
 544 |   //   Line 1 of function script
 545 |   //     try { xxx('hi'); return false; } catch(ex) { ErrorWatch.report(ex); }
 546 |   //   ...
 547 | 
 548 |   const lines = ex.message.split('\n');
 549 |   if (lines.length < 4) {
 550 |     return null;
 551 |   }
 552 | 
 553 |   const lineRE1 = /^\s*Line (\d+) of linked script ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,
 554 |     lineRE2 = /^\s*Line (\d+) of inline#(\d+) script in ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,
 555 |     lineRE3 = /^\s*Line (\d+) of function script\s*$/i,
 556 |     stack = [],
 557 |     scripts = (window && window.document && window.document.getElementsByTagName('script'));
 558 |   let inlineScriptBlocks = [],
 559 |     parts;
 560 | 
 561 |   for (let s in scripts) {
 562 |     if (_has(scripts, s) && !scripts[s].src) {
 563 |       inlineScriptBlocks.push(scripts[s]);
 564 |     }
 565 |   }
 566 | 
 567 |   for (let line = 2; line < lines.length; line += 2) {
 568 |     let item = null;
 569 |     if ((parts = lineRE1.exec(lines[line]))) {
 570 |       item = {
 571 |         'url': parts[2],
 572 |         'func': parts[3],
 573 |         'args': [],
 574 |         'line': +parts[1],
 575 |         'column': null
 576 |       };
 577 |     } else if ((parts = lineRE2.exec(lines[line]))) {
 578 |       item = {
 579 |         'url': parts[3],
 580 |         'func': parts[4],
 581 |         'args': [],
 582 |         'line': +parts[1],
 583 |         'column': null // TODO: Check to see if inline#1 (+parts[2]) points to the script number or column number.
 584 |       };
 585 |       const relativeLine = (+parts[1]); // relative to the start of the <SCRIPT> block
 586 |       const script = inlineScriptBlocks[parts[2] - 1];
 587 |       if (script) {
 588 |         let source = getSource(item.url);
 589 |         if (source) {
 590 |           source = source.join('\n');
 591 |           const pos = source.indexOf(script.innerText);
 592 |           if (pos >= 0) {
 593 |             item.line = relativeLine + source.substring(0, pos).split('\n').length;
 594 |           }
 595 |         }
 596 |       }
 597 |     } else if ((parts = lineRE3.exec(lines[line]))) {
 598 |       const url = window.location.href.replace(/#.*$/, '');
 599 |       const re = new RegExp(escapeCodeAsRegExpForMatchingInsideHTML(lines[line + 1]));
 600 |       const src = findSourceInUrls(re, [url]);
 601 |       item = {
 602 |         'url': url,
 603 |         'func': '',
 604 |         'args': [],
 605 |         'line': src ? src.line : parts[1],
 606 |         'column': null
 607 |       };
 608 |     }
 609 | 
 610 |     if (item) {
 611 |       if (!item.func) {
 612 |         item.func = guessFunctionName(item.url, item.line);
 613 |       }
 614 |       const context = gatherContext(item.url, item.line);
 615 |       const midline = (context ? context[Math.floor(context.length / 2)] : null);
 616 |       if (context && midline.replace(/^\s*/, '') === lines[line + 1].replace(/^\s*/, '')) {
 617 |         item.context = context;
 618 |       } else {
 619 |         // if (context) alert("Context mismatch. Correct midline:\n" + lines[i+1] + "\n\nMidline:\n" + midline + "\n\nContext:\n" + context.join("\n") + "\n\nURL:\n" + item.url);
 620 |         item.context = [lines[line + 1]];
 621 |       }
 622 |       stack.push(item);
 623 |     }
 624 |   }
 625 |   if (!stack.length) {
 626 |     return null; // could not parse multiline exception message as Opera stack trace
 627 |   }
 628 | 
 629 |   return {
 630 |     'mode': 'multiline',
 631 |     'name': ex.name,
 632 |     'message': lines[0],
 633 |     'stack': stack
 634 |   };
 635 | }
 636 | 
 637 | /**
 638 |  * Adds information about the first frame to incomplete stack traces.
 639 |  * Safari and IE require this to get complete data on the first frame.
 640 |  * @param {ErrorWatch.StackTrace} stackInfo Stack trace information from
 641 |  * one of the compute* methods.
 642 |  * @param {string} url The URL of the script that caused an error.
 643 |  * @param {(number|string)} lineNo The line number of the script that
 644 |  * caused an error.
 645 |  * @param {string=} message The error generated by the browser, which
 646 |  * hopefully contains the name of the object that caused the error.
 647 |  * @return {boolean} Whether or not the stack information was
 648 |  * augmented.
 649 |  * @memberof ErrorWatch.computeStackTrace
 650 |  */
 651 | function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {
 652 |   let initial = {
 653 |     'url': url,
 654 |     'line': lineNo
 655 |   };
 656 | 
 657 |   if (initial.url && initial.line) {
 658 |     stackInfo.incomplete = false;
 659 | 
 660 |     if (!initial.func) {
 661 |       initial.func = guessFunctionName(initial.url, initial.line);
 662 |     }
 663 | 
 664 |     if (!initial.context) {
 665 |       initial.context = gatherContext(initial.url, initial.line);
 666 |     }
 667 | 
 668 |     const reference = / '([^']+)' /.exec(message);
 669 |     if (reference) {
 670 |       initial.column = findSourceInLine(reference[1], initial.url, initial.line);
 671 |     }
 672 | 
 673 |     if (stackInfo.stack.length > 0) {
 674 |       if (stackInfo.stack[0].url === initial.url) {
 675 |         if (stackInfo.stack[0].line === initial.line) {
 676 |           return false; // already in stack trace
 677 |         } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {
 678 |           stackInfo.stack[0].line = initial.line;
 679 |           stackInfo.stack[0].context = initial.context;
 680 |           return false;
 681 |         }
 682 |       }
 683 |     }
 684 | 
 685 |     stackInfo.stack.unshift(initial);
 686 |     stackInfo.partial = true;
 687 |     return true;
 688 |   } else {
 689 |     stackInfo.incomplete = true;
 690 |   }
 691 | 
 692 |   return false;
 693 | }
 694 | 
 695 | /**
 696 |  * Computes stack trace information by walking the arguments.caller
 697 |  * chain at the time the exception occurred. This will cause earlier
 698 |  * frames to be missed but is the only way to get any stack trace in
 699 |  * Safari and IE. The top frame is restored by
 700 |  * {@link augmentStackTraceWithInitialElement}.
 701 |  * @param {Error} ex
 702 |  * @return {ErrorWatch.StackTrace=} Stack trace information.
 703 |  * @memberof ErrorWatch.computeStackTrace
 704 |  */
 705 | function computeStackTraceByWalkingCallerChain(ex, depth) {
 706 |   const functionName = /function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i;
 707 |   let stack = [],
 708 |     funcs = {},
 709 |     recursion = false,
 710 |     parts,
 711 |     item,
 712 |     source;
 713 | 
 714 |   for (let curr = computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {
 715 |     if (curr === computeStackTrace || (curr && curr.__name__ === reportFuncName)) { // curr ===  report 避免循环依赖
 716 |       continue;
 717 |     }
 718 | 
 719 |     item = {
 720 |       'url': null,
 721 |       'func': UNKNOWN_FUNCTION,
 722 |       'args': [],
 723 |       'line': null,
 724 |       'column': null
 725 |     };
 726 | 
 727 |     if (curr.name) {
 728 |       item.func = curr.name;
 729 |     } else if ((parts = functionName.exec(curr.toString()))) {
 730 |       item.func = parts[1];
 731 |     }
 732 | 
 733 |     if (typeof item.func === 'undefined') {
 734 |       try {
 735 |         item.func = parts.input.substring(0, parts.input.indexOf('{'));
 736 |       } catch (e) { }
 737 |     }
 738 | 
 739 |     if ((source = findSourceByFunctionBody(curr))) {
 740 |       item.url = source.url;
 741 |       item.line = source.line;
 742 | 
 743 |       if (item.func === UNKNOWN_FUNCTION) {
 744 |         item.func = guessFunctionName(item.url, item.line);
 745 |       }
 746 | 
 747 |       const reference = / '([^']+)' /.exec(ex.message || ex.description);
 748 |       if (reference) {
 749 |         item.column = findSourceInLine(reference[1], source.url, source.line);
 750 |       }
 751 |     }
 752 | 
 753 |     if (funcs['' + curr]) {
 754 |       recursion = true;
 755 |     }else {
 756 |       funcs['' + curr] = true;
 757 |     }
 758 | 
 759 |     stack.push(item);
 760 |   }
 761 | 
 762 |   if (depth) {
 763 |     stack.splice(0, depth);
 764 |   }
 765 | 
 766 |   let result = {
 767 |     'mode': 'callers',
 768 |     'name': ex.name,
 769 |     'message': ex.message,
 770 |     'stack': stack
 771 |   };
 772 |   augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);
 773 |   return result;
 774 | }
 775 | 
 776 | /**
 777 |  * Computes a stack trace for an exception.
 778 |  * @param {Error} ex
 779 |  * @param {(string|number)=} depth
 780 |  * @memberof ErrorWatch.computeStackTrace
 781 |  */
 782 | function computeStackTrace(ex, depth) {
 783 |   let stack = null;
 784 |   depth = (depth == null ? 0 : +depth);
 785 | 
 786 |   try {
 787 |     // This must be tried first because Opera 10 *destroys*
 788 |     // its stacktrace property if you try to access the stack
 789 |     // property first!!
 790 |     stack = computeStackTraceFromStacktraceProp(ex);
 791 |     if (stack) {
 792 |       return stack;
 793 |     }
 794 |   } catch (e) {
 795 |   }
 796 | 
 797 |   try {
 798 |     stack = computeStackTraceFromStackProp(ex);
 799 |     if (stack) {
 800 |       return stack;
 801 |     }
 802 |   } catch (e) {
 803 |   }
 804 | 
 805 |   try {
 806 |     stack = computeStackTraceFromOperaMultiLineMessage(ex);
 807 |     if (stack) {
 808 |       return stack;
 809 |     }
 810 |   } catch (e) {
 811 |   }
 812 | 
 813 |   try {
 814 |     stack = computeStackTraceByWalkingCallerChain(ex, depth + 1);
 815 |     if (stack) {
 816 |       return stack;
 817 |     }
 818 |   } catch (e) {
 819 |   }
 820 | 
 821 |   return {
 822 |     'name': ex.name,
 823 |     'message': ex.message,
 824 |     'mode': 'failed'
 825 |   };
 826 | }
 827 | 
 828 | /**
 829 |  * Logs a stacktrace starting from the previous call and working down.
 830 |  * @param {(number|string)=} depth How many frames deep to trace.
 831 |  * @return {ErrorWatch.StackTrace} Stack trace information.
 832 |  * @memberof ErrorWatch.computeStackTrace
 833 |  */
 834 | function computeStackTraceOfCaller(depth) {
 835 |   depth = (depth == null ? 0 : +depth) + 1; // "+ 1" because "ofCaller" should drop one frame
 836 |   try {
 837 |     throw new Error();
 838 |   } catch (ex) {
 839 |     return computeStackTrace(ex, depth + 1);
 840 |   }
 841 | }
 842 | 
 843 | computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement;
 844 | computeStackTrace.computeStackTraceFromStackProp = computeStackTraceFromStackProp;
 845 | computeStackTrace.guessFunctionName = guessFunctionName;
 846 | computeStackTrace.gatherContext = gatherContext;
 847 | computeStackTrace.ofCaller = computeStackTraceOfCaller;
 848 | computeStackTrace.getSource = getSource;
 849 | 
 850 | let isRegisterListener = false;
 851 | let _handler = null;
 852 | 
 853 | /**
 854 |  * 资源加载错误上报
 855 |  * @param handler
 856 |  */
 857 | function installResourceLoadError(handler) {
 858 |   if(!isRegisterListener && collectSourceErrors) {
 859 |     _handler = handler;
 860 |     window.addEventListener && window.addEventListener('error', function (e) {
 861 |       try {
 862 |         if(e.target !== window) {  // 避免重复上报
 863 |           const stack = {
 864 |             message: `${e.target.localName} is load error`,
 865 |             mode: 'resource',
 866 |             name: e.target.src || e.target.href || e.target.currentSrc,
 867 |             stack: null,
 868 |           };
 869 |           handler(stack, true, e);
 870 |         }
 871 |       } catch (e) {
 872 |         throw e;
 873 |       }
 874 |     }, true);
 875 |   }
 876 |   isRegisterListener = true;
 877 | }
 878 | 
 879 | /**
 880 |  * 移除资源错误加载监听
 881 |  */
 882 | function uninstallResourceLoadError() {
 883 |   if(isRegisterListener && collectSourceErrors && _handler) {
 884 |     window.removeEventListener && window.removeEventListener('error', _handler);
 885 |     _handler = null;
 886 |     isRegisterListener = false;
 887 |   }
 888 | }
 889 | 
 890 | /**
 891 |  * Cross-browser processing of unhandled exceptions
 892 |  *
 893 |  * Syntax:
 894 |  * ```js
 895 |  *   ErrorWatch.report.subscribe(function(stackInfo) { ... })
 896 |  *   ErrorWatch.report.unsubscribe(function(stackInfo) { ... })
 897 |  *   ErrorWatch.report(exception)
 898 |  *   try { ...code... } catch(ex) { ErrorWatch.report(ex); }
 899 |  * ```
 900 |  *
 901 |  * Supports:
 902 |  *   - Firefox: full stack trace with line numbers, plus column number
 903 |  *     on top frame; column number is not guaranteed
 904 |  *   - Opera: full stack trace with line and column numbers
 905 |  *   - Chrome: full stack trace with line and column numbers
 906 |  *   - Safari: line and column number for the top frame only; some frames
 907 |  *     may be missing, and column number is not guaranteed
 908 |  *   - IE: line and column number for the top frame only; some frames
 909 |  *     may be missing, and column number is not guaranteed
 910 |  *
 911 |  * In theory, ErrorWatch should work on all of the following versions:
 912 |  *   - IE5.5+ (only 8.0 tested)
 913 |  *   - Firefox 0.9+ (only 3.5+ tested)
 914 |  *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
 915 |  *     Exceptions Have Stacktrace to be enabled in opera:config)
 916 |  *   - Safari 3+ (only 4+ tested)
 917 |  *   - Chrome 1+ (only 5+ tested)
 918 |  *   - Konqueror 3.5+ (untested)
 919 |  *
 920 |  * Requires ErrorWatch.computeStackTrace.
 921 |  *
 922 |  * Tries to catch all unhandled exceptions and report them to the
 923 |  * subscribed handlers. Please note that ErrorWatch.report will rethrow the
 924 |  * exception. This is REQUIRED in order to get a useful stack trace in IE.
 925 |  * If the exception does not reach the top of the browser, you will only
 926 |  * get a stack trace from the point where ErrorWatch.report was called.
 927 |  *
 928 |  * Handlers receive a ErrorWatch.StackTrace object as described in the
 929 |  * ErrorWatch.computeStackTrace docs.
 930 |  *
 931 |  * @memberof ErrorWatch
 932 |  * @namespace
 933 |  */
 934 | 
 935 | // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
 936 | const ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;
 937 | 
 938 | 
 939 | let handlers = [],
 940 |   lastException = null,
 941 |   lastExceptionStack = null;
 942 | 
 943 | /**
 944 |  * Add a crash handler.
 945 |  * @param {Function} handler
 946 |  * @memberof ErrorWatch.report
 947 |  */
 948 | function subscribe(handler) {
 949 |   installGlobalHandler();
 950 |   installGlobalUnhandledRejectionHandler();
 951 |   handlers.push(handler);
 952 | }
 953 | 
 954 | /**
 955 |  * Remove a crash handler.
 956 |  * @param {Function} handler
 957 |  * @memberof ErrorWatch.report
 958 |  */
 959 | function unsubscribe(handler) {
 960 |   for (let i = handlers.length - 1; i >= 0; --i) {
 961 |     if (handlers[i] === handler) {
 962 |       handlers.splice(i, 1);
 963 |     }
 964 |   }
 965 | 
 966 |   if (handlers.length === 0) {
 967 |     uninstallGlobalHandler();
 968 |     uninstallGlobalUnhandledRejectionHandler();
 969 |   }
 970 | }
 971 | 
 972 | /**
 973 |  * Dispatch stack information to all handlers.
 974 |  * @param {ErrorWatch.StackTrace} stack
 975 |  * @param {boolean} isWindowError Is this a top-level window error?
 976 |  * @param {Error=} error The error that's being handled (if available, null otherwise)
 977 |  * @memberof ErrorWatch.report
 978 |  * @throws An exception if an error occurs while calling an handler.
 979 |  */
 980 | function notifyHandlers(stack, isWindowError, error) {
 981 |   let exception = null;
 982 |   if (isWindowError && !collectWindowErrors) {
 983 |     return;
 984 |   }
 985 |   for (let i in handlers) {
 986 |     if (_has(handlers, i)) {
 987 |       try {
 988 |         handlers[i](stack, isWindowError, error);
 989 |       } catch (inner) {
 990 |         exception = inner;
 991 |       }
 992 |     }
 993 |   }
 994 | 
 995 |   if (exception) {
 996 |     throw exception;
 997 |   }
 998 | }
 999 | 
1000 | let _oldOnerrorHandler, _onErrorHandlerInstalled;
1001 | let _oldOnunhandledrejectionHandler, _onUnhandledRejectionHandlerInstalled;
1002 | 
1003 | /**
1004 |  * Ensures all global unhandled exceptions are recorded.
1005 |  * Supported by Gecko and IE.
1006 |  * @param {string} message Error message.
1007 |  * @param {string} url URL of script that generated the exception.
1008 |  * @param {(number|string)} lineNo The line number at which the error occurred.
1009 |  * @param {(number|string)=} columnNo The column number at which the error occurred.
1010 |  * @param {Error=} errorObj The actual Error object.
1011 |  * @memberof ErrorWatch.report
1012 |  */
1013 | function errorWatchWindowOnError(message, url, lineNo, columnNo, errorObj) {
1014 |   let stack = null;
1015 | 
1016 |   if (lastExceptionStack) {
1017 |     computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);
1018 |     processLastException();
1019 |   } else if (errorObj) {
1020 |     stack = computeStackTrace(errorObj);
1021 |     notifyHandlers(stack, true, errorObj);
1022 |   } else {
1023 |     let location = {
1024 |       'url': url,
1025 |       'line': lineNo,
1026 |       'column': columnNo
1027 |     };
1028 | 
1029 |     let name;
1030 |     let msg = message; // must be new var or will modify original `arguments`
1031 |     if ({}.toString.call(message) === '[object String]') {
1032 |       const groups = message.match(ERROR_TYPES_RE);
1033 |       if (groups) {
1034 |         name = groups[1];
1035 |         msg = groups[2];
1036 |       }
1037 |     }
1038 | 
1039 |     location.func = computeStackTrace.guessFunctionName(location.url, location.line);
1040 |     location.context = computeStackTrace.gatherContext(location.url, location.line);
1041 |     stack = {
1042 |       'name': name,
1043 |       'message': msg,
1044 |       'mode': 'onerror',
1045 |       'stack': [location]
1046 |     };
1047 | 
1048 |     notifyHandlers(stack, true, null);
1049 |   }
1050 | 
1051 |   if (_oldOnerrorHandler) {
1052 |     return _oldOnerrorHandler.apply(this, arguments);
1053 |   }
1054 | 
1055 |   return false;
1056 | }
1057 | 
1058 | /**
1059 |  * Ensures all unhandled rejections are recorded.
1060 |  * @param {PromiseRejectionEvent} e event.
1061 |  * @memberof ErrorWatch.report
1062 |  * @see https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onunhandledrejection
1063 |  * @see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
1064 |  */
1065 | function errorWatchWindowOnUnhandledRejection(e) {
1066 |   const stack = computeStackTrace(e.reason);
1067 |   notifyHandlers(stack, true, e.reason);
1068 | }
1069 | 
1070 | /**
1071 |  * Install a global onerror handler
1072 |  * @memberof ErrorWatch.report
1073 |  */
1074 | function installGlobalHandler() {
1075 |   if (_onErrorHandlerInstalled === true) {
1076 |     return;
1077 |   }
1078 | 
1079 |   _oldOnerrorHandler = window.onerror;
1080 |   window.onerror = errorWatchWindowOnError;
1081 |   installResourceLoadError(function handleResourceError(stack, isWindowError, error) {
1082 |     notifyHandlers(stack, isWindowError, error);
1083 |   });
1084 |   _onErrorHandlerInstalled = true;
1085 | }
1086 | 
1087 | /**
1088 |  * Uninstall the global onerror handler
1089 |  * @memberof ErrorWatch.report
1090 |  */
1091 | function uninstallGlobalHandler() {
1092 |   if (_onErrorHandlerInstalled) {
1093 |     window.onerror = _oldOnerrorHandler;
1094 |     uninstallResourceLoadError();
1095 |     _onErrorHandlerInstalled = false;
1096 |   }
1097 | }
1098 | 
1099 | /**
1100 |  * Install a global onunhandledrejection handler
1101 |  * @memberof ErrorWatch.report
1102 |  */
1103 | function installGlobalUnhandledRejectionHandler() {
1104 |   if (_onUnhandledRejectionHandlerInstalled === true) {
1105 |     return;
1106 |   }
1107 | 
1108 |   _oldOnunhandledrejectionHandler = window.onunhandledrejection;
1109 |   window.onunhandledrejection = errorWatchWindowOnUnhandledRejection;
1110 |   _onUnhandledRejectionHandlerInstalled = true;
1111 | }
1112 | 
1113 | /**
1114 |  * Uninstall the global onunhandledrejection handler
1115 |  * @memberof ErrorWatch.report
1116 |  */
1117 | function uninstallGlobalUnhandledRejectionHandler() {
1118 |   if (_onUnhandledRejectionHandlerInstalled) {
1119 |     window.onunhandledrejection = _oldOnunhandledrejectionHandler;
1120 |     _onUnhandledRejectionHandlerInstalled = false;
1121 |   }
1122 | }
1123 | 
1124 | /**
1125 |  * Process the most recent exception
1126 |  * @memberof ErrorWatch.report
1127 |  */
1128 | function processLastException() {
1129 |   let _lastExceptionStack = lastExceptionStack,
1130 |     _lastException = lastException;
1131 |   lastExceptionStack = null;
1132 |   lastException = null;
1133 |   notifyHandlers(_lastExceptionStack, false, _lastException);
1134 | }
1135 | 
1136 | /**
1137 |  * Reports an unhandled Error to ErrorWatch.
1138 |  * @param {Error} ex
1139 |  * @memberof ErrorWatch.report
1140 |  * @throws An exception if an incomplete stack trace is detected (old IE browsers).
1141 |  */
1142 | function report(ex) {
1143 |   if (lastExceptionStack) {
1144 |     if (lastException === ex) {
1145 |       return; // already caught by an inner catch block, ignore
1146 |     } else {
1147 |       processLastException();
1148 |     }
1149 |   }
1150 | 
1151 |   const stack = computeStackTrace(ex);
1152 |   lastExceptionStack = stack;
1153 |   lastException = ex;
1154 | 
1155 |   // If the stack trace is incomplete, wait for 2 seconds for
1156 |   // slow slow IE to see if onerror occurs or not before reporting
1157 |   // this exception; otherwise, we will end up with an incomplete
1158 |   // stack trace
1159 |   setTimeout(function () {
1160 |     if (lastException === ex) {
1161 |       processLastException();
1162 |     }
1163 |   }, (stack.incomplete ? 2000 : 0));
1164 | 
1165 |   throw ex; // re-throw to propagate to the top level (and cause window.onerror)
1166 | }
1167 | 
1168 | report.subscribe = subscribe;
1169 | report.unsubscribe = unsubscribe;
1170 | 
1171 | report.__name__ = reportFuncName;
1172 | 
1173 | /**
1174 |  * Wrap any function in a ErrorWatch reporter<br/>
1175 |  * Example: `func = ErrorWatch.wrap(func);`
1176 |  *
1177 |  * @param {Function} func Function to be wrapped
1178 |  * @return {Function} The wrapped func
1179 |  * @memberof ErrorWatch
1180 |  */
1181 | function wrap(func) {
1182 |   function wrapped() {
1183 |     try {
1184 |       return func.apply(this, arguments);
1185 |     } catch (e) {
1186 |       report(e);
1187 |       throw e;
1188 |     }
1189 |   }
1190 |   return wrapped;
1191 | }
1192 | 
1193 | // global reference to slice
1194 | const _slice = [].slice;
1195 | 
1196 | /**
1197 |  * Extends support for global error handling for asynchronous browser
1198 |  * functions. Adopted from Closure Library's errorhandler.js
1199 |  * @memberof ErrorWatch
1200 |  */
1201 | function _helper(fnName) {
1202 |   const originalFn = window[fnName];
1203 | 
1204 |   window[fnName] = function errorWatchAsyncExtension() {
1205 |     // Make a copy of the arguments
1206 |     let args = _slice.call(arguments);
1207 |     const originalCallback = args[0];
1208 |     if (typeof (originalCallback) === 'function') {
1209 |       args[0] = wrap(originalCallback);
1210 |     }
1211 |     // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it
1212 |     // also only supports 2 argument and doesn't care what "this" is, so we
1213 |     // can just call the original function directly.
1214 |     if (originalFn.apply) {
1215 |       return originalFn.apply(this, args);
1216 |     } else {
1217 |       return originalFn(args[0], args[1]);
1218 |     }
1219 |   };
1220 | }
1221 | 
1222 | function extendToAsynchronousCallbacks() {
1223 |   _helper('setTimeout');
1224 |   _helper('setInterval');
1225 | }
1226 | 
1227 | const _oldErrorWatch = window.ErrorWatch;
1228 | let ErrorWatch;
1229 | /**
1230 |  * Export ErrorWatch out to another variable<br/>
1231 |  * Example: `var TK = ErrorWatch.noConflict()`
1232 |  * @return {Object} The ErrorWatch object
1233 |  * @memberof ErrorWatch
1234 |  */
1235 | function noConflict() {
1236 |   window.ErrorWatch = _oldErrorWatch;
1237 |   return ErrorWatch;
1238 | }
1239 | 
1240 | function makeError() {
1241 |   const tmp = thisIsAbug;
1242 |   return tmp + '';
1243 | }
1244 | 
1245 | ErrorWatch =  {
1246 |   noConflict,
1247 |   report,
1248 |   computeStackTrace,
1249 |   wrap,
1250 |   extendToAsynchronousCallbacks,
1251 |   makeError,
1252 | };
1253 | 
1254 | var ErrorWatch$1 = ErrorWatch;
1255 | 
1256 | export default ErrorWatch$1;
1257 | 


--------------------------------------------------------------------------------
/dist/errorWatch.js:
--------------------------------------------------------------------------------
   1 | (function (global, factory) {
   2 |   typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
   3 |   typeof define === 'function' && define.amd ? define(factory) :
   4 |   (global = global || self, global.ErrorWatch = factory());
   5 | }(this, (function () { 'use strict';
   6 | 
   7 |   //Default options:
   8 | 
   9 |   var collectWindowErrors = true; // 是否通知 window 全局错误，开启，关掉了这个脚本就没意义了
  10 | 
  11 |   var collectSourceErrors = true; // 是否在捕获阶段获取资源加载错误，默认开启
  12 | 
  13 |   var linesOfContext = 11; // 5 lines before, the offending line, 5 lines after，没啥用
  14 |   var reportFuncName = 'ErrorWatch.report';
  15 | 
  16 |   /**
  17 |    * A better form of hasOwnProperty<br/>
  18 |    * Example: `_has(MainHostObject, property) === true/false`
  19 |    *
  20 |    * @param {Object} object to check property
  21 |    * @param {string} key to check
  22 |    * @return {Boolean} true if the object has the key and it is not inherited
  23 |    */
  24 |   function _has(object, key) {
  25 |     return Object.prototype.hasOwnProperty.call(object, key);
  26 |   }
  27 |   /**
  28 |    * Returns true if the parameter is undefined<br/>
  29 |    * Example: `_isUndefined(val) === true/false`
  30 |    *
  31 |    * @param {*} what Value to check
  32 |    * @return {Boolean} true if undefined and false otherwise
  33 |    */
  34 | 
  35 |   function _isUndefined(what) {
  36 |     return typeof what === 'undefined';
  37 |   }
  38 | 
  39 |   /**
  40 |    * An object representing a single stack frame.
  41 |    * @typedef {Object} StackFrame
  42 |    * @property {string} url The JavaScript or HTML file URL.
  43 |    * @property {string} func The function name, or empty for anonymous functions (if guessing did not work).
  44 |    * @property {string[]?} args The arguments passed to the function, if known.
  45 |    * @property {number=} line The line number, if known.
  46 |    * @property {number=} column The column number, if known.
  47 |    * @property {string[]} context An array of source code lines; the middle element corresponds to the correct line#.
  48 |    * @memberof ErrorWatch
  49 |    */
  50 |   var UNKNOWN_FUNCTION = '?';
  51 |   var sourceCache = {};
  52 |   /**
  53 |    * Attempts to retrieve source code via XMLHttpRequest, which is used
  54 |    * to look up anonymous function names.
  55 |    * @param {string} url URL of source code.
  56 |    * @return {string} Source contents.
  57 |    * @memberof ErrorWatch.computeStackTrace
  58 |    */
  59 | 
  60 |   function loadSource(url) {
  61 |     {
  62 |       //Only attempt request if remoteFetching is on.
  63 |       return '';
  64 |     }
  65 |   }
  66 |   /**
  67 |    * Retrieves source code from the source code cache.
  68 |    * @param {string} url URL of source code.
  69 |    * @return {Array.<string>} Source contents.
  70 |    * @memberof ErrorWatch.computeStackTrace
  71 |    */
  72 | 
  73 | 
  74 |   function getSource(url) {
  75 |     if (typeof url !== 'string') {
  76 |       return [];
  77 |     }
  78 | 
  79 |     if (!_has(sourceCache, url)) {
  80 |       // URL needs to be able to fetched within the acceptable domain.  Otherwise,
  81 |       // cross-domain errors will be triggered.
  82 | 
  83 |       /*
  84 |           Regex matches:
  85 |           0 - Full Url
  86 |           1 - Protocol
  87 |           2 - Domain
  88 |           3 - Port (Useful for internal applications)
  89 |           4 - Path
  90 |       */
  91 |       var source = '',
  92 |           domain = '';
  93 | 
  94 |       try {
  95 |         domain = window.document.domain;
  96 |       } catch (e) {}
  97 | 
  98 |       var match = /(.*)\:\/\/([^:\/]+)([:\d]*)\/{0,1}([\s\S]*)/.exec(url);
  99 | 
 100 |       if (match && match[2] === domain) {
 101 |         source = loadSource();
 102 |       }
 103 | 
 104 |       sourceCache[url] = source ? source.split('\n') : [];
 105 |     }
 106 | 
 107 |     return sourceCache[url];
 108 |   }
 109 |   /**
 110 |    * Tries to use an externally loaded copy of source code to determine
 111 |    * the name of a function by looking at the name of the variable it was
 112 |    * assigned to, if any.
 113 |    * @param {string} url URL of source code.
 114 |    * @param {(string|number)} lineNo Line number in source code.
 115 |    * @return {string} The function name, if discoverable.
 116 |    * @memberof ErrorWatch.computeStackTrace
 117 |    */
 118 | 
 119 | 
 120 |   function guessFunctionName(url, lineNo) {
 121 |     var reFunctionArgNames = /function ([^(]*)\(([^)]*)\)/,
 122 |         reGuessFunction = /['"]?([0-9A-Za-z$_]+)['"]?\s*[:=]\s*(function|eval|new Function)/,
 123 |         maxLines = 10,
 124 |         source = getSource(url);
 125 |     var line = '',
 126 |         m;
 127 | 
 128 |     if (!source.length) {
 129 |       return UNKNOWN_FUNCTION;
 130 |     } // Walk backwards from the first line in the function until we find the line which
 131 |     // matches the pattern above, which is the function definition
 132 | 
 133 | 
 134 |     for (var i = 0; i < maxLines; ++i) {
 135 |       line = source[lineNo - i] + line;
 136 | 
 137 |       if (!_isUndefined(line)) {
 138 |         // 这里有个bug，永远为 true
 139 |         if (m = reGuessFunction.exec(line)) {
 140 |           return m[1];
 141 |         } else if (m = reFunctionArgNames.exec(line)) {
 142 |           return m[1];
 143 |         }
 144 |       }
 145 |     }
 146 | 
 147 |     return UNKNOWN_FUNCTION;
 148 |   }
 149 |   /**
 150 |    * Retrieves the surrounding lines from where an exception occurred.
 151 |    * @param {string} url URL of source code.
 152 |    * @param {(string|number)} line Line number in source code to center around for context.
 153 |    * @return {?Array.<string>} Lines of source code.
 154 |    * @memberof ErrorWatch.computeStackTrace
 155 |    */
 156 | 
 157 | 
 158 |   function gatherContext(url, line) {
 159 |     var source = getSource(url);
 160 | 
 161 |     if (!source.length) {
 162 |       return null;
 163 |     }
 164 | 
 165 |     var context = [],
 166 |         // linesBefore & linesAfter are inclusive with the offending line.
 167 |     // if linesOfContext is even, there will be one extra line
 168 |     //   *before* the offending line.
 169 |     linesBefore = Math.floor(linesOfContext / 2),
 170 |         // Add one extra line if linesOfContext is odd
 171 |     linesAfter = linesBefore + linesOfContext % 2,
 172 |         start = Math.max(0, line - linesBefore - 1),
 173 |         end = Math.min(source.length, line + linesAfter - 1);
 174 |     line -= 1; // convert to 0-based index
 175 | 
 176 |     for (var i = start; i < end; ++i) {
 177 |       if (!_isUndefined(source[i])) {
 178 |         context.push(source[i]);
 179 |       }
 180 |     }
 181 | 
 182 |     return context.length > 0 ? context : null;
 183 |   }
 184 |   /**
 185 |    * Escapes special characters, except for whitespace, in a string to be
 186 |    * used inside a regular expression as a string literal.
 187 |    * @param {string} text The string.
 188 |    * @return {string} The escaped string literal.
 189 |    * @memberof ErrorWatch.computeStackTrace
 190 |    */
 191 | 
 192 | 
 193 |   function escapeRegExp(text) {
 194 |     return text.replace(/[\-\[\]{}()*+?.,\\\^$|#]/g, '\\$&');
 195 |   }
 196 |   /**
 197 |    * Escapes special characters in a string to be used inside a regular
 198 |    * expression as a string literal. Also ensures that HTML entities will
 199 |    * be matched the same as their literal friends.
 200 |    * @param {string} body The string.
 201 |    * @return {string} The escaped string.
 202 |    * @memberof ErrorWatch.computeStackTrace
 203 |    */
 204 | 
 205 | 
 206 |   function escapeCodeAsRegExpForMatchingInsideHTML(body) {
 207 |     return escapeRegExp(body).replace('<', '(?:<|&lt;)').replace('>', '(?:>|&gt;)').replace('&', '(?:&|&amp;)').replace('"', '(?:"|&quot;)').replace(/\s+/g, '\\s+');
 208 |   }
 209 |   /**
 210 |    * Determines where a code fragment occurs in the source code.
 211 |    * @param {RegExp} re The function definition.
 212 |    * @param {Array.<string>} urls A list of URLs to search.
 213 |    * @return {?Object.<string, (string|number)>} An object containing
 214 |    * the url, line, and column number of the defined function.
 215 |    * @memberof ErrorWatch.computeStackTrace
 216 |    */
 217 | 
 218 | 
 219 |   function findSourceInUrls(re, urls) {
 220 |     var source, m;
 221 | 
 222 |     for (var i = 0, j = urls.length; i < j; ++i) {
 223 |       if ((source = getSource(urls[i])).length) {
 224 |         source = source.join('\n');
 225 | 
 226 |         if (m = re.exec(source)) {
 227 |           return {
 228 |             'url': urls[i],
 229 |             'line': source.substring(0, m.index).split('\n').length,
 230 |             'column': m.index - source.lastIndexOf('\n', m.index) - 1
 231 |           };
 232 |         }
 233 |       }
 234 |     }
 235 | 
 236 |     return null;
 237 |   }
 238 |   /**
 239 |    * Determines at which column a code fragment occurs on a line of the
 240 |    * source code.
 241 |    * @param {string} fragment The code fragment.
 242 |    * @param {string} url The URL to search.
 243 |    * @param {(string|number)} line The line number to examine.
 244 |    * @return {?number} The column number.
 245 |    * @memberof ErrorWatch.computeStackTrace
 246 |    */
 247 | 
 248 | 
 249 |   function findSourceInLine(fragment, url, line) {
 250 |     var source = getSource(url),
 251 |         re = new RegExp('\\b' + escapeRegExp(fragment) + '\\b');
 252 |     var m;
 253 |     line -= 1;
 254 | 
 255 |     if (source && source.length > line && (m = re.exec(source[line]))) {
 256 |       return m.index;
 257 |     }
 258 | 
 259 |     return null;
 260 |   }
 261 |   /**
 262 |    * Determines where a function was defined within the source code.
 263 |    * @param {(Function|string)} func A function reference or serialized
 264 |    * function definition.
 265 |    * @return {?Object.<string, (string|number)>} An object containing
 266 |    * the url, line, and column number of the defined function.
 267 |    * @memberof ErrorWatch.computeStackTrace
 268 |    */
 269 | 
 270 | 
 271 |   function findSourceByFunctionBody(func) {
 272 |     if (_isUndefined(window && window.document)) {
 273 |       return null;
 274 |     }
 275 | 
 276 |     var urls = [window.location.href],
 277 |         scripts = window.document.getElementsByTagName('script'),
 278 |         code = '' + func,
 279 |         codeRE = /^function(?:\s+([\w$]+))?\s*\(([\w\s,]*)\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,
 280 |         eventRE = /^function on([\w$]+)\s*\(event\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/;
 281 |     var body, re, parts, result;
 282 | 
 283 |     for (var i = 0; i < scripts.length; ++i) {
 284 |       var script = scripts[i];
 285 | 
 286 |       if (script.src) {
 287 |         urls.push(script.src);
 288 |       }
 289 |     }
 290 | 
 291 |     if (!(parts = codeRE.exec(code))) {
 292 |       re = new RegExp(escapeRegExp(code).replace(/\s+/g, '\\s+'));
 293 |     } // not sure if this is really necessary, but I don’t have a test
 294 |     // corpus large enough to confirm that and it was in the original.
 295 |     else {
 296 |         var name = parts[1] ? '\\s+' + parts[1] : '',
 297 |             args = parts[2].split(',').join('\\s*,\\s*');
 298 |         body = escapeRegExp(parts[3]).replace(/;$/, ';?'); // semicolon is inserted if the function ends with a comment.replace(/\s+/g, '\\s+');
 299 | 
 300 |         re = new RegExp('function' + name + '\\s*\\(\\s*' + args + '\\s*\\)\\s*{\\s*' + body + '\\s*}');
 301 |       } // look for a normal function definition
 302 | 
 303 | 
 304 |     if (result = findSourceInUrls(re, urls)) {
 305 |       return result;
 306 |     } // look for an old-school event handler function
 307 | 
 308 | 
 309 |     if (parts = eventRE.exec(code)) {
 310 |       var event = parts[1];
 311 |       body = escapeCodeAsRegExpForMatchingInsideHTML(parts[2]); // look for a function defined in HTML as an onXXX handler
 312 | 
 313 |       re = new RegExp('on' + event + '=[\\\'"]\\s*' + body + '\\s*[\\\'"]', 'i');
 314 | 
 315 |       if (result = findSourceInUrls(re, urls[0])) {
 316 |         return result;
 317 |       } // look for ???
 318 | 
 319 | 
 320 |       re = new RegExp(body);
 321 | 
 322 |       if (result = findSourceInUrls(re, urls)) {
 323 |         return result;
 324 |       }
 325 |     }
 326 | 
 327 |     return null;
 328 |   } // Contents of Exception in various browsers.
 329 |   //
 330 |   // SAFARI:
 331 |   // ex.message = Can't find variable: qq
 332 |   // ex.line = 59
 333 |   // ex.sourceId = 580238192
 334 |   // ex.sourceURL = http://...
 335 |   // ex.expressionBeginOffset = 96
 336 |   // ex.expressionCaretOffset = 98
 337 |   // ex.expressionEndOffset = 98
 338 |   // ex.name = ReferenceError
 339 |   //
 340 |   // FIREFOX:
 341 |   // ex.message = qq is not defined
 342 |   // ex.fileName = http://...
 343 |   // ex.lineNumber = 59
 344 |   // ex.columnNumber = 69
 345 |   // ex.stack = ...stack trace... (see the example below)
 346 |   // ex.name = ReferenceError
 347 |   //
 348 |   // CHROME:
 349 |   // ex.message = qq is not defined
 350 |   // ex.name = ReferenceError
 351 |   // ex.type = not_defined
 352 |   // ex.arguments = ['aa']
 353 |   // ex.stack = ...stack trace...
 354 |   //
 355 |   // INTERNET EXPLORER:
 356 |   // ex.message = ...
 357 |   // ex.name = ReferenceError
 358 |   //
 359 |   // OPERA:
 360 |   // ex.message = ...message... (see the example below)
 361 |   // ex.name = ReferenceError
 362 |   // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)
 363 |   // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'
 364 | 
 365 |   /**
 366 |    * Computes stack trace information from the stack property.
 367 |    * Chrome and Gecko use this property.
 368 |    * @param {Error} ex
 369 |    * @return {?ErrorWatch.StackTrace} Stack trace information.
 370 |    * @memberof ErrorWatch.computeStackTrace
 371 |    */
 372 | 
 373 | 
 374 |   function computeStackTraceFromStackProp(ex) {
 375 |     if (!ex.stack) {
 376 |       return null;
 377 |     }
 378 | 
 379 |     var chrome = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,
 380 |         gecko = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i,
 381 |         winjs = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
 382 |         geckoEval = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i,
 383 |         chromeEval = /\((\S*)(?::(\d+))(?::(\d+))\)/,
 384 |         lines = ex.stack.split('\n'),
 385 |         reference = /^(.*) is undefined$/.exec(ex.message);
 386 |     var stack = [],
 387 |         // Used to additionally parse URL/line/column from eval frames
 388 |     isEval,
 389 |         submatch,
 390 |         parts,
 391 |         element;
 392 | 
 393 |     for (var i = 0, j = lines.length; i < j; ++i) {
 394 |       if (parts = chrome.exec(lines[i])) {
 395 |         var isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line
 396 | 
 397 |         isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
 398 | 
 399 |         if (isEval && (submatch = chromeEval.exec(parts[2]))) {
 400 |           // throw out eval line/column and use top-most line/column number
 401 |           parts[2] = submatch[1]; // url
 402 | 
 403 |           parts[3] = submatch[2]; // line
 404 | 
 405 |           parts[4] = submatch[3]; // column
 406 |         }
 407 | 
 408 |         element = {
 409 |           'url': !isNative ? parts[2] : null,
 410 |           'func': parts[1] || UNKNOWN_FUNCTION,
 411 |           'args': isNative ? [parts[2]] : [],
 412 |           'line': parts[3] ? +parts[3] : null,
 413 |           'column': parts[4] ? +parts[4] : null
 414 |         };
 415 |       } else if (parts = winjs.exec(lines[i])) {
 416 |         element = {
 417 |           'url': parts[2],
 418 |           'func': parts[1] || UNKNOWN_FUNCTION,
 419 |           'args': [],
 420 |           'line': +parts[3],
 421 |           'column': parts[4] ? +parts[4] : null
 422 |         };
 423 |       } else if (parts = gecko.exec(lines[i])) {
 424 |         isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
 425 | 
 426 |         if (isEval && (submatch = geckoEval.exec(parts[3]))) {
 427 |           // throw out eval line/column and use top-most line number
 428 |           parts[3] = submatch[1];
 429 |           parts[4] = submatch[2];
 430 |           parts[5] = null; // no column when eval
 431 |         } else if (i === 0 && !parts[5] && !_isUndefined(ex.columnNumber)) {
 432 |           // FireFox uses this awesome columnNumber property for its top frame
 433 |           // Also note, Firefox's column number is 0-based and everything else expects 1-based,
 434 |           // so adding 1
 435 |           // NOTE: this hack doesn't work if top-most frame is eval
 436 |           stack[0].column = ex.columnNumber + 1;
 437 |         }
 438 | 
 439 |         element = {
 440 |           'url': parts[3],
 441 |           'func': parts[1] || UNKNOWN_FUNCTION,
 442 |           'args': parts[2] ? parts[2].split(',') : [],
 443 |           'line': parts[4] ? +parts[4] : null,
 444 |           'column': parts[5] ? +parts[5] : null
 445 |         };
 446 |       } else {
 447 |         continue;
 448 |       }
 449 | 
 450 |       if (!element.func && element.line) {
 451 |         element.func = guessFunctionName(element.url, element.line);
 452 |       }
 453 | 
 454 |       element.context = element.line ? gatherContext(element.url, element.line) : null;
 455 |       stack.push(element);
 456 |     }
 457 | 
 458 |     if (!stack.length) {
 459 |       return null;
 460 |     }
 461 | 
 462 |     if (stack[0] && stack[0].line && !stack[0].column && reference) {
 463 |       stack[0].column = findSourceInLine(reference[1], stack[0].url, stack[0].line);
 464 |     }
 465 | 
 466 |     return {
 467 |       'mode': 'stack',
 468 |       'name': ex.name,
 469 |       'message': ex.message,
 470 |       'stack': stack
 471 |     };
 472 |   }
 473 |   /**
 474 |    * Computes stack trace information from the stacktrace property.
 475 |    * Opera 10+ uses this property.
 476 |    * @param {Error} ex
 477 |    * @return {?ErrorWatch.StackTrace} Stack trace information.
 478 |    * @memberof ErrorWatch.computeStackTrace
 479 |    */
 480 | 
 481 | 
 482 |   function computeStackTraceFromStacktraceProp(ex) {
 483 |     // Access and store the stacktrace property before doing ANYTHING
 484 |     // else to it because Opera is not very good at providing it
 485 |     // reliably in other circumstances.
 486 |     var stacktrace = ex.stacktrace;
 487 | 
 488 |     if (!stacktrace) {
 489 |       return;
 490 |     }
 491 | 
 492 |     var opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i,
 493 |         opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^\)]+))\((.*)\))? in (.*):\s*$/i,
 494 |         lines = stacktrace.split('\n');
 495 |     var stack = [],
 496 |         parts;
 497 | 
 498 |     for (var line = 0; line < lines.length; line += 2) {
 499 |       var element = null;
 500 | 
 501 |       if (parts = opera10Regex.exec(lines[line])) {
 502 |         element = {
 503 |           'url': parts[2],
 504 |           'line': +parts[1],
 505 |           'column': null,
 506 |           'func': parts[3],
 507 |           'args': []
 508 |         };
 509 |       } else if (parts = opera11Regex.exec(lines[line])) {
 510 |         element = {
 511 |           'url': parts[6],
 512 |           'line': +parts[1],
 513 |           'column': +parts[2],
 514 |           'func': parts[3] || parts[4],
 515 |           'args': parts[5] ? parts[5].split(',') : []
 516 |         };
 517 |       }
 518 | 
 519 |       if (element) {
 520 |         if (!element.func && element.line) {
 521 |           element.func = guessFunctionName(element.url, element.line);
 522 |         }
 523 | 
 524 |         if (element.line) {
 525 |           try {
 526 |             element.context = gatherContext(element.url, element.line);
 527 |           } catch (exc) {}
 528 |         }
 529 | 
 530 |         if (!element.context) {
 531 |           element.context = [lines[line + 1]];
 532 |         }
 533 | 
 534 |         stack.push(element);
 535 |       }
 536 |     }
 537 | 
 538 |     if (!stack.length) {
 539 |       return null;
 540 |     }
 541 | 
 542 |     return {
 543 |       'mode': 'stacktrace',
 544 |       'name': ex.name,
 545 |       'message': ex.message,
 546 |       'stack': stack
 547 |     };
 548 |   }
 549 |   /**
 550 |    * NOT TESTED.
 551 |    * Computes stack trace information from an error message that includes
 552 |    * the stack trace.
 553 |    * Opera 9 and earlier use this method if the option to show stack
 554 |    * traces is turned on in opera:config.
 555 |    * @param {Error} ex
 556 |    * @return {?ErrorWatch.StackTrace} Stack information.
 557 |    * @memberof ErrorWatch.computeStackTrace
 558 |    */
 559 | 
 560 | 
 561 |   function computeStackTraceFromOperaMultiLineMessage(ex) {
 562 |     // TODO: Clean this function up
 563 |     // Opera includes a stack trace into the exception message. An example is:
 564 |     //
 565 |     // Statement on line 3: Undefined variable: undefinedFunc
 566 |     // Backtrace:
 567 |     //   Line 3 of linked script file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.js: In function zzz
 568 |     //         undefinedFunc(a);
 569 |     //   Line 7 of inline#1 script in file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.html: In function yyy
 570 |     //           zzz(x, y, z);
 571 |     //   Line 3 of inline#1 script in file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.html: In function xxx
 572 |     //           yyy(a, a, a);
 573 |     //   Line 1 of function script
 574 |     //     try { xxx('hi'); return false; } catch(ex) { ErrorWatch.report(ex); }
 575 |     //   ...
 576 |     var lines = ex.message.split('\n');
 577 | 
 578 |     if (lines.length < 4) {
 579 |       return null;
 580 |     }
 581 | 
 582 |     var lineRE1 = /^\s*Line (\d+) of linked script ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,
 583 |         lineRE2 = /^\s*Line (\d+) of inline#(\d+) script in ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,
 584 |         lineRE3 = /^\s*Line (\d+) of function script\s*$/i,
 585 |         stack = [],
 586 |         scripts = window && window.document && window.document.getElementsByTagName('script');
 587 |     var inlineScriptBlocks = [],
 588 |         parts;
 589 | 
 590 |     for (var s in scripts) {
 591 |       if (_has(scripts, s) && !scripts[s].src) {
 592 |         inlineScriptBlocks.push(scripts[s]);
 593 |       }
 594 |     }
 595 | 
 596 |     for (var line = 2; line < lines.length; line += 2) {
 597 |       var item = null;
 598 | 
 599 |       if (parts = lineRE1.exec(lines[line])) {
 600 |         item = {
 601 |           'url': parts[2],
 602 |           'func': parts[3],
 603 |           'args': [],
 604 |           'line': +parts[1],
 605 |           'column': null
 606 |         };
 607 |       } else if (parts = lineRE2.exec(lines[line])) {
 608 |         item = {
 609 |           'url': parts[3],
 610 |           'func': parts[4],
 611 |           'args': [],
 612 |           'line': +parts[1],
 613 |           'column': null // TODO: Check to see if inline#1 (+parts[2]) points to the script number or column number.
 614 | 
 615 |         };
 616 |         var relativeLine = +parts[1]; // relative to the start of the <SCRIPT> block
 617 | 
 618 |         var script = inlineScriptBlocks[parts[2] - 1];
 619 | 
 620 |         if (script) {
 621 |           var source = getSource(item.url);
 622 | 
 623 |           if (source) {
 624 |             source = source.join('\n');
 625 |             var pos = source.indexOf(script.innerText);
 626 | 
 627 |             if (pos >= 0) {
 628 |               item.line = relativeLine + source.substring(0, pos).split('\n').length;
 629 |             }
 630 |           }
 631 |         }
 632 |       } else if (parts = lineRE3.exec(lines[line])) {
 633 |         var url = window.location.href.replace(/#.*$/, '');
 634 |         var re = new RegExp(escapeCodeAsRegExpForMatchingInsideHTML(lines[line + 1]));
 635 |         var src = findSourceInUrls(re, [url]);
 636 |         item = {
 637 |           'url': url,
 638 |           'func': '',
 639 |           'args': [],
 640 |           'line': src ? src.line : parts[1],
 641 |           'column': null
 642 |         };
 643 |       }
 644 | 
 645 |       if (item) {
 646 |         if (!item.func) {
 647 |           item.func = guessFunctionName(item.url, item.line);
 648 |         }
 649 | 
 650 |         var context = gatherContext(item.url, item.line);
 651 |         var midline = context ? context[Math.floor(context.length / 2)] : null;
 652 | 
 653 |         if (context && midline.replace(/^\s*/, '') === lines[line + 1].replace(/^\s*/, '')) {
 654 |           item.context = context;
 655 |         } else {
 656 |           // if (context) alert("Context mismatch. Correct midline:\n" + lines[i+1] + "\n\nMidline:\n" + midline + "\n\nContext:\n" + context.join("\n") + "\n\nURL:\n" + item.url);
 657 |           item.context = [lines[line + 1]];
 658 |         }
 659 | 
 660 |         stack.push(item);
 661 |       }
 662 |     }
 663 | 
 664 |     if (!stack.length) {
 665 |       return null; // could not parse multiline exception message as Opera stack trace
 666 |     }
 667 | 
 668 |     return {
 669 |       'mode': 'multiline',
 670 |       'name': ex.name,
 671 |       'message': lines[0],
 672 |       'stack': stack
 673 |     };
 674 |   }
 675 |   /**
 676 |    * Adds information about the first frame to incomplete stack traces.
 677 |    * Safari and IE require this to get complete data on the first frame.
 678 |    * @param {ErrorWatch.StackTrace} stackInfo Stack trace information from
 679 |    * one of the compute* methods.
 680 |    * @param {string} url The URL of the script that caused an error.
 681 |    * @param {(number|string)} lineNo The line number of the script that
 682 |    * caused an error.
 683 |    * @param {string=} message The error generated by the browser, which
 684 |    * hopefully contains the name of the object that caused the error.
 685 |    * @return {boolean} Whether or not the stack information was
 686 |    * augmented.
 687 |    * @memberof ErrorWatch.computeStackTrace
 688 |    */
 689 | 
 690 | 
 691 |   function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {
 692 |     var initial = {
 693 |       'url': url,
 694 |       'line': lineNo
 695 |     };
 696 | 
 697 |     if (initial.url && initial.line) {
 698 |       stackInfo.incomplete = false;
 699 | 
 700 |       if (!initial.func) {
 701 |         initial.func = guessFunctionName(initial.url, initial.line);
 702 |       }
 703 | 
 704 |       if (!initial.context) {
 705 |         initial.context = gatherContext(initial.url, initial.line);
 706 |       }
 707 | 
 708 |       var reference = / '([^']+)' /.exec(message);
 709 | 
 710 |       if (reference) {
 711 |         initial.column = findSourceInLine(reference[1], initial.url, initial.line);
 712 |       }
 713 | 
 714 |       if (stackInfo.stack.length > 0) {
 715 |         if (stackInfo.stack[0].url === initial.url) {
 716 |           if (stackInfo.stack[0].line === initial.line) {
 717 |             return false; // already in stack trace
 718 |           } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {
 719 |             stackInfo.stack[0].line = initial.line;
 720 |             stackInfo.stack[0].context = initial.context;
 721 |             return false;
 722 |           }
 723 |         }
 724 |       }
 725 | 
 726 |       stackInfo.stack.unshift(initial);
 727 |       stackInfo.partial = true;
 728 |       return true;
 729 |     } else {
 730 |       stackInfo.incomplete = true;
 731 |     }
 732 | 
 733 |     return false;
 734 |   }
 735 |   /**
 736 |    * Computes stack trace information by walking the arguments.caller
 737 |    * chain at the time the exception occurred. This will cause earlier
 738 |    * frames to be missed but is the only way to get any stack trace in
 739 |    * Safari and IE. The top frame is restored by
 740 |    * {@link augmentStackTraceWithInitialElement}.
 741 |    * @param {Error} ex
 742 |    * @return {ErrorWatch.StackTrace=} Stack trace information.
 743 |    * @memberof ErrorWatch.computeStackTrace
 744 |    */
 745 | 
 746 | 
 747 |   function computeStackTraceByWalkingCallerChain(ex, depth) {
 748 |     var functionName = /function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i;
 749 |     var stack = [],
 750 |         funcs = {},
 751 |         recursion = false,
 752 |         parts,
 753 |         item,
 754 |         source;
 755 | 
 756 |     for (var curr = computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {
 757 |       if (curr === computeStackTrace || curr && curr.__name__ === reportFuncName) {
 758 |         // curr ===  report 避免循环依赖
 759 |         continue;
 760 |       }
 761 | 
 762 |       item = {
 763 |         'url': null,
 764 |         'func': UNKNOWN_FUNCTION,
 765 |         'args': [],
 766 |         'line': null,
 767 |         'column': null
 768 |       };
 769 | 
 770 |       if (curr.name) {
 771 |         item.func = curr.name;
 772 |       } else if (parts = functionName.exec(curr.toString())) {
 773 |         item.func = parts[1];
 774 |       }
 775 | 
 776 |       if (typeof item.func === 'undefined') {
 777 |         try {
 778 |           item.func = parts.input.substring(0, parts.input.indexOf('{'));
 779 |         } catch (e) {}
 780 |       }
 781 | 
 782 |       if (source = findSourceByFunctionBody(curr)) {
 783 |         item.url = source.url;
 784 |         item.line = source.line;
 785 | 
 786 |         if (item.func === UNKNOWN_FUNCTION) {
 787 |           item.func = guessFunctionName(item.url, item.line);
 788 |         }
 789 | 
 790 |         var reference = / '([^']+)' /.exec(ex.message || ex.description);
 791 | 
 792 |         if (reference) {
 793 |           item.column = findSourceInLine(reference[1], source.url, source.line);
 794 |         }
 795 |       }
 796 | 
 797 |       if (funcs['' + curr]) {
 798 |         recursion = true;
 799 |       } else {
 800 |         funcs['' + curr] = true;
 801 |       }
 802 | 
 803 |       stack.push(item);
 804 |     }
 805 | 
 806 |     if (depth) {
 807 |       stack.splice(0, depth);
 808 |     }
 809 | 
 810 |     var result = {
 811 |       'mode': 'callers',
 812 |       'name': ex.name,
 813 |       'message': ex.message,
 814 |       'stack': stack
 815 |     };
 816 |     augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);
 817 |     return result;
 818 |   }
 819 |   /**
 820 |    * Computes a stack trace for an exception.
 821 |    * @param {Error} ex
 822 |    * @param {(string|number)=} depth
 823 |    * @memberof ErrorWatch.computeStackTrace
 824 |    */
 825 | 
 826 | 
 827 |   function computeStackTrace(ex, depth) {
 828 |     var stack = null;
 829 |     depth = depth == null ? 0 : +depth;
 830 | 
 831 |     try {
 832 |       // This must be tried first because Opera 10 *destroys*
 833 |       // its stacktrace property if you try to access the stack
 834 |       // property first!!
 835 |       stack = computeStackTraceFromStacktraceProp(ex);
 836 | 
 837 |       if (stack) {
 838 |         return stack;
 839 |       }
 840 |     } catch (e) {
 841 |     }
 842 | 
 843 |     try {
 844 |       stack = computeStackTraceFromStackProp(ex);
 845 | 
 846 |       if (stack) {
 847 |         return stack;
 848 |       }
 849 |     } catch (e) {
 850 |     }
 851 | 
 852 |     try {
 853 |       stack = computeStackTraceFromOperaMultiLineMessage(ex);
 854 | 
 855 |       if (stack) {
 856 |         return stack;
 857 |       }
 858 |     } catch (e) {
 859 |     }
 860 | 
 861 |     try {
 862 |       stack = computeStackTraceByWalkingCallerChain(ex, depth + 1);
 863 | 
 864 |       if (stack) {
 865 |         return stack;
 866 |       }
 867 |     } catch (e) {
 868 |     }
 869 | 
 870 |     return {
 871 |       'name': ex.name,
 872 |       'message': ex.message,
 873 |       'mode': 'failed'
 874 |     };
 875 |   }
 876 |   /**
 877 |    * Logs a stacktrace starting from the previous call and working down.
 878 |    * @param {(number|string)=} depth How many frames deep to trace.
 879 |    * @return {ErrorWatch.StackTrace} Stack trace information.
 880 |    * @memberof ErrorWatch.computeStackTrace
 881 |    */
 882 | 
 883 | 
 884 |   function computeStackTraceOfCaller(depth) {
 885 |     depth = (depth == null ? 0 : +depth) + 1; // "+ 1" because "ofCaller" should drop one frame
 886 | 
 887 |     try {
 888 |       throw new Error();
 889 |     } catch (ex) {
 890 |       return computeStackTrace(ex, depth + 1);
 891 |     }
 892 |   }
 893 | 
 894 |   computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement;
 895 |   computeStackTrace.computeStackTraceFromStackProp = computeStackTraceFromStackProp;
 896 |   computeStackTrace.guessFunctionName = guessFunctionName;
 897 |   computeStackTrace.gatherContext = gatherContext;
 898 |   computeStackTrace.ofCaller = computeStackTraceOfCaller;
 899 |   computeStackTrace.getSource = getSource;
 900 | 
 901 |   var isRegisterListener = false;
 902 |   var _handler = null;
 903 |   /**
 904 |    * 资源加载错误上报
 905 |    * @param handler
 906 |    */
 907 | 
 908 |   function installResourceLoadError(handler) {
 909 |     if (!isRegisterListener && collectSourceErrors) {
 910 |       _handler = handler;
 911 |       window.addEventListener && window.addEventListener('error', function (e) {
 912 |         try {
 913 |           if (e.target !== window) {
 914 |             // 避免重复上报
 915 |             var stack = {
 916 |               message: "".concat(e.target.localName, " is load error"),
 917 |               mode: 'resource',
 918 |               name: e.target.src || e.target.href || e.target.currentSrc,
 919 |               stack: null
 920 |             };
 921 |             handler(stack, true, e);
 922 |           }
 923 |         } catch (e) {
 924 |           throw e;
 925 |         }
 926 |       }, true);
 927 |     }
 928 | 
 929 |     isRegisterListener = true;
 930 |   }
 931 |   /**
 932 |    * 移除资源错误加载监听
 933 |    */
 934 | 
 935 |   function uninstallResourceLoadError() {
 936 |     if (isRegisterListener && collectSourceErrors && _handler) {
 937 |       window.removeEventListener && window.removeEventListener('error', _handler);
 938 |       _handler = null;
 939 |       isRegisterListener = false;
 940 |     }
 941 |   }
 942 | 
 943 |   /**
 944 |    * Cross-browser processing of unhandled exceptions
 945 |    *
 946 |    * Syntax:
 947 |    * ```js
 948 |    *   ErrorWatch.report.subscribe(function(stackInfo) { ... })
 949 |    *   ErrorWatch.report.unsubscribe(function(stackInfo) { ... })
 950 |    *   ErrorWatch.report(exception)
 951 |    *   try { ...code... } catch(ex) { ErrorWatch.report(ex); }
 952 |    * ```
 953 |    *
 954 |    * Supports:
 955 |    *   - Firefox: full stack trace with line numbers, plus column number
 956 |    *     on top frame; column number is not guaranteed
 957 |    *   - Opera: full stack trace with line and column numbers
 958 |    *   - Chrome: full stack trace with line and column numbers
 959 |    *   - Safari: line and column number for the top frame only; some frames
 960 |    *     may be missing, and column number is not guaranteed
 961 |    *   - IE: line and column number for the top frame only; some frames
 962 |    *     may be missing, and column number is not guaranteed
 963 |    *
 964 |    * In theory, ErrorWatch should work on all of the following versions:
 965 |    *   - IE5.5+ (only 8.0 tested)
 966 |    *   - Firefox 0.9+ (only 3.5+ tested)
 967 |    *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
 968 |    *     Exceptions Have Stacktrace to be enabled in opera:config)
 969 |    *   - Safari 3+ (only 4+ tested)
 970 |    *   - Chrome 1+ (only 5+ tested)
 971 |    *   - Konqueror 3.5+ (untested)
 972 |    *
 973 |    * Requires ErrorWatch.computeStackTrace.
 974 |    *
 975 |    * Tries to catch all unhandled exceptions and report them to the
 976 |    * subscribed handlers. Please note that ErrorWatch.report will rethrow the
 977 |    * exception. This is REQUIRED in order to get a useful stack trace in IE.
 978 |    * If the exception does not reach the top of the browser, you will only
 979 |    * get a stack trace from the point where ErrorWatch.report was called.
 980 |    *
 981 |    * Handlers receive a ErrorWatch.StackTrace object as described in the
 982 |    * ErrorWatch.computeStackTrace docs.
 983 |    *
 984 |    * @memberof ErrorWatch
 985 |    * @namespace
 986 |    */
 987 | 
 988 |   var ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;
 989 |   var handlers = [],
 990 |       lastException = null,
 991 |       lastExceptionStack = null;
 992 |   /**
 993 |    * Add a crash handler.
 994 |    * @param {Function} handler
 995 |    * @memberof ErrorWatch.report
 996 |    */
 997 | 
 998 |   function subscribe(handler) {
 999 |     installGlobalHandler();
1000 |     installGlobalUnhandledRejectionHandler();
1001 |     handlers.push(handler);
1002 |   }
1003 |   /**
1004 |    * Remove a crash handler.
1005 |    * @param {Function} handler
1006 |    * @memberof ErrorWatch.report
1007 |    */
1008 | 
1009 | 
1010 |   function unsubscribe(handler) {
1011 |     for (var i = handlers.length - 1; i >= 0; --i) {
1012 |       if (handlers[i] === handler) {
1013 |         handlers.splice(i, 1);
1014 |       }
1015 |     }
1016 | 
1017 |     if (handlers.length === 0) {
1018 |       uninstallGlobalHandler();
1019 |       uninstallGlobalUnhandledRejectionHandler();
1020 |     }
1021 |   }
1022 |   /**
1023 |    * Dispatch stack information to all handlers.
1024 |    * @param {ErrorWatch.StackTrace} stack
1025 |    * @param {boolean} isWindowError Is this a top-level window error?
1026 |    * @param {Error=} error The error that's being handled (if available, null otherwise)
1027 |    * @memberof ErrorWatch.report
1028 |    * @throws An exception if an error occurs while calling an handler.
1029 |    */
1030 | 
1031 | 
1032 |   function notifyHandlers(stack, isWindowError, error) {
1033 |     var exception = null;
1034 | 
1035 |     if (isWindowError && !collectWindowErrors) {
1036 |       return;
1037 |     }
1038 | 
1039 |     for (var i in handlers) {
1040 |       if (_has(handlers, i)) {
1041 |         try {
1042 |           handlers[i](stack, isWindowError, error);
1043 |         } catch (inner) {
1044 |           exception = inner;
1045 |         }
1046 |       }
1047 |     }
1048 | 
1049 |     if (exception) {
1050 |       throw exception;
1051 |     }
1052 |   }
1053 | 
1054 |   var _oldOnerrorHandler, _onErrorHandlerInstalled;
1055 | 
1056 |   var _oldOnunhandledrejectionHandler, _onUnhandledRejectionHandlerInstalled;
1057 |   /**
1058 |    * Ensures all global unhandled exceptions are recorded.
1059 |    * Supported by Gecko and IE.
1060 |    * @param {string} message Error message.
1061 |    * @param {string} url URL of script that generated the exception.
1062 |    * @param {(number|string)} lineNo The line number at which the error occurred.
1063 |    * @param {(number|string)=} columnNo The column number at which the error occurred.
1064 |    * @param {Error=} errorObj The actual Error object.
1065 |    * @memberof ErrorWatch.report
1066 |    */
1067 | 
1068 | 
1069 |   function errorWatchWindowOnError(message, url, lineNo, columnNo, errorObj) {
1070 |     var stack = null;
1071 | 
1072 |     if (lastExceptionStack) {
1073 |       computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);
1074 |       processLastException();
1075 |     } else if (errorObj) {
1076 |       stack = computeStackTrace(errorObj);
1077 |       notifyHandlers(stack, true, errorObj);
1078 |     } else {
1079 |       var location = {
1080 |         'url': url,
1081 |         'line': lineNo,
1082 |         'column': columnNo
1083 |       };
1084 |       var name;
1085 |       var msg = message; // must be new var or will modify original `arguments`
1086 | 
1087 |       if ({}.toString.call(message) === '[object String]') {
1088 |         var groups = message.match(ERROR_TYPES_RE);
1089 | 
1090 |         if (groups) {
1091 |           name = groups[1];
1092 |           msg = groups[2];
1093 |         }
1094 |       }
1095 | 
1096 |       location.func = computeStackTrace.guessFunctionName(location.url, location.line);
1097 |       location.context = computeStackTrace.gatherContext(location.url, location.line);
1098 |       stack = {
1099 |         'name': name,
1100 |         'message': msg,
1101 |         'mode': 'onerror',
1102 |         'stack': [location]
1103 |       };
1104 |       notifyHandlers(stack, true, null);
1105 |     }
1106 | 
1107 |     if (_oldOnerrorHandler) {
1108 |       return _oldOnerrorHandler.apply(this, arguments);
1109 |     }
1110 | 
1111 |     return false;
1112 |   }
1113 |   /**
1114 |    * Ensures all unhandled rejections are recorded.
1115 |    * @param {PromiseRejectionEvent} e event.
1116 |    * @memberof ErrorWatch.report
1117 |    * @see https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onunhandledrejection
1118 |    * @see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
1119 |    */
1120 | 
1121 | 
1122 |   function errorWatchWindowOnUnhandledRejection(e) {
1123 |     var stack = computeStackTrace(e.reason);
1124 |     notifyHandlers(stack, true, e.reason);
1125 |   }
1126 |   /**
1127 |    * Install a global onerror handler
1128 |    * @memberof ErrorWatch.report
1129 |    */
1130 | 
1131 | 
1132 |   function installGlobalHandler() {
1133 |     if (_onErrorHandlerInstalled === true) {
1134 |       return;
1135 |     }
1136 | 
1137 |     _oldOnerrorHandler = window.onerror;
1138 |     window.onerror = errorWatchWindowOnError;
1139 |     installResourceLoadError(function handleResourceError(stack, isWindowError, error) {
1140 |       notifyHandlers(stack, isWindowError, error);
1141 |     });
1142 |     _onErrorHandlerInstalled = true;
1143 |   }
1144 |   /**
1145 |    * Uninstall the global onerror handler
1146 |    * @memberof ErrorWatch.report
1147 |    */
1148 | 
1149 | 
1150 |   function uninstallGlobalHandler() {
1151 |     if (_onErrorHandlerInstalled) {
1152 |       window.onerror = _oldOnerrorHandler;
1153 |       uninstallResourceLoadError();
1154 |       _onErrorHandlerInstalled = false;
1155 |     }
1156 |   }
1157 |   /**
1158 |    * Install a global onunhandledrejection handler
1159 |    * @memberof ErrorWatch.report
1160 |    */
1161 | 
1162 | 
1163 |   function installGlobalUnhandledRejectionHandler() {
1164 |     if (_onUnhandledRejectionHandlerInstalled === true) {
1165 |       return;
1166 |     }
1167 | 
1168 |     _oldOnunhandledrejectionHandler = window.onunhandledrejection;
1169 |     window.onunhandledrejection = errorWatchWindowOnUnhandledRejection;
1170 |     _onUnhandledRejectionHandlerInstalled = true;
1171 |   }
1172 |   /**
1173 |    * Uninstall the global onunhandledrejection handler
1174 |    * @memberof ErrorWatch.report
1175 |    */
1176 | 
1177 | 
1178 |   function uninstallGlobalUnhandledRejectionHandler() {
1179 |     if (_onUnhandledRejectionHandlerInstalled) {
1180 |       window.onunhandledrejection = _oldOnunhandledrejectionHandler;
1181 |       _onUnhandledRejectionHandlerInstalled = false;
1182 |     }
1183 |   }
1184 |   /**
1185 |    * Process the most recent exception
1186 |    * @memberof ErrorWatch.report
1187 |    */
1188 | 
1189 | 
1190 |   function processLastException() {
1191 |     var _lastExceptionStack = lastExceptionStack,
1192 |         _lastException = lastException;
1193 |     lastExceptionStack = null;
1194 |     lastException = null;
1195 |     notifyHandlers(_lastExceptionStack, false, _lastException);
1196 |   }
1197 |   /**
1198 |    * Reports an unhandled Error to ErrorWatch.
1199 |    * @param {Error} ex
1200 |    * @memberof ErrorWatch.report
1201 |    * @throws An exception if an incomplete stack trace is detected (old IE browsers).
1202 |    */
1203 | 
1204 | 
1205 |   function report(ex) {
1206 |     if (lastExceptionStack) {
1207 |       if (lastException === ex) {
1208 |         return; // already caught by an inner catch block, ignore
1209 |       } else {
1210 |         processLastException();
1211 |       }
1212 |     }
1213 | 
1214 |     var stack = computeStackTrace(ex);
1215 |     lastExceptionStack = stack;
1216 |     lastException = ex; // If the stack trace is incomplete, wait for 2 seconds for
1217 |     // slow slow IE to see if onerror occurs or not before reporting
1218 |     // this exception; otherwise, we will end up with an incomplete
1219 |     // stack trace
1220 | 
1221 |     setTimeout(function () {
1222 |       if (lastException === ex) {
1223 |         processLastException();
1224 |       }
1225 |     }, stack.incomplete ? 2000 : 0);
1226 |     throw ex; // re-throw to propagate to the top level (and cause window.onerror)
1227 |   }
1228 | 
1229 |   report.subscribe = subscribe;
1230 |   report.unsubscribe = unsubscribe;
1231 |   report.__name__ = reportFuncName;
1232 | 
1233 |   /**
1234 |    * Wrap any function in a ErrorWatch reporter<br/>
1235 |    * Example: `func = ErrorWatch.wrap(func);`
1236 |    *
1237 |    * @param {Function} func Function to be wrapped
1238 |    * @return {Function} The wrapped func
1239 |    * @memberof ErrorWatch
1240 |    */
1241 | 
1242 |   function wrap(func) {
1243 |     function wrapped() {
1244 |       try {
1245 |         return func.apply(this, arguments);
1246 |       } catch (e) {
1247 |         report(e);
1248 |         throw e;
1249 |       }
1250 |     }
1251 | 
1252 |     return wrapped;
1253 |   }
1254 | 
1255 |   var _slice = [].slice;
1256 |   /**
1257 |    * Extends support for global error handling for asynchronous browser
1258 |    * functions. Adopted from Closure Library's errorhandler.js
1259 |    * @memberof ErrorWatch
1260 |    */
1261 | 
1262 |   function _helper(fnName) {
1263 |     var originalFn = window[fnName];
1264 | 
1265 |     window[fnName] = function errorWatchAsyncExtension() {
1266 |       // Make a copy of the arguments
1267 |       var args = _slice.call(arguments);
1268 | 
1269 |       var originalCallback = args[0];
1270 | 
1271 |       if (typeof originalCallback === 'function') {
1272 |         args[0] = wrap(originalCallback);
1273 |       } // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it
1274 |       // also only supports 2 argument and doesn't care what "this" is, so we
1275 |       // can just call the original function directly.
1276 | 
1277 | 
1278 |       if (originalFn.apply) {
1279 |         return originalFn.apply(this, args);
1280 |       } else {
1281 |         return originalFn(args[0], args[1]);
1282 |       }
1283 |     };
1284 |   }
1285 | 
1286 |   function extendToAsynchronousCallbacks() {
1287 |     _helper('setTimeout');
1288 | 
1289 |     _helper('setInterval');
1290 |   }
1291 | 
1292 |   var _oldErrorWatch = window.ErrorWatch;
1293 |   var ErrorWatch;
1294 |   /**
1295 |    * Export ErrorWatch out to another variable<br/>
1296 |    * Example: `var TK = ErrorWatch.noConflict()`
1297 |    * @return {Object} The ErrorWatch object
1298 |    * @memberof ErrorWatch
1299 |    */
1300 | 
1301 |   function noConflict() {
1302 |     window.ErrorWatch = _oldErrorWatch;
1303 |     return ErrorWatch;
1304 |   }
1305 | 
1306 |   function makeError() {
1307 |     var tmp = thisIsAbug;
1308 |     return tmp + '';
1309 |   }
1310 | 
1311 |   ErrorWatch = {
1312 |     noConflict: noConflict,
1313 |     report: report,
1314 |     computeStackTrace: computeStackTrace,
1315 |     wrap: wrap,
1316 |     extendToAsynchronousCallbacks: extendToAsynchronousCallbacks,
1317 |     makeError: makeError
1318 |   };
1319 |   var ErrorWatch$1 = ErrorWatch;
1320 | 
1321 |   return ErrorWatch$1;
1322 | 
1323 | })));
1324 | 


--------------------------------------------------------------------------------
/dist/errorWatch.min.js:
--------------------------------------------------------------------------------
1 | !function(n,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(n=n||self).ErrorWatch=e()}(this,function(){"use strict";var i=!0,r=!0,a=11,m="ErrorWatch.report";function b(n,e){return Object.prototype.hasOwnProperty.call(n,e)}function g(n){return void 0===n}var h="?",l={};function k(n){if("string"!=typeof n)return[];if(!b(l,n)){var e="",t="";try{t=window.document.domain}catch(n){}var r=/(.*)\:\/\/([^:\/]+)([:\d]*)\/{0,1}([\s\S]*)/.exec(n);r&&r[2]===t&&(e=""),l[n]=e?e.split("\n"):[]}return l[n]}function y(n,e){var t,r=/function ([^(]*)\(([^)]*)\)/,l=/['"]?([0-9A-Za-z$_]+)['"]?\s*[:=]\s*(function|eval|new Function)/,i=k(n),u="";if(!i.length)return h;for(var c=0;c<10;++c)if(!g(u=i[e-c]+u)){if(t=l.exec(u))return t[1];if(t=r.exec(u))return t[1]}return h}function S(n,e){var t=k(n);if(!t.length)return null;var r=[],l=Math.floor(a/2),i=l+a%2,u=Math.max(0,e-l-1),c=Math.min(t.length,e+i-1);--e;for(var o=u;o<c;++o)g(t[o])||r.push(t[o]);return 0<r.length?r:null}function d(n){return n.replace(/[\-\[\]{}()*+?.,\\\^$|#]/g,"\\$&")}function E(n){return d(n).replace("<","(?:<|&lt;)").replace(">","(?:>|&gt;)").replace("&","(?:&|&amp;)").replace('"','(?:"|&quot;)').replace(/\s+/g,"\\s+")}function $(n,e){for(var t,r,l=0,i=e.length;l<i;++l)if((t=k(e[l])).length&&(t=t.join("\n"),r=n.exec(t)))return{url:e[l],line:t.substring(0,r.index).split("\n").length,column:r.index-t.lastIndexOf("\n",r.index)-1};return null}function w(n,e,t){var r,l=k(e),i=new RegExp("\\b"+d(n)+"\\b");return--t,l&&l.length>t&&(r=i.exec(l[t]))?r.index:null}function u(n){if(!n.stack)return null;for(var e,t,r,l=/^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,i=/^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i,u=/^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i,c=/(\S+) line (\d+)(?: > eval line \d+)* > eval/i,o=/\((\S*)(?::(\d+))(?::(\d+))\)/,a=n.stack.split("\n"),s=/^(.*) is undefined$/.exec(n.message),f=[],m=0,d=a.length;m<d;++m){if(t=l.exec(a[m])){var p=t[2]&&0===t[2].indexOf("native");t[2]&&0===t[2].indexOf("eval")&&(e=o.exec(t[2]))&&(t[2]=e[1],t[3]=e[2],t[4]=e[3]),r={url:p?null:t[2],func:t[1]||h,args:p?[t[2]]:[],line:t[3]?+t[3]:null,column:t[4]?+t[4]:null}}else if(t=u.exec(a[m]))r={url:t[2],func:t[1]||h,args:[],line:+t[3],column:t[4]?+t[4]:null};else{if(!(t=i.exec(a[m])))continue;t[3]&&-1<t[3].indexOf(" > eval")&&(e=c.exec(t[3]))?(t[3]=e[1],t[4]=e[2],t[5]=null):0!==m||t[5]||g(n.columnNumber)||(f[0].column=n.columnNumber+1),r={url:t[3],func:t[1]||h,args:t[2]?t[2].split(","):[],line:t[4]?+t[4]:null,column:t[5]?+t[5]:null}}!r.func&&r.line&&(r.func=y(r.url,r.line)),r.context=r.line?S(r.url,r.line):null,f.push(r)}return f.length?(f[0]&&f[0].line&&!f[0].column&&s&&(f[0].column=w(s[1],f[0].url,f[0].line)),{mode:"stack",name:n.name,message:n.message,stack:f}):null}function p(n,e,t,r){var l={url:e,line:t};if(l.url&&l.line){n.incomplete=!1,l.func||(l.func=y(l.url,l.line)),l.context||(l.context=S(l.url,l.line));var i=/ '([^']+)' /.exec(r);if(i&&(l.column=w(i[1],l.url,l.line)),0<n.stack.length&&n.stack[0].url===l.url){if(n.stack[0].line===l.line)return!1;if(!n.stack[0].line&&n.stack[0].func===l.func)return n.stack[0].line=l.line,n.stack[0].context=l.context,!1}return n.stack.unshift(l),n.partial=!0}return!(n.incomplete=!0)}function v(n,e){for(var t,r,l,i,u=/function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i,c=[],o={},a=!1,s=v.caller;s&&!a;s=s.caller)if(!(s===x||s&&s.__name__===m)){if(r={url:null,func:h,args:[],line:null,column:null},s.name?r.func=s.name:(t=u.exec(s.toString()))&&(r.func=t[1]),void 0===r.func)try{r.func=t.input.substring(0,t.input.indexOf("{"))}catch(n){}(l=function(n){if(g(window&&window.document))return null;for(var e,t,r,l,i,u=[window.location.href],c=window.document.getElementsByTagName("script"),o=""+n,a=0;a<c.length;++a){var s=c[a];s.src&&u.push(s.src)}if(t=$((e=/^function(?:\s+([\w$]+))?\s*\(([\w\s,]*)\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/.exec(o))?(r=e[1]?"\\s+"+e[1]:"",l=e[2].split(",").join("\\s*,\\s*"),i=d(e[3]).replace(/;$/,";?"),new RegExp("function"+r+"\\s*\\(\\s*"+l+"\\s*\\)\\s*{\\s*"+i+"\\s*}")):new RegExp(d(o).replace(/\s+/g,"\\s+")),u))return t;if(e=/^function on([\w$]+)\s*\(event\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/.exec(o)){var f=e[1];if(i=E(e[2]),t=$(new RegExp("on"+f+"=[\\'\"]\\s*"+i+"\\s*[\\'\"]","i"),u[0]))return t;if(t=$(new RegExp(i),u))return t}return null}(s))&&(r.url=l.url,r.line=l.line,r.func===h&&(r.func=y(r.url,r.line)),(i=/ '([^']+)' /.exec(n.message||n.description))&&(r.column=w(i[1],l.url,l.line))),o[""+s]?a=!0:o[""+s]=!0,c.push(r)}e&&c.splice(0,e);var f={mode:"callers",name:n.name,message:n.message,stack:c};return p(f,n.sourceURL||n.fileName,n.line||n.lineNumber,n.message||n.description),f}function x(n,e){var t=null;e=null==e?0:+e;try{if(t=function(n){var e=n.stacktrace;if(e){for(var t,r=/ line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i,l=/ line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^\)]+))\((.*)\))? in (.*):\s*$/i,i=e.split("\n"),u=[],c=0;c<i.length;c+=2){var o=null;if((t=r.exec(i[c]))?o={url:t[2],line:+t[1],column:null,func:t[3],args:[]}:(t=l.exec(i[c]))&&(o={url:t[6],line:+t[1],column:+t[2],func:t[3]||t[4],args:t[5]?t[5].split(","):[]}),o){if(!o.func&&o.line&&(o.func=y(o.url,o.line)),o.line)try{o.context=S(o.url,o.line)}catch(n){}o.context||(o.context=[i[c+1]]),u.push(o)}}return u.length?{mode:"stacktrace",name:n.name,message:n.message,stack:u}:null}}(n))return t}catch(n){}try{if(t=u(n))return t}catch(n){}try{if(t=function(n){var e=n.message.split("\n");if(e.length<4)return null;var t,r=/^\s*Line (\d+) of linked script ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,l=/^\s*Line (\d+) of inline#(\d+) script in ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,i=/^\s*Line (\d+) of function script\s*$/i,u=[],c=window&&window.document&&window.document.getElementsByTagName("script"),o=[];for(var a in c)b(c,a)&&!c[a].src&&o.push(c[a]);for(var s=2;s<e.length;s+=2){var f,m,d,p,g,h,w,v,x=null;(t=r.exec(e[s]))?x={url:t[2],func:t[3],args:[],line:+t[1],column:null}:(t=l.exec(e[s]))?(x={url:t[3],func:t[4],args:[],line:+t[1],column:null},f=+t[1],(m=o[t[2]-1])&&(!(d=k(x.url))||0<=(p=(d=d.join("\n")).indexOf(m.innerText))&&(x.line=f+d.substring(0,p).split("\n").length))):(t=i.exec(e[s]))&&(x={url:g=window.location.href.replace(/#.*$/,""),func:"",args:[],line:(h=$(new RegExp(E(e[s+1])),[g]))?h.line:t[1],column:null}),x&&(x.func||(x.func=y(x.url,x.line)),v=(w=S(x.url,x.line))?w[Math.floor(w.length/2)]:null,w&&v.replace(/^\s*/,"")===e[s+1].replace(/^\s*/,"")?x.context=w:x.context=[e[s+1]],u.push(x))}return u.length?{mode:"multiline",name:n.name,message:e[0],stack:u}:null}(n))return t}catch(n){}try{if(t=v(n,e+1))return t}catch(n){}return{name:n.name,message:n.message,mode:"failed"}}x.augmentStackTraceWithInitialElement=p,x.computeStackTraceFromStackProp=u,x.guessFunctionName=y,x.gatherContext=S,x.ofCaller=function(e){e=1+(null==e?0:+e);try{throw new Error}catch(n){return x(n,e+1)}},x.getSource=k;var c=!1,o=null;var s,t,f,F,j=/^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/,T=[],_=null,R=null;function N(n,e,t){var r=null;if(!e||i){for(var l in T)if(b(T,l))try{T[l](n,e,t)}catch(n){r=n}if(r)throw r}}function e(n,e,t,r,l){var i,u,c,o;return R?(x.augmentStackTraceWithInitialElement(R,e,t,n),O()):l?N(x(l),!0,l):(i={url:e,line:t,column:r},c=n,"[object String]"!=={}.toString.call(n)||(o=n.match(j))&&(u=o[1],c=o[2]),i.func=x.guessFunctionName(i.url,i.line),i.context=x.gatherContext(i.url,i.line),N({name:u,message:c,mode:"onerror",stack:[i]},!0,null)),!!s&&s.apply(this,arguments)}function L(n){N(x(n.reason),!0,n.reason)}function O(){var n=R,e=_;_=R=null,N(n,!1,e)}function A(n){if(R){if(_===n)return;O()}var e=x(n);throw R=e,_=n,setTimeout(function(){_===n&&O()},e.incomplete?2e3:0),n}function I(n){return function(){try{return n.apply(this,arguments)}catch(n){throw A(n),n}}}A.subscribe=function(n){!function(){if(!0===t)return;s=window.onerror,window.onerror=e,function(t){!c&&r&&(o=t,window.addEventListener&&window.addEventListener("error",function(n){try{var e;n.target!==window&&(e={message:"".concat(n.target.localName," is load error"),mode:"resource",name:n.target.src||n.target.href||n.target.currentSrc,stack:null},t(e,!0,n))}catch(n){throw n}},!0)),c=!0}(function(n,e,t){N(n,e,t)}),t=!0}(),function(){if(!0===F)return;f=window.onunhandledrejection,window.onunhandledrejection=L,F=!0}(),T.push(n)},A.unsubscribe=function(n){for(var e=T.length-1;0<=e;--e)T[e]===n&&T.splice(e,1);0===T.length&&(t&&(window.onerror=s,c&&r&&o&&(window.removeEventListener&&window.removeEventListener("error",o),o=null,c=!1),t=!1),F&&(window.onunhandledrejection=f,F=!1))},A.__name__=m;var W=[].slice;function n(n){var t=window[n];window[n]=function(){var n=W.call(arguments),e=n[0];return"function"==typeof e&&(n[0]=I(e)),t.apply?t.apply(this,n):t(n[0],n[1])}}var C,M=window.ErrorWatch;return C={noConflict:function(){return window.ErrorWatch=M,C},report:A,computeStackTrace:x,wrap:I,extendToAsynchronousCallbacks:function(){n("setTimeout"),n("setInterval")},makeError:function(){return thisIsAbug+""}}});
2 | //# sourceMappingURL=errorWatch.min.js.map
3 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "error-watch",
 3 |   "version": "1.0.0",
 4 |   "description": "前端错误解析",
 5 |   "main": "dist/errorWatch.js",
 6 |   "module": "dist/errorWatch.esm.js",
 7 |   "unpkg": "dist/errorWatch.min.js",
 8 |   "jsdelivr": "dist/errorWatch.min.js",
 9 |   "scripts": {
10 |     "test": "jest --color",
11 |     "build": "rollup --config"
12 |   },
13 |   "author": "godis",
14 |   "keywords": [
15 |     "javascript",
16 |     "error",
17 |     "前端错误",
18 |     "错误监控"
19 |   ],
20 |   "repository": {
21 |     "type": "git",
22 |     "url": "https://github.com/Godiswill/errorWatch.git"
23 |   },
24 |   "license": "MIT",
25 |   "jest": {
26 |     "testPathIgnorePatterns": [
27 |       "/node_modules/",
28 |       "<rootDir>/__tests__/fixtures/"
29 |     ]
30 |   },
31 |   "devDependencies": {
32 |     "@babel/core": "^7.10.5",
33 |     "@babel/preset-env": "^7.10.4",
34 |     "babel-plugin-external-helpers": "^6.22.0",
35 |     "babel-preset-latest": "^6.24.1",
36 |     "jest": "^26.1.0",
37 |     "rollup": "^2.22.1",
38 |     "rollup-plugin-babel": "^4.4.0",
39 |     "rollup-plugin-json": "^4.0.0",
40 |     "rollup-plugin-node-resolve": "^5.2.0",
41 |     "rollup-plugin-uglify": "^6.0.4"
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/ref/supplement.js:
--------------------------------------------------------------------------------
  1 | function exceptionalException(message) {
  2 |   'use strict';
  3 |   if (exceptionalException.emailErrors !== false) {
  4 |     exceptionalException.emailErrors = confirm('We had an error reporting an error! Please email us so we can fix it?');
  5 |   }
  6 | }
  7 | //test
  8 | //exceptionalException('try 1!');
  9 | //exceptionalException('try 2!');
 10 | 
 11 | //I have much better versions of the code below, you should totally bark at me if you want that code
 12 | var dev = (window.localStorage ? localStorage.getItem('workingLocally') : false);
 13 | 
 14 | /**
 15 |  * sendError
 16 |  * accepts string or object. if object, it gets stringified
 17 |  * if there is a failure to send due to being offline, it will retry in 2 minutes.
 18 |  */
 19 | function sendError(uniqueData) {
 20 |   'use strict';
 21 |   //hrmm..
 22 |   try {
 23 |     if (!uniqueData.stack) {
 24 |       uniqueData.stack = (new Error('make stack')).stack;
 25 |       if (uniqueData.stack) {
 26 |         uniqueData.stack = uniqueData.stack.toString();
 27 |       }
 28 |     }
 29 |   } catch (e) {}
 30 |   if (typeof uniqueData !== 'string') {
 31 |     uniqueData = JSON.stringify(uniqueData);
 32 |   }
 33 | 
 34 |   function jserrorPostFail() {
 35 |     checkOnline(function(online) {
 36 |       if (online) {
 37 |         //if online, alert error
 38 |         var args = [].slice.call(arguments, 0);
 39 |         var xhr;
 40 |         if (args[0].getAllResponseHeaders) {
 41 |           xhr = args[0];
 42 |         } else {
 43 |           xhr = args[2];
 44 |         }
 45 |         try {
 46 |           args.push('headers:' + xhr.getAllResponseHeaders());
 47 |         } catch (e) { }
 48 |         args.push('uniqueData: ' + uniqueData);
 49 |         exceptionalException(JSON.stringify(args));
 50 |       } else {
 51 |         //if offline, retry request
 52 |         console.log('failure from being offline. Will retry in 2 minutes.');
 53 |         setTimeout(function offlineRetryIn2Min() {
 54 |           fireRequest();
 55 |         }, 1000 * 60 * 2); //2 minutes
 56 |       }
 57 |     });
 58 |   };
 59 | 
 60 |   function fireRequest() {
 61 |     var data = {'sub.domain.com': uniqueData};
 62 |     if (dev) {
 63 |       data = {'dev': 'test'}; //still send intentionally failiing request to better simulate production
 64 |       console.error(uniqueData);
 65 |     }
 66 |     console.warn('sendError');
 67 |     $.ajax({
 68 |       url: 'https://foo.com/jserror/',
 69 |       type: 'POST', //POST has no request size limit like GET
 70 |       data: data
 71 |     })
 72 |       .fail(jserrorPostFail)
 73 |       .done(function jserrorPostDone(resp) {
 74 |         console.warn('sendError END ' + resp);
 75 |         if (resp.status === 'error') {
 76 |           jserrorPostFail.apply(this, arguments);
 77 |         }
 78 |       });
 79 |   }
 80 |   fireRequest();
 81 | }
 82 | 
 83 | TraceKit.report.subscribe(sendError);
 84 | 
 85 | 
 86 | /**
 87 |  * Usage:
 88 |  * $.ajax()
 89 |  * .fail(ajaxFail(function(){
 90 |  *   //apology: alert('Sorry that action failed')
 91 |  * }))
 92 |  *
 93 |  * In the future, I hope to directly modify the fail function to only trigger when there's actually a server or api error
 94 |  * Failures due to beign offline will go into a que, and the window onoffline event will trigger.
 95 |  * Polling every X seconds can be done to try and get back online, and trigger window ononline handler
 96 |  */
 97 | function ajaxFail(apology) {
 98 |   if (!apology) {
 99 |     apology = function noop(){};
100 |   } else if (apology.getAllResponseHeaders) {
101 |     alert('You are supposed to call ajaxFail like: ajaxFail(), you can pass in a callback to alert a sorry message to the user if you want.');
102 |   }
103 |   return function ajaxFailFnName(xhr, status, errorThrown) {
104 |     var args = [].slice.call(arguments, 0);
105 |     apology.apply(this, args);
106 |     var headers = xhr.getAllResponseHeaders();
107 |     if (headers) {
108 |       args.push('headers:' + headers);
109 |     }
110 |     checkOnline(function ajaxFailCheckOffline(online) {
111 |       if (online) {
112 |         sendError(args);
113 |       } else {
114 |         //que or something to retry, but don't save to localStorage, just the in-page memory
115 |         //Storing to localStorage would result in pretty unpredictable behavior
116 |         //for users and probably other js code too.
117 | 
118 |         //I also plan to
119 |       }
120 |     });
121 |   };
122 | }
123 | 
124 | //checkOnline is defined in check-online.js: http://github.com/devinrhode2/check-online
125 | 
126 | 
127 | 
128 | //OTHER I DONT KNOW POTENTIALLY BETTER VERSION
129 | 
130 | var exceptionalException = function exceptionalExceptionF(message) {
131 |   'use strict';
132 |   alert('HOLY MOLY! Please email this error to support@'+location.host+'.com: \n\nSubject:Error\n' + message);
133 | };
134 | 
135 | /**
136 |  * sendError
137 |  * accepts string or object. if object, it gets stringified
138 |  * if there is a failure to send due to being offline, it will retry in 2 minutes.
139 |  */
140 | function sendError(error) {
141 |   'use strict';
142 |   try {
143 |     if (!error.stack) {
144 |       error.stack = (new Error('force-added stack')).stack;
145 |       if (error.stack) {
146 |         error.stack = error.stack.toString();
147 |       }
148 |     }
149 |   } catch (e) {}
150 | 
151 |   if (typeof uniqueData !== 'string') {
152 |     uniqueData = JSON.stringify(uniqueData);
153 |   }
154 | 
155 |   $.ajax({
156 |     url: 'https://parsing-api.trackif.com/jserror/',
157 |     type: 'POST',
158 |     data: data
159 |   })
160 |     .fail(jserrorPostFail)
161 |     .done(function jserrorPostDone(resp) {
162 |       console.warn('sendError END ' + resp);
163 |       if (resp.status === 'error') {
164 |         jserrorPostFail.apply(this, arguments);
165 |       }
166 |     });
167 | }
168 | 
169 | //override
170 | (function jQueryAjaxOverride($) {
171 | 
172 |   //apologizeAndReport, for when we have an error with the request and we're online:
173 |   //Broken out of ajaxFail for less memory use.
174 |   function apologizeAndReport(args, apology) {
175 |     sendError(args);
176 |     //Maybe TraceKit.report(Error('ajax error'), args); //... probably...
177 |     try {
178 |       //if you do $.ajax().fail(ajaxFail) this will throw because apology will the the xhr object and not a function
179 |       apology && apology.apply(this, args);
180 |     } catch (e) {
181 |       //if you did $.ajax().fail(ajaxFail) we know what's up
182 |       if (apology.getAllResponseHeaders) {
183 |         alert('You are supposed to call ajaxFail like: \n' +
184 |           '$.ajax().fail(ajaxFail(function(){ \n' +
185 |           'alert(\'sorry we suck\'); \n' +
186 |           '}))');
187 |       } else { //else user has error in apology
188 |         throw e;
189 |       }
190 |     }
191 |   }
192 | 
193 |   function ajaxFail(apology) {
194 |     return function ajaxFailsFnForjQuery(xhr, status, errorThrown) {
195 |       checkOnline(function ajaxFailCheckOffline(online) {
196 |         if (online) {
197 |           //looks like we have an explicit error reponse
198 |           apologizeAndReport.call(this, args, apology);
199 |         } else {
200 |           //que or something to retry, but don't save to localStorage, just the in-page memory
201 |           //Storing to localStorage would result in pretty unpredictable behavior
202 |           //for users and probably other js code too.
203 |           runAjax();
204 |         }
205 |       }, arguments);
206 |     };
207 |   }
208 | 
209 |   extendFunction('$.ajax', function ajaxExtension(ajaxArgs, normalAjax) {
210 |     //let's re-attempt every 2 minutes.
211 |     if (ajaxArgs[1].reconnect) {
212 | 
213 |     }
214 | 
215 |     function runAjax() {
216 |       var jax = normalAjax.apply(this, ajaxArgs);
217 |       jax.fail = extendFunction(jax.fail, function failOverride(args, oldFail) {
218 |         return oldFail(
219 |           ajaxFail(
220 |             args[0], //args[0] is the failureCallback
221 |             ajaxArgs[1].reconnect || ajaxArgs[0].reconnect
222 |           )
223 |         );
224 |       });
225 |       return jax;
226 |     }
227 |     return runAjax();
228 |   });
229 | 
230 |   //$.ajax.reconnect(); //try reconnecting, you can manually make //return setTimeout that you can override? OR if no timeout arg, default..
231 | 
232 | }(jQuery));
233 | 


--------------------------------------------------------------------------------
/rollup.config.js:
--------------------------------------------------------------------------------
 1 | // import json from 'rollup-plugin-json';
 2 | // import resolve from 'rollup-plugin-node-resolve';
 3 | import babel from 'rollup-plugin-babel';
 4 | import { uglify } from "rollup-plugin-uglify";
 5 | 
 6 | export default [{
 7 |   input: 'src/index.js',
 8 |   output: {
 9 |     file: 'dist/errorWatch.esm.js',
10 |     format: 'esm'
11 |   },
12 | }, {
13 |   input: 'src/index.js',
14 |   output: {
15 |     // file: 'bundle.es.js',
16 |     entryFileNames: 'errorWatch.js',
17 |     // chunkFileNames: '[name].es[hash].js',
18 |     dir: 'dist',
19 |     name: 'ErrorWatch',
20 |     format: 'umd'
21 |   },
22 |   plugins: [
23 |     // json(),
24 |     // resolve(),
25 |     babel(),
26 |     // uglify(),
27 |   ]
28 | }, {
29 |   input: 'src/index.js',
30 |   output: {
31 |     // file: 'bundle.es.js',
32 |     entryFileNames: 'errorWatch.min.js',
33 |     // chunkFileNames: '[name].es[hash].js',
34 |     dir: 'dist',
35 |     name: 'ErrorWatch',
36 |     format: 'umd',
37 |       sourcemap: true,
38 |       sourcemapFile: 'errorWatch.min.js.map',
39 |   },
40 |   plugins: [
41 |     // json(),
42 |     // resolve(),
43 |     babel(),
44 |     uglify(),
45 |   ]
46 | }]
47 | 


--------------------------------------------------------------------------------
/src/.babelrc:
--------------------------------------------------------------------------------
1 | {
2 |   "presets": [
3 |     ["@babel/env", {"modules": false}]
4 |   ]
5 | }


--------------------------------------------------------------------------------
/src/computeStackTrace.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * An object representing a single stack frame.
  3 |  * @typedef {Object} StackFrame
  4 |  * @property {string} url The JavaScript or HTML file URL.
  5 |  * @property {string} func The function name, or empty for anonymous functions (if guessing did not work).
  6 |  * @property {string[]?} args The arguments passed to the function, if known.
  7 |  * @property {number=} line The line number, if known.
  8 |  * @property {number=} column The column number, if known.
  9 |  * @property {string[]} context An array of source code lines; the middle element corresponds to the correct line#.
 10 |  * @memberof ErrorWatch
 11 |  */
 12 | /**
 13 |  * An object representing a JavaScript stack trace.
 14 |  * @typedef {Object} StackTrace
 15 |  * @property {string} name The name of the thrown exception.
 16 |  * @property {string} message The exception error message.
 17 |  * @property {ErrorWatch.StackFrame[]} stack An array of stack frames.
 18 |  * @property {string} mode 'stack', 'stacktrace', 'multiline', 'callers', 'onerror', or 'failed' -- method used to collect the stack trace.
 19 |  * @memberof ErrorWatch
 20 |  */
 21 | /**
 22 |  * ErrorWatch.computeStackTrace: cross-browser stack traces in JavaScript
 23 |  *
 24 |  * Syntax:
 25 |  *   ```js
 26 |  *   s = ErrorWatch.computeStackTrace.ofCaller([depth])
 27 |  *   s = ErrorWatch.computeStackTrace(exception) // consider using ErrorWatch.report instead (see below)
 28 |  *   ```
 29 |  *
 30 |  * Supports:
 31 |  *   - Firefox:  full stack trace with line numbers and unreliable column
 32 |  *               number on top frame
 33 |  *   - Opera 10: full stack trace with line and column numbers
 34 |  *   - Opera 9-: full stack trace with line numbers
 35 |  *   - Chrome:   full stack trace with line and column numbers
 36 |  *   - Safari:   line and column number for the topmost stacktrace element
 37 |  *               only
 38 |  *   - IE:       no line numbers whatsoever
 39 |  *
 40 |  * Tries to guess names of anonymous functions by looking for assignments
 41 |  * in the source code. In IE and Safari, we have to guess source file names
 42 |  * by searching for function bodies inside all page scripts. This will not
 43 |  * work for scripts that are loaded cross-domain.
 44 |  * Here be dragons: some function names may be guessed incorrectly, and
 45 |  * duplicate functions may be mismatched.
 46 |  *
 47 |  * ErrorWatch.computeStackTrace should only be used for tracing purposes.
 48 |  * Logging of unhandled exceptions should be done with ErrorWatch.report,
 49 |  * which builds on top of ErrorWatch.computeStackTrace and provides better
 50 |  * IE support by utilizing the window.onerror event to retrieve information
 51 |  * about the top of the stack.
 52 |  *
 53 |  * Note: In IE and Safari, no stack trace is recorded on the Error object,
 54 |  * so computeStackTrace instead walks its *own* chain of callers.
 55 |  * This means that:
 56 |  *  * in Safari, some methods may be missing from the stack trace;
 57 |  *  * in IE, the topmost function in the stack trace will always be the
 58 |  *    caller of computeStackTrace.
 59 |  *
 60 |  * This is okay for tracing (because you are likely to be calling
 61 |  * computeStackTrace from the function you want to be the topmost element
 62 |  * of the stack trace anyway), but not okay for logging unhandled
 63 |  * exceptions (because your catch block will likely be far away from the
 64 |  * inner function that actually caused the exception).
 65 |  *
 66 |  * Tracing example:
 67 |  *  ```js
 68 |  *     function trace(message) {
 69 |  *         var stackInfo = ErrorWatch.computeStackTrace.ofCaller();
 70 |  *         var data = message + "\n";
 71 |  *         for(var i in stackInfo.stack) {
 72 |  *             var item = stackInfo.stack[i];
 73 |  *             data += (item.func || '[anonymous]') + "() in " + item.url + ":" + (item.line || '0') + "\n";
 74 |  *         }
 75 |  *         if (window.console)
 76 |  *             console.info(data);
 77 |  *         else
 78 |  *             alert(data);
 79 |  *     }
 80 |  * ```
 81 |  * @memberof ErrorWatch
 82 |  * @namespace
 83 |  */
 84 | import { remoteFetching, linesOfContext, debug, reportFuncName } from './config';
 85 | import { _has, _isUndefined } from './utils';
 86 | 
 87 | const UNKNOWN_FUNCTION = '?';
 88 | 
 89 | let sourceCache = {};
 90 | 
 91 | /**
 92 |  * Attempts to retrieve source code via XMLHttpRequest, which is used
 93 |  * to look up anonymous function names.
 94 |  * @param {string} url URL of source code.
 95 |  * @return {string} Source contents.
 96 |  * @memberof ErrorWatch.computeStackTrace
 97 |  */
 98 | function loadSource(url) {
 99 |   if (!remoteFetching) { //Only attempt request if remoteFetching is on.
100 |     return '';
101 |   }
102 |   try {
103 |     const getXHR = function() {
104 |       try {
105 |         return new window.XMLHttpRequest();
106 |       } catch (e) {
107 |         // explicitly bubble up the exception if not found
108 |         return new window.ActiveXObject('Microsoft.XMLHTTP');
109 |       }
110 |     };
111 | 
112 |     const request = getXHR();
113 |     request.open('GET', url, false);
114 |     request.send('');
115 |     return request.responseText;
116 |   } catch (e) {
117 |     return '';
118 |   }
119 | }
120 | 
121 | /**
122 |  * Retrieves source code from the source code cache.
123 |  * @param {string} url URL of source code.
124 |  * @return {Array.<string>} Source contents.
125 |  * @memberof ErrorWatch.computeStackTrace
126 |  */
127 | function getSource(url) {
128 |   if (typeof url !== 'string') {
129 |     return [];
130 |   }
131 | 
132 |   if (!_has(sourceCache, url)) {
133 |     // URL needs to be able to fetched within the acceptable domain.  Otherwise,
134 |     // cross-domain errors will be triggered.
135 |     /*
136 |         Regex matches:
137 |         0 - Full Url
138 |         1 - Protocol
139 |         2 - Domain
140 |         3 - Port (Useful for internal applications)
141 |         4 - Path
142 |     */
143 |     let source = '',
144 |         domain = '';
145 |     try { domain = window.document.domain; } catch (e) { }
146 |     const match = /(.*)\:\/\/([^:\/]+)([:\d]*)\/{0,1}([\s\S]*)/.exec(url);
147 |     if (match && match[2] === domain) {
148 |       source = loadSource(url);
149 |     }
150 |     sourceCache[url] = source ? source.split('\n') : [];
151 |   }
152 | 
153 |   return sourceCache[url];
154 | }
155 | 
156 | /**
157 |  * Tries to use an externally loaded copy of source code to determine
158 |  * the name of a function by looking at the name of the variable it was
159 |  * assigned to, if any.
160 |  * @param {string} url URL of source code.
161 |  * @param {(string|number)} lineNo Line number in source code.
162 |  * @return {string} The function name, if discoverable.
163 |  * @memberof ErrorWatch.computeStackTrace
164 |  */
165 | function guessFunctionName(url, lineNo) {
166 |   const reFunctionArgNames = /function ([^(]*)\(([^)]*)\)/,
167 |     reGuessFunction = /['"]?([0-9A-Za-z$_]+)['"]?\s*[:=]\s*(function|eval|new Function)/,
168 |     maxLines = 10,
169 |     source = getSource(url);
170 |   let line = '', m;
171 | 
172 |   if (!source.length) {
173 |     return UNKNOWN_FUNCTION;
174 |   }
175 | 
176 |   // Walk backwards from the first line in the function until we find the line which
177 |   // matches the pattern above, which is the function definition
178 |   for (let i = 0; i < maxLines; ++i) {
179 |     line = source[lineNo - i] + line;
180 | 
181 |     if (!_isUndefined(line)) { // 这里有个bug，永远为 true
182 |       if ((m = reGuessFunction.exec(line))) {
183 |         return m[1];
184 |       } else if ((m = reFunctionArgNames.exec(line))) {
185 |         return m[1];
186 |       }
187 |     }
188 |   }
189 | 
190 |   return UNKNOWN_FUNCTION;
191 | }
192 | 
193 | /**
194 |  * Retrieves the surrounding lines from where an exception occurred.
195 |  * @param {string} url URL of source code.
196 |  * @param {(string|number)} line Line number in source code to center around for context.
197 |  * @return {?Array.<string>} Lines of source code.
198 |  * @memberof ErrorWatch.computeStackTrace
199 |  */
200 | function gatherContext(url, line) {
201 |   const source = getSource(url);
202 | 
203 |   if (!source.length) {
204 |     return null;
205 |   }
206 | 
207 |   let context = [],
208 |     // linesBefore & linesAfter are inclusive with the offending line.
209 |     // if linesOfContext is even, there will be one extra line
210 |     //   *before* the offending line.
211 |     linesBefore = Math.floor(linesOfContext / 2),
212 |     // Add one extra line if linesOfContext is odd
213 |     linesAfter = linesBefore + (linesOfContext % 2),
214 |     start = Math.max(0, line - linesBefore - 1),
215 |     end = Math.min(source.length, line + linesAfter - 1);
216 | 
217 |   line -= 1; // convert to 0-based index
218 | 
219 |   for (let i = start; i < end; ++i) {
220 |     if (!_isUndefined(source[i])) {
221 |       context.push(source[i]);
222 |     }
223 |   }
224 | 
225 |   return context.length > 0 ? context : null;
226 | }
227 | 
228 | /**
229 |  * Escapes special characters, except for whitespace, in a string to be
230 |  * used inside a regular expression as a string literal.
231 |  * @param {string} text The string.
232 |  * @return {string} The escaped string literal.
233 |  * @memberof ErrorWatch.computeStackTrace
234 |  */
235 | function escapeRegExp(text) {
236 |   return text.replace(/[\-\[\]{}()*+?.,\\\^$|#]/g, '\\$&');
237 | }
238 | 
239 | /**
240 |  * Escapes special characters in a string to be used inside a regular
241 |  * expression as a string literal. Also ensures that HTML entities will
242 |  * be matched the same as their literal friends.
243 |  * @param {string} body The string.
244 |  * @return {string} The escaped string.
245 |  * @memberof ErrorWatch.computeStackTrace
246 |  */
247 | function escapeCodeAsRegExpForMatchingInsideHTML(body) {
248 |   return escapeRegExp(body).replace('<', '(?:<|&lt;)').replace('>', '(?:>|&gt;)').replace('&', '(?:&|&amp;)').replace('"', '(?:"|&quot;)').replace(/\s+/g, '\\s+');
249 | }
250 | 
251 | /**
252 |  * Determines where a code fragment occurs in the source code.
253 |  * @param {RegExp} re The function definition.
254 |  * @param {Array.<string>} urls A list of URLs to search.
255 |  * @return {?Object.<string, (string|number)>} An object containing
256 |  * the url, line, and column number of the defined function.
257 |  * @memberof ErrorWatch.computeStackTrace
258 |  */
259 | function findSourceInUrls(re, urls) {
260 |   let source, m;
261 |   for (let i = 0, j = urls.length; i < j; ++i) {
262 |     if ((source = getSource(urls[i])).length) {
263 |       source = source.join('\n');
264 |       if ((m = re.exec(source))) {
265 | 
266 |         return {
267 |           'url': urls[i],
268 |           'line': source.substring(0, m.index).split('\n').length,
269 |           'column': m.index - source.lastIndexOf('\n', m.index) - 1
270 |         };
271 |       }
272 |     }
273 |   }
274 | 
275 |   return null;
276 | }
277 | 
278 | /**
279 |  * Determines at which column a code fragment occurs on a line of the
280 |  * source code.
281 |  * @param {string} fragment The code fragment.
282 |  * @param {string} url The URL to search.
283 |  * @param {(string|number)} line The line number to examine.
284 |  * @return {?number} The column number.
285 |  * @memberof ErrorWatch.computeStackTrace
286 |  */
287 | function findSourceInLine(fragment, url, line) {
288 |   const source = getSource(url),
289 |     re = new RegExp('\\b' + escapeRegExp(fragment) + '\\b');
290 |   let m;
291 | 
292 |   line -= 1;
293 | 
294 |   if (source && source.length > line && (m = re.exec(source[line]))) {
295 |     return m.index;
296 |   }
297 | 
298 |   return null;
299 | }
300 | 
301 | /**
302 |  * Determines where a function was defined within the source code.
303 |  * @param {(Function|string)} func A function reference or serialized
304 |  * function definition.
305 |  * @return {?Object.<string, (string|number)>} An object containing
306 |  * the url, line, and column number of the defined function.
307 |  * @memberof ErrorWatch.computeStackTrace
308 |  */
309 | function findSourceByFunctionBody(func) {
310 |   if (_isUndefined(window && window.document)) {
311 |     return null;
312 |   }
313 | 
314 |   const urls = [window.location.href],
315 |     scripts = window.document.getElementsByTagName('script'),
316 |     code = '' + func,
317 |     codeRE = /^function(?:\s+([\w$]+))?\s*\(([\w\s,]*)\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,
318 |     eventRE = /^function on([\w$]+)\s*\(event\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/;
319 |   let body,
320 |     re,
321 |     parts,
322 |     result;
323 | 
324 |   for (let i = 0; i < scripts.length; ++i) {
325 |     const script = scripts[i];
326 |     if (script.src) {
327 |       urls.push(script.src);
328 |     }
329 |   }
330 | 
331 |   if (!(parts = codeRE.exec(code))) {
332 |     re = new RegExp(escapeRegExp(code).replace(/\s+/g, '\\s+'));
333 |   }
334 | 
335 |   // not sure if this is really necessary, but I don’t have a test
336 |   // corpus large enough to confirm that and it was in the original.
337 |   else {
338 |     const name = parts[1] ? '\\s+' + parts[1] : '',
339 |       args = parts[2].split(',').join('\\s*,\\s*');
340 | 
341 |     body = escapeRegExp(parts[3]).replace(/;$/, ';?'); // semicolon is inserted if the function ends with a comment.replace(/\s+/g, '\\s+');
342 |     re = new RegExp('function' + name + '\\s*\\(\\s*' + args + '\\s*\\)\\s*{\\s*' + body + '\\s*}');
343 |   }
344 | 
345 |   // look for a normal function definition
346 |   if ((result = findSourceInUrls(re, urls))) {
347 |     return result;
348 |   }
349 | 
350 |   // look for an old-school event handler function
351 |   if ((parts = eventRE.exec(code))) {
352 |     const event = parts[1];
353 |     body = escapeCodeAsRegExpForMatchingInsideHTML(parts[2]);
354 | 
355 |     // look for a function defined in HTML as an onXXX handler
356 |     re = new RegExp('on' + event + '=[\\\'"]\\s*' + body + '\\s*[\\\'"]', 'i');
357 | 
358 |     if ((result = findSourceInUrls(re, urls[0]))) {
359 |       return result;
360 |     }
361 | 
362 |     // look for ???
363 |     re = new RegExp(body);
364 | 
365 |     if ((result = findSourceInUrls(re, urls))) {
366 |       return result;
367 |     }
368 |   }
369 | 
370 |   return null;
371 | }
372 | 
373 | // Contents of Exception in various browsers.
374 | //
375 | // SAFARI:
376 | // ex.message = Can't find variable: qq
377 | // ex.line = 59
378 | // ex.sourceId = 580238192
379 | // ex.sourceURL = http://...
380 | // ex.expressionBeginOffset = 96
381 | // ex.expressionCaretOffset = 98
382 | // ex.expressionEndOffset = 98
383 | // ex.name = ReferenceError
384 | //
385 | // FIREFOX:
386 | // ex.message = qq is not defined
387 | // ex.fileName = http://...
388 | // ex.lineNumber = 59
389 | // ex.columnNumber = 69
390 | // ex.stack = ...stack trace... (see the example below)
391 | // ex.name = ReferenceError
392 | //
393 | // CHROME:
394 | // ex.message = qq is not defined
395 | // ex.name = ReferenceError
396 | // ex.type = not_defined
397 | // ex.arguments = ['aa']
398 | // ex.stack = ...stack trace...
399 | //
400 | // INTERNET EXPLORER:
401 | // ex.message = ...
402 | // ex.name = ReferenceError
403 | //
404 | // OPERA:
405 | // ex.message = ...message... (see the example below)
406 | // ex.name = ReferenceError
407 | // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)
408 | // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'
409 | 
410 | /**
411 |  * Computes stack trace information from the stack property.
412 |  * Chrome and Gecko use this property.
413 |  * @param {Error} ex
414 |  * @return {?ErrorWatch.StackTrace} Stack trace information.
415 |  * @memberof ErrorWatch.computeStackTrace
416 |  */
417 | function computeStackTraceFromStackProp(ex) {
418 |   if (!ex.stack) {
419 |     return null;
420 |   }
421 | 
422 |   const chrome = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i,
423 |     gecko = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i,
424 |     winjs = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
425 | 
426 |     geckoEval = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i,
427 |     chromeEval = /\((\S*)(?::(\d+))(?::(\d+))\)/,
428 | 
429 |     lines = ex.stack.split('\n'),
430 |     reference = /^(.*) is undefined$/.exec(ex.message);
431 |   let stack = [],
432 |     // Used to additionally parse URL/line/column from eval frames
433 |     isEval,
434 |     submatch,
435 |     parts,
436 |     element;
437 | 
438 |   for (let i = 0, j = lines.length; i < j; ++i) {
439 |     if ((parts = chrome.exec(lines[i]))) {
440 |       const isNative = parts[2] && parts[2].indexOf('native') === 0; // start of line
441 |       isEval = parts[2] && parts[2].indexOf('eval') === 0; // start of line
442 |       if (isEval && (submatch = chromeEval.exec(parts[2]))) {
443 |         // throw out eval line/column and use top-most line/column number
444 |         parts[2] = submatch[1]; // url
445 |         parts[3] = submatch[2]; // line
446 |         parts[4] = submatch[3]; // column
447 |       }
448 |       element = {
449 |         'url': !isNative ? parts[2] : null,
450 |         'func': parts[1] || UNKNOWN_FUNCTION,
451 |         'args': isNative ? [parts[2]] : [],
452 |         'line': parts[3] ? +parts[3] : null,
453 |         'column': parts[4] ? +parts[4] : null
454 |       };
455 |     } else if ( parts = winjs.exec(lines[i]) ) {
456 |       element = {
457 |         'url': parts[2],
458 |         'func': parts[1] || UNKNOWN_FUNCTION,
459 |         'args': [],
460 |         'line': +parts[3],
461 |         'column': parts[4] ? +parts[4] : null
462 |       };
463 |     } else if ((parts = gecko.exec(lines[i]))) {
464 |       isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
465 |       if (isEval && (submatch = geckoEval.exec(parts[3]))) {
466 |         // throw out eval line/column and use top-most line number
467 |         parts[3] = submatch[1];
468 |         parts[4] = submatch[2];
469 |         parts[5] = null; // no column when eval
470 |       } else if (i === 0 && !parts[5] && !_isUndefined(ex.columnNumber)) {
471 |         // FireFox uses this awesome columnNumber property for its top frame
472 |         // Also note, Firefox's column number is 0-based and everything else expects 1-based,
473 |         // so adding 1
474 |         // NOTE: this hack doesn't work if top-most frame is eval
475 |         stack[0].column = ex.columnNumber + 1;
476 |       }
477 |       element = {
478 |         'url': parts[3],
479 |         'func': parts[1] || UNKNOWN_FUNCTION,
480 |         'args': parts[2] ? parts[2].split(',') : [],
481 |         'line': parts[4] ? +parts[4] : null,
482 |         'column': parts[5] ? +parts[5] : null
483 |       };
484 |     } else {
485 |       continue;
486 |     }
487 | 
488 |     if (!element.func && element.line) {
489 |       element.func = guessFunctionName(element.url, element.line);
490 |     }
491 | 
492 |     element.context = element.line ? gatherContext(element.url, element.line) : null;
493 |     stack.push(element);
494 |   }
495 | 
496 |   if (!stack.length) {
497 |     return null;
498 |   }
499 | 
500 |   if (stack[0] && stack[0].line && !stack[0].column && reference) {
501 |     stack[0].column = findSourceInLine(reference[1], stack[0].url, stack[0].line);
502 |   }
503 | 
504 |   return {
505 |     'mode': 'stack',
506 |     'name': ex.name,
507 |     'message': ex.message,
508 |     'stack': stack
509 |   };
510 | }
511 | 
512 | /**
513 |  * Computes stack trace information from the stacktrace property.
514 |  * Opera 10+ uses this property.
515 |  * @param {Error} ex
516 |  * @return {?ErrorWatch.StackTrace} Stack trace information.
517 |  * @memberof ErrorWatch.computeStackTrace
518 |  */
519 | function computeStackTraceFromStacktraceProp(ex) {
520 |   // Access and store the stacktrace property before doing ANYTHING
521 |   // else to it because Opera is not very good at providing it
522 |   // reliably in other circumstances.
523 |   const stacktrace = ex.stacktrace;
524 |   if (!stacktrace) {
525 |     return;
526 |   }
527 | 
528 |   const opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i,
529 |     opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^\)]+))\((.*)\))? in (.*):\s*$/i,
530 |     lines = stacktrace.split('\n');
531 |   let stack = [],
532 |     parts;
533 | 
534 |   for (let line = 0; line < lines.length; line += 2) {
535 |     let element = null;
536 |     if ((parts = opera10Regex.exec(lines[line]))) {
537 |       element = {
538 |         'url': parts[2],
539 |         'line': +parts[1],
540 |         'column': null,
541 |         'func': parts[3],
542 |         'args':[]
543 |       };
544 |     } else if ((parts = opera11Regex.exec(lines[line]))) {
545 |       element = {
546 |         'url': parts[6],
547 |         'line': +parts[1],
548 |         'column': +parts[2],
549 |         'func': parts[3] || parts[4],
550 |         'args': parts[5] ? parts[5].split(',') : []
551 |       };
552 |     }
553 | 
554 |     if (element) {
555 |       if (!element.func && element.line) {
556 |         element.func = guessFunctionName(element.url, element.line);
557 |       }
558 |       if (element.line) {
559 |         try {
560 |           element.context = gatherContext(element.url, element.line);
561 |         } catch (exc) {}
562 |       }
563 | 
564 |       if (!element.context) {
565 |         element.context = [lines[line + 1]];
566 |       }
567 | 
568 |       stack.push(element);
569 |     }
570 |   }
571 | 
572 |   if (!stack.length) {
573 |     return null;
574 |   }
575 | 
576 |   return {
577 |     'mode': 'stacktrace',
578 |     'name': ex.name,
579 |     'message': ex.message,
580 |     'stack': stack
581 |   };
582 | }
583 | 
584 | /**
585 |  * NOT TESTED.
586 |  * Computes stack trace information from an error message that includes
587 |  * the stack trace.
588 |  * Opera 9 and earlier use this method if the option to show stack
589 |  * traces is turned on in opera:config.
590 |  * @param {Error} ex
591 |  * @return {?ErrorWatch.StackTrace} Stack information.
592 |  * @memberof ErrorWatch.computeStackTrace
593 |  */
594 | function computeStackTraceFromOperaMultiLineMessage(ex) {
595 |   // TODO: Clean this function up
596 |   // Opera includes a stack trace into the exception message. An example is:
597 |   //
598 |   // Statement on line 3: Undefined variable: undefinedFunc
599 |   // Backtrace:
600 |   //   Line 3 of linked script file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.js: In function zzz
601 |   //         undefinedFunc(a);
602 |   //   Line 7 of inline#1 script in file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.html: In function yyy
603 |   //           zzz(x, y, z);
604 |   //   Line 3 of inline#1 script in file://localhost/Users/andreyvit/Projects/ErrorWatch/javascript-client/sample.html: In function xxx
605 |   //           yyy(a, a, a);
606 |   //   Line 1 of function script
607 |   //     try { xxx('hi'); return false; } catch(ex) { ErrorWatch.report(ex); }
608 |   //   ...
609 | 
610 |   const lines = ex.message.split('\n');
611 |   if (lines.length < 4) {
612 |     return null;
613 |   }
614 | 
615 |   const lineRE1 = /^\s*Line (\d+) of linked script ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,
616 |     lineRE2 = /^\s*Line (\d+) of inline#(\d+) script in ((?:file|https?|blob)\S+)(?:: in function (\S+))?\s*$/i,
617 |     lineRE3 = /^\s*Line (\d+) of function script\s*$/i,
618 |     stack = [],
619 |     scripts = (window && window.document && window.document.getElementsByTagName('script'));
620 |   let inlineScriptBlocks = [],
621 |     parts;
622 | 
623 |   for (let s in scripts) {
624 |     if (_has(scripts, s) && !scripts[s].src) {
625 |       inlineScriptBlocks.push(scripts[s]);
626 |     }
627 |   }
628 | 
629 |   for (let line = 2; line < lines.length; line += 2) {
630 |     let item = null;
631 |     if ((parts = lineRE1.exec(lines[line]))) {
632 |       item = {
633 |         'url': parts[2],
634 |         'func': parts[3],
635 |         'args': [],
636 |         'line': +parts[1],
637 |         'column': null
638 |       };
639 |     } else if ((parts = lineRE2.exec(lines[line]))) {
640 |       item = {
641 |         'url': parts[3],
642 |         'func': parts[4],
643 |         'args': [],
644 |         'line': +parts[1],
645 |         'column': null // TODO: Check to see if inline#1 (+parts[2]) points to the script number or column number.
646 |       };
647 |       const relativeLine = (+parts[1]); // relative to the start of the <SCRIPT> block
648 |       const script = inlineScriptBlocks[parts[2] - 1];
649 |       if (script) {
650 |         let source = getSource(item.url);
651 |         if (source) {
652 |           source = source.join('\n');
653 |           const pos = source.indexOf(script.innerText);
654 |           if (pos >= 0) {
655 |             item.line = relativeLine + source.substring(0, pos).split('\n').length;
656 |           }
657 |         }
658 |       }
659 |     } else if ((parts = lineRE3.exec(lines[line]))) {
660 |       const url = window.location.href.replace(/#.*$/, '');
661 |       const re = new RegExp(escapeCodeAsRegExpForMatchingInsideHTML(lines[line + 1]));
662 |       const src = findSourceInUrls(re, [url]);
663 |       item = {
664 |         'url': url,
665 |         'func': '',
666 |         'args': [],
667 |         'line': src ? src.line : parts[1],
668 |         'column': null
669 |       };
670 |     }
671 | 
672 |     if (item) {
673 |       if (!item.func) {
674 |         item.func = guessFunctionName(item.url, item.line);
675 |       }
676 |       const context = gatherContext(item.url, item.line);
677 |       const midline = (context ? context[Math.floor(context.length / 2)] : null);
678 |       if (context && midline.replace(/^\s*/, '') === lines[line + 1].replace(/^\s*/, '')) {
679 |         item.context = context;
680 |       } else {
681 |         // if (context) alert("Context mismatch. Correct midline:\n" + lines[i+1] + "\n\nMidline:\n" + midline + "\n\nContext:\n" + context.join("\n") + "\n\nURL:\n" + item.url);
682 |         item.context = [lines[line + 1]];
683 |       }
684 |       stack.push(item);
685 |     }
686 |   }
687 |   if (!stack.length) {
688 |     return null; // could not parse multiline exception message as Opera stack trace
689 |   }
690 | 
691 |   return {
692 |     'mode': 'multiline',
693 |     'name': ex.name,
694 |     'message': lines[0],
695 |     'stack': stack
696 |   };
697 | }
698 | 
699 | /**
700 |  * Adds information about the first frame to incomplete stack traces.
701 |  * Safari and IE require this to get complete data on the first frame.
702 |  * @param {ErrorWatch.StackTrace} stackInfo Stack trace information from
703 |  * one of the compute* methods.
704 |  * @param {string} url The URL of the script that caused an error.
705 |  * @param {(number|string)} lineNo The line number of the script that
706 |  * caused an error.
707 |  * @param {string=} message The error generated by the browser, which
708 |  * hopefully contains the name of the object that caused the error.
709 |  * @return {boolean} Whether or not the stack information was
710 |  * augmented.
711 |  * @memberof ErrorWatch.computeStackTrace
712 |  */
713 | function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {
714 |   let initial = {
715 |     'url': url,
716 |     'line': lineNo
717 |   };
718 | 
719 |   if (initial.url && initial.line) {
720 |     stackInfo.incomplete = false;
721 | 
722 |     if (!initial.func) {
723 |       initial.func = guessFunctionName(initial.url, initial.line);
724 |     }
725 | 
726 |     if (!initial.context) {
727 |       initial.context = gatherContext(initial.url, initial.line);
728 |     }
729 | 
730 |     const reference = / '([^']+)' /.exec(message);
731 |     if (reference) {
732 |       initial.column = findSourceInLine(reference[1], initial.url, initial.line);
733 |     }
734 | 
735 |     if (stackInfo.stack.length > 0) {
736 |       if (stackInfo.stack[0].url === initial.url) {
737 |         if (stackInfo.stack[0].line === initial.line) {
738 |           return false; // already in stack trace
739 |         } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {
740 |           stackInfo.stack[0].line = initial.line;
741 |           stackInfo.stack[0].context = initial.context;
742 |           return false;
743 |         }
744 |       }
745 |     }
746 | 
747 |     stackInfo.stack.unshift(initial);
748 |     stackInfo.partial = true;
749 |     return true;
750 |   } else {
751 |     stackInfo.incomplete = true;
752 |   }
753 | 
754 |   return false;
755 | }
756 | 
757 | /**
758 |  * Computes stack trace information by walking the arguments.caller
759 |  * chain at the time the exception occurred. This will cause earlier
760 |  * frames to be missed but is the only way to get any stack trace in
761 |  * Safari and IE. The top frame is restored by
762 |  * {@link augmentStackTraceWithInitialElement}.
763 |  * @param {Error} ex
764 |  * @return {ErrorWatch.StackTrace=} Stack trace information.
765 |  * @memberof ErrorWatch.computeStackTrace
766 |  */
767 | function computeStackTraceByWalkingCallerChain(ex, depth) {
768 |   const functionName = /function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i;
769 |   let stack = [],
770 |     funcs = {},
771 |     recursion = false,
772 |     parts,
773 |     item,
774 |     source;
775 | 
776 |   for (let curr = computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {
777 |     if (curr === computeStackTrace || (curr && curr.__name__ === reportFuncName)) { // curr ===  report 避免循环依赖
778 |       continue;
779 |     }
780 | 
781 |     item = {
782 |       'url': null,
783 |       'func': UNKNOWN_FUNCTION,
784 |       'args': [],
785 |       'line': null,
786 |       'column': null
787 |     };
788 | 
789 |     if (curr.name) {
790 |       item.func = curr.name;
791 |     } else if ((parts = functionName.exec(curr.toString()))) {
792 |       item.func = parts[1];
793 |     }
794 | 
795 |     if (typeof item.func === 'undefined') {
796 |       try {
797 |         item.func = parts.input.substring(0, parts.input.indexOf('{'));
798 |       } catch (e) { }
799 |     }
800 | 
801 |     if ((source = findSourceByFunctionBody(curr))) {
802 |       item.url = source.url;
803 |       item.line = source.line;
804 | 
805 |       if (item.func === UNKNOWN_FUNCTION) {
806 |         item.func = guessFunctionName(item.url, item.line);
807 |       }
808 | 
809 |       const reference = / '([^']+)' /.exec(ex.message || ex.description);
810 |       if (reference) {
811 |         item.column = findSourceInLine(reference[1], source.url, source.line);
812 |       }
813 |     }
814 | 
815 |     if (funcs['' + curr]) {
816 |       recursion = true;
817 |     }else{
818 |       funcs['' + curr] = true;
819 |     }
820 | 
821 |     stack.push(item);
822 |   }
823 | 
824 |   if (depth) {
825 |     stack.splice(0, depth);
826 |   }
827 | 
828 |   let result = {
829 |     'mode': 'callers',
830 |     'name': ex.name,
831 |     'message': ex.message,
832 |     'stack': stack
833 |   };
834 |   augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);
835 |   return result;
836 | }
837 | 
838 | /**
839 |  * Computes a stack trace for an exception.
840 |  * @param {Error} ex
841 |  * @param {(string|number)=} depth
842 |  * @memberof ErrorWatch.computeStackTrace
843 |  */
844 | function computeStackTrace(ex, depth) {
845 |   let stack = null;
846 |   depth = (depth == null ? 0 : +depth);
847 | 
848 |   try {
849 |     // This must be tried first because Opera 10 *destroys*
850 |     // its stacktrace property if you try to access the stack
851 |     // property first!!
852 |     stack = computeStackTraceFromStacktraceProp(ex);
853 |     if (stack) {
854 |       return stack;
855 |     }
856 |   } catch (e) {
857 |     if (debug) {
858 |       throw e;
859 |     }
860 |   }
861 | 
862 |   try {
863 |     stack = computeStackTraceFromStackProp(ex);
864 |     if (stack) {
865 |       return stack;
866 |     }
867 |   } catch (e) {
868 |     if (debug) {
869 |       throw e;
870 |     }
871 |   }
872 | 
873 |   try {
874 |     stack = computeStackTraceFromOperaMultiLineMessage(ex);
875 |     if (stack) {
876 |       return stack;
877 |     }
878 |   } catch (e) {
879 |     if (debug) {
880 |       throw e;
881 |     }
882 |   }
883 | 
884 |   try {
885 |     stack = computeStackTraceByWalkingCallerChain(ex, depth + 1);
886 |     if (stack) {
887 |       return stack;
888 |     }
889 |   } catch (e) {
890 |     if (debug) {
891 |       throw e;
892 |     }
893 |   }
894 | 
895 |   return {
896 |     'name': ex.name,
897 |     'message': ex.message,
898 |     'mode': 'failed'
899 |   };
900 | }
901 | 
902 | /**
903 |  * Logs a stacktrace starting from the previous call and working down.
904 |  * @param {(number|string)=} depth How many frames deep to trace.
905 |  * @return {ErrorWatch.StackTrace} Stack trace information.
906 |  * @memberof ErrorWatch.computeStackTrace
907 |  */
908 | function computeStackTraceOfCaller(depth) {
909 |   depth = (depth == null ? 0 : +depth) + 1; // "+ 1" because "ofCaller" should drop one frame
910 |   try {
911 |     throw new Error();
912 |   } catch (ex) {
913 |     return computeStackTrace(ex, depth + 1);
914 |   }
915 | }
916 | 
917 | computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement;
918 | computeStackTrace.computeStackTraceFromStackProp = computeStackTraceFromStackProp;
919 | computeStackTrace.guessFunctionName = guessFunctionName;
920 | computeStackTrace.gatherContext = gatherContext;
921 | computeStackTrace.ofCaller = computeStackTraceOfCaller;
922 | computeStackTrace.getSource = getSource;
923 | 
924 | export default computeStackTrace;
925 | 


--------------------------------------------------------------------------------
/src/config.js:
--------------------------------------------------------------------------------
1 | //Default options:
2 | export const remoteFetching = false;     // 获取远程源文件，没什么用关掉
3 | export const collectWindowErrors = true; // 是否通知 window 全局错误，开启，关掉了这个脚本就没意义了
4 | export const collectSourceErrors = true; // 是否在捕获阶段获取资源加载错误，默认开启
5 | export const linesOfContext = 11;        // 5 lines before, the offending line, 5 lines after，没啥用
6 | export const debug = false;
7 | export const reportFuncName = 'ErrorWatch.report';
8 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
 1 | import report from './report';
 2 | import computeStackTrace from './computeStackTrace';
 3 | import {wrap} from './wrap';
 4 | import { extendToAsynchronousCallbacks } from './tryCatch';
 5 | 
 6 | const _oldErrorWatch = window.ErrorWatch;
 7 | let ErrorWatch;
 8 | /**
 9 |  * Export ErrorWatch out to another variable<br/>
10 |  * Example: `var TK = ErrorWatch.noConflict()`
11 |  * @return {Object} The ErrorWatch object
12 |  * @memberof ErrorWatch
13 |  */
14 | function noConflict() {
15 |   window.ErrorWatch = _oldErrorWatch;
16 |   return ErrorWatch;
17 | }
18 | 
19 | function makeError() {
20 |   const tmp = thisIsAbug;
21 |   return tmp + '';
22 | }
23 | 
24 | ErrorWatch =  {
25 |   noConflict,
26 |   report,
27 |   computeStackTrace,
28 |   wrap,
29 |   extendToAsynchronousCallbacks,
30 |   makeError,
31 | };
32 | 
33 | export default ErrorWatch;
34 | 


--------------------------------------------------------------------------------
/src/report.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Cross-browser processing of unhandled exceptions
  3 |  *
  4 |  * Syntax:
  5 |  * ```js
  6 |  *   ErrorWatch.report.subscribe(function(stackInfo) { ... })
  7 |  *   ErrorWatch.report.unsubscribe(function(stackInfo) { ... })
  8 |  *   ErrorWatch.report(exception)
  9 |  *   try { ...code... } catch(ex) { ErrorWatch.report(ex); }
 10 |  * ```
 11 |  *
 12 |  * Supports:
 13 |  *   - Firefox: full stack trace with line numbers, plus column number
 14 |  *     on top frame; column number is not guaranteed
 15 |  *   - Opera: full stack trace with line and column numbers
 16 |  *   - Chrome: full stack trace with line and column numbers
 17 |  *   - Safari: line and column number for the top frame only; some frames
 18 |  *     may be missing, and column number is not guaranteed
 19 |  *   - IE: line and column number for the top frame only; some frames
 20 |  *     may be missing, and column number is not guaranteed
 21 |  *
 22 |  * In theory, ErrorWatch should work on all of the following versions:
 23 |  *   - IE5.5+ (only 8.0 tested)
 24 |  *   - Firefox 0.9+ (only 3.5+ tested)
 25 |  *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
 26 |  *     Exceptions Have Stacktrace to be enabled in opera:config)
 27 |  *   - Safari 3+ (only 4+ tested)
 28 |  *   - Chrome 1+ (only 5+ tested)
 29 |  *   - Konqueror 3.5+ (untested)
 30 |  *
 31 |  * Requires ErrorWatch.computeStackTrace.
 32 |  *
 33 |  * Tries to catch all unhandled exceptions and report them to the
 34 |  * subscribed handlers. Please note that ErrorWatch.report will rethrow the
 35 |  * exception. This is REQUIRED in order to get a useful stack trace in IE.
 36 |  * If the exception does not reach the top of the browser, you will only
 37 |  * get a stack trace from the point where ErrorWatch.report was called.
 38 |  *
 39 |  * Handlers receive a ErrorWatch.StackTrace object as described in the
 40 |  * ErrorWatch.computeStackTrace docs.
 41 |  *
 42 |  * @memberof ErrorWatch
 43 |  * @namespace
 44 |  */
 45 | 
 46 | import computeStackTrace from './computeStackTrace';
 47 | import {collectWindowErrors, reportFuncName} from './config';
 48 | import { _has } from './utils';
 49 | import { installResourceLoadError, uninstallResourceLoadError } from './resourceError';
 50 | 
 51 | // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types
 52 | const ERROR_TYPES_RE = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/;
 53 | 
 54 | 
 55 | let handlers = [],
 56 |   lastException = null,
 57 |   lastExceptionStack = null;
 58 | 
 59 | /**
 60 |  * Add a crash handler.
 61 |  * @param {Function} handler
 62 |  * @memberof ErrorWatch.report
 63 |  */
 64 | function subscribe(handler) {
 65 |   installGlobalHandler();
 66 |   installGlobalUnhandledRejectionHandler();
 67 |   handlers.push(handler);
 68 | }
 69 | 
 70 | /**
 71 |  * Remove a crash handler.
 72 |  * @param {Function} handler
 73 |  * @memberof ErrorWatch.report
 74 |  */
 75 | function unsubscribe(handler) {
 76 |   for (let i = handlers.length - 1; i >= 0; --i) {
 77 |     if (handlers[i] === handler) {
 78 |       handlers.splice(i, 1);
 79 |     }
 80 |   }
 81 | 
 82 |   if (handlers.length === 0) {
 83 |     uninstallGlobalHandler();
 84 |     uninstallGlobalUnhandledRejectionHandler();
 85 |   }
 86 | }
 87 | 
 88 | /**
 89 |  * Dispatch stack information to all handlers.
 90 |  * @param {ErrorWatch.StackTrace} stack
 91 |  * @param {boolean} isWindowError Is this a top-level window error?
 92 |  * @param {Error=} error The error that's being handled (if available, null otherwise)
 93 |  * @memberof ErrorWatch.report
 94 |  * @throws An exception if an error occurs while calling an handler.
 95 |  */
 96 | function notifyHandlers(stack, isWindowError, error) {
 97 |   let exception = null;
 98 |   if (isWindowError && !collectWindowErrors) {
 99 |     return;
100 |   }
101 |   for (let i in handlers) {
102 |     if (_has(handlers, i)) {
103 |       try {
104 |         handlers[i](stack, isWindowError, error);
105 |       } catch (inner) {
106 |         exception = inner;
107 |       }
108 |     }
109 |   }
110 | 
111 |   if (exception) {
112 |     throw exception;
113 |   }
114 | }
115 | 
116 | let _oldOnerrorHandler, _onErrorHandlerInstalled;
117 | let _oldOnunhandledrejectionHandler, _onUnhandledRejectionHandlerInstalled;
118 | 
119 | /**
120 |  * Ensures all global unhandled exceptions are recorded.
121 |  * Supported by Gecko and IE.
122 |  * @param {string} message Error message.
123 |  * @param {string} url URL of script that generated the exception.
124 |  * @param {(number|string)} lineNo The line number at which the error occurred.
125 |  * @param {(number|string)=} columnNo The column number at which the error occurred.
126 |  * @param {Error=} errorObj The actual Error object.
127 |  * @memberof ErrorWatch.report
128 |  */
129 | function errorWatchWindowOnError(message, url, lineNo, columnNo, errorObj) {
130 |   let stack = null;
131 | 
132 |   if (lastExceptionStack) {
133 |     computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);
134 |     processLastException();
135 |   } else if (errorObj) {
136 |     stack = computeStackTrace(errorObj);
137 |     notifyHandlers(stack, true, errorObj);
138 |   } else {
139 |     let location = {
140 |       'url': url,
141 |       'line': lineNo,
142 |       'column': columnNo
143 |     };
144 | 
145 |     let name;
146 |     let msg = message; // must be new var or will modify original `arguments`
147 |     if ({}.toString.call(message) === '[object String]') {
148 |       const groups = message.match(ERROR_TYPES_RE);
149 |       if (groups) {
150 |         name = groups[1];
151 |         msg = groups[2];
152 |       }
153 |     }
154 | 
155 |     location.func = computeStackTrace.guessFunctionName(location.url, location.line);
156 |     location.context = computeStackTrace.gatherContext(location.url, location.line);
157 |     stack = {
158 |       'name': name,
159 |       'message': msg,
160 |       'mode': 'onerror',
161 |       'stack': [location]
162 |     };
163 | 
164 |     notifyHandlers(stack, true, null);
165 |   }
166 | 
167 |   if (_oldOnerrorHandler) {
168 |     return _oldOnerrorHandler.apply(this, arguments);
169 |   }
170 | 
171 |   return false;
172 | }
173 | 
174 | /**
175 |  * Ensures all unhandled rejections are recorded.
176 |  * @param {PromiseRejectionEvent} e event.
177 |  * @memberof ErrorWatch.report
178 |  * @see https://developer.mozilla.org/en-US/docs/Web/API/WindowEventHandlers/onunhandledrejection
179 |  * @see https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
180 |  */
181 | function errorWatchWindowOnUnhandledRejection(e) {
182 |   const stack = computeStackTrace(e.reason);
183 |   notifyHandlers(stack, true, e.reason);
184 | }
185 | 
186 | /**
187 |  * Install a global onerror handler
188 |  * @memberof ErrorWatch.report
189 |  */
190 | function installGlobalHandler() {
191 |   if (_onErrorHandlerInstalled === true) {
192 |     return;
193 |   }
194 | 
195 |   _oldOnerrorHandler = window.onerror;
196 |   window.onerror = errorWatchWindowOnError;
197 |   installResourceLoadError(function handleResourceError(stack, isWindowError, error) {
198 |     notifyHandlers(stack, isWindowError, error);
199 |   });
200 |   _onErrorHandlerInstalled = true;
201 | }
202 | 
203 | /**
204 |  * Uninstall the global onerror handler
205 |  * @memberof ErrorWatch.report
206 |  */
207 | function uninstallGlobalHandler() {
208 |   if (_onErrorHandlerInstalled) {
209 |     window.onerror = _oldOnerrorHandler;
210 |     uninstallResourceLoadError();
211 |     _onErrorHandlerInstalled = false;
212 |   }
213 | }
214 | 
215 | /**
216 |  * Install a global onunhandledrejection handler
217 |  * @memberof ErrorWatch.report
218 |  */
219 | function installGlobalUnhandledRejectionHandler() {
220 |   if (_onUnhandledRejectionHandlerInstalled === true) {
221 |     return;
222 |   }
223 | 
224 |   _oldOnunhandledrejectionHandler = window.onunhandledrejection;
225 |   window.onunhandledrejection = errorWatchWindowOnUnhandledRejection;
226 |   _onUnhandledRejectionHandlerInstalled = true;
227 | }
228 | 
229 | /**
230 |  * Uninstall the global onunhandledrejection handler
231 |  * @memberof ErrorWatch.report
232 |  */
233 | function uninstallGlobalUnhandledRejectionHandler() {
234 |   if (_onUnhandledRejectionHandlerInstalled) {
235 |     window.onunhandledrejection = _oldOnunhandledrejectionHandler;
236 |     _onUnhandledRejectionHandlerInstalled = false;
237 |   }
238 | }
239 | 
240 | /**
241 |  * Process the most recent exception
242 |  * @memberof ErrorWatch.report
243 |  */
244 | function processLastException() {
245 |   let _lastExceptionStack = lastExceptionStack,
246 |     _lastException = lastException;
247 |   lastExceptionStack = null;
248 |   lastException = null;
249 |   notifyHandlers(_lastExceptionStack, false, _lastException);
250 | }
251 | 
252 | /**
253 |  * Reports an unhandled Error to ErrorWatch.
254 |  * @param {Error} ex
255 |  * @memberof ErrorWatch.report
256 |  * @throws An exception if an incomplete stack trace is detected (old IE browsers).
257 |  */
258 | function report(ex) {
259 |   if (lastExceptionStack) {
260 |     if (lastException === ex) {
261 |       return; // already caught by an inner catch block, ignore
262 |     } else {
263 |       processLastException();
264 |     }
265 |   }
266 | 
267 |   const stack = computeStackTrace(ex);
268 |   lastExceptionStack = stack;
269 |   lastException = ex;
270 | 
271 |   // If the stack trace is incomplete, wait for 2 seconds for
272 |   // slow slow IE to see if onerror occurs or not before reporting
273 |   // this exception; otherwise, we will end up with an incomplete
274 |   // stack trace
275 |   setTimeout(function () {
276 |     if (lastException === ex) {
277 |       processLastException();
278 |     }
279 |   }, (stack.incomplete ? 2000 : 0));
280 | 
281 |   throw ex; // re-throw to propagate to the top level (and cause window.onerror)
282 | }
283 | 
284 | report.subscribe = subscribe;
285 | report.unsubscribe = unsubscribe;
286 | 
287 | report.__name__ = reportFuncName;
288 | 
289 | export default report;
290 | 


--------------------------------------------------------------------------------
/src/resourceError.js:
--------------------------------------------------------------------------------
 1 | import { collectSourceErrors } from './config';
 2 | 
 3 | let isRegisterListener = false;
 4 | let _handler = null;
 5 | 
 6 | /**
 7 |  * 资源加载错误上报
 8 |  * @param handler
 9 |  */
10 | export function installResourceLoadError(handler) {
11 |   if(!isRegisterListener && collectSourceErrors) {
12 |     _handler = handler;
13 |     window.addEventListener && window.addEventListener('error', function (e) {
14 |       try {
15 |         if(e.target !== window) {  // 避免重复上报
16 |           const stack = {
17 |             message: `${e.target.localName} is load error`,
18 |             mode: 'resource',
19 |             name: e.target.src || e.target.href || e.target.currentSrc,
20 |             stack: null,
21 |           };
22 |           handler(stack, true, e);
23 |         }
24 |       } catch (e) {
25 |         throw e;
26 |       }
27 |     }, true);
28 |   }
29 |   isRegisterListener = true;
30 | }
31 | 
32 | /**
33 |  * 移除资源错误加载监听
34 |  */
35 | export function uninstallResourceLoadError() {
36 |   if(isRegisterListener && collectSourceErrors && _handler) {
37 |     window.removeEventListener && window.removeEventListener('error', _handler);
38 |     _handler = null;
39 |     isRegisterListener = false;
40 |   }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/tryCatch.js:
--------------------------------------------------------------------------------
 1 | import { wrap } from './wrap';
 2 | 
 3 | // global reference to slice
 4 | const _slice = [].slice;
 5 | 
 6 | /**
 7 |  * Extends support for global error handling for asynchronous browser
 8 |  * functions. Adopted from Closure Library's errorhandler.js
 9 |  * @memberof ErrorWatch
10 |  */
11 | function _helper(fnName) {
12 |   const originalFn = window[fnName];
13 | 
14 |   window[fnName] = function errorWatchAsyncExtension() {
15 |     // Make a copy of the arguments
16 |     let args = _slice.call(arguments);
17 |     const originalCallback = args[0];
18 |     if (typeof (originalCallback) === 'function') {
19 |       args[0] = wrap(originalCallback);
20 |     }
21 |     // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it
22 |     // also only supports 2 argument and doesn't care what "this" is, so we
23 |     // can just call the original function directly.
24 |     if (originalFn.apply) {
25 |       return originalFn.apply(this, args);
26 |     } else {
27 |       return originalFn(args[0], args[1]);
28 |     }
29 |   };
30 | }
31 | 
32 | export function extendToAsynchronousCallbacks() {
33 |   _helper('setTimeout');
34 |   _helper('setInterval');
35 | }
36 | 


--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * A better form of hasOwnProperty<br/>
 3 |  * Example: `_has(MainHostObject, property) === true/false`
 4 |  *
 5 |  * @param {Object} object to check property
 6 |  * @param {string} key to check
 7 |  * @return {Boolean} true if the object has the key and it is not inherited
 8 |  */
 9 | export function _has(object, key) {
10 |   return Object.prototype.hasOwnProperty.call(object, key);
11 | }
12 | 
13 | /**
14 |  * Returns true if the parameter is undefined<br/>
15 |  * Example: `_isUndefined(val) === true/false`
16 |  *
17 |  * @param {*} what Value to check
18 |  * @return {Boolean} true if undefined and false otherwise
19 |  */
20 | export function _isUndefined(what) {
21 |   return typeof what === 'undefined';
22 | }


--------------------------------------------------------------------------------
/src/wrap.js:
--------------------------------------------------------------------------------
 1 | import report from "./report";
 2 | 
 3 | /**
 4 |  * Wrap any function in a ErrorWatch reporter<br/>
 5 |  * Example: `func = ErrorWatch.wrap(func);`
 6 |  *
 7 |  * @param {Function} func Function to be wrapped
 8 |  * @return {Function} The wrapped func
 9 |  * @memberof ErrorWatch
10 |  */
11 | export function wrap(func) {
12 |   function wrapped() {
13 |     try {
14 |       return func.apply(this, arguments);
15 |     } catch (e) {
16 |       report(e);
17 |       throw e;
18 |     }
19 |   }
20 |   return wrapped;
21 | }
22 | 


--------------------------------------------------------------------------------