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.
- checksums.yaml +4 -4
- data/.gitignore +2 -1
- data/README.md +1 -1
- data/config.ru +3 -2
- data/lib/stackprofiler.rb +0 -1
- data/lib/stackprofiler/filters/build_tree.rb +3 -4
- data/lib/stackprofiler/filters/gem_removal.rb +3 -0
- data/lib/stackprofiler/web_ui.rb +34 -11
- data/lib/stackprofiler/web_ui/public/css/stackprofiler.css +77 -0
- data/lib/stackprofiler/web_ui/public/js/stackprofiler.js +129 -58
- data/lib/stackprofiler/web_ui/public/vendor/ace/ace.js +18298 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-beautify.js +334 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-chromevox.js +541 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-elastic_tabstops_lite.js +275 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-emmet.js +1190 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-error_marker.js +6 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-keybinding_menu.js +170 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-language_tools.js +1934 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-linking.js +52 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-modelist.js +187 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-old_ie.js +494 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-searchbox.js +409 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-settings_menu.js +637 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-spellcheck.js +71 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-split.js +246 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-static_highlight.js +154 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-statusbar.js +51 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-textarea.js +632 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-themelist.js +58 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/ext-whitespace.js +181 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/keybinding-emacs.js +1182 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/keybinding-vim.js +5320 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/mode-haml.js +525 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/mode-html.js +2427 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/mode-html_ruby.js +2955 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/mode-javascript.js +1025 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/mode-json.js +668 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/mode-ruby.js +839 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/mode-xml.js +637 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/mode-yaml.js +256 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/theme-xcode.js +89 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/worker-coffee.js +7599 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/worker-css.js +8682 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/worker-html.js +11527 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/worker-javascript.js +10429 -0
- data/lib/stackprofiler/web_ui/public/vendor/ace/worker-json.js +2319 -0
- data/lib/stackprofiler/web_ui/views/index.erb +1 -1
- data/lib/stackprofiler/web_ui/views/layout.erb +2 -55
- data/stackprofiler.gemspec +2 -4
- metadata +42 -19
- 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, "&").replace(/"/g, """).replace(/'/g, "'").replace(/</g, "<");
|
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
|
+
});
|