stackprofiler 0.0.3 → 0.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (51) hide show
  1. checksums.yaml +4 -4
  2. data/.gitignore +2 -1
  3. data/README.md +1 -1
  4. data/config.ru +3 -2
  5. data/lib/stackprofiler.rb +0 -1
  6. data/lib/stackprofiler/filters/build_tree.rb +3 -4
  7. data/lib/stackprofiler/filters/gem_removal.rb +3 -0
  8. data/lib/stackprofiler/web_ui.rb +34 -11
  9. data/lib/stackprofiler/web_ui/public/css/stackprofiler.css +77 -0
  10. data/lib/stackprofiler/web_ui/public/js/stackprofiler.js +129 -58
  11. data/lib/stackprofiler/web_ui/public/vendor/ace/ace.js +18298 -0
  12. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-beautify.js +334 -0
  13. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-chromevox.js +541 -0
  14. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-elastic_tabstops_lite.js +275 -0
  15. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-emmet.js +1190 -0
  16. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-error_marker.js +6 -0
  17. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-keybinding_menu.js +170 -0
  18. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-language_tools.js +1934 -0
  19. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-linking.js +52 -0
  20. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-modelist.js +187 -0
  21. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-old_ie.js +494 -0
  22. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-searchbox.js +409 -0
  23. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-settings_menu.js +637 -0
  24. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-spellcheck.js +71 -0
  25. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-split.js +246 -0
  26. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-static_highlight.js +154 -0
  27. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-statusbar.js +51 -0
  28. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-textarea.js +632 -0
  29. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-themelist.js +58 -0
  30. data/lib/stackprofiler/web_ui/public/vendor/ace/ext-whitespace.js +181 -0
  31. data/lib/stackprofiler/web_ui/public/vendor/ace/keybinding-emacs.js +1182 -0
  32. data/lib/stackprofiler/web_ui/public/vendor/ace/keybinding-vim.js +5320 -0
  33. data/lib/stackprofiler/web_ui/public/vendor/ace/mode-haml.js +525 -0
  34. data/lib/stackprofiler/web_ui/public/vendor/ace/mode-html.js +2427 -0
  35. data/lib/stackprofiler/web_ui/public/vendor/ace/mode-html_ruby.js +2955 -0
  36. data/lib/stackprofiler/web_ui/public/vendor/ace/mode-javascript.js +1025 -0
  37. data/lib/stackprofiler/web_ui/public/vendor/ace/mode-json.js +668 -0
  38. data/lib/stackprofiler/web_ui/public/vendor/ace/mode-ruby.js +839 -0
  39. data/lib/stackprofiler/web_ui/public/vendor/ace/mode-xml.js +637 -0
  40. data/lib/stackprofiler/web_ui/public/vendor/ace/mode-yaml.js +256 -0
  41. data/lib/stackprofiler/web_ui/public/vendor/ace/theme-xcode.js +89 -0
  42. data/lib/stackprofiler/web_ui/public/vendor/ace/worker-coffee.js +7599 -0
  43. data/lib/stackprofiler/web_ui/public/vendor/ace/worker-css.js +8682 -0
  44. data/lib/stackprofiler/web_ui/public/vendor/ace/worker-html.js +11527 -0
  45. data/lib/stackprofiler/web_ui/public/vendor/ace/worker-javascript.js +10429 -0
  46. data/lib/stackprofiler/web_ui/public/vendor/ace/worker-json.js +2319 -0
  47. data/lib/stackprofiler/web_ui/views/index.erb +1 -1
  48. data/lib/stackprofiler/web_ui/views/layout.erb +2 -55
  49. data/stackprofiler.gemspec +2 -4
  50. metadata +42 -19
  51. data/lib/stackprofiler/web_ui/views/code.erb +0 -17
