/lenasys/trunk

/* ***** BEGIN LICENSE BLOCK *****

 * Distributed under the BSD license:

 *

 * Copyright (c) 2010, Ajax.org B.V.

 * All rights reserved.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *     * Redistributions of source code must retain the above copyright

 *       notice, this list of conditions and the following disclaimer.

 *     * Redistributions in binary form must reproduce the above copyright

 *       notice, this list of conditions and the following disclaimer in the

 *       documentation and/or other materials provided with the distribution.

 *     * Neither the name of Ajax.org B.V. nor the

 *       names of its contributors may be used to endorse or promote products

 *       derived from this software without specific prior written permission.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY

 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * ***** END LICENSE BLOCK ***** */

(function() {

var ACE_NAMESPACE = "";

var global = (function() {

    return this;

})();

if (!ACE_NAMESPACE && typeof requirejs !== "undefined")

    return;

var _define = function(module, deps, payload) {

    if (typeof module !== 'string') {

        if (_define.original)

            _define.original.apply(window, arguments);

        else {

            console.error('dropping module because define wasn\'t a string.');

            console.trace();

        }

        return;

    }

    if (arguments.length == 2)

        payload = deps;

    if (!_define.modules)

        _define.modules = {};

    _define.modules[module] = payload;

};

var _require = function(parentId, module, callback) {

    if (Object.prototype.toString.call(module) === "[object Array]") {

        var params = [];

        for (var i = 0, l = module.length; i < l; ++i) {

            var dep = lookup(parentId, module[i]);

            if (!dep && _require.original)

                return _require.original.apply(window, arguments);

            params.push(dep);

        }

        if (callback) {

            callback.apply(null, params);

        }

    }

    else if (typeof module === 'string') {

        var payload = lookup(parentId, module);

        if (!payload && _require.original)

            return _require.original.apply(window, arguments);

        if (callback) {

            callback();

        }

        return payload;

    }

    else {

        if (_require.original)

            return _require.original.apply(window, arguments);

    }

};

var normalizeModule = function(parentId, moduleName) {

    if (moduleName.indexOf("!") !== -1) {

        var chunks = moduleName.split("!");

        return normalizeModule(parentId, chunks[0]) + "!" + normalizeModule(parentId, chunks[1]);

    }

    if (moduleName.charAt(0) == ".") {

        var base = parentId.split("/").slice(0, -1).join("/");

        moduleName = base + "/" + moduleName;

        while(moduleName.indexOf(".") !== -1 && previous != moduleName) {

            var previous = moduleName;

            moduleName = moduleName.replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, "");

        }

    }

    return moduleName;

};

var lookup = function(parentId, moduleName) {

    moduleName = normalizeModule(parentId, moduleName);

    var module = _define.modules[moduleName];

    if (!module) {

        return null;

    }

    if (typeof module === 'function') {

        var exports = {};

        var mod = {

            id: moduleName,

            uri: '',

            exports: exports,

            packaged: true

        };

        var req = function(module, callback) {

            return _require(moduleName, module, callback);

        };

        var returnValue = module(req, exports, mod);

        exports = returnValue || mod.exports;

        _define.modules[moduleName] = exports;

        return exports;

    }

    return module;

};

function exportAce(ns) {

    var require = function(module, callback) {

        return _require("", module, callback);

    };    

    var root = global;

    if (ns) {

        if (!global[ns])

            global[ns] = {};

        root = global[ns];

    }

    if (!root.define || !root.define.packaged) {

        _define.original = root.define;

        root.define = _define;

        root.define.packaged = true;

    }

    if (!root.require || !root.require.packaged) {

        _require.original = root.require;

        root.require = require;

        root.require.packaged = true;

    }

}

exportAce(ACE_NAMESPACE);

})();

