define("ace/mode/latex_highlight_rules", ["require", "exports", "module", "ace/lib/oop", "ace/mode/text_highlight_rules"], function (require, exports, module) {
    "use strict";

    var oop = require("../lib/oop");
    var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;

    var LatexHighlightRules = function () {

        this.$rules = {
            "start": [{
                token: "comment",
                regex: "%.*$"
            }, {
                token: ["keyword", "lparen", "variable.parameter", "rparen", "lparen", "storage.type", "rparen"],
                regex: "(\\\\(?:documentclass|usepackage|input))(?:(\\[)([^\\]]*)(\\]))?({)([^}]*)(})"
            }, {
                token: ["keyword", "lparen", "variable.parameter", "rparen"],
                regex: "(\\\\label)(?:({)([^}]*)(}))?"
            }, {
                token: ["storage.type", "lparen", "variable.parameter", "rparen"],
                regex: "(\\\\(?:begin|end))({)(\\w*)(})"
            }, {
                token: "storage.type",
                regex: "\\\\[a-zA-Z]+"
            }, {
                token: "lparen",
                regex: "[[({]"
            }, {
                token: "rparen",
                regex: "[\\])}]"
            }, {
                token: "constant.character.escape",
                regex: "\\\\[^a-zA-Z]?"
            }, {
                token: "string",
                regex: "\\${1,2}",
                next: "equation"
            }],
            "equation": [{
                token: "comment",
                regex: "%.*$"
            }, {
                token: "string",
                regex: "\\${1,2}",
                next: "start"
            }, {
                token: "constant.character.escape",
                regex: "\\\\(?:[^a-zA-Z]|[a-zA-Z]+)"
            }, {
                token: "error",
                regex: "^\\s*$",
                next: "start"
            }, {
                defaultToken: "string"
            }]

        };
    };
    oop.inherits(LatexHighlightRules, TextHighlightRules);

    exports.LatexHighlightRules = LatexHighlightRules;

});

define("ace/mode/rdoc_highlight_rules", ["require", "exports", "module", "ace/lib/oop", "ace/lib/lang", "ace/mode/text_highlight_rules", "ace/mode/latex_highlight_rules"], function (require, exports, module) {
    "use strict";

    var oop = require("../lib/oop");
    var lang = require("../lib/lang");
    var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
    var LaTeXHighlightRules = require("./latex_highlight_rules");

    var RDocHighlightRules = function () {

        this.$rules = {
            "start": [
                {
                    token: "comment",
                    regex: "%.*$"
                }, {
                    token: "text", // non-command
                    regex: "\\\\[$&%#\\{\\}]"
                }, {
                    token: "keyword", // command
                    regex: "\\\\(?:name|alias|method|S3method|S4method|item|code|preformatted|kbd|pkg|var|env|option|command|author|email|url|source|cite|acronym|href|code|preformatted|link|eqn|deqn|keyword|usage|examples|dontrun|dontshow|figure|if|ifelse|Sexpr|RdOpts|inputencoding|usepackage)\\b",
                    next: "nospell"
                }, {
                    token: "keyword", // command
                    regex: "\\\\(?:[a-zA-z0-9]+|[^a-zA-z0-9])"
                }, {
                    token: "paren.keyword.operator",
                    regex: "[[({]"
                }, {
                    token: "paren.keyword.operator",
                    regex: "[\\])}]"
                }, {
                    token: "text",
                    regex: "\\s+"
                }
            ],
            "nospell": [
                {
                    token: "comment",
                    regex: "%.*$",
                    next: "start"
                }, {
                    token: "nospell.text", // non-command
                    regex: "\\\\[$&%#\\{\\}]"
                }, {
                    token: "keyword", // command
                    regex: "\\\\(?:name|alias|method|S3method|S4method|item|code|preformatted|kbd|pkg|var|env|option|command|author|email|url|source|cite|acronym|href|code|preformatted|link|eqn|deqn|keyword|usage|examples|dontrun|dontshow|figure|if|ifelse|Sexpr|RdOpts|inputencoding|usepackage)\\b"
                }, {
                    token: "keyword", // command
                    regex: "\\\\(?:[a-zA-z0-9]+|[^a-zA-z0-9])",
                    next: "start"
                }, {
                    token: "paren.keyword.operator",
                    regex: "[[({]"
                }, {
                    token: "paren.keyword.operator",
                    regex: "[\\])]"
                }, {
                    token: "paren.keyword.operator",
                    regex: "}",
                    next: "start"
                }, {
                    token: "nospell.text",
                    regex: "\\s+"
                }, {
                    token: "nospell.text",
                    regex: "\\w+"
                }
            ]
        };
    };

    oop.inherits(RDocHighlightRules, TextHighlightRules);

    exports.RDocHighlightRules = RDocHighlightRules;
});

define("ace/mode/matching_brace_outdent", ["require", "exports", "module", "ace/range"], function (require, exports, module) {
    "use strict";

    var Range = require("../range").Range;

    var MatchingBraceOutdent = function () {
    };

    (function () {

        this.checkOutdent = function (line, input) {
            if (!/^\s+$/.test(line))
                return false;

            return /^\s*\}/.test(input);
        };

        this.autoOutdent = function (doc, row) {
            var line = doc.getLine(row);
            var match = line.match(/^(\s*\})/);

            if (!match) return 0;

            var column = match[1].length;
            var openBracePos = doc.findMatchingBracket({row: row, column: column});

            if (!openBracePos || openBracePos.row == row) return 0;

            var indent = this.$getIndent(doc.getLine(openBracePos.row));
            doc.replace(new Range(row, 0, row, column - 1), indent);
        };

        this.$getIndent = function (line) {
            return line.match(/^\s*/)[0];
        };

    }).call(MatchingBraceOutdent.prototype);

    exports.MatchingBraceOutdent = MatchingBraceOutdent;
});

define("ace/mode/rdoc", ["require", "exports", "module", "ace/lib/oop", "ace/mode/text", "ace/mode/text_highlight_rules", "ace/mode/rdoc_highlight_rules", "ace/mode/matching_brace_outdent"], function (require, exports, module) {
    "use strict";

    var oop = require("../lib/oop");
    var TextMode = require("./text").Mode;
    var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
    var RDocHighlightRules = require("./rdoc_highlight_rules").RDocHighlightRules;
    var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;

    var Mode = function (suppressHighlighting) {
        this.HighlightRules = RDocHighlightRules;
        this.$outdent = new MatchingBraceOutdent();
    };
    oop.inherits(Mode, TextMode);

    (function () {
        this.getNextLineIndent = function (state, line, tab) {
            return this.$getIndent(line);
        };
        this.$id = "ace/mode/rdoc";
    }).call(Mode.prototype);

    exports.Mode = Mode;
});
