/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: galaxyAbstractor
  • Date: 2013-04-10 15:49:32 UTC
  • mto: (19.1.5 lenasys)
  • mto: This revision was merged to the branch mainline in revision 23.
  • Revision ID: galaxyabstractor@gmail.com-20130410154932-4vizlzk0ar5gykvi
* Added an simple admin panel to the codeviewer-cmssy stuff
* Redesigned a bit like the mockups - still stuff to come
* Implemented the codeviewer + admin panel again using the Framework CodeIgniter instead 

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
});