define('ace/ace', ['require', 'exports', 'module' , 'ace/lib/fixoldbrowsers', 'ace/lib/dom', 'ace/lib/event', 'ace/editor', 'ace/edit_session', 'ace/undomanager', 'ace/virtual_renderer', 'ace/multi_select', 'ace/worker/worker_client', 'ace/keyboard/hash_handler', 'ace/placeholder', 'ace/mode/folding/fold_mode', 'ace/theme/textmate', 'ace/config'], function(require, exports, module) {

require("./lib/fixoldbrowsers");

var dom = require("./lib/dom");

var event = require("./lib/event");

var Editor = require("./editor").Editor;

var EditSession = require("./edit_session").EditSession;

var UndoManager = require("./undomanager").UndoManager;

var Renderer = require("./virtual_renderer").VirtualRenderer;

var MultiSelect = require("./multi_select").MultiSelect;

require("./worker/worker_client");

require("./keyboard/hash_handler");

require("./placeholder");

require("./mode/folding/fold_mode");

require("./theme/textmate");

exports.config = require("./config");

exports.require = require;

exports.edit = function(el) {

    if (typeof(el) == "string") {

        var _id = el;

        var el = document.getElementById(_id);

        if (!el)

            throw "ace.edit can't find div #" + _id;

    }

    if (el.env && el.env.editor instanceof Editor)

        return el.env.editor;

    var doc = exports.createEditSession(dom.getInnerText(el));

    el.innerHTML = '';

    var editor = new Editor(new Renderer(el));

    new MultiSelect(editor);

    editor.setSession(doc);

    var env = {

        document: doc,

        editor: editor,

        onResize: editor.resize.bind(editor, null)

    };

    event.addListener(window, "resize", env.onResize);

    editor.on("destroy", function() {

        event.removeListener(window, "resize", env.onResize);

    });

    el.env = editor.env = env;

    return editor;

};

exports.createEditSession = function(text, mode) {

    var doc = new EditSession(text, doc);

    doc.setUndoManager(new UndoManager());

    return doc;

}

exports.EditSession = EditSession;

exports.UndoManager = UndoManager;

});

define('ace/lib/fixoldbrowsers', ['require', 'exports', 'module' , 'ace/lib/regexp', 'ace/lib/es5-shim'], function(require, exports, module) {

require("./regexp");

require("./es5-shim");

});

define('ace/lib/regexp', ['require', 'exports', 'module' ], function(require, exports, module) {

    var real = {

            exec: RegExp.prototype.exec,

            test: RegExp.prototype.test,

            match: String.prototype.match,

            replace: String.prototype.replace,

            split: String.prototype.split

        },

        compliantExecNpcg = real.exec.call(/()??/, "")[1] === undefined, // check `exec` handling of nonparticipating capturing groups

        compliantLastIndexIncrement = function () {

            var x = /^/g;

            real.test.call(x, "");

            return !x.lastIndex;

        }();

    if (compliantLastIndexIncrement && compliantExecNpcg)

        return;

    RegExp.prototype.exec = function (str) {

        var match = real.exec.apply(this, arguments),

            name, r2;

        if ( typeof(str) == 'string' && match) {

            if (!compliantExecNpcg && match.length > 1 && indexOf(match, "") > -1) {

                r2 = RegExp(this.source, real.replace.call(getNativeFlags(this), "g", ""));

                real.replace.call(str.slice(match.index), r2, function () {

                    for (var i = 1; i < arguments.length - 2; i++) {

                        if (arguments[i] === undefined)

                            match[i] = undefined;

                    }

                });

            }

            if (this._xregexp && this._xregexp.captureNames) {

                for (var i = 1; i < match.length; i++) {

                    name = this._xregexp.captureNames[i - 1];

                    if (name)

                       match[name] = match[i];

                }

            }

            if (!compliantLastIndexIncrement && this.global && !match[0].length && (this.lastIndex > match.index))

                this.lastIndex--;

        }

        return match;

    };

    if (!compliantLastIndexIncrement) {

        RegExp.prototype.test = function (str) {

            var match = real.exec.call(this, str);

            if (match && this.global && !match[0].length && (this.lastIndex > match.index))

                this.lastIndex--;

            return !!match;

        };

    }

    function getNativeFlags (regex) {

        return (regex.global     ? "g" : "") +

               (regex.ignoreCase ? "i" : "") +

               (regex.multiline  ? "m" : "") +

               (regex.extended   ? "x" : "") + // Proposed for ES4; included in AS3

               (regex.sticky     ? "y" : "");

    }

    function indexOf (array, item, from) {

        if (Array.prototype.indexOf) // Use the native array method if available

            return array.indexOf(item, from);

        for (var i = from || 0; i < array.length; i++) {

            if (array[i] === item)

                return i;

        }

        return -1;

    }

});

