/lenasys/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/lenasys/trunk

« back to all changes in this revision

Viewing changes to codeigniter/js/ace/worker-json.js

  • Committer: Gustav Hatvigsson
  • Date: 2013-05-30 12:02:31 UTC
  • mfrom: (85.1.28 lenasys)
  • Revision ID: gustav.hartvigsson@gmail.com-20130530120231-ttqgqjqw2w8enn7g
Merged Ohlsons changes:
added function to get ssn and name for the registrationspages in the user model.
added the registrationpage for students.
edited the registration page for instructors
edited the css for both the registrationpages
minor fix to registration css

Show diffs side-by-side

added added

removed removed

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