ace.define("ace/mode/c9search_highlight_rules", ["require", "exports", "module", "ace/lib/oop", "ace/lib/lang", "ace/mode/text_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;

  function safeCreateRegexp(source, flag) {
    try {
      return new RegExp(source, flag);
    } catch (e) {}
  }

  var C9SearchHighlightRules = function C9SearchHighlightRules() {
    this.$rules = {
      "start": [{
        tokenNames: ["c9searchresults.constant.numeric", "c9searchresults.text", "c9searchresults.text", "c9searchresults.keyword"],
        regex: /(^\s+[0-9]+)(:)(\d*\s?)([^\r\n]+)/,
        onMatch: function onMatch(val, state, stack) {
          var values = this.splitRegex.exec(val);
          var types = this.tokenNames;
          var tokens = [{
            type: types[0],
            value: values[1]
          }, {
            type: types[1],
            value: values[2]
          }];

          if (values[3]) {
            if (values[3] == " ") tokens[1] = {
              type: types[1],
              value: values[2] + " "
            };else tokens.push({
              type: types[1],
              value: values[3]
            });
          }

          var regex = stack[1];
          var str = values[4];
          var m;
          var last = 0;

          if (regex && regex.exec) {
            regex.lastIndex = 0;

            while (m = regex.exec(str)) {
              var skipped = str.substring(last, m.index);
              last = regex.lastIndex;
              if (skipped) tokens.push({
                type: types[2],
                value: skipped
              });
              if (m[0]) tokens.push({
                type: types[3],
                value: m[0]
              });else if (!skipped) break;
            }
          }

          if (last < str.length) tokens.push({
            type: types[2],
            value: str.substr(last)
          });
          return tokens;
        }
      }, {
        regex: "^Searching for [^\\r\\n]*$",
        onMatch: function onMatch(val, state, stack) {
          var parts = val.split("\x01");
          if (parts.length < 3) return "text";
          var options, search;
          var i = 0;
          var tokens = [{
            value: parts[i++] + "'",
            type: "text"
          }, {
            value: search = parts[i++],
            type: "text" // "c9searchresults.keyword"

          }, {
            value: "'" + parts[i++],
            type: "text"
          }];

          if (parts[2] !== " in") {
            tokens.push({
              value: "'" + parts[i++] + "'",
              type: "text"
            }, {
              value: parts[i++],
              type: "text"
            });
          }

          tokens.push({
            value: " " + parts[i++] + " ",
            type: "text"
          });

          if (parts[i + 1]) {
            options = parts[i + 1];
            tokens.push({
              value: "(" + parts[i + 1] + ")",
              type: "text"
            });
            i += 1;
          } else {
            i -= 1;
          }

          while (i++ < parts.length) {
            parts[i] && tokens.push({
              value: parts[i],
              type: "text"
            });
          }

          if (search) {
            if (!/regex/.test(options)) search = lang.escapeRegExp(search);
            if (/whole/.test(options)) search = "\\b" + search + "\\b";
          }

          var regex = search && safeCreateRegexp("(" + search + ")", / sensitive/.test(options) ? "g" : "ig");

          if (regex) {
            stack[0] = state;
            stack[1] = regex;
          }

          return tokens;
        }
      }, {
        regex: "^(?=Found \\d+ matches)",
        token: "text",
        next: "numbers"
      }, {
        token: "string",
        // single line
        regex: "^\\S:?[^:]+",
        next: "numbers"
      }],
      numbers: [{
        regex: "\\d+",
        token: "constant.numeric"
      }, {
        regex: "$",
        token: "text",
        next: "start"
      }]
    };
    this.normalizeRules();
  };

  oop.inherits(C9SearchHighlightRules, TextHighlightRules);
  exports.C9SearchHighlightRules = C9SearchHighlightRules;
});
ace.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 MatchingBraceOutdent() {};

  (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;
});
ace.define("ace/mode/folding/c9search", ["require", "exports", "module", "ace/lib/oop", "ace/range", "ace/mode/folding/fold_mode"], function (require, exports, module) {
  "use strict";

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

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

  var BaseFoldMode = require("./fold_mode").FoldMode;

  var FoldMode = exports.FoldMode = function () {};

  oop.inherits(FoldMode, BaseFoldMode);
  (function () {
    this.foldingStartMarker = /^(\S.*:|Searching for.*)$/;
    this.foldingStopMarker = /^(\s+|Found.*)$/;

    this.getFoldWidgetRange = function (session, foldStyle, row) {
      var lines = session.doc.getAllLines(row);
      var line = lines[row];
      var level1 = /^(Found.*|Searching for.*)$/;
      var level2 = /^(\S.*:|\s*)$/;
      var re = level1.test(line) ? level1 : level2;
      var startRow = row;
      var endRow = row;

      if (this.foldingStartMarker.test(line)) {
        for (var i = row + 1, l = session.getLength(); i < l; i++) {
          if (re.test(lines[i])) break;
        }

        endRow = i;
      } else if (this.foldingStopMarker.test(line)) {
        for (var i = row - 1; i >= 0; i--) {
          line = lines[i];
          if (re.test(line)) break;
        }

        startRow = i;
      }

      if (startRow != endRow) {
        var col = line.length;
        if (re === level1) col = line.search(/\(Found[^)]+\)$|$/);
        return new Range(startRow, col, endRow, 0);
      }
    };
  }).call(FoldMode.prototype);
});
ace.define("ace/mode/c9search", ["require", "exports", "module", "ace/lib/oop", "ace/mode/text", "ace/mode/c9search_highlight_rules", "ace/mode/matching_brace_outdent", "ace/mode/folding/c9search"], function (require, exports, module) {
  "use strict";

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

  var TextMode = require("./text").Mode;

  var C9SearchHighlightRules = require("./c9search_highlight_rules").C9SearchHighlightRules;

  var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;

  var C9StyleFoldMode = require("./folding/c9search").FoldMode;

  var Mode = function Mode() {
    this.HighlightRules = C9SearchHighlightRules;
    this.$outdent = new MatchingBraceOutdent();
    this.foldingRules = new C9StyleFoldMode();
  };

  oop.inherits(Mode, TextMode);
  (function () {
    this.getNextLineIndent = function (state, line, tab) {
      var indent = this.$getIndent(line);
      return indent;
    };

    this.checkOutdent = function (state, line, input) {
      return this.$outdent.checkOutdent(line, input);
    };

    this.autoOutdent = function (state, doc, row) {
      this.$outdent.autoOutdent(doc, row);
    };

    this.$id = "ace/mode/c9search";
  }).call(Mode.prototype);
  exports.Mode = Mode;
});

(function () {
  ace.require(["ace/mode/c9search"], function (m) {
    if (typeof module == "object" && typeof exports == "object" && module) {
      module.exports = m;
    }
  });
})();