define('ace/lib/es5-shim', ['require', 'exports', 'module' ], function(require, exports, module) {

function Empty() {}

if (!Function.prototype.bind) {

    Function.prototype.bind = function bind(that) { // .length is 1

        var target = this;

        if (typeof target != "function") {

            throw new TypeError("Function.prototype.bind called on incompatible " + target);

        }

        var args = slice.call(arguments, 1); // for normal call

        var bound = function () {

            if (this instanceof bound) {

                var result = target.apply(

                    this,

                    args.concat(slice.call(arguments))

                );

                if (Object(result) === result) {

                    return result;

                }

                return this;

            } else {

                return target.apply(

                    that,

                    args.concat(slice.call(arguments))

                );

            }

        };

        if(target.prototype) {

            Empty.prototype = target.prototype;

            bound.prototype = new Empty();

            Empty.prototype = null;

        }

        return bound;

    };

}

var call = Function.prototype.call;

var prototypeOfArray = Array.prototype;

var prototypeOfObject = Object.prototype;

var slice = prototypeOfArray.slice;

var _toString = call.bind(prototypeOfObject.toString);

var owns = call.bind(prototypeOfObject.hasOwnProperty);

var defineGetter;

var defineSetter;

var lookupGetter;

var lookupSetter;

var supportsAccessors;

if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) {

    defineGetter = call.bind(prototypeOfObject.__defineGetter__);

    defineSetter = call.bind(prototypeOfObject.__defineSetter__);

    lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);

    lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);

}

if ([1,2].splice(0).length != 2) {

    if(function() { // test IE < 9 to splice bug - see issue #138

        function makeArray(l) {

            var a = new Array(l+2);

            a[0] = a[1] = 0;

            return a;

        }

        var array = [], lengthBefore;

        array.splice.apply(array, makeArray(20));

        array.splice.apply(array, makeArray(26));

        lengthBefore = array.length; //46

        array.splice(5, 0, "XXX"); // add one element

        lengthBefore + 1 == array.length

        if (lengthBefore + 1 == array.length) {

            return true;// has right splice implementation without bugs

        }

    }()) {//IE 6/7

        var array_splice = Array.prototype.splice;

        Array.prototype.splice = function(start, deleteCount) {

            if (!arguments.length) {

                return [];

            } else {

                return array_splice.apply(this, [

                    start === void 0 ? 0 : start,

                    deleteCount === void 0 ? (this.length - start) : deleteCount

                ].concat(slice.call(arguments, 2)))

            }

        };

    } else {//IE8

        Array.prototype.splice = function(pos, removeCount){

            var length = this.length;

            if (pos > 0) {

                if (pos > length)

                    pos = length;

            } else if (pos == void 0) {

                pos = 0;

            } else if (pos < 0) {

                pos = Math.max(length + pos, 0);

            }

            if (!(pos+removeCount < length))

                removeCount = length - pos;

            var removed = this.slice(pos, pos+removeCount);

            var insert = slice.call(arguments, 2);

            var add = insert.length;            

            if (pos === length) {

                if (add) {

                    this.push.apply(this, insert);

                }

            } else {

                var remove = Math.min(removeCount, length - pos);

                var tailOldPos = pos + remove;

                var tailNewPos = tailOldPos + add - remove;

                var tailCount = length - tailOldPos;

                var lengthAfterRemove = length - remove;

                if (tailNewPos < tailOldPos) { // case A

                    for (var i = 0; i < tailCount; ++i) {

                        this[tailNewPos+i] = this[tailOldPos+i];

                    }

                } else if (tailNewPos > tailOldPos) { // case B

                    for (i = tailCount; i--; ) {

                        this[tailNewPos+i] = this[tailOldPos+i];

                    }

                } // else, add == remove (nothing to do)

                if (add && pos === lengthAfterRemove) {

                    this.length = lengthAfterRemove; // truncate array

                    this.push.apply(this, insert);

                } else {

                    this.length = lengthAfterRemove + add; // reserves space

                    for (i = 0; i < add; ++i) {

                        this[pos+i] = insert[i];

                    }

                }

            }

            return removed;

        };

    }

}

if (!Array.isArray) {

    Array.isArray = function isArray(obj) {

        return _toString(obj) == "[object Array]";

    };

}

var boxedString = Object("a"),

    splitString = boxedString[0] != "a" || !(0 in boxedString);

if (!Array.prototype.forEach) {

    Array.prototype.forEach = function forEach(fun /*, thisp*/) {

        var object = toObject(this),

            self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                object,

            thisp = arguments[1],

            i = -1,

            length = self.length >>> 0;

        if (_toString(fun) != "[object Function]") {

            throw new TypeError(); // TODO message

        }

        while (++i < length) {

            if (i in self) {

                fun.call(thisp, self[i], i, object);

            }

        }

    };

}

