text: 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|v?ref|cite(?:[^{]*)))(?:({)([^}]*)(}))?"
              }, {
                  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;
  });
  