konacha 2.1.0 → 2.2.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -58,6 +58,293 @@ module.exports = function(type){
58
58
  }); // module: browser/debug.js
59
59
 
60
60
  require.register("browser/diff.js", function(module, exports, require){
61
+ /* See license.txt for terms of usage */
62
+
63
+ /*
64
+ * Text diff implementation.
65
+ *
66
+ * This library supports the following APIS:
67
+ * JsDiff.diffChars: Character by character diff
68
+ * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
69
+ * JsDiff.diffLines: Line based diff
70
+ *
71
+ * JsDiff.diffCss: Diff targeted at CSS content
72
+ *
73
+ * These methods are based on the implementation proposed in
74
+ * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
75
+ * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
76
+ */
77
+ var JsDiff = (function() {
78
+ function clonePath(path) {
79
+ return { newPos: path.newPos, components: path.components.slice(0) };
80
+ }
81
+ function removeEmpty(array) {
82
+ var ret = [];
83
+ for (var i = 0; i < array.length; i++) {
84
+ if (array[i]) {
85
+ ret.push(array[i]);
86
+ }
87
+ }
88
+ return ret;
89
+ }
90
+ function escapeHTML(s) {
91
+ var n = s;
92
+ n = n.replace(/&/g, "&amp;");
93
+ n = n.replace(/</g, "&lt;");
94
+ n = n.replace(/>/g, "&gt;");
95
+ n = n.replace(/"/g, "&quot;");
96
+
97
+ return n;
98
+ }
99
+
100
+
101
+ var fbDiff = function(ignoreWhitespace) {
102
+ this.ignoreWhitespace = ignoreWhitespace;
103
+ };
104
+ fbDiff.prototype = {
105
+ diff: function(oldString, newString) {
106
+ // Handle the identity case (this is due to unrolling editLength == 0
107
+ if (newString == oldString) {
108
+ return [{ value: newString }];
109
+ }
110
+ if (!newString) {
111
+ return [{ value: oldString, removed: true }];
112
+ }
113
+ if (!oldString) {
114
+ return [{ value: newString, added: true }];
115
+ }
116
+
117
+ newString = this.tokenize(newString);
118
+ oldString = this.tokenize(oldString);
119
+
120
+ var newLen = newString.length, oldLen = oldString.length;
121
+ var maxEditLength = newLen + oldLen;
122
+ var bestPath = [{ newPos: -1, components: [] }];
123
+
124
+ // Seed editLength = 0
125
+ var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);
126
+ if (bestPath[0].newPos+1 >= newLen && oldPos+1 >= oldLen) {
127
+ return bestPath[0].components;
128
+ }
129
+
130
+ for (var editLength = 1; editLength <= maxEditLength; editLength++) {
131
+ for (var diagonalPath = -1*editLength; diagonalPath <= editLength; diagonalPath+=2) {
132
+ var basePath;
133
+ var addPath = bestPath[diagonalPath-1],
134
+ removePath = bestPath[diagonalPath+1];
135
+ oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;
136
+ if (addPath) {
137
+ // No one else is going to attempt to use this value, clear it
138
+ bestPath[diagonalPath-1] = undefined;
139
+ }
140
+
141
+ var canAdd = addPath && addPath.newPos+1 < newLen;
142
+ var canRemove = removePath && 0 <= oldPos && oldPos < oldLen;
143
+ if (!canAdd && !canRemove) {
144
+ bestPath[diagonalPath] = undefined;
145
+ continue;
146
+ }
147
+
148
+ // Select the diagonal that we want to branch from. We select the prior
149
+ // path whose position in the new string is the farthest from the origin
150
+ // and does not pass the bounds of the diff graph
151
+ if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {
152
+ basePath = clonePath(removePath);
153
+ this.pushComponent(basePath.components, oldString[oldPos], undefined, true);
154
+ } else {
155
+ basePath = clonePath(addPath);
156
+ basePath.newPos++;
157
+ this.pushComponent(basePath.components, newString[basePath.newPos], true, undefined);
158
+ }
159
+
160
+ var oldPos = this.extractCommon(basePath, newString, oldString, diagonalPath);
161
+
162
+ if (basePath.newPos+1 >= newLen && oldPos+1 >= oldLen) {
163
+ return basePath.components;
164
+ } else {
165
+ bestPath[diagonalPath] = basePath;
166
+ }
167
+ }
168
+ }
169
+ },
170
+
171
+ pushComponent: function(components, value, added, removed) {
172
+ var last = components[components.length-1];
173
+ if (last && last.added === added && last.removed === removed) {
174
+ // We need to clone here as the component clone operation is just
175
+ // as shallow array clone
176
+ components[components.length-1] =
177
+ {value: this.join(last.value, value), added: added, removed: removed };
178
+ } else {
179
+ components.push({value: value, added: added, removed: removed });
180
+ }
181
+ },
182
+ extractCommon: function(basePath, newString, oldString, diagonalPath) {
183
+ var newLen = newString.length,
184
+ oldLen = oldString.length,
185
+ newPos = basePath.newPos,
186
+ oldPos = newPos - diagonalPath;
187
+ while (newPos+1 < newLen && oldPos+1 < oldLen && this.equals(newString[newPos+1], oldString[oldPos+1])) {
188
+ newPos++;
189
+ oldPos++;
190
+
191
+ this.pushComponent(basePath.components, newString[newPos], undefined, undefined);
192
+ }
193
+ basePath.newPos = newPos;
194
+ return oldPos;
195
+ },
196
+
197
+ equals: function(left, right) {
198
+ var reWhitespace = /\S/;
199
+ if (this.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right)) {
200
+ return true;
201
+ } else {
202
+ return left == right;
203
+ }
204
+ },
205
+ join: function(left, right) {
206
+ return left + right;
207
+ },
208
+ tokenize: function(value) {
209
+ return value;
210
+ }
211
+ };
212
+
213
+ var CharDiff = new fbDiff();
214
+
215
+ var WordDiff = new fbDiff(true);
216
+ WordDiff.tokenize = function(value) {
217
+ return removeEmpty(value.split(/(\s+|\b)/));
218
+ };
219
+
220
+ var CssDiff = new fbDiff(true);
221
+ CssDiff.tokenize = function(value) {
222
+ return removeEmpty(value.split(/([{}:;,]|\s+)/));
223
+ };
224
+
225
+ var LineDiff = new fbDiff();
226
+ LineDiff.tokenize = function(value) {
227
+ return value.split(/^/m);
228
+ };
229
+
230
+ return {
231
+ diffChars: function(oldStr, newStr) { return CharDiff.diff(oldStr, newStr); },
232
+ diffWords: function(oldStr, newStr) { return WordDiff.diff(oldStr, newStr); },
233
+ diffLines: function(oldStr, newStr) { return LineDiff.diff(oldStr, newStr); },
234
+
235
+ diffCss: function(oldStr, newStr) { return CssDiff.diff(oldStr, newStr); },
236
+
237
+ createPatch: function(fileName, oldStr, newStr, oldHeader, newHeader) {
238
+ var ret = [];
239
+
240
+ ret.push("Index: " + fileName);
241
+ ret.push("===================================================================");
242
+ ret.push("--- " + fileName + (typeof oldHeader === "undefined" ? "" : "\t" + oldHeader));
243
+ ret.push("+++ " + fileName + (typeof newHeader === "undefined" ? "" : "\t" + newHeader));
244
+
245
+ var diff = LineDiff.diff(oldStr, newStr);
246
+ if (!diff[diff.length-1].value) {
247
+ diff.pop(); // Remove trailing newline add
248
+ }
249
+ diff.push({value: "", lines: []}); // Append an empty value to make cleanup easier
250
+
251
+ function contextLines(lines) {
252
+ return lines.map(function(entry) { return ' ' + entry; });
253
+ }
254
+ function eofNL(curRange, i, current) {
255
+ var last = diff[diff.length-2],
256
+ isLast = i === diff.length-2,
257
+ isLastOfType = i === diff.length-3 && (current.added === !last.added || current.removed === !last.removed);
258
+
259
+ // Figure out if this is the last line for the given file and missing NL
260
+ if (!/\n$/.test(current.value) && (isLast || isLastOfType)) {
261
+ curRange.push('\');
262
+ }
263
+ }
264
+
265
+ var oldRangeStart = 0, newRangeStart = 0, curRange = [],
266
+ oldLine = 1, newLine = 1;
267
+ for (var i = 0; i < diff.length; i++) {
268
+ var current = diff[i],
269
+ lines = current.lines || current.value.replace(/\n$/, "").split("\n");
270
+ current.lines = lines;
271
+
272
+ if (current.added || current.removed) {
273
+ if (!oldRangeStart) {
274
+ var prev = diff[i-1];
275
+ oldRangeStart = oldLine;
276
+ newRangeStart = newLine;
277
+
278
+ if (prev) {
279
+ curRange = contextLines(prev.lines.slice(-4));
280
+ oldRangeStart -= curRange.length;
281
+ newRangeStart -= curRange.length;
282
+ }
283
+ }
284
+ curRange.push.apply(curRange, lines.map(function(entry) { return (current.added?"+":"-") + entry; }));
285
+ eofNL(curRange, i, current);
286
+
287
+ if (current.added) {
288
+ newLine += lines.length;
289
+ } else {
290
+ oldLine += lines.length;
291
+ }
292
+ } else {
293
+ if (oldRangeStart) {
294
+ // Close out any changes that have been output (or join overlapping)
295
+ if (lines.length <= 8 && i < diff.length-2) {
296
+ // Overlapping
297
+ curRange.push.apply(curRange, contextLines(lines));
298
+ } else {
299
+ // end the range and output
300
+ var contextSize = Math.min(lines.length, 4);
301
+ ret.push(
302
+ "@@ -" + oldRangeStart + "," + (oldLine-oldRangeStart+contextSize)
303
+ + " +" + newRangeStart + "," + (newLine-newRangeStart+contextSize)
304
+ + " @@");
305
+ ret.push.apply(ret, curRange);
306
+ ret.push.apply(ret, contextLines(lines.slice(0, contextSize)));
307
+ if (lines.length <= 4) {
308
+ eofNL(ret, i, current);
309
+ }
310
+
311
+ oldRangeStart = 0; newRangeStart = 0; curRange = [];
312
+ }
313
+ }
314
+ oldLine += lines.length;
315
+ newLine += lines.length;
316
+ }
317
+ }
318
+
319
+ return ret.join('\n') + '\n';
320
+ },
321
+
322
+ convertChangesToXML: function(changes){
323
+ var ret = [];
324
+ for ( var i = 0; i < changes.length; i++) {
325
+ var change = changes[i];
326
+ if (change.added) {
327
+ ret.push("<ins>");
328
+ } else if (change.removed) {
329
+ ret.push("<del>");
330
+ }
331
+
332
+ ret.push(escapeHTML(change.value));
333
+
334
+ if (change.added) {
335
+ ret.push("</ins>");
336
+ } else if (change.removed) {
337
+ ret.push("</del>");
338
+ }
339
+ }
340
+ return ret.join("");
341
+ }
342
+ };
343
+ })();
344
+
345
+ if (typeof module !== "undefined") {
346
+ module.exports = JsDiff;
347
+ }
61
348
 
62
349
  }); // module: browser/diff.js