if (!Array.prototype.map) {

    Array.prototype.map = function map(fun /*, thisp*/) {

        var object = toObject(this),

            self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                object,

            length = self.length >>> 0,

            result = Array(length),

            thisp = arguments[1];

        if (_toString(fun) != "[object Function]") {

            throw new TypeError(fun + " is not a function");

        }

        for (var i = 0; i < length; i++) {

            if (i in self)

                result[i] = fun.call(thisp, self[i], i, object);

        }

        return result;

    };

}

if (!Array.prototype.filter) {

    Array.prototype.filter = function filter(fun /*, thisp */) {

        var object = toObject(this),

            self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                    object,

            length = self.length >>> 0,

            result = [],

            value,

            thisp = arguments[1];

        if (_toString(fun) != "[object Function]") {

            throw new TypeError(fun + " is not a function");

        }

        for (var i = 0; i < length; i++) {

            if (i in self) {

                value = self[i];

                if (fun.call(thisp, value, i, object)) {

                    result.push(value);

                }

            }

        }

        return result;

    };

}

if (!Array.prototype.every) {

    Array.prototype.every = function every(fun /*, thisp */) {

        var object = toObject(this),

            self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                object,

            length = self.length >>> 0,

            thisp = arguments[1];

        if (_toString(fun) != "[object Function]") {

            throw new TypeError(fun + " is not a function");

        }

        for (var i = 0; i < length; i++) {

            if (i in self && !fun.call(thisp, self[i], i, object)) {

                return false;

            }

        }

        return true;

    };

}

if (!Array.prototype.some) {

    Array.prototype.some = function some(fun /*, thisp */) {

        var object = toObject(this),

            self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                object,

            length = self.length >>> 0,

            thisp = arguments[1];

        if (_toString(fun) != "[object Function]") {

            throw new TypeError(fun + " is not a function");

        }

        for (var i = 0; i < length; i++) {

            if (i in self && fun.call(thisp, self[i], i, object)) {

                return true;

            }

        }

        return false;

    };

}

if (!Array.prototype.reduce) {

    Array.prototype.reduce = function reduce(fun /*, initial*/) {

        var object = toObject(this),

            self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                object,

            length = self.length >>> 0;

        if (_toString(fun) != "[object Function]") {

            throw new TypeError(fun + " is not a function");

        }

        if (!length && arguments.length == 1) {

            throw new TypeError("reduce of empty array with no initial value");

        }

        var i = 0;

        var result;

        if (arguments.length >= 2) {

            result = arguments[1];

        } else {

            do {

                if (i in self) {

                    result = self[i++];

                    break;

                }

                if (++i >= length) {

                    throw new TypeError("reduce of empty array with no initial value");

                }

            } while (true);

        }

        for (; i < length; i++) {

            if (i in self) {

                result = fun.call(void 0, result, self[i], i, object);

            }

        }

        return result;

    };

}

if (!Array.prototype.reduceRight) {

    Array.prototype.reduceRight = function reduceRight(fun /*, initial*/) {

        var object = toObject(this),

            self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                object,

            length = self.length >>> 0;

        if (_toString(fun) != "[object Function]") {

            throw new TypeError(fun + " is not a function");

        }

        if (!length && arguments.length == 1) {

            throw new TypeError("reduceRight of empty array with no initial value");

        }

        var result, i = length - 1;

        if (arguments.length >= 2) {

            result = arguments[1];

        } else {

            do {

                if (i in self) {

                    result = self[i--];

                    break;

                }

                if (--i < 0) {

                    throw new TypeError("reduceRight of empty array with no initial value");

                }

            } while (true);

        }

        do {

            if (i in this) {

                result = fun.call(void 0, result, self[i], i, object);

            }

        } while (i--);

        return result;

    };

}

if (!Array.prototype.indexOf || ([0, 1].indexOf(1, 2) != -1)) {

    Array.prototype.indexOf = function indexOf(sought /*, fromIndex */ ) {

        var self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                toObject(this),

            length = self.length >>> 0;

        if (!length) {

            return -1;

        }

        var i = 0;

        if (arguments.length > 1) {

            i = toInteger(arguments[1]);

        }

        i = i >= 0 ? i : Math.max(0, length + i);

        for (; i < length; i++) {

            if (i in self && self[i] === sought) {

                return i;

            }

        }

        return -1;

    };

}