@@ -0,0 +1,2319 @@
1
+ "no use strict";
2
+ ;(function(window) {
3
+ if (typeof window.window != "undefined" && window.document) {
4
+ return;
5
+ }
6
+
7
+ window.console = function() {
8
+ var msgs = Array.prototype.slice.call(arguments, 0);
9
+ postMessage({type: "log", data: msgs});
10
+ };
11
+ window.console.error =
12
+ window.console.warn =
13
+ window.console.log =
14
+ window.console.trace = window.console;
15
+
16
+ window.window = window;
17
+ window.ace = window;
18
+
19
+ window.onerror = function(message, file, line, col, err) {
20
+ postMessage({type: "error", data: {
21
+ message: message,
22
+ file: file,
23
+ line: line,
24
+ col: col,
25
+ stack: err.stack
26
+ }});
27
+ };
28
+
29
+ window.normalizeModule = function(parentId, moduleName) {
30
+ // normalize plugin requires
31
+ if (moduleName.indexOf("!") !== -1) {
32
+ var chunks = moduleName.split("!");
33
+ return window.normalizeModule(parentId, chunks[0]) + "!" + window.normalizeModule(parentId, chunks[1]);
34
+ }
35
+ // normalize relative requires
36
+ if (moduleName.charAt(0) == ".") {
37
+ var base = parentId.split("/").slice(0, -1).join("/");
38
+ moduleName = (base ? base + "/" : "") + moduleName;
39
+
40
+ while(moduleName.indexOf(".") !== -1 && previous != moduleName) {
41
+ var previous = moduleName;
42
+ moduleName = moduleName.replace(/^\.\//, "").replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, "");
43
+ }
44
+ }
45
+
46
+ return moduleName;
47
+ };
48
+
49
+ window.require = function(parentId, id) {
50
+ if (!id) {
51
+ id = parentId;
52
+ parentId = null;
53
+ }
54
+ if (!id.charAt)
55
+ throw new Error("worker.js require() accepts only (parentId, id) as arguments");
56
+
57
+ id = window.normalizeModule(parentId, id);
58
+
59
+ var module = window.require.modules[id];
60
+ if (module) {
61
+ if (!module.initialized) {
62
+ module.initialized = true;
63
+ module.exports = module.factory().exports;
64
+ }
65
+ return module.exports;
66
+ }
67
+
68
+ var chunks = id.split("/");
69
+ if (!window.require.tlns)
70
+ return console.log("unable to load " + id);
71
+ chunks[0] = window.require.tlns[chunks[0]] || chunks[0];
72
+ var path = chunks.join("/") + ".js";
73
+
74
+ window.require.id = id;
75
+ importScripts(path);
76
+ return window.require(parentId, id);
77
+ };
78
+ window.require.modules = {};
79
+ window.require.tlns = {};
80
+
81
+ window.define = function(id, deps, factory) {
82
+ if (arguments.length == 2) {
83
+ factory = deps;
84
+ if (typeof id != "string") {
85
+ deps = id;
86
+ id = window.require.id;
87
+ }
88
+ } else if (arguments.length == 1) {
89
+ factory = id;
90
+ deps = [];
91
+ id = window.require.id;
92
+ }
93
+
94
+ if (typeof factory != "function") {
95
+ window.require.modules[id] = {
96
+ exports: factory,
97
+ initialized: true
98
+ };
99
+ return;
100
+ }
101
+
102
+ if (!deps.length)
103
+ // If there is no dependencies, we inject 'require', 'exports' and
104
+ // 'module' as dependencies, to provide CommonJS compatibility.
105
+ deps = ['require', 'exports', 'module'];
106
+
107
+ var req = function(childId) {
108
+ return window.require(id, childId);
109
+ };
110
+
111
+ window.require.modules[id] = {
112
+ exports: {},
113
+ factory: function() {
114
+ var module = this;
115
+ var returnExports = factory.apply(this, deps.map(function(dep) {
116
+ switch(dep) {
117
+ // Because 'require', 'exports' and 'module' aren't actual
118
+ // dependencies, we must handle them seperately.
119
+ case 'require': return req;
120
+ case 'exports': return module.exports;
121
+ case 'module': return module;
122
+ // But for all other dependencies, we can just go ahead and
123
+ // require them.
124
+ default: return req(dep);
125
+ }
126
+ }));
127
+ if (returnExports)
128
+ module.exports = returnExports;
129
+ return module;
130
+ }
131
+ };
132
+ };
133
+ window.define.amd = {};
134
+
135
+ window.initBaseUrls = function initBaseUrls(topLevelNamespaces) {
136
+ require.tlns = topLevelNamespaces;
137
+ };
138
+
139
+ window.initSender = function initSender() {
140
+
141
+ var EventEmitter = window.require("ace/lib/event_emitter").EventEmitter;
142
+ var oop = window.require("ace/lib/oop");
143
+
144
+ var Sender = function() {};
145
+
146
+ (function() {
147
+
148
+ oop.implement(this, EventEmitter);
149
+
150
+ this.callback = function(data, callbackId) {
151
+ postMessage({
152
+ type: "call",
153
+ id: callbackId,
154
+ data: data
155
+ });
156
+ };
157
+
158
+ this.emit = function(name, data) {
159
+ postMessage({
160
+ type: "event",
161
+ name: name,
162
+ data: data
163
+ });
164
+ };
165
+
166
+ }).call(Sender.prototype);
167
+
168
+ return new Sender();
169
+ };
170
+
171
+ var main = window.main = null;
172
+ var sender = window.sender = null;
173
+
174
+ window.onmessage = function(e) {
175
+ var msg = e.data;
176
+ if (msg.command) {
177
+ if (main[msg.command])
178
+ main[msg.command].apply(main, msg.args);
179
+ else
180
+ throw new Error("Unknown command:" + msg.command);
181
+ }
182
+ else if (msg.init) {
183
+ initBaseUrls(msg.tlns);
184
+ require("ace/lib/es5-shim");
185
+ sender = window.sender = initSender();
186
+ var clazz = require(msg.module)[msg.classname];
187
+ main = window.main = new clazz(sender);
188
+ }
189
+ else if (msg.event && sender) {
190
+ sender._signal(msg.event, msg.data);
191
+ }
192
+ };
193
+ })(this);
194
+
195
+ ace.define("ace/lib/oop",["require","exports","module"], function(require, exports, module) {
196
+ "use strict";
197
+
198
+ exports.inherits = function(ctor, superCtor) {
199
+ ctor.super_ = superCtor;
200
+ ctor.prototype = Object.create(superCtor.prototype, {
201
+ constructor: {
202
+ value: ctor,
203
+ enumerable: false,
204
+ writable: true,
205
+ configurable: true
206
+ }
207
+ });
208
+ };
209
+
210
+ exports.mixin = function(obj, mixin) {
211
+ for (var key in mixin) {
212
+ obj[key] = mixin[key];
213
+ }
214
+ return obj;
215
+ };
216
+
217
+ exports.implement = function(proto, mixin) {
218
+ exports.mixin(proto, mixin);
219
+ };
220
+
221
+ });
222
+
223
+ ace.define("ace/lib/event_emitter",["require","exports","module"], function(require, exports, module) {
224
+ "use strict";
225
+
226
+ var EventEmitter = {};
227
+ var stopPropagation = function() { this.propagationStopped = true; };
228
+ var preventDefault = function() { this.defaultPrevented = true; };
229
+
230
+ EventEmitter._emit =
231
+ EventEmitter._dispatchEvent = function(eventName, e) {
232
+ this._eventRegistry || (this._eventRegistry = {});
233
+ this._defaultHandlers || (this._defaultHandlers = {});
234
+
235
+ var listeners = this._eventRegistry[eventName] || [];
236
+ var defaultHandler = this._defaultHandlers[eventName];
237
+ if (!listeners.length && !defaultHandler)
238
+ return;
239
+
240
+ if (typeof e != "object" || !e)
241
+ e = {};
242
+
243
+ if (!e.type)
244
+ e.type = eventName;
245
+ if (!e.stopPropagation)
246
+ e.stopPropagation = stopPropagation;
247
+ if (!e.preventDefault)
248
+ e.preventDefault = preventDefault;
249
+
250
+ listeners = listeners.slice();
251
+ for (var i=0; i<listeners.length; i++) {
252
+ listeners[i](e, this);
253
+ if (e.propagationStopped)
254
+ break;
255
+ }
256
+
257
+ if (defaultHandler && !e.defaultPrevented)
258
+ return defaultHandler(e, this);
259
+ };
260
+
261
+
262
+ EventEmitter._signal = function(eventName, e) {
263
+ var listeners = (this._eventRegistry || {})[eventName];
264
+ if (!listeners)
265
+ return;
266
+ listeners = listeners.slice();
267
+ for (var i=0; i<listeners.length; i++)
268
+ listeners[i](e, this);
269
+ };
270
+
271
+ EventEmitter.once = function(eventName, callback) {
272
+ var _self = this;
273
+ callback && this.addEventListener(eventName, function newCallback() {
274
+ _self.removeEventListener(eventName, newCallback);
275
+ callback.apply(null, arguments);
276
+ });
277
+ };
278
+
279
+
280
+ EventEmitter.setDefaultHandler = function(eventName, callback) {
281
+ var handlers = this._defaultHandlers
282
+ if (!handlers)
283
+ handlers = this._defaultHandlers = {_disabled_: {}};
284
+
285
+ if (handlers[eventName]) {
286
+ var old = handlers[eventName];
287
+ var disabled = handlers._disabled_[eventName];
288
+ if (!disabled)
289
+ handlers._disabled_[eventName] = disabled = [];
290
+ disabled.push(old);
291
+ var i = disabled.indexOf(callback);
292
+ if (i != -1)
293
+ disabled.splice(i, 1);
294
+ }
295
+ handlers[eventName] = callback;
296
+ };
297
+ EventEmitter.removeDefaultHandler = function(eventName, callback) {
298
+ var handlers = this._defaultHandlers
299
+ if (!handlers)
300
+ return;
301
+ var disabled = handlers._disabled_[eventName];
302
+
303
+ if (handlers[eventName] == callback) {
304
+ var old = handlers[eventName];
305
+ if (disabled)
306
+ this.setDefaultHandler(eventName, disabled.pop());
307
+ } else if (disabled) {
308
+ var i = disabled.indexOf(callback);
309
+ if (i != -1)
310
+ disabled.splice(i, 1);
311
+ }
312
+ };
313
+
314
+ EventEmitter.on =
315
+ EventEmitter.addEventListener = function(eventName, callback, capturing) {
316
+ this._eventRegistry = this._eventRegistry || {};
317
+
318
+ var listeners = this._eventRegistry[eventName];
319
+ if (!listeners)
320
+ listeners = this._eventRegistry[eventName] = [];
321
+
322
+ if (listeners.indexOf(callback) == -1)
323
+ listeners[capturing ? "unshift" : "push"](callback);
324
+ return callback;
325
+ };
326
+
327
+ EventEmitter.off =
328
+ EventEmitter.removeListener =
329
+ EventEmitter.removeEventListener = function(eventName, callback) {
330
+ this._eventRegistry = this._eventRegistry || {};
331
+
332
+ var listeners = this._eventRegistry[eventName];
333
+ if (!listeners)
334
+ return;
335
+
336
+ var index = listeners.indexOf(callback);
337
+ if (index !== -1)
338
+ listeners.splice(index, 1);
339
+ };
340
+
341
+ EventEmitter.removeAllListeners = function(eventName) {
342
+ if (this._eventRegistry) this._eventRegistry[eventName] = [];
343
+ };
344
+
345
+ exports.EventEmitter = EventEmitter;
346
+
347
+ });
348
+
349
+ ace.define("ace/range",["require","exports","module"], function(require, exports, module) {
350
+ "use strict";
351
+ var comparePoints = function(p1, p2) {
352
+ return p1.row - p2.row || p1.column - p2.column;
353
+ };
354
+ var Range = function(startRow, startColumn, endRow, endColumn) {
355
+ this.start = {
356
+ row: startRow,
357
+ column: startColumn
358
+ };
359
+
360
+ this.end = {
361
+ row: endRow,
362
+ column: endColumn
363
+ };
364
+ };
365
+
366
+ (function() {
367
+ this.isEqual = function(range) {
368
+ return this.start.row === range.start.row &&
369
+ this.end.row === range.end.row &&
370
+ this.start.column === range.start.column &&
371
+ this.end.column === range.end.column;
372
+ };
373
+ this.toString = function() {
374
+ return ("Range: [" + this.start.row + "/" + this.start.column +
375
+ "] -> [" + this.end.row + "/" + this.end.column + "]");
376
+ };
377
+
378
+ this.contains = function(row, column) {
379
+ return this.compare(row, column) == 0;
380
+ };
381
+ this.compareRange = function(range) {
382
+ var cmp,
383
+ end = range.end,
384
+ start = range.start;
385
+
386
+ cmp = this.compare(end.row, end.column);
387
+ if (cmp == 1) {
388
+ cmp = this.compare(start.row, start.column);
389
+ if (cmp == 1) {
390
+ return 2;
391
+ } else if (cmp == 0) {
392
+ return 1;
393
+ } else {
394
+ return 0;
395
+ }
396
+ } else if (cmp == -1) {
397
+ return -2;
398
+ } else {
399
+ cmp = this.compare(start.row, start.column);
400
+ if (cmp == -1) {
401
+ return -1;
402
+ } else if (cmp == 1) {
403
+ return 42;
404
+ } else {
405
+ return 0;
406
+ }
407
+ }
408
+ };
409
+ this.comparePoint = function(p) {
410
+ return this.compare(p.row, p.column);
411
+ };
412
+ this.containsRange = function(range) {
413
+ return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0;
414
+ };
415
+ this.intersects = function(range) {
416
+ var cmp = this.compareRange(range);
417
+ return (cmp == -1 || cmp == 0 || cmp == 1);
418
+ };
419
+ this.isEnd = function(row, column) {
420
+ return this.end.row == row && this.end.column == column;
421
+ };
422
+ this.isStart = function(row, column) {
423
+ return this.start.row == row && this.start.column == column;
424
+ };
425
+ this.setStart = function(row, column) {
426
+ if (typeof row == "object") {
427
+ this.start.column = row.column;
428
+ this.start.row = row.row;
429
+ } else {
430
+ this.start.row = row;
431
+ this.start.column = column;
432
+ }
433
+ };
434
+ this.setEnd = function(row, column) {
435
+ if (typeof row == "object") {
436
+ this.end.column = row.column;
437
+ this.end.row = row.row;
438
+ } else {
439
+ this.end.row = row;
440
+ this.end.column = column;
441
+ }
442
+ };
443
+ this.inside = function(row, column) {
444
+ if (this.compare(row, column) == 0) {
445
+ if (this.isEnd(row, column) || this.isStart(row, column)) {
446
+ return false;
447
+ } else {
448
+ return true;
449
+ }
450
+ }
451
+ return false;
452
+ };
453
+ this.insideStart = function(row, column) {
454
+ if (this.compare(row, column) == 0) {
455
+ if (this.isEnd(row, column)) {
456
+ return false;
457
+ } else {
458
+ return true;
459
+ }
460
+ }
461
+ return false;
462
+ };
463
+ this.insideEnd = function(row, column) {
464
+ if (this.compare(row, column) == 0) {
465
+ if (this.isStart(row, column)) {
466
+ return false;
467
+ } else {
468
+ return true;
469
+ }
470
+ }
471
+ return false;
472
+ };
473
+ this.compare = function(row, column) {
474
+ if (!this.isMultiLine()) {
475
+ if (row === this.start.row) {
476
+ return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0);
477
+ };
478
+ }
479
+
480
+ if (row < this.start.row)
481
+ return -1;
482
+
483
+ if (row > this.end.row)
484
+ return 1;
485
+
486
+ if (this.start.row === row)
487
+ return column >= this.start.column ? 0 : -1;
488
+
489
+ if (this.end.row === row)
490
+ return column <= this.end.column ? 0 : 1;
491
+
492
+ return 0;
493
+ };
494
+ this.compareStart = function(row, column) {
495
+ if (this.start.row == row && this.start.column == column) {
496
+ return -1;
497
+ } else {
498
+ return this.compare(row, column);
499
+ }
500
+ };
501
+ this.compareEnd = function(row, column) {
502
+ if (this.end.row == row && this.end.column == column) {
503
+ return 1;
504
+ } else {
505
+ return this.compare(row, column);
506
+ }
507
+ };
508
+ this.compareInside = function(row, column) {
509
+ if (this.end.row == row && this.end.column == column) {
510
+ return 1;
511
+ } else if (this.start.row == row && this.start.column == column) {
512
+ return -1;
513
+ } else {
514
+ return this.compare(row, column);
515
+ }
516
+ };
517
+ this.clipRows = function(firstRow, lastRow) {
518
+ if (this.end.row > lastRow)
519
+ var end = {row: lastRow + 1, column: 0};
520
+ else if (this.end.row < firstRow)
521
+ var end = {row: firstRow, column: 0};
522
+
523
+ if (this.start.row > lastRow)
524
+ var start = {row: lastRow + 1, column: 0};
525
+ else if (this.start.row < firstRow)
526
+ var start = {row: firstRow, column: 0};
527
+
528
+ return Range.fromPoints(start || this.start, end || this.end);
529
+ };
530
+ this.extend = function(row, column) {
531
+ var cmp = this.compare(row, column);
532
+
533
+ if (cmp == 0)
534
+ return this;
535
+ else if (cmp == -1)
536
+ var start = {row: row, column: column};
537
+ else
538
+ var end = {row: row, column: column};
539
+
540
+ return Range.fromPoints(start || this.start, end || this.end);
541
+ };
542
+
543
+ this.isEmpty = function() {
544
+ return (this.start.row === this.end.row && this.start.column === this.end.column);
545
+ };
546
+ this.isMultiLine = function() {
547
+ return (this.start.row !== this.end.row);
548
+ };
549
+ this.clone = function() {
550
+ return Range.fromPoints(this.start, this.end);
551
+ };
552
+ this.collapseRows = function() {
553
+ if (this.end.column == 0)
554
+ return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row-1), 0)
555
+ else
556
+ return new Range(this.start.row, 0, this.end.row, 0)
557
+ };
558
+ this.toScreenRange = function(session) {
559
+ var screenPosStart = session.documentToScreenPosition(this.start);
560
+ var screenPosEnd = session.documentToScreenPosition(this.end);
561
+
562
+ return new Range(
563
+ screenPosStart.row, screenPosStart.column,
564
+ screenPosEnd.row, screenPosEnd.column
565
+ );
566
+ };
567
+ this.moveBy = function(row, column) {
568
+ this.start.row += row;
569
+ this.start.column += column;
570
+ this.end.row += row;
571
+ this.end.column += column;
572
+ };
573
+
574
+ }).call(Range.prototype);
575
+ Range.fromPoints = function(start, end) {
576
+ return new Range(start.row, start.column, end.row, end.column);
577
+ };
578
+ Range.comparePoints = comparePoints;
579
+
580
+ Range.comparePoints = function(p1, p2) {
581
+ return p1.row - p2.row || p1.column - p2.column;
582
+ };
583
+
584
+
585
+ exports.Range = Range;
586
+ });
587
+
588
+ ace.define("ace/anchor",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"], function(require, exports, module) {
589
+ "use strict";
590
+
591
+ var oop = require("./lib/oop");
592
+ var EventEmitter = require("./lib/event_emitter").EventEmitter;
593
+
594
+ var Anchor = exports.Anchor = function(doc, row, column) {
595
+ this.$onChange = this.onChange.bind(this);
596
+ this.attach(doc);
597
+
598
+ if (typeof column == "undefined")
599
+ this.setPosition(row.row, row.column);
600
+ else
601
+ this.setPosition(row, column);
602
+ };
603
+
604
+ (function() {
605
+
606
+ oop.implement(this, EventEmitter);
607
+ this.getPosition = function() {
608
+ return this.$clipPositionToDocument(this.row, this.column);
609
+ };
610
+ this.getDocument = function() {
611
+ return this.document;
612
+ };
613
+ this.$insertRight = false;
614
+ this.onChange = function(e) {
615
+ var delta = e.data;
616
+ var range = delta.range;
617
+
618
+ if (range.start.row == range.end.row && range.start.row != this.row)
619
+ return;
620
+
621
+ if (range.start.row > this.row)
622
+ return;
623
+
624
+ if (range.start.row == this.row && range.start.column > this.column)
625
+ return;
626
+
627
+ var row = this.row;
628
+ var column = this.column;
629
+ var start = range.start;
630
+ var end = range.end;
631
+
632
+ if (delta.action === "insertText") {
633
+ if (start.row === row && start.column <= column) {
634
+ if (start.column === column && this.$insertRight) {
635
+ } else if (start.row === end.row) {
636
+ column += end.column - start.column;
637
+ } else {
638
+ column -= start.column;
639
+ row += end.row - start.row;
640
+ }
641
+ } else if (start.row !== end.row && start.row < row) {
642
+ row += end.row - start.row;
643
+ }
644
+ } else if (delta.action === "insertLines") {
645
+ if (start.row === row && column === 0 && this.$insertRight) {
646
+ }
647
+ else if (start.row <= row) {
648
+ row += end.row - start.row;
649
+ }
650
+ } else if (delta.action === "removeText") {
651
+ if (start.row === row && start.column < column) {
652
+ if (end.column >= column)
653
+ column = start.column;
654
+ else
655
+ column = Math.max(0, column - (end.column - start.column));
656
+
657
+ } else if (start.row !== end.row && start.row < row) {
658
+ if (end.row === row)
659
+ column = Math.max(0, column - end.column) + start.column;
660
+ row -= (end.row - start.row);
661
+ } else if (end.row === row) {
662
+ row -= end.row - start.row;
663
+ column = Math.max(0, column - end.column) + start.column;
664
+ }
665
+ } else if (delta.action == "removeLines") {
666
+ if (start.row <= row) {
667
+ if (end.row <= row)
668
+ row -= end.row - start.row;
669
+ else {
670
+ row = start.row;
671
+ column = 0;
672
+ }
673
+ }
674
+ }
675
+
676
+ this.setPosition(row, column, true);
677
+ };
678
+ this.setPosition = function(row, column, noClip) {
679
+ var pos;
680
+ if (noClip) {
681
+ pos = {
682
+ row: row,
683
+ column: column
684
+ };
685
+ } else {
686
+ pos = this.$clipPositionToDocument(row, column);
687
+ }
688
+
689
+ if (this.row == pos.row && this.column == pos.column)
690
+ return;
691
+
692
+ var old = {
693
+ row: this.row,
694
+ column: this.column
695
+ };
696
+
697
+ this.row = pos.row;
698
+ this.column = pos.column;
699
+ this._signal("change", {
700
+ old: old,
701
+ value: pos
702
+ });
703
+ };
704
+ this.detach = function() {
705
+ this.document.removeEventListener("change", this.$onChange);
706
+ };
707
+ this.attach = function(doc) {
708
+ this.document = doc || this.document;
709
+ this.document.on("change", this.$onChange);
710
+ };
711
+ this.$clipPositionToDocument = function(row, column) {
712
+ var pos = {};
713
+
714
+ if (row >= this.document.getLength()) {
715
+ pos.row = Math.max(0, this.document.getLength() - 1);
716
+ pos.column = this.document.getLine(pos.row).length;
717
+ }
718
+ else if (row < 0) {
719
+ pos.row = 0;
720
+ pos.column = 0;
721
+ }
722
+ else {
723
+ pos.row = row;
724
+ pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column));
725
+ }
726
+
727
+ if (column < 0)
728
+ pos.column = 0;
729
+
730
+ return pos;
731
+ };
732
+
733
+ }).call(Anchor.prototype);
734
+
735
+ });
736
+
737
+ ace.define("ace/document",["require","exports","module","ace/lib/oop","ace/lib/event_emitter","ace/range","ace/anchor"], function(require, exports, module) {
738
+ "use strict";
739
+
740
+ var oop = require("./lib/oop");
741
+ var EventEmitter = require("./lib/event_emitter").EventEmitter;
742
+ var Range = require("./range").Range;
743
+ var Anchor = require("./anchor").Anchor;
744
+
745
+ var Document = function(text) {
746
+ this.$lines = [];
747
+ if (text.length === 0) {
748
+ this.$lines = [""];
749
+ } else if (Array.isArray(text)) {
750
+ this._insertLines(0, text);
751
+ } else {
752
+ this.insert({row: 0, column:0}, text);
753
+ }
754
+ };
755
+
756
+ (function() {
757
+
758
+ oop.implement(this, EventEmitter);
759
+ this.setValue = function(text) {
760
+ var len = this.getLength();
761
+ this.remove(new Range(0, 0, len, this.getLine(len-1).length));
762
+ this.insert({row: 0, column:0}, text);
763
+ };
764
+ this.getValue = function() {
765
+ return this.getAllLines().join(this.getNewLineCharacter());
766
+ };
767
+ this.createAnchor = function(row, column) {
768
+ return new Anchor(this, row, column);
769
+ };
770
+ if ("aaa".split(/a/).length === 0)
771
+ this.$split = function(text) {
772
+ return text.replace(/\r\n|\r/g, "\n").split("\n");
773
+ };
774
+ else
775
+ this.$split = function(text) {
776
+ return text.split(/\r\n|\r|\n/);
777
+ };
778
+
779
+
780
+ this.$detectNewLine = function(text) {
781
+ var match = text.match(/^.*?(\r\n|\r|\n)/m);
782
+ this.$autoNewLine = match ? match[1] : "\n";
783
+ this._signal("changeNewLineMode");
784
+ };
785
+ this.getNewLineCharacter = function() {
786
+ switch (this.$newLineMode) {
787
+ case "windows":
788
+ return "\r\n";
789
+ case "unix":
790
+ return "\n";
791
+ default:
792
+ return this.$autoNewLine || "\n";
793
+ }
794
+ };
795
+
796
+ this.$autoNewLine = "";
797
+ this.$newLineMode = "auto";
798
+ this.setNewLineMode = function(newLineMode) {
799
+ if (this.$newLineMode === newLineMode)
800
+ return;
801
+
802
+ this.$newLineMode = newLineMode;
803
+ this._signal("changeNewLineMode");
804
+ };
805
+ this.getNewLineMode = function() {
806
+ return this.$newLineMode;
807
+ };
808
+ this.isNewLine = function(text) {
809
+ return (text == "\r\n" || text == "\r" || text == "\n");
810
+ };
811
+ this.getLine = function(row) {
812
+ return this.$lines[row] || "";
813
+ };
814
+ this.getLines = function(firstRow, lastRow) {
815
+ return this.$lines.slice(firstRow, lastRow + 1);
816
+ };
817
+ this.getAllLines = function() {
818
+ return this.getLines(0, this.getLength());
819
+ };
820
+ this.getLength = function() {
821
+ return this.$lines.length;
822
+ };
823
+ this.getTextRange = function(range) {
824
+ if (range.start.row == range.end.row) {
825
+ return this.getLine(range.start.row)
826
+ .substring(range.start.column, range.end.column);
827
+ }
828
+ var lines = this.getLines(range.start.row, range.end.row);
829
+ lines[0] = (lines[0] || "").substring(range.start.column);
830
+ var l = lines.length - 1;
831
+ if (range.end.row - range.start.row == l)
832
+ lines[l] = lines[l].substring(0, range.end.column);
833
+ return lines.join(this.getNewLineCharacter());
834
+ };
835
+
836
+ this.$clipPosition = function(position) {
837
+ var length = this.getLength();
838
+ if (position.row >= length) {
839
+ position.row = Math.max(0, length - 1);
840
+ position.column = this.getLine(length-1).length;
841
+ } else if (position.row < 0)
842
+ position.row = 0;
843
+ return position;
844
+ };
845
+ this.insert = function(position, text) {
846
+ if (!text || text.length === 0)
847
+ return position;
848
+
849
+ position = this.$clipPosition(position);
850
+ if (this.getLength() <= 1)
851
+ this.$detectNewLine(text);
852
+
853
+ var lines = this.$split(text);
854
+ var firstLine = lines.splice(0, 1)[0];
855
+ var lastLine = lines.length == 0 ? null : lines.splice(lines.length - 1, 1)[0];
856
+
857
+ position = this.insertInLine(position, firstLine);
858
+ if (lastLine !== null) {
859
+ position = this.insertNewLine(position); // terminate first line
860
+ position = this._insertLines(position.row, lines);
861
+ position = this.insertInLine(position, lastLine || "");
862
+ }
863
+ return position;
864
+ };
865
+ this.insertLines = function(row, lines) {
866
+ if (row >= this.getLength())
867
+ return this.insert({row: row, column: 0}, "\n" + lines.join("\n"));
868
+ return this._insertLines(Math.max(row, 0), lines);
869
+ };
870
+ this._insertLines = function(row, lines) {
871
+ if (lines.length == 0)
872
+ return {row: row, column: 0};
873
+ while (lines.length > 0xF000) {
874
+ var end = this._insertLines(row, lines.slice(0, 0xF000));
875
+ lines = lines.slice(0xF000);
876
+ row = end.row;
877
+ }
878
+
879
+ var args = [row, 0];
880
+ args.push.apply(args, lines);
881
+ this.$lines.splice.apply(this.$lines, args);
882
+
883
+ var range = new Range(row, 0, row + lines.length, 0);
884
+ var delta = {
885
+ action: "insertLines",
886
+ range: range,
887
+ lines: lines
888
+ };
889
+ this._signal("change", { data: delta });
890
+ return range.end;
891
+ };
892
+ this.insertNewLine = function(position) {
893
+ position = this.$clipPosition(position);
894
+ var line = this.$lines[position.row] || "";
895
+
896
+ this.$lines[position.row] = line.substring(0, position.column);
897
+ this.$lines.splice(position.row + 1, 0, line.substring(position.column, line.length));
898
+
899
+ var end = {
900
+ row : position.row + 1,
901
+ column : 0
902
+ };
903
+
904
+ var delta = {
905
+ action: "insertText",
906
+ range: Range.fromPoints(position, end),
907
+ text: this.getNewLineCharacter()
908
+ };
909
+ this._signal("change", { data: delta });
910
+
911
+ return end;
912
+ };
913
+ this.insertInLine = function(position, text) {
914
+ if (text.length == 0)
915
+ return position;
916
+
917
+ var line = this.$lines[position.row] || "";
918
+
919
+ this.$lines[position.row] = line.substring(0, position.column) + text
920
+ + line.substring(position.column);
921
+
922
+ var end = {
923
+ row : position.row,
924
+ column : position.column + text.length
925
+ };
926
+
927
+ var delta = {
928
+ action: "insertText",
929
+ range: Range.fromPoints(position, end),
930
+ text: text
931
+ };
932
+ this._signal("change", { data: delta });
933
+
934
+ return end;
935
+ };
936
+ this.remove = function(range) {
937
+ if (!(range instanceof Range))
938
+ range = Range.fromPoints(range.start, range.end);
939
+ range.start = this.$clipPosition(range.start);
940
+ range.end = this.$clipPosition(range.end);
941
+
942
+ if (range.isEmpty())
943
+ return range.start;
944
+
945
+ var firstRow = range.start.row;
946
+ var lastRow = range.end.row;
947
+
948
+ if (range.isMultiLine()) {
949
+ var firstFullRow = range.start.column == 0 ? firstRow : firstRow + 1;
950
+ var lastFullRow = lastRow - 1;
951
+
952
+ if (range.end.column > 0)
953
+ this.removeInLine(lastRow, 0, range.end.column);
954
+
955
+ if (lastFullRow >= firstFullRow)
956
+ this._removeLines(firstFullRow, lastFullRow);
957
+
958
+ if (firstFullRow != firstRow) {
959
+ this.removeInLine(firstRow, range.start.column, this.getLine(firstRow).length);
960
+ this.removeNewLine(range.start.row);
961
+ }
962
+ }
963
+ else {
964
+ this.removeInLine(firstRow, range.start.column, range.end.column);
965
+ }
966
+ return range.start;
967
+ };
968
+ this.removeInLine = function(row, startColumn, endColumn) {
969
+ if (startColumn == endColumn)
970
+ return;
971
+
972
+ var range = new Range(row, startColumn, row, endColumn);
973
+ var line = this.getLine(row);
974
+ var removed = line.substring(startColumn, endColumn);
975
+ var newLine = line.substring(0, startColumn) + line.substring(endColumn, line.length);
976
+ this.$lines.splice(row, 1, newLine);
977
+
978
+ var delta = {
979
+ action: "removeText",
980
+ range: range,
981
+ text: removed
982
+ };
983
+ this._signal("change", { data: delta });
984
+ return range.start;
985
+ };
986
+ this.removeLines = function(firstRow, lastRow) {
987
+ if (firstRow < 0 || lastRow >= this.getLength())
988
+ return this.remove(new Range(firstRow, 0, lastRow + 1, 0));
989
+ return this._removeLines(firstRow, lastRow);
990
+ };
991
+
992
+ this._removeLines = function(firstRow, lastRow) {
993
+ var range = new Range(firstRow, 0, lastRow + 1, 0);
994
+ var removed = this.$lines.splice(firstRow, lastRow - firstRow + 1);
995
+
996
+ var delta = {
997
+ action: "removeLines",
998
+ range: range,
999
+ nl: this.getNewLineCharacter(),
1000
+ lines: removed
1001
+ };
1002
+ this._signal("change", { data: delta });
1003
+ return removed;
1004
+ };
1005
+ this.removeNewLine = function(row) {
1006
+ var firstLine = this.getLine(row);
1007
+ var secondLine = this.getLine(row+1);
1008
+
1009
+ var range = new Range(row, firstLine.length, row+1, 0);
1010
+ var line = firstLine + secondLine;
1011
+
1012
+ this.$lines.splice(row, 2, line);
1013
+
1014
+ var delta = {
1015
+ action: "removeText",
1016
+ range: range,
1017
+ text: this.getNewLineCharacter()
1018
+ };
1019
+ this._signal("change", { data: delta });
1020
+ };
1021
+ this.replace = function(range, text) {
1022
+ if (!(range instanceof Range))
1023
+ range = Range.fromPoints(range.start, range.end);
1024
+ if (text.length == 0 && range.isEmpty())
1025
+ return range.start;
1026
+ if (text == this.getTextRange(range))
1027
+ return range.end;
1028
+
1029
+ this.remove(range);
1030
+ if (text) {
1031
+ var end = this.insert(range.start, text);
1032
+ }
1033
+ else {
1034
+ end = range.start;
1035
+ }
1036
+
1037
+ return end;
1038
+ };
1039
+ this.applyDeltas = function(deltas) {
1040
+ for (var i=0; i<deltas.length; i++) {
1041
+ var delta = deltas[i];
1042
+ var range = Range.fromPoints(delta.range.start, delta.range.end);
1043
+
1044
+ if (delta.action == "insertLines")
1045
+ this.insertLines(range.start.row, delta.lines);
1046
+ else if (delta.action == "insertText")
1047
+ this.insert(range.start, delta.text);
1048
+ else if (delta.action == "removeLines")
1049
+ this._removeLines(range.start.row, range.end.row - 1);
1050
+ else if (delta.action == "removeText")
1051
+ this.remove(range);
1052
+ }
1053
+ };
1054
+ this.revertDeltas = function(deltas) {
1055
+ for (var i=deltas.length-1; i>=0; i--) {
1056
+ var delta = deltas[i];
1057
+
1058
+ var range = Range.fromPoints(delta.range.start, delta.range.end);
1059
+
1060
+ if (delta.action == "insertLines")
1061
+ this._removeLines(range.start.row, range.end.row - 1);
1062
+ else if (delta.action == "insertText")
1063
+ this.remove(range);
1064
+ else if (delta.action == "removeLines")
1065
+ this._insertLines(range.start.row, delta.lines);
1066
+ else if (delta.action == "removeText")
1067
+ this.insert(range.start, delta.text);
1068
+ }
1069
+ };
1070
+ this.indexToPosition = function(index, startRow) {
1071
+ var lines = this.$lines || this.getAllLines();
1072
+ var newlineLength = this.getNewLineCharacter().length;
1073
+ for (var i = startRow || 0, l = lines.length; i < l; i++) {
1074
+ index -= lines[i].length + newlineLength;
1075
+ if (index < 0)
1076
+ return {row: i, column: index + lines[i].length + newlineLength};
1077
+ }
1078
+ return {row: l-1, column: lines[l-1].length};
1079
+ };
1080
+ this.positionToIndex = function(pos, startRow) {
1081
+ var lines = this.$lines || this.getAllLines();
1082
+ var newlineLength = this.getNewLineCharacter().length;
1083
+ var index = 0;
1084
+ var row = Math.min(pos.row, lines.length);
1085
+ for (var i = startRow || 0; i < row; ++i)
1086
+ index += lines[i].length + newlineLength;
1087
+
1088
+ return index + pos.column;
1089
+ };
1090
+
1091
+ }).call(Document.prototype);
1092
+
1093
+ exports.Document = Document;
1094
+ });
1095
+
1096
+ ace.define("ace/lib/lang",["require","exports","module"], function(require, exports, module) {
1097
+ "use strict";
1098
+
1099
+ exports.last = function(a) {
1100
+ return a[a.length - 1];
1101
+ };
1102
+
1103
+ exports.stringReverse = function(string) {
1104
+ return string.split("").reverse().join("");
1105
+ };
1106
+
1107
+ exports.stringRepeat = function (string, count) {
1108
+ var result = '';
1109
+ while (count > 0) {
1110
+ if (count & 1)
1111
+ result += string;
1112
+
1113
+ if (count >>= 1)
1114
+ string += string;
1115
+ }
1116
+ return result;
1117
+ };
1118
+
1119
+ var trimBeginRegexp = /^\s\s*/;
1120
+ var trimEndRegexp = /\s\s*$/;
1121
+
1122
+ exports.stringTrimLeft = function (string) {
1123
+ return string.replace(trimBeginRegexp, '');
1124
+ };
1125
+
1126
+ exports.stringTrimRight = function (string) {
1127
+ return string.replace(trimEndRegexp, '');
1128
+ };
1129
+
1130
+ exports.copyObject = function(obj) {
1131
+ var copy = {};
1132
+ for (var key in obj) {
1133
+ copy[key] = obj[key];
1134
+ }
1135
+ return copy;
1136
+ };
1137
+
1138
+ exports.copyArray = function(array){
1139
+ var copy = [];
1140
+ for (var i=0, l=array.length; i<l; i++) {
1141
+ if (array[i] && typeof array[i] == "object")
1142
+ copy[i] = this.copyObject( array[i] );
1143
+ else
1144
+ copy[i] = array[i];
1145
+ }
1146
+ return copy;
1147
+ };
1148
+
1149
+ exports.deepCopy = function (obj) {
1150
+ if (typeof obj !== "object" || !obj)
1151
+ return obj;
1152
+ var cons = obj.constructor;
1153
+ if (cons === RegExp)
1154
+ return obj;
1155
+
1156
+ var copy = cons();
1157
+ for (var key in obj) {
1158
+ if (typeof obj[key] === "object") {
1159
+ copy[key] = exports.deepCopy(obj[key]);
1160
+ } else {
1161
+ copy[key] = obj[key];
1162
+ }
1163
+ }
1164
+ return copy;
1165
+ };
1166
+
1167
+ exports.arrayToMap = function(arr) {
1168
+ var map = {};
1169
+ for (var i=0; i<arr.length; i++) {
1170
+ map[arr[i]] = 1;
1171
+ }
1172
+ return map;
1173
+
1174
+ };
1175
+
1176
+ exports.createMap = function(props) {
1177
+ var map = Object.create(null);
1178
+ for (var i in props) {
1179
+ map[i] = props[i];
1180
+ }
1181
+ return map;
1182
+ };
1183
+ exports.arrayRemove = function(array, value) {
1184
+ for (var i = 0; i <= array.length; i++) {
1185
+ if (value === array[i]) {
1186
+ array.splice(i, 1);
1187
+ }
1188
+ }
1189
+ };
1190
+
1191
+ exports.escapeRegExp = function(str) {
1192
+ return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');
1193
+ };
1194
+
1195
+ exports.escapeHTML = function(str) {
1196
+ return str.replace(/&/g, "&#38;").replace(/"/g, "&#34;").replace(/'/g, "&#39;").replace(/</g, "&#60;");
1197
+ };
1198
+
1199
+ exports.getMatchOffsets = function(string, regExp) {
1200
+ var matches = [];
1201
+
1202
+ string.replace(regExp, function(str) {
1203
+ matches.push({
1204
+ offset: arguments[arguments.length-2],
1205
+ length: str.length
1206
+ });
1207
+ });
1208
+
1209
+ return matches;
1210
+ };
1211
+ exports.deferredCall = function(fcn) {
1212
+ var timer = null;
1213
+ var callback = function() {
1214
+ timer = null;
1215
+ fcn();
1216
+ };
1217
+
1218
+ var deferred = function(timeout) {
1219
+ deferred.cancel();
1220
+ timer = setTimeout(callback, timeout || 0);
1221
+ return deferred;
1222
+ };
1223
+
1224
+ deferred.schedule = deferred;
1225
+
1226
+ deferred.call = function() {
1227
+ this.cancel();
1228
+ fcn();
1229
+ return deferred;
1230
+ };
1231
+
1232
+ deferred.cancel = function() {
1233
+ clearTimeout(timer);
1234
+ timer = null;
1235
+ return deferred;
1236
+ };
1237
+
1238
+ deferred.isPending = function() {
1239
+ return timer;
1240
+ };
1241
+
1242
+ return deferred;
1243
+ };
1244
+
1245
+
1246
+ exports.delayedCall = function(fcn, defaultTimeout) {
1247
+ var timer = null;
1248
+ var callback = function() {
1249
+ timer = null;
1250
+ fcn();
1251
+ };
1252
+
1253
+ var _self = function(timeout) {
1254
+ if (timer == null)
1255
+ timer = setTimeout(callback, timeout || defaultTimeout);
1256
+ };
1257
+
1258
+ _self.delay = function(timeout) {
1259
+ timer && clearTimeout(timer);
1260
+ timer = setTimeout(callback, timeout || defaultTimeout);
1261
+ };
1262
+ _self.schedule = _self;
1263
+
1264
+ _self.call = function() {
1265
+ this.cancel();
1266
+ fcn();
1267
+ };
1268
+
1269
+ _self.cancel = function() {
1270
+ timer && clearTimeout(timer);
1271
+ timer = null;
1272
+ };
1273
+
1274
+ _self.isPending = function() {
1275
+ return timer;
1276
+ };
1277
+
1278
+ return _self;
1279
+ };
1280
+ });
1281
+
1282
+ ace.define("ace/worker/mirror",["require","exports","module","ace/document","ace/lib/lang"], function(require, exports, module) {
1283
+ "use strict";
1284
+
1285
+ var Document = require("../document").Document;
1286
+ var lang = require("../lib/lang");
1287
+
1288
+ var Mirror = exports.Mirror = function(sender) {
1289
+ this.sender = sender;
1290
+ var doc = this.doc = new Document("");
1291
+
1292
+ var deferredUpdate = this.deferredUpdate = lang.delayedCall(this.onUpdate.bind(this));
1293
+
1294
+ var _self = this;
1295
+ sender.on("change", function(e) {
1296
+ doc.applyDeltas(e.data);
1297
+ if (_self.$timeout)
1298
+ return deferredUpdate.schedule(_self.$timeout);
1299
+ _self.onUpdate();
1300
+ });
1301
+ };
1302
+
1303
+ (function() {
1304
+
1305
+ this.$timeout = 500;
1306
+
1307
+ this.setTimeout = function(timeout) {
1308
+ this.$timeout = timeout;
1309
+ };
1310
+
1311
+ this.setValue = function(value) {
1312
+ this.doc.setValue(value);
1313
+ this.deferredUpdate.schedule(this.$timeout);
1314
+ };
1315
+
1316
+ this.getValue = function(callbackId) {
1317
+ this.sender.callback(this.doc.getValue(), callbackId);
1318
+ };
1319
+
1320
+ this.onUpdate = function() {
1321
+ };
1322
+
1323
+ this.isPending = function() {
1324
+ return this.deferredUpdate.isPending();
1325
+ };
1326
+
1327
+ }).call(Mirror.prototype);
1328
+
1329
+ });
1330
+
1331
+ ace.define("ace/mode/json/json_parse",["require","exports","module"], function(require, exports, module) {
1332
+ "use strict";
1333
+
1334
+ var at, // The index of the current character
1335
+ ch, // The current character
1336
+ escapee = {
1337
+ '"': '"',
1338
+ '\\': '\\',
1339
+ '/': '/',
1340
+ b: '\b',
1341
+ f: '\f',
1342
+ n: '\n',
1343
+ r: '\r',
1344
+ t: '\t'
1345
+ },
1346
+ text,
1347
+
1348
+ error = function (m) {
1349
+
1350
+ throw {
1351
+ name: 'SyntaxError',
1352
+ message: m,
1353
+ at: at,
1354
+ text: text
1355
+ };
1356
+ },
1357
+
1358
+ next = function (c) {
1359
+
1360
+ if (c && c !== ch) {
1361
+ error("Expected '" + c + "' instead of '" + ch + "'");
1362
+ }
1363
+
1364
+ ch = text.charAt(at);
1365
+ at += 1;
1366
+ return ch;
1367
+ },
1368
+
1369
+ number = function () {
1370
+
1371
+ var number,
1372
+ string = '';
1373
+
1374
+ if (ch === '-') {
1375
+ string = '-';
1376
+ next('-');
1377
+ }
1378
+ while (ch >= '0' && ch <= '9') {
1379
+ string += ch;
1380
+ next();
1381
+ }
1382
+ if (ch === '.') {
1383
+ string += '.';
1384
+ while (next() && ch >= '0' && ch <= '9') {
1385
+ string += ch;
1386
+ }
1387
+ }
1388
+ if (ch === 'e' || ch === 'E') {
1389
+ string += ch;
1390
+ next();
1391
+ if (ch === '-' || ch === '+') {
1392
+ string += ch;
1393
+ next();
1394
+ }
1395
+ while (ch >= '0' && ch <= '9') {
1396
+ string += ch;
1397
+ next();
1398
+ }
1399
+ }
1400
+ number = +string;
1401
+ if (isNaN(number)) {
1402
+ error("Bad number");
1403
+ } else {
1404
+ return number;
1405
+ }
1406
+ },
1407
+
1408
+ string = function () {
1409
+
1410
+ var hex,
1411
+ i,
1412
+ string = '',
1413
+ uffff;
1414
+
1415
+ if (ch === '"') {
1416
+ while (next()) {
1417
+ if (ch === '"') {
1418
+ next();
1419
+ return string;
1420
+ } else if (ch === '\\') {
1421
+ next();
1422
+ if (ch === 'u') {
1423
+ uffff = 0;
1424
+ for (i = 0; i < 4; i += 1) {
1425
+ hex = parseInt(next(), 16);
1426
+ if (!isFinite(hex)) {
1427
+ break;
1428
+ }
1429
+ uffff = uffff * 16 + hex;
1430
+ }
1431
+ string += String.fromCharCode(uffff);
1432
+ } else if (typeof escapee[ch] === 'string') {
1433
+ string += escapee[ch];
1434
+ } else {
1435
+ break;
1436
+ }
1437
+ } else {
1438
+ string += ch;
1439
+ }
1440
+ }
1441
+ }
1442
+ error("Bad string");
1443
+ },
1444
+
1445
+ white = function () {
1446
+
1447
+ while (ch && ch <= ' ') {
1448
+ next();
1449
+ }
1450
+ },
1451
+
1452
+ word = function () {
1453
+
1454
+ switch (ch) {
1455
+ case 't':
1456
+ next('t');
1457
+ next('r');
1458
+ next('u');
1459
+ next('e');
1460
+ return true;
1461
+ case 'f':
1462
+ next('f');
1463
+ next('a');
1464
+ next('l');
1465
+ next('s');
1466
+ next('e');
1467
+ return false;
1468
+ case 'n':
1469
+ next('n');
1470
+ next('u');
1471
+ next('l');
1472
+ next('l');
1473
+ return null;
1474
+ }
1475
+ error("Unexpected '" + ch + "'");
1476
+ },
1477
+
1478
+ value, // Place holder for the value function.
1479
+
1480
+ array = function () {
1481
+
1482
+ var array = [];
1483
+
1484
+ if (ch === '[') {
1485
+ next('[');
1486
+ white();
1487
+ if (ch === ']') {
1488
+ next(']');
1489
+ return array; // empty array
1490
+ }
1491
+ while (ch) {
1492
+ array.push(value());
1493
+ white();
1494
+ if (ch === ']') {
1495
+ next(']');
1496
+ return array;
1497
+ }
1498
+ next(',');
1499
+ white();
1500
+ }
1501
+ }
1502
+ error("Bad array");
1503
+ },
1504
+
1505
+ object = function () {
1506
+
1507
+ var key,
1508
+ object = {};
1509
+
1510
+ if (ch === '{') {
1511
+ next('{');
1512
+ white();
1513
+ if (ch === '}') {
1514
+ next('}');
1515
+ return object; // empty object
1516
+ }
1517
+ while (ch) {
1518
+ key = string();
1519
+ white();
1520
+ next(':');
1521
+ if (Object.hasOwnProperty.call(object, key)) {
1522
+ error('Duplicate key "' + key + '"');
1523
+ }
1524
+ object[key] = value();
1525
+ white();
1526
+ if (ch === '}') {
1527
+ next('}');
1528
+ return object;
1529
+ }
1530
+ next(',');
1531
+ white();
1532
+ }
1533
+ }
1534
+ error("Bad object");
1535
+ };
1536
+
1537
+ value = function () {
1538
+
1539
+ white();
1540
+ switch (ch) {
1541
+ case '{':
1542
+ return object();
1543
+ case '[':
1544
+ return array();
1545
+ case '"':
1546
+ return string();
1547
+ case '-':
1548
+ return number();
1549
+ default:
1550
+ return ch >= '0' && ch <= '9' ? number() : word();
1551
+ }
1552
+ };
1553
+
1554
+ return function (source, reviver) {
1555
+ var result;
1556
+
1557
+ text = source;
1558
+ at = 0;
1559
+ ch = ' ';
1560
+ result = value();
1561
+ white();
1562
+ if (ch) {
1563
+ error("Syntax error");
1564
+ }
1565
+
1566
+ return typeof reviver === 'function' ? function walk(holder, key) {
1567
+ var k, v, value = holder[key];
1568
+ if (value && typeof value === 'object') {
1569
+ for (k in value) {
1570
+ if (Object.hasOwnProperty.call(value, k)) {
1571
+ v = walk(value, k);
1572
+ if (v !== undefined) {
1573
+ value[k] = v;
1574
+ } else {
1575
+ delete value[k];
1576
+ }
1577
+ }
1578
+ }
1579
+ }
1580
+ return reviver.call(holder, key, value);
1581
+ }({'': result}, '') : result;
1582
+ };
1583
+ });
1584
+
1585
+ ace.define("ace/mode/json_worker",["require","exports","module","ace/lib/oop","ace/worker/mirror","ace/mode/json/json_parse"], function(require, exports, module) {
1586
+ "use strict";
1587
+
1588
+ var oop = require("../lib/oop");
1589
+ var Mirror = require("../worker/mirror").Mirror;
1590
+ var parse = require("./json/json_parse");
1591
+
1592
+ var JsonWorker = exports.JsonWorker = function(sender) {
1593
+ Mirror.call(this, sender);
1594
+ this.setTimeout(200);
1595
+ };
1596
+
1597
+ oop.inherits(JsonWorker, Mirror);
1598
+
1599
+ (function() {
1600
+
1601
+ this.onUpdate = function() {
1602
+ var value = this.doc.getValue();
1603
+
1604
+ try {
1605
+ if (value)
1606
+ parse(value);
1607
+ } catch (e) {
1608
+ var pos = this.doc.indexToPosition(e.at-1);
1609
+ this.sender.emit("error", {
1610
+ row: pos.row,
1611
+ column: pos.column,
1612
+ text: e.message,
1613
+ type: "error"
1614
+ });
1615
+ return;
1616
+ }
1617
+ this.sender.emit("ok");
1618
+ };
1619
+
1620
+ }).call(JsonWorker.prototype);
1621
+
1622
+ });
1623
+
1624
+ ace.define("ace/lib/es5-shim",["require","exports","module"], function(require, exports, module) {
1625
+
1626
+ function Empty() {}
1627
+
1628
+ if (!Function.prototype.bind) {
1629
+ Function.prototype.bind = function bind(that) { // .length is 1
1630
+ var target = this;
1631
+ if (typeof target != "function") {
1632
+ throw new TypeError("Function.prototype.bind called on incompatible " + target);
1633
+ }
1634
+ var args = slice.call(arguments, 1); // for normal call
1635
+ var bound = function () {
1636
+
1637
+ if (this instanceof bound) {
1638
+
1639
+ var result = target.apply(
1640
+ this,
1641
+ args.concat(slice.call(arguments))
1642
+ );
1643
+ if (Object(result) === result) {
1644
+ return result;
1645
+ }
1646
+ return this;
1647
+
1648
+ } else {
1649
+ return target.apply(
1650
+ that,
1651
+ args.concat(slice.call(arguments))
1652
+ );
1653
+
1654
+ }
1655
+
1656
+ };
1657
+ if(target.prototype) {
1658
+ Empty.prototype = target.prototype;
1659
+ bound.prototype = new Empty();
1660
+ Empty.prototype = null;
1661
+ }
1662
+ return bound;
1663
+ };
1664
+ }
1665
+ var call = Function.prototype.call;
1666
+ var prototypeOfArray = Array.prototype;
1667
+ var prototypeOfObject = Object.prototype;
1668
+ var slice = prototypeOfArray.slice;
1669
+ var _toString = call.bind(prototypeOfObject.toString);
1670
+ var owns = call.bind(prototypeOfObject.hasOwnProperty);
1671
+ var defineGetter;
1672
+ var defineSetter;
1673
+ var lookupGetter;
1674
+ var lookupSetter;
1675
+ var supportsAccessors;
1676
+ if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) {
1677
+ defineGetter = call.bind(prototypeOfObject.__defineGetter__);
1678
+ defineSetter = call.bind(prototypeOfObject.__defineSetter__);
1679
+ lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
1680
+ lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
1681
+ }
1682
+ if ([1,2].splice(0).length != 2) {
1683
+ if(function() { // test IE < 9 to splice bug - see issue #138
1684
+ function makeArray(l) {
1685
+ var a = new Array(l+2);
1686
+ a[0] = a[1] = 0;
1687
+ return a;
1688
+ }
1689
+ var array = [], lengthBefore;
1690
+
1691
+ array.splice.apply(array, makeArray(20));
1692
+ array.splice.apply(array, makeArray(26));
1693
+
1694
+ lengthBefore = array.length; //46
1695
+ array.splice(5, 0, "XXX"); // add one element
1696
+
1697
+ lengthBefore + 1 == array.length
1698
+
1699
+ if (lengthBefore + 1 == array.length) {
1700
+ return true;// has right splice implementation without bugs
1701
+ }
1702
+ }()) {//IE 6/7
1703
+ var array_splice = Array.prototype.splice;
1704
+ Array.prototype.splice = function(start, deleteCount) {
1705
+ if (!arguments.length) {
1706
+ return [];
1707
+ } else {
1708
+ return array_splice.apply(this, [
1709
+ start === void 0 ? 0 : start,
1710
+ deleteCount === void 0 ? (this.length - start) : deleteCount
1711
+ ].concat(slice.call(arguments, 2)))
1712
+ }
1713
+ };
1714
+ } else {//IE8
1715
+ Array.prototype.splice = function(pos, removeCount){
1716
+ var length = this.length;
1717
+ if (pos > 0) {
1718
+ if (pos > length)
1719
+ pos = length;
1720
+ } else if (pos == void 0) {
1721
+ pos = 0;
1722
+ } else if (pos < 0) {
1723
+ pos = Math.max(length + pos, 0);
1724
+ }
1725
+
1726
+ if (!(pos+removeCount < length))
1727
+ removeCount = length - pos;
1728
+
1729
+ var removed = this.slice(pos, pos+removeCount);
1730
+ var insert = slice.call(arguments, 2);
1731
+ var add = insert.length;
1732
+ if (pos === length) {
1733
+ if (add) {
1734
+ this.push.apply(this, insert);
1735
+ }
1736
+ } else {
1737
+ var remove = Math.min(removeCount, length - pos);
1738
+ var tailOldPos = pos + remove;
1739
+ var tailNewPos = tailOldPos + add - remove;
1740
+ var tailCount = length - tailOldPos;
1741
+ var lengthAfterRemove = length - remove;
1742
+
1743
+ if (tailNewPos < tailOldPos) { // case A
1744
+ for (var i = 0; i < tailCount; ++i) {
1745
+ this[tailNewPos+i] = this[tailOldPos+i];
1746
+ }
1747
+ } else if (tailNewPos > tailOldPos) { // case B
1748
+ for (i = tailCount; i--; ) {
1749
+ this[tailNewPos+i] = this[tailOldPos+i];
1750
+ }
1751
+ } // else, add == remove (nothing to do)
1752
+
1753
+ if (add && pos === lengthAfterRemove) {
1754
+ this.length = lengthAfterRemove; // truncate array
1755
+ this.push.apply(this, insert);
1756
+ } else {
1757
+ this.length = lengthAfterRemove + add; // reserves space
1758
+ for (i = 0; i < add; ++i) {
1759
+ this[pos+i] = insert[i];
1760
+ }
1761
+ }
1762
+ }
1763
+ return removed;
1764
+ };
1765
+ }
1766
+ }
1767
+ if (!Array.isArray) {
1768
+ Array.isArray = function isArray(obj) {
1769
+ return _toString(obj) == "[object Array]";
1770
+ };
1771
+ }
1772
+ var boxedString = Object("a"),
1773
+ splitString = boxedString[0] != "a" || !(0 in boxedString);
1774
+
1775
+ if (!Array.prototype.forEach) {
1776
+ Array.prototype.forEach = function forEach(fun /*, thisp*/) {
1777
+ var object = toObject(this),
1778
+ self = splitString && _toString(this) == "[object String]" ?
1779
+ this.split("") :
1780
+ object,
1781
+ thisp = arguments[1],
1782
+ i = -1,
1783
+ length = self.length >>> 0;
1784
+ if (_toString(fun) != "[object Function]") {
1785
+ throw new TypeError(); // TODO message
1786
+ }
1787
+
1788
+ while (++i < length) {
1789
+ if (i in self) {
1790
+ fun.call(thisp, self[i], i, object);
1791
+ }
1792
+ }
1793
+ };
1794
+ }
1795
+ if (!Array.prototype.map) {
1796
+ Array.prototype.map = function map(fun /*, thisp*/) {
1797
+ var object = toObject(this),
1798
+ self = splitString && _toString(this) == "[object String]" ?
1799
+ this.split("") :
1800
+ object,
1801
+ length = self.length >>> 0,
1802
+ result = Array(length),
1803
+ thisp = arguments[1];
1804
+ if (_toString(fun) != "[object Function]") {
1805
+ throw new TypeError(fun + " is not a function");
1806
+ }
1807
+
1808
+ for (var i = 0; i < length; i++) {
1809
+ if (i in self)
1810
+ result[i] = fun.call(thisp, self[i], i, object);
1811
+ }
1812
+ return result;
1813
+ };
1814
+ }
1815
+ if (!Array.prototype.filter) {
1816
+ Array.prototype.filter = function filter(fun /*, thisp */) {
1817
+ var object = toObject(this),
1818
+ self = splitString && _toString(this) == "[object String]" ?
1819
+ this.split("") :
1820
+ object,
1821
+ length = self.length >>> 0,
1822
+ result = [],
1823
+ value,
1824
+ thisp = arguments[1];
1825
+ if (_toString(fun) != "[object Function]") {
1826
+ throw new TypeError(fun + " is not a function");
1827
+ }
1828
+
1829
+ for (var i = 0; i < length; i++) {
1830
+ if (i in self) {
1831
+ value = self[i];
1832
+ if (fun.call(thisp, value, i, object)) {
1833
+ result.push(value);
1834
+ }
1835
+ }
1836
+ }
1837
+ return result;
1838
+ };
1839
+ }
1840
+ if (!Array.prototype.every) {
1841
+ Array.prototype.every = function every(fun /*, thisp */) {
1842
+ var object = toObject(this),
1843
+ self = splitString && _toString(this) == "[object String]" ?
1844
+ this.split("") :
1845
+ object,
1846
+ length = self.length >>> 0,
1847
+ thisp = arguments[1];
1848
+ if (_toString(fun) != "[object Function]") {
1849
+ throw new TypeError(fun + " is not a function");
1850
+ }
1851
+
1852
+ for (var i = 0; i < length; i++) {
1853
+ if (i in self && !fun.call(thisp, self[i], i, object)) {
1854
+ return false;
1855
+ }
1856
+ }
1857
+ return true;
1858
+ };
1859
+ }
1860
+ if (!Array.prototype.some) {
1861
+ Array.prototype.some = function some(fun /*, thisp */) {
1862
+ var object = toObject(this),
1863
+ self = splitString && _toString(this) == "[object String]" ?
1864
+ this.split("") :
1865
+ object,
1866
+ length = self.length >>> 0,
1867
+ thisp = arguments[1];
1868
+ if (_toString(fun) != "[object Function]") {
1869
+ throw new TypeError(fun + " is not a function");
1870
+ }
1871
+
1872
+ for (var i = 0; i < length; i++) {
1873
+ if (i in self && fun.call(thisp, self[i], i, object)) {
1874
+ return true;
1875
+ }
1876
+ }
1877
+ return false;
1878
+ };
1879
+ }
1880
+ if (!Array.prototype.reduce) {
1881
+ Array.prototype.reduce = function reduce(fun /*, initial*/) {
1882
+ var object = toObject(this),
1883
+ self = splitString && _toString(this) == "[object String]" ?
1884
+ this.split("") :
1885
+ object,
1886
+ length = self.length >>> 0;
1887
+ if (_toString(fun) != "[object Function]") {
1888
+ throw new TypeError(fun + " is not a function");
1889
+ }
1890
+ if (!length && arguments.length == 1) {
1891
+ throw new TypeError("reduce of empty array with no initial value");
1892
+ }
1893
+
1894
+ var i = 0;
1895
+ var result;
1896
+ if (arguments.length >= 2) {
1897
+ result = arguments[1];
1898
+ } else {
1899
+ do {
1900
+ if (i in self) {
1901
+ result = self[i++];
1902
+ break;
1903
+ }
1904
+ if (++i >= length) {
1905
+ throw new TypeError("reduce of empty array with no initial value");
1906
+ }
1907
+ } while (true);
1908
+ }
1909
+
1910
+ for (; i < length; i++) {
1911
+ if (i in self) {
1912
+ result = fun.call(void 0, result, self[i], i, object);
1913
+ }
1914
+ }
1915
+
1916
+ return result;
1917
+ };
1918
+ }
1919
+ if (!Array.prototype.reduceRight) {
1920
+ Array.prototype.reduceRight = function reduceRight(fun /*, initial*/) {
1921
+ var object = toObject(this),
1922
+ self = splitString && _toString(this) == "[object String]" ?
1923
+ this.split("") :
1924
+ object,
1925
+ length = self.length >>> 0;
1926
+ if (_toString(fun) != "[object Function]") {
1927
+ throw new TypeError(fun + " is not a function");
1928
+ }
1929
+ if (!length && arguments.length == 1) {
1930
+ throw new TypeError("reduceRight of empty array with no initial value");
1931
+ }
1932
+
1933
+ var result, i = length - 1;
1934
+ if (arguments.length >= 2) {
1935
+ result = arguments[1];
1936
+ } else {
1937
+ do {
1938
+ if (i in self) {
1939
+ result = self[i--];
1940
+ break;
1941
+ }
1942
+ if (--i < 0) {
1943
+ throw new TypeError("reduceRight of empty array with no initial value");
1944
+ }
1945
+ } while (true);
1946
+ }
1947
+
1948
+ do {
1949
+ if (i in this) {
1950
+ result = fun.call(void 0, result, self[i], i, object);
1951
+ }
1952
+ } while (i--);
1953
+
1954
+ return result;
1955
+ };
1956
+ }
1957
+ if (!Array.prototype.indexOf || ([0, 1].indexOf(1, 2) != -1)) {
1958
+ Array.prototype.indexOf = function indexOf(sought /*, fromIndex */ ) {
1959
+ var self = splitString && _toString(this) == "[object String]" ?
1960
+ this.split("") :
1961
+ toObject(this),
1962
+ length = self.length >>> 0;
1963
+
1964
+ if (!length) {
1965
+ return -1;
1966
+ }
1967
+
1968
+ var i = 0;
1969
+ if (arguments.length > 1) {
1970
+ i = toInteger(arguments[1]);
1971
+ }
1972
+ i = i >= 0 ? i : Math.max(0, length + i);
1973
+ for (; i < length; i++) {
1974
+ if (i in self && self[i] === sought) {
1975
+ return i;
1976
+ }
1977
+ }
1978
+ return -1;
1979
+ };
1980
+ }
1981
+ if (!Array.prototype.lastIndexOf || ([0, 1].lastIndexOf(0, -3) != -1)) {
1982
+ Array.prototype.lastIndexOf = function lastIndexOf(sought /*, fromIndex */) {
1983
+ var self = splitString && _toString(this) == "[object String]" ?
1984
+ this.split("") :
1985
+ toObject(this),
1986
+ length = self.length >>> 0;
1987
+
1988
+ if (!length) {
1989
+ return -1;
1990
+ }
1991
+ var i = length - 1;
1992
+ if (arguments.length > 1) {
1993
+ i = Math.min(i, toInteger(arguments[1]));
1994
+ }
1995
+ i = i >= 0 ? i : length - Math.abs(i);
1996
+ for (; i >= 0; i--) {
1997
+ if (i in self && sought === self[i]) {
1998
+ return i;
1999
+ }
2000
+ }
2001
+ return -1;
2002
+ };
2003
+ }
2004
+ if (!Object.getPrototypeOf) {
2005
+ Object.getPrototypeOf = function getPrototypeOf(object) {
2006
+ return object.__proto__ || (
2007
+ object.constructor ?
2008
+ object.constructor.prototype :
2009
+ prototypeOfObject
2010
+ );
2011
+ };
2012
+ }
2013
+ if (!Object.getOwnPropertyDescriptor) {
2014
+ var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a " +
2015
+ "non-object: ";
2016
+ Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {
2017
+ if ((typeof object != "object" && typeof object != "function") || object === null)
2018
+ throw new TypeError(ERR_NON_OBJECT + object);
2019
+ if (!owns(object, property))
2020
+ return;
2021
+
2022
+ var descriptor, getter, setter;
2023
+ descriptor = { enumerable: true, configurable: true };
2024
+ if (supportsAccessors) {
2025
+ var prototype = object.__proto__;
2026
+ object.__proto__ = prototypeOfObject;
2027
+
2028
+ var getter = lookupGetter(object, property);
2029
+ var setter = lookupSetter(object, property);
2030
+ object.__proto__ = prototype;
2031
+
2032
+ if (getter || setter) {
2033
+ if (getter) descriptor.get = getter;
2034
+ if (setter) descriptor.set = setter;
2035
+ return descriptor;
2036
+ }
2037
+ }
2038
+ descriptor.value = object[property];
2039
+ return descriptor;
2040
+ };
2041
+ }
2042
+ if (!Object.getOwnPropertyNames) {
2043
+ Object.getOwnPropertyNames = function getOwnPropertyNames(object) {
2044
+ return Object.keys(object);
2045
+ };
2046
+ }
2047
+ if (!Object.create) {
2048
+ var createEmpty;
2049
+ if (Object.prototype.__proto__ === null) {
2050
+ createEmpty = function () {
2051
+ return { "__proto__": null };
2052
+ };
2053
+ } else {
2054
+ createEmpty = function () {
2055
+ var empty = {};
2056
+ for (var i in empty)
2057
+ empty[i] = null;
2058
+ empty.constructor =
2059
+ empty.hasOwnProperty =
2060
+ empty.propertyIsEnumerable =
2061
+ empty.isPrototypeOf =
2062
+ empty.toLocaleString =
2063
+ empty.toString =
2064
+ empty.valueOf =
2065
+ empty.__proto__ = null;
2066
+ return empty;
2067
+ }
2068
+ }
2069
+
2070
+ Object.create = function create(prototype, properties) {
2071
+ var object;
2072
+ if (prototype === null) {
2073
+ object = createEmpty();
2074
+ } else {
2075
+ if (typeof prototype != "object")
2076
+ throw new TypeError("typeof prototype["+(typeof prototype)+"] != 'object'");
2077
+ var Type = function () {};
2078
+ Type.prototype = prototype;
2079
+ object = new Type();
2080
+ object.__proto__ = prototype;
2081
+ }
2082
+ if (properties !== void 0)
2083
+ Object.defineProperties(object, properties);
2084
+ return object;
2085
+ };
2086
+ }
2087
+
2088
+ function doesDefinePropertyWork(object) {
2089
+ try {
2090
+ Object.defineProperty(object, "sentinel", {});
2091
+ return "sentinel" in object;
2092
+ } catch (exception) {
2093
+ }
2094
+ }
2095
+ if (Object.defineProperty) {
2096
+ var definePropertyWorksOnObject = doesDefinePropertyWork({});
2097
+ var definePropertyWorksOnDom = typeof document == "undefined" ||
2098
+ doesDefinePropertyWork(document.createElement("div"));
2099
+ if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {
2100
+ var definePropertyFallback = Object.defineProperty;
2101
+ }
2102
+ }
2103
+
2104
+ if (!Object.defineProperty || definePropertyFallback) {
2105
+ var ERR_NON_OBJECT_DESCRIPTOR = "Property description must be an object: ";
2106
+ var ERR_NON_OBJECT_TARGET = "Object.defineProperty called on non-object: "
2107
+ var ERR_ACCESSORS_NOT_SUPPORTED = "getters & setters can not be defined " +
2108
+ "on this javascript engine";
2109
+
2110
+ Object.defineProperty = function defineProperty(object, property, descriptor) {
2111
+ if ((typeof object != "object" && typeof object != "function") || object === null)
2112
+ throw new TypeError(ERR_NON_OBJECT_TARGET + object);
2113
+ if ((typeof descriptor != "object" && typeof descriptor != "function") || descriptor === null)
2114
+ throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);
2115
+ if (definePropertyFallback) {
2116
+ try {
2117
+ return definePropertyFallback.call(Object, object, property, descriptor);
2118
+ } catch (exception) {
2119
+ }
2120
+ }
2121
+ if (owns(descriptor, "value")) {
2122
+
2123
+ if (supportsAccessors && (lookupGetter(object, property) ||
2124
+ lookupSetter(object, property)))
2125
+ {
2126
+ var prototype = object.__proto__;
2127
+ object.__proto__ = prototypeOfObject;
2128
+ delete object[property];
2129
+ object[property] = descriptor.value;
2130
+ object.__proto__ = prototype;
2131
+ } else {
2132
+ object[property] = descriptor.value;
2133
+ }
2134
+ } else {
2135
+ if (!supportsAccessors)
2136
+ throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
2137
+ if (owns(descriptor, "get"))
2138
+ defineGetter(object, property, descriptor.get);
2139
+ if (owns(descriptor, "set"))
2140
+ defineSetter(object, property, descriptor.set);
2141
+ }
2142
+
2143
+ return object;
2144
+ };
2145
+ }
2146
+ if (!Object.defineProperties) {
2147
+ Object.defineProperties = function defineProperties(object, properties) {
2148
+ for (var property in properties) {
2149
+ if (owns(properties, property))
2150
+ Object.defineProperty(object, property, properties[property]);
2151
+ }
2152
+ return object;
2153
+ };
2154
+ }
2155
+ if (!Object.seal) {
2156
+ Object.seal = function seal(object) {
2157
+ return object;
2158
+ };
2159
+ }
2160
+ if (!Object.freeze) {
2161
+ Object.freeze = function freeze(object) {
2162
+ return object;
2163
+ };
2164
+ }
2165
+ try {
2166
+ Object.freeze(function () {});
2167
+ } catch (exception) {
2168
+ Object.freeze = (function freeze(freezeObject) {
2169
+ return function freeze(object) {
2170
+ if (typeof object == "function") {
2171
+ return object;
2172
+ } else {
2173
+ return freezeObject(object);
2174
+ }
2175
+ };
2176
+ })(Object.freeze);
2177
+ }
2178
+ if (!Object.preventExtensions) {
2179
+ Object.preventExtensions = function preventExtensions(object) {
2180
+ return object;
2181
+ };
2182
+ }
2183
+ if (!Object.isSealed) {
2184
+ Object.isSealed = function isSealed(object) {
2185
+ return false;
2186
+ };
2187
+ }
2188
+ if (!Object.isFrozen) {
2189
+ Object.isFrozen = function isFrozen(object) {
2190
+ return false;
2191
+ };
2192
+ }
2193
+ if (!Object.isExtensible) {
2194
+ Object.isExtensible = function isExtensible(object) {
2195
+ if (Object(object) === object) {
2196
+ throw new TypeError(); // TODO message
2197
+ }
2198
+ var name = '';
2199
+ while (owns(object, name)) {
2200
+ name += '?';
2201
+ }
2202
+ object[name] = true;
2203
+ var returnValue = owns(object, name);
2204
+ delete object[name];
2205
+ return returnValue;
2206
+ };
2207
+ }
2208
+ if (!Object.keys) {
2209
+ var hasDontEnumBug = true,
2210
+ dontEnums = [
2211
+ "toString",
2212
+ "toLocaleString",
2213
+ "valueOf",
2214
+ "hasOwnProperty",
2215
+ "isPrototypeOf",
2216
+ "propertyIsEnumerable",
2217
+ "constructor"
2218
+ ],
2219
+ dontEnumsLength = dontEnums.length;
2220
+
2221
+ for (var key in {"toString": null}) {
2222
+ hasDontEnumBug = false;
2223
+ }
2224
+
2225
+ Object.keys = function keys(object) {
2226
+
2227
+ if (
2228
+ (typeof object != "object" && typeof object != "function") ||
2229
+ object === null
2230
+ ) {
2231
+ throw new TypeError("Object.keys called on a non-object");
2232
+ }
2233
+
2234
+ var keys = [];
2235
+ for (var name in object) {
2236
+ if (owns(object, name)) {
2237
+ keys.push(name);
2238
+ }
2239
+ }
2240
+
2241
+ if (hasDontEnumBug) {
2242
+ for (var i = 0, ii = dontEnumsLength; i < ii; i++) {
2243
+ var dontEnum = dontEnums[i];
2244
+ if (owns(object, dontEnum)) {
2245
+ keys.push(dontEnum);
2246
+ }
2247
+ }
2248
+ }
2249
+ return keys;
2250
+ };
2251
+
2252
+ }
2253
+ if (!Date.now) {
2254
+ Date.now = function now() {
2255
+ return new Date().getTime();
2256
+ };
2257
+ }
2258
+ var ws = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003" +
2259
+ "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028" +
2260
+ "\u2029\uFEFF";
2261
+ if (!String.prototype.trim || ws.trim()) {
2262
+ ws = "[" + ws + "]";
2263
+ var trimBeginRegexp = new RegExp("^" + ws + ws + "*"),
2264
+ trimEndRegexp = new RegExp(ws + ws + "*$");
2265
+ String.prototype.trim = function trim() {
2266
+ return String(this).replace(trimBeginRegexp, "").replace(trimEndRegexp, "");
2267
+ };
2268
+ }
2269
+
2270
+ function toInteger(n) {
2271
+ n = +n;
2272
+ if (n !== n) { // isNaN
2273
+ n = 0;
2274
+ } else if (n !== 0 && n !== (1/0) && n !== -(1/0)) {
2275
+ n = (n > 0 || -1) * Math.floor(Math.abs(n));
2276
+ }
2277
+ return n;
2278
+ }
2279
+
2280
+ function isPrimitive(input) {
2281
+ var type = typeof input;
2282
+ return (
2283
+ input === null ||
2284
+ type === "undefined" ||
2285
+ type === "boolean" ||
2286
+ type === "number" ||
2287
+ type === "string"
2288
+ );
2289
+ }
2290
+
2291
+ function toPrimitive(input) {
2292
+ var val, valueOf, toString;
2293
+ if (isPrimitive(input)) {
2294
+ return input;
2295
+ }
2296
+ valueOf = input.valueOf;
2297
+ if (typeof valueOf === "function") {
2298
+ val = valueOf.call(input);
2299
+ if (isPrimitive(val)) {
2300
+ return val;
2301
+ }
2302
+ }
2303
+ toString = input.toString;
2304
+ if (typeof toString === "function") {
2305
+ val = toString.call(input);
2306
+ if (isPrimitive(val)) {
2307
+ return val;
2308
+ }
2309
+ }
2310
+ throw new TypeError();
2311
+ }
2312
+ var toObject = function (o) {
2313
+ if (o == null) { // this matches both null and undefined
2314
+ throw new TypeError("can't convert "+o+" to object");
2315
+ }
2316
+ return Object(o);
2317
+ };
2318
+
2319
+ });