63
350
 
@@ -494,7 +781,9 @@ function Hook(title, fn) {
494
781
  * Inherit from `Runnable.prototype`.
495
782
  */
496
783
 
497
- Hook.prototype = new Runnable;
784
+ function F(){};
785
+ F.prototype = Runnable.prototype;
786
+ Hook.prototype = new F;
498
787
  Hook.prototype.constructor = Hook;
499
788
 
500
789
 
@@ -1005,6 +1294,7 @@ function image(name) {
1005
1294
  * - `reporter` reporter instance, defaults to `mocha.reporters.Dot`
1006
1295
  * - `globals` array of accepted globals
1007
1296
  * - `timeout` timeout in milliseconds
1297
+ * - `bail` bail on the first test failure
1008
1298
  * - `slow` milliseconds to wait before considering a test slow
1009
1299
  * - `ignoreLeaks` ignore global leaks
1010
1300
  * - `grep` string or regexp to filter tests with
@@ -1020,11 +1310,25 @@ function Mocha(options) {
1020
1310
  this.grep(options.grep);
1021
1311
  this.suite = new exports.Suite('', new exports.Context);
1022
1312
  this.ui(options.ui);
1313
+ this.bail(options.bail);
1023
1314
  this.reporter(options.reporter);
1024
1315
  if (options.timeout) this.timeout(options.timeout);
1025
1316
  if (options.slow) this.slow(options.slow);
1026
1317
  }
1027
1318
 
1319
+ /**
1320
+ * Enable or disable bailing on the first failure.
1321
+ *
1322
+ * @param {Boolean} [bail]
1323
+ * @api public
1324
+ */
1325
+
1326
+ Mocha.prototype.bail = function(bail){
1327
+ if (0 == arguments.length) bail = true;
1328
+ this.suite.bail(bail);
1329
+ return this;
1330
+ };
1331
+
1028
1332
  /**
1029
1333
  * Add test `file`.
1030
1334
  *
@@ -1040,7 +1344,7 @@ Mocha.prototype.addFile = function(file){
1040
1344
  /**
1041
1345
  * Set reporter to `reporter`, defaults to "dot".
1042
1346
  *
1043
- * @param {String|Function} reporter name of a reporter or a reporter constructor
1347
+ * @param {String|Function} reporter name or constructor
1044
1348
  * @api public
1045
1349
  */
1046
1350
 
@@ -1408,7 +1712,7 @@ exports.colors = {
1408
1712
  */
1409
1713
 
1410
1714
  exports.symbols = {
1411
- ok: '',
1715
+ ok: '',
1412
1716
  err: '✖',
1413
1717
  dot: '․'
1414
1718
  };
@@ -1651,7 +1955,7 @@ Base.prototype.epilogue = function(){
1651
1955
  }
1652
1956
 
1653
1957
  // pass
1654
- fmt = color('bright pass', ' ' + exports.symbols.ok)
1958
+ fmt = color('bright pass', ' ')
1655
1959
  + color('green', ' %d %s complete')
1656
1960
  + color('light', ' (%s)');
1657
1961
 
@@ -1662,7 +1966,7 @@ Base.prototype.epilogue = function(){
1662
1966
 
1663
1967
  // pending
1664
1968
  if (stats.pending) {
1665
- fmt = color('pending', '')
1969
+ fmt = color('pending', ' ')
1666
1970
  + color('pending', ' %d %s pending');
1667
1971
 
1668
1972
  console.log(fmt, stats.pending, pluralize(stats.pending));
@@ -1846,7 +2150,9 @@ function Dot(runner) {
1846
2150
  * Inherit from `Base.prototype`.
1847
2151
  */
1848
2152
 
1849
- Dot.prototype = new Base;
2153
+ function F(){};
2154
+ F.prototype = Base.prototype;
2155
+ Dot.prototype = new F;
1850
2156
  Dot.prototype.constructor = Dot;
1851
2157
 
1852
2158
  }); // module: reporters/dot.js
@@ -2024,7 +2330,7 @@ function HTML(runner, root) {
2024
2330
  });
2025
2331
 
2026
2332
  runner.on('fail', function(test, err){
2027
- if ('hook' == test.type || err.uncaught) runner.emit('test end', test);
2333
+ if ('hook' == test.type) runner.emit('test end', test);
2028
2334
  });
2029
2335
 
2030
2336
  runner.on('test end', function(test){
@@ -2073,7 +2379,7 @@ function HTML(runner, root) {
2073
2379
 
2074
2380
  on(h2, 'click', function(){
2075
2381
  pre.style.display = 'none' == pre.style.display
2076
- ? 'inline-block'
2382
+ ? 'block'
2077
2383
  : 'none';
2078
2384
  });
2079
2385
 
@@ -2578,7 +2884,9 @@ function Landing(runner) {
2578
2884
  * Inherit from `Base.prototype`.
2579
2885
  */
2580
2886
 
2581
- Landing.prototype = new Base;
2887
+ function F(){};
2888
+ F.prototype = Base.prototype;
2889
+ Landing.prototype = new F;
2582
2890
  Landing.prototype.constructor = Landing;
2583
2891
 
2584
2892
  }); // module: reporters/landing.js
@@ -2647,7 +2955,9 @@ function List(runner) {
2647
2955
  * Inherit from `Base.prototype`.
2648
2956
  */
2649
2957
 
2650
- List.prototype = new Base;
2958
+ function F(){};
2959
+ F.prototype = Base.prototype;
2960
+ List.prototype = new F;
2651
2961
  List.prototype.constructor = List;
2652
2962
 
2653
2963
 
@@ -2679,7 +2989,6 @@ function Markdown(runner) {
2679
2989
 
2680
2990
  var self = this
2681
2991
  , stats = this.stats
2682
- , total = runner.total
2683
2992
  , level = 0
2684
2993
  , buf = '';
2685
2994
 
@@ -2786,7 +3095,9 @@ function Min(runner) {
2786
3095
  * Inherit from `Base.prototype`.
2787
3096
  */
2788
3097
 
2789
- Min.prototype = new Base;
3098
+ function F(){};
3099
+ F.prototype = Base.prototype;
3100
+ Min.prototype = new F;
2790
3101
  Min.prototype.constructor = Min;
2791
3102
 
2792
3103
  }); // module: reporters/min.js
@@ -3050,7 +3361,9 @@ function write(string) {
3050
3361
  * Inherit from `Base.prototype`.
3051
3362
  */
3052
3363
 
3053
- NyanCat.prototype = new Base;
3364
+ function F(){};
3365
+ F.prototype = Base.prototype;
3366
+ NyanCat.prototype = new F;
3054
3367
  NyanCat.prototype.constructor = NyanCat;
3055
3368
 
3056
3369
 
@@ -3142,7 +3455,9 @@ function Progress(runner, options) {
3142
3455
  * Inherit from `Base.prototype`.
3143
3456
  */
3144
3457
 
3145
- Progress.prototype = new Base;
3458
+ function F(){};
3459
+ F.prototype = Base.prototype;
3460
+ Progress.prototype = new F;
3146
3461
  Progress.prototype.constructor = Progress;
3147
3462
 
3148
3463
 
@@ -3235,7 +3550,9 @@ function Spec(runner) {
3235
3550
  * Inherit from `Base.prototype`.
3236
3551
  */
3237
3552
 
3238
- Spec.prototype = new Base;
3553
+ function F(){};
3554
+ F.prototype = Base.prototype;
3555
+ Spec.prototype = new F;
3239
3556
  Spec.prototype.constructor = Spec;
3240
3557
 
3241
3558
 
@@ -3269,7 +3586,9 @@ function TAP(runner) {
3269
3586
 
3270
3587
  var self = this
3271
3588
  , stats = this.stats
3272
- , n = 1;
3589
+ , n = 1
3590
+ , passes = 0
3591
+ , failures = 0;
3273
3592
 
3274
3593
  runner.on('start', function(){
3275
3594
  var total = runner.grepTotal(runner.suite);
@@ -3285,12 +3604,20 @@ function TAP(runner) {
3285
3604
  });
3286
3605
 
3287
3606
  runner.on('pass', function(test){
3607
+ passes++;
3288
3608
  console.log('ok %d %s', n, title(test));
3289
3609
  });
3290
3610
 
3291
3611
  runner.on('fail', function(test, err){
3612
+ failures++;
3292
3613
  console.log('not ok %d %s', n, title(test));
3293
- console.log(err.stack.replace(/^/gm, ' '));
3614
+ if (err.stack) console.log(err.stack.replace(/^/gm, ' '));
3615
+ });
3616
+
3617
+ runner.on('end', function(){
3618
+ console.log('# tests ' + (passes + failures));
3619
+ console.log('# pass ' + passes);
3620
+ console.log('# fail ' + failures);
3294
3621
  });
3295
3622
  }
3296
3623
 
@@ -3444,7 +3771,9 @@ function XUnit(runner) {
3444
3771
  * Inherit from `Base.prototype`.
3445
3772
  */
3446
3773
 
3447
- XUnit.prototype = new Base;
3774
+ function F(){};
3775
+ F.prototype = Base.prototype;
3776
+ XUnit.prototype = new F;
3448
3777
  XUnit.prototype.constructor = XUnit;
3449
3778
 
3450
3779
 
@@ -3552,7 +3881,9 @@ function Runnable(title, fn) {
3552
3881
  * Inherit from `EventEmitter.prototype`.
3553
3882
  */
3554
3883
 
3555
- Runnable.prototype = new EventEmitter;
3884
+ function F(){};
3885
+ F.prototype = EventEmitter.prototype;
3886
+ Runnable.prototype = new F;
3556
3887
  Runnable.prototype.constructor = Runnable;
3557
3888
 
3558
3889
 
@@ -3697,7 +4028,7 @@ Runnable.prototype.run = function(fn){
3697
4028
  if (this.async) {
3698
4029
  try {
3699
4030
  this.fn.call(ctx, function(err){
3700
- if (toString.call(err) === "[object Error]") return done(err);
4031
+ if (err instanceof Error || toString.call(err) === "[object Error]") return done(err);
3701
4032
  if (null != err) return done(new Error('done() invoked with non-Error: ' + err));
3702
4033
  done();
3703
4034
  });
@@ -3791,7 +4122,9 @@ function Runner(suite) {
3791
4122
  * Inherit from `EventEmitter.prototype`.
3792
4123
  */
3793
4124
 
3794
- Runner.prototype = new EventEmitter;
4125
+ function F(){};
4126
+ F.prototype = EventEmitter.prototype;
4127
+ Runner.prototype = new F;
3795
4128
  Runner.prototype.constructor = Runner;
3796
4129
 
3797
4130
 
@@ -3847,7 +4180,7 @@ Runner.prototype.globalProps = function() {
3847
4180
 
3848
4181
  // non-enumerables
3849
4182
  for (var i = 0; i < globals.length; ++i) {
3850
- if (~props.indexOf(globals[i])) continue;
4183
+ if (~utils.indexOf(props, globals[i])) continue;
3851
4184
  props.push(globals[i]);
3852
4185
  }
3853
4186
 
@@ -3909,9 +4242,11 @@ Runner.prototype.checkGlobals = function(test){
3909
4242
  Runner.prototype.fail = function(test, err){
3910
4243
  ++this.failures;
3911
4244
  test.state = 'failed';
4245
+
3912
4246
  if ('string' == typeof err) {
3913
4247
  err = new Error('the string "' + err + '" was thrown, throw an Error :)');
3914
4248
  }
4249
+
3915
4250
  this.emit('fail', test, err);
3916
4251
  };
3917
4252
 
@@ -4213,15 +4548,12 @@ Runner.prototype.run = function(fn){
4213
4548
 
4214
4549
  debug('start');
4215
4550
 
4216
- // uncaught callback
4217
- function uncaught(err) {
4218
- self.uncaught(err);
4219
- }
4220
-
4221
4551
  // callback
4222
4552
  this.on('end', function(){
4223
4553
  debug('end');
4224
- process.removeListener('uncaughtException', uncaught);
4554
+ process.removeListener('uncaughtException', function(err){
4555
+ self.uncaught(err);
4556
+ });
4225
4557
  fn(self.failures);
4226
4558
  });
4227
4559
 
@@ -4233,7 +4565,9 @@ Runner.prototype.run = function(fn){
4233
4565
  });
4234
4566
 
4235
4567
  // uncaught exception
4236
- process.on('uncaughtException', uncaught);
4568
+ process.on('uncaughtException', function(err){
4569
+ self.uncaught(err);
4570
+ });
4237
4571
 
4238
4572
  return this;
4239
4573
  };
@@ -4330,7 +4664,9 @@ function Suite(title, ctx) {
4330
4664
  * Inherit from `EventEmitter.prototype`.
4331
4665
  */
4332
4666
 
4333
- Suite.prototype = new EventEmitter;
4667
+ function F(){};
4668
+ F.prototype = EventEmitter.prototype;
4669
+ Suite.prototype = new F;
4334
4670
  Suite.prototype.constructor = Suite;
4335
4671
 
4336
4672
 
@@ -4595,7 +4931,9 @@ function Test(title, fn) {
4595
4931
  * Inherit from `Runnable.prototype`.
4596
4932
  */
4597
4933
 
4598
- Test.prototype = new Runnable;
4934
+ function F(){};
4935
+ F.prototype = Runnable.prototype;
4936
+ Test.prototype = new F;
4599
4937
  Test.prototype.constructor = Test;
4600
4938
 
4601
4939
 
@@ -4944,7 +5282,9 @@ process.removeListener = function(e){
4944
5282
 
4945
5283
  process.on = function(e, fn){
4946
5284
  if ('uncaughtException' == e) {
4947
- window.onerror = fn;
5285
+ window.onerror = function(err, url, line){
5286
+ fn(new Error(err + ' (' + url + ':' + line + ')'));
5287
+ };
4948
5288
  }
4949
5289
  };
4950
5290