if (!Array.prototype.lastIndexOf || ([0, 1].lastIndexOf(0, -3) != -1)) {

    Array.prototype.lastIndexOf = function lastIndexOf(sought /*, fromIndex */) {

        var self = splitString && _toString(this) == "[object String]" ?

                this.split("") :

                toObject(this),

            length = self.length >>> 0;

        if (!length) {

            return -1;

        }

        var i = length - 1;

        if (arguments.length > 1) {

            i = Math.min(i, toInteger(arguments[1]));

        }

        i = i >= 0 ? i : length - Math.abs(i);

        for (; i >= 0; i--) {

            if (i in self && sought === self[i]) {

                return i;

            }

        }

        return -1;

    };

}

if (!Object.getPrototypeOf) {

    Object.getPrototypeOf = function getPrototypeOf(object) {

        return object.__proto__ || (

            object.constructor ?

            object.constructor.prototype :

            prototypeOfObject

        );

    };

}

if (!Object.getOwnPropertyDescriptor) {

    var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a " +

                         "non-object: ";

    Object.getOwnPropertyDescriptor = function getOwnPropertyDescriptor(object, property) {

        if ((typeof object != "object" && typeof object != "function") || object === null)

            throw new TypeError(ERR_NON_OBJECT + object);

        if (!owns(object, property))

            return;

        var descriptor, getter, setter;

        descriptor =  { enumerable: true, configurable: true };

        if (supportsAccessors) {

            var prototype = object.__proto__;

            object.__proto__ = prototypeOfObject;

            var getter = lookupGetter(object, property);

            var setter = lookupSetter(object, property);

            object.__proto__ = prototype;

            if (getter || setter) {

                if (getter) descriptor.get = getter;

                if (setter) descriptor.set = setter;

                return descriptor;

            }

        }

        descriptor.value = object[property];

        return descriptor;

    };

}

if (!Object.getOwnPropertyNames) {

    Object.getOwnPropertyNames = function getOwnPropertyNames(object) {

        return Object.keys(object);

    };

}

if (!Object.create) {

    var createEmpty;

    if (Object.prototype.__proto__ === null) {

        createEmpty = function () {

            return { "__proto__": null };

        };

    } else {

        createEmpty = function () {

            var empty = {};

            for (var i in empty)

                empty[i] = null;

            empty.constructor =

            empty.hasOwnProperty =

            empty.propertyIsEnumerable =

            empty.isPrototypeOf =

            empty.toLocaleString =

            empty.toString =

            empty.valueOf =

            empty.__proto__ = null;

            return empty;

        }

    }

    Object.create = function create(prototype, properties) {

        var object;

        if (prototype === null) {

            object = createEmpty();

        } else {

            if (typeof prototype != "object")

                throw new TypeError("typeof prototype["+(typeof prototype)+"] != 'object'");

            var Type = function () {};

            Type.prototype = prototype;

            object = new Type();

            object.__proto__ = prototype;

        }

        if (properties !== void 0)

            Object.defineProperties(object, properties);

        return object;

    };

}

function doesDefinePropertyWork(object) {

    try {

        Object.defineProperty(object, "sentinel", {});

        return "sentinel" in object;

    } catch (exception) {

    }

}

if (Object.defineProperty) {

    var definePropertyWorksOnObject = doesDefinePropertyWork({});

    var definePropertyWorksOnDom = typeof document == "undefined" ||

        doesDefinePropertyWork(document.createElement("div"));

    if (!definePropertyWorksOnObject || !definePropertyWorksOnDom) {

        var definePropertyFallback = Object.defineProperty;

    }

}

if (!Object.defineProperty || definePropertyFallback) {

    var ERR_NON_OBJECT_DESCRIPTOR = "Property description must be an object: ";

    var ERR_NON_OBJECT_TARGET = "Object.defineProperty called on non-object: "

    var ERR_ACCESSORS_NOT_SUPPORTED = "getters & setters can not be defined " +

                                      "on this javascript engine";

    Object.defineProperty = function defineProperty(object, property, descriptor) {

        if ((typeof object != "object" && typeof object != "function") || object === null)

            throw new TypeError(ERR_NON_OBJECT_TARGET + object);

        if ((typeof descriptor != "object" && typeof descriptor != "function") || descriptor === null)

            throw new TypeError(ERR_NON_OBJECT_DESCRIPTOR + descriptor);

        if (definePropertyFallback) {

            try {

                return definePropertyFallback.call(Object, object, property, descriptor);

            } catch (exception) {

            }

        }

        if (owns(descriptor, "value")) {

            if (supportsAccessors && (lookupGetter(object, property) ||

                                      lookupSetter(object, property)))

            {

                var prototype = object.__proto__;

                object.__proto__ = prototypeOfObject;

                delete object[property];

                object[property] = descriptor.value;

                object.__proto__ = prototype;

            } else {

                object[property] = descriptor.value;

            }

        } else {

            if (!supportsAccessors)

                throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);

            if (owns(descriptor, "get"))

                defineGetter(object, property, descriptor.get);

            if (owns(descriptor, "set"))

                defineSetter(object, property, descriptor.set);

        }

        return object;

    };

}

if (!Object.defineProperties) {

    Object.defineProperties = function defineProperties(object, properties) {

        for (var property in properties) {

            if (owns(properties, property))

                Object.defineProperty(object, property, properties[property]);

        }

        return object;

    };

}

if (!Object.seal) {

    Object.seal = function seal(object) {

        return object;

    };

}

if (!Object.freeze) {

    Object.freeze = function freeze(object) {

        return object;

    };

}

try {

    Object.freeze(function () {});

} catch (exception) {

    Object.freeze = (function freeze(freezeObject) {

        return function freeze(object) {

            if (typeof object == "function") {

                return object;

            } else {

                return freezeObject(object);

            }

        };

    })(Object.freeze);

}

if (!Object.preventExtensions) {

    Object.preventExtensions = function preventExtensions(object) {

        return object;

    };

}

if (!Object.isSealed) {

    Object.isSealed = function isSealed(object) {

        return false;

    };

}

if (!Object.isFrozen) {

    Object.isFrozen = function isFrozen(object) {

        return false;

    };

}

if (!Object.isExtensible) {

    Object.isExtensible = function isExtensible(object) {

        if (Object(object) === object) {

            throw new TypeError(); // TODO message

        }

        var name = '';

        while (owns(object, name)) {

            name += '?';

        }

        object[name] = true;

        var returnValue = owns(object, name);

        delete object[name];

        return returnValue;

    };

}

if (!Object.keys) {

    var hasDontEnumBug = true,

        dontEnums = [

            "toString",

            "toLocaleString",

            "valueOf",

            "hasOwnProperty",

            "isPrototypeOf",

            "propertyIsEnumerable",

            "constructor"

        ],

        dontEnumsLength = dontEnums.length;

    for (var key in {"toString": null}) {

        hasDontEnumBug = false;

    }

    Object.keys = function keys(object) {

        if (

            (typeof object != "object" && typeof object != "function") ||

            object === null

        ) {

            throw new TypeError("Object.keys called on a non-object");

        }

        var keys = [];

        for (var name in object) {

            if (owns(object, name)) {

                keys.push(name);

            }

        }

        if (hasDontEnumBug) {

            for (var i = 0, ii = dontEnumsLength; i < ii; i++) {

                var dontEnum = dontEnums[i];

                if (owns(object, dontEnum)) {

                    keys.push(dontEnum);

                }

            }

        }

        return keys;

    };

}

if (!Date.now) {

    Date.now = function now() {

        return new Date().getTime();

    };

}

var ws = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003" +

    "\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028" +

    "\u2029\uFEFF";

if (!String.prototype.trim || ws.trim()) {

    ws = "[" + ws + "]";

    var trimBeginRegexp = new RegExp("^" + ws + ws + "*"),

        trimEndRegexp = new RegExp(ws + ws + "*$");

    String.prototype.trim = function trim() {

        return String(this).replace(trimBeginRegexp, "").replace(trimEndRegexp, "");

    };

}

function toInteger(n) {

    n = +n;

    if (n !== n) { // isNaN

        n = 0;

    } else if (n !== 0 && n !== (1/0) && n !== -(1/0)) {

        n = (n > 0 || -1) * Math.floor(Math.abs(n));

    }

    return n;

}

function isPrimitive(input) {

    var type = typeof input;

    return (

        input === null ||

        type === "undefined" ||

        type === "boolean" ||

        type === "number" ||

        type === "string"

    );

}

function toPrimitive(input) {

    var val, valueOf, toString;

    if (isPrimitive(input)) {

        return input;

    }

    valueOf = input.valueOf;

    if (typeof valueOf === "function") {

        val = valueOf.call(input);

        if (isPrimitive(val)) {

            return val;

        }

    }

    toString = input.toString;

    if (typeof toString === "function") {

        val = toString.call(input);

        if (isPrimitive(val)) {

            return val;

        }

    }

    throw new TypeError();

}

var toObject = function (o) {

    if (o == null) { // this matches both null and undefined

        throw new TypeError("can't convert "+o+" to object");

    }

    return Object(o);

};

});

define('ace/lib/dom', ['require', 'exports', 'module' ], function(require, exports, module) {

if (typeof document == "undefined")

    return;

var XHTML_NS = "http://www.w3.org/1999/xhtml";

exports.getDocumentHead = function(doc) {

    if (!doc)

        doc = document;

    return doc.head || doc.getElementsByTagName("head")[0] || doc.documentElement;

}

exports.createElement = function(tag, ns) {

    return document.createElementNS ?

           document.createElementNS(ns || XHTML_NS, tag) :

           document.createElement(tag);

};

exports.hasCssClass = function(el, name) {

    var classes = el.className.split(/\s+/g);

    return classes.indexOf(name) !== -1;

};

exports.addCssClass = function(el, name) {

    if (!exports.hasCssClass(el, name)) {

        el.className += " " + name;

    }

};

exports.removeCssClass = function(el, name) {

    var classes = el.className.split(/\s+/g);

    while (true) {

        var index = classes.indexOf(name);

        if (index == -1) {

            break;

        }

        classes.splice(index, 1);

    }

    el.className = classes.join(" ");

};

exports.toggleCssClass = function(el, name) {

    var classes = el.className.split(/\s+/g), add = true;

    while (true) {

        var index = classes.indexOf(name);

        if (index == -1) {

            break;

        }

        add = false;

        classes.splice(index, 1);

    }

    if(add)

        classes.push(name);

    el.className = classes.join(" ");

    return add;

};

exports.setCssClass = function(node, className, include) {

    if (include) {

        exports.addCssClass(node, className);

    } else {

        exports.removeCssClass(node, className);

    }

};

exports.hasCssString = function(id, doc) {

    var index = 0, sheets;

    doc = doc || document;

    if (doc.createStyleSheet && (sheets = doc.styleSheets)) {

        while (index < sheets.length)

            if (sheets[index++].owningElement.id === id) return true;

    } else if ((sheets = doc.getElementsByTagName("style"))) {

        while (index < sheets.length)

            if (sheets[index++].id === id) return true;

    }

    return false;

};

exports.importCssString = function importCssString(cssText, id, doc) {

    doc = doc || document;

    if (id && exports.hasCssString(id, doc))

        return null;

    var style;

    if (doc.createStyleSheet) {

        style = doc.createStyleSheet();

        style.cssText = cssText;

        if (id)

            style.owningElement.id = id;

    } else {

        style = doc.createElementNS

            ? doc.createElementNS(XHTML_NS, "style")

            : doc.createElement("style");

        style.appendChild(doc.createTextNode(cssText));

        if (id)

            style.id = id;

        exports.getDocumentHead(doc).appendChild(style);

    }

};

exports.importCssStylsheet = function(uri, doc) {

    if (doc.createStyleSheet) {

        doc.createStyleSheet(uri);

    } else {

        var link = exports.createElement('link');

        link.rel = 'stylesheet';

        link.href = uri;

        exports.getDocumentHead(doc).appendChild(link);

    }

};

exports.getInnerWidth = function(element) {

    return (

        parseInt(exports.computedStyle(element, "paddingLeft"), 10) +

        parseInt(exports.computedStyle(element, "paddingRight"), 10) + 

        element.clientWidth

    );

};

exports.getInnerHeight = function(element) {

    return (

        parseInt(exports.computedStyle(element, "paddingTop"), 10) +

        parseInt(exports.computedStyle(element, "paddingBottom"), 10) +

        element.clientHeight

    );

};

if (window.pageYOffset !== undefined) {

    exports.getPageScrollTop = function() {

        return window.pageYOffset;

    };

    exports.getPageScrollLeft = function() {

        return window.pageXOffset;

    };

}

else {

    exports.getPageScrollTop = function() {

        return document.body.scrollTop;

    };

    exports.getPageScrollLeft = function() {

        return document.body.scrollLeft;

    };

}

if (window.getComputedStyle)

    exports.computedStyle = function(element, style) {

        if (style)

            return (window.getComputedStyle(element, "") || {})[style] || "";

        return window.getComputedStyle(element, "") || {};

    };

else

    exports.computedStyle = function(element, style) {

        if (style)

            return element.currentStyle[style];

        return element.currentStyle;

    };

exports.scrollbarWidth = function(document) {

    var inner = exports.createElement("ace_inner");

    inner.style.width = "100%";

    inner.style.minWidth = "0px";

    inner.style.height = "200px";

    inner.style.display = "block";

    var outer = exports.createElement("ace_outer");

    var style = outer.style;

    style.position = "absolute";

    style.left = "-10000px";

    style.overflow = "hidden";

    style.width = "200px";

    style.minWidth = "0px";

    style.height = "150px";

    style.display = "block";

    outer.appendChild(inner);

    var body = document.documentElement;

    body.appendChild(outer);

    var noScrollbar = inner.offsetWidth;

    style.overflow = "scroll";

    var withScrollbar = inner.offsetWidth;

    if (noScrollbar == withScrollbar) {

        withScrollbar = outer.clientWidth;

    }

    body.removeChild(outer);

    return noScrollbar-withScrollbar;

};

exports.setInnerHtml = function(el, innerHtml) {

    var element = el.cloneNode(false);//document.createElement("div");

    element.innerHTML = innerHtml;

    el.parentNode.replaceChild(element, el);

    return element;

};

if ("textContent" in document.documentElement) {

    exports.setInnerText = function(el, innerText) {

        el.textContent = innerText;

    };

    exports.getInnerText = function(el) {

        return el.textContent;

    };

}

else {

    exports.setInnerText = function(el, innerText) {

        el.innerText = innerText;

    };

    exports.getInnerText = function(el) {

        return el.innerText;

    };

}

exports.getParentWindow = function(document) {

    return document.defaultView || document.parentWindow;

};

});

define('ace/lib/event', ['require', 'exports', 'module' , 'ace/lib/keys', 'ace/lib/useragent', 'ace/lib/dom'], function(require, exports, module) {

var keys = require("./keys");

var useragent = require("./useragent");

var dom = require("./dom");

exports.addListener = function(elem, type, callback) {

    if (elem.addEventListener) {

        return elem.addEventListener(type, callback, false);

    }

    if (elem.attachEvent) {

        var wrapper = function() {

            callback(window.event);

        };

        callback._wrapper = wrapper;

        elem.attachEvent("on" + type, wrapper);

    }

};

exports.removeListener = function(elem, type, callback) {

    if (elem.removeEventListener) {

        return elem.removeEventListener(type, callback, false);

    }

    if (elem.detachEvent) {

        elem.detachEvent("on" + type, callback._wrapper || callback);

    }

};

exports.stopEvent = function(e) {

    exports.stopPropagation(e);

    exports.preventDefault(e);

    return false;

};

exports.stopPropagation = function(e) {

    if (e.stopPropagation)

        e.stopPropagation();

    else

        e.cancelBubble = true;

};

exports.preventDefault = function(e) {

    if (e.preventDefault)

        e.preventDefault();

    else

        e.returnValue = false;

};

exports.getButton = function(e) {

    if (e.type == "dblclick")

        return 0;

    if (e.type == "contextmenu" || (e.ctrlKey && useragent.isMac))

        return 2;

    if (e.preventDefault) {

        return e.button;

    }

    else {

        return {1:0, 2:2, 4:1}[e.button];

    }

};

if (document.documentElement.setCapture) {

    exports.capture = function(el, eventHandler, releaseCaptureHandler) {

        var called = false;

        function onReleaseCapture(e) {

            eventHandler(e);

            if (!called) {

                called = true;

                releaseCaptureHandler(e);

            }

            exports.removeListener(el, "mousemove", eventHandler);

            exports.removeListener(el, "mouseup", onReleaseCapture);

            exports.removeListener(el, "losecapture", onReleaseCapture);

            el.releaseCapture();

        }

        exports.addListener(el, "mousemove", eventHandler);

        exports.addListener(el, "mouseup", onReleaseCapture);

        exports.addListener(el, "losecapture", onReleaseCapture);

        el.setCapture();

    };

}

else {

    exports.capture = function(el, eventHandler, releaseCaptureHandler) {

        function onMouseUp(e) {