define("ace/mode/asciidoc_highlight_rules", ["require", "exports", "module", "ace/lib/oop", "ace/mode/text_highlight_rules"], function (e, t, n) {
    "use strict";
    var r = e("../lib/oop"), i = e("./text_highlight_rules").TextHighlightRules, s = function () {
        function t(e) {
            var t = /\w/.test(e) ? "\\b" : "(?:\\B|^)";
            return t + e + "[^" + e + "].*?" + e + "(?![\\w*])"
        }

        var e = "[a-zA-Z\u00a1-\uffff]+\\b";
        this.$rules = {
            start: [{token: "empty", regex: /$/}, {
                token: "literal",
                regex: /^\.{4,}\s*$/,
                next: "listingBlock"
            }, {token: "literal", regex: /^-{4,}\s*$/, next: "literalBlock"}, {
                token: "string",
                regex: /^\+{4,}\s*$/,
                next: "passthroughBlock"
            }, {token: "keyword", regex: /^={4,}\s*$/}, {token: "text", regex: /^\s*$/}, {
                token: "empty",
                regex: "",
                next: "dissallowDelimitedBlock"
            }],
            dissallowDelimitedBlock: [{include: "paragraphEnd"}, {token: "comment", regex: "^//.+$"}, {
                token: "keyword",
                regex: "^(?:NOTE|TIP|IMPORTANT|WARNING|CAUTION):"
            }, {include: "listStart"}, {token: "literal", regex: /^\s+.+$/, next: "indentedBlock"}, {
                token: "empty",
                regex: "",
                next: "text"
            }],
            paragraphEnd: [{token: "doc.comment", regex: /^\/{4,}\s*$/, next: "commentBlock"}, {
                token: "tableBlock",
                regex: /^\s*[|!]=+\s*$/,
                next: "tableBlock"
            }, {token: "keyword", regex: /^(?:--|''')\s*$/, next: "start"}, {
                token: "option",
                regex: /^\[.*\]\s*$/,
                next: "start"
            }, {token: "pageBreak", regex: /^>{3,}$/, next: "start"}, {
                token: "literal",
                regex: /^\.{4,}\s*$/,
                next: "listingBlock"
            }, {
                token: "titleUnderline",
                regex: /^(?:={2,}|-{2,}|~{2,}|\^{2,}|\+{2,})\s*$/,
                next: "start"
            }, {token: "singleLineTitle", regex: /^={1,5}\s+\S.*$/, next: "start"}, {
                token: "otherBlock",
                regex: /^(?:\*{2,}|_{2,})\s*$/,
                next: "start"
            }, {token: "optionalTitle", regex: /^\.[^.\s].+$/, next: "start"}],
            listStart: [{
                token: "keyword",
                regex: /^\s*(?:\d+\.|[a-zA-Z]\.|[ixvmIXVM]+\)|\*{1,5}|-|\.{1,5})\s/,
                next: "listText"
            }, {
                token: "meta.tag",
                regex: /^.+(?::{2,4}|;;)(?: |$)/,
                next: "listText"
            }, {token: "support.function.list.callout", regex: /^(?:<\d+>|\d+>|>) /, next: "text"}, {
                token: "keyword",
                regex: /^\+\s*$/,
                next: "start"
            }],
            text: [{
                token: ["link", "variable.language"],
                regex: /((?:https?:\/\/|ftp:\/\/|file:\/\/|mailto:|callto:)[^\s\[]+)(\[.*?\])/
            }, {token: "link", regex: /(?:https?:\/\/|ftp:\/\/|file:\/\/|mailto:|callto:)[^\s\[]+/}, {
                token: "link",
                regex: /\b[\w\.\/\-]+@[\w\.\/\-]+\b/
            }, {include: "macros"}, {include: "paragraphEnd"}, {
                token: "literal",
                regex: /\+{3,}/,
                next: "smallPassthrough"
            }, {
                token: "escape",
                regex: /\((?:C|TM|R)\)|\.{3}|->|<-|=>|<=|&#(?:\d+|x[a-fA-F\d]+);|(?: |^)--(?=\s+\S)/
            }, {token: "escape", regex: /\\[_*'`+#]|\\{2}[_*'`+#]{2}/}, {
                token: "keyword",
                regex: /\s\+$/
            }, {token: "text", regex: e}, {
                token: ["keyword", "string", "keyword"],
                regex: /(<<[\w\d\-$]+,)(.*?)(>>|$)/
            }, {token: "keyword", regex: /<<[\w\d\-$]+,?|>>/}, {
                token: "constant.character",
                regex: /\({2,3}.*?\){2,3}/
            }, {token: "keyword", regex: /\[\[.+?\]\]/}, {
                token: "support",
                regex: /^\[{3}[\w\d =\-]+\]{3}/
            }, {include: "quotes"}, {token: "empty", regex: /^\s*$/, next: "start"}],
            listText: [{include: "listStart"}, {include: "text"}],
            indentedBlock: [{token: "literal", regex: /^[\s\w].+$/, next: "indentedBlock"}, {
                token: "literal",
                regex: "",
                next: "start"
            }],
            listingBlock: [{
                token: "literal",
                regex: /^\.{4,}\s*$/,
                next: "dissallowDelimitedBlock"
            }, {token: "constant.numeric", regex: "<\\d+>"}, {token: "literal", regex: "[^<]+"}, {
                token: "literal",
                regex: "<"
            }],
            literalBlock: [{
                token: "literal",
                regex: /^-{4,}\s*$/,
                next: "dissallowDelimitedBlock"
            }, {token: "constant.numeric", regex: "<\\d+>"}, {token: "literal", regex: "[^<]+"}, {
                token: "literal",
                regex: "<"
            }],
            passthroughBlock: [{
                token: "literal",
                regex: /^\+{4,}\s*$/,
                next: "dissallowDelimitedBlock"
            }, {token: "literal", regex: e + "|\\d+"}, {include: "macros"}, {token: "literal", regex: "."}],
            smallPassthrough: [{token: "literal", regex: /[+]{3,}/, next: "dissallowDelimitedBlock"}, {
                token: "literal",
                regex: /^\s*$/,
                next: "dissallowDelimitedBlock"
            }, {token: "literal", regex: e + "|\\d+"}, {include: "macros"}],
            commentBlock: [{
                token: "doc.comment",
                regex: /^\/{4,}\s*$/,
                next: "dissallowDelimitedBlock"
            }, {token: "doc.comment", regex: "^.*$"}],
            tableBlock: [{
                token: "tableBlock",
                regex: /^\s*\|={3,}\s*$/,
                next: "dissallowDelimitedBlock"
            }, {token: "tableBlock", regex: /^\s*!={3,}\s*$/, next: "innerTableBlock"}, {
                token: "tableBlock",
                regex: /\|/
            }, {include: "text", noEscape: !0}],
            innerTableBlock: [{token: "tableBlock", regex: /^\s*!={3,}\s*$/, next: "tableBlock"}, {
                token: "tableBlock",
                regex: /^\s*|={3,}\s*$/,
                next: "dissallowDelimitedBlock"
            }, {token: "tableBlock", regex: /\!/}],
            macros: [{
                token: "macro",
                regex: /{[\w\-$]+}/
            }, {
                token: ["text", "string", "text", "constant.character", "text"],
                regex: /({)([\w\-$]+)(:)?(.+)?(})/
            }, {
                token: ["text", "markup.list.macro", "keyword", "string"],
                regex: /(\w+)(footnote(?:ref)?::?)([^\s\[]+)?(\[.*?\])?/
            }, {
                token: ["markup.list.macro", "keyword", "string"],
                regex: /([a-zA-Z\-][\w\.\/\-]*::?)([^\s\[]+)(\[.*?\])?/
            }, {
                token: ["markup.list.macro", "keyword"],
                regex: /([a-zA-Z\-][\w\.\/\-]+::?)(\[.*?\])/
            }, {token: "keyword", regex: /^:.+?:(?= |$)/}],
            quotes: [{token: "string.italic", regex: /__[^_\s].*?__/}, {
                token: "string.italic",
                regex: t("_")
            }, {token: "keyword.bold", regex: /\*\*[^*\s].*?\*\*/}, {
                token: "keyword.bold",
                regex: t("\\*")
            }, {token: "literal", regex: t("\\+")}, {token: "literal", regex: /\+\+[^+\s].*?\+\+/}, {
                token: "literal",
                regex: /\$\$.+?\$\$/
            }, {token: "literal", regex: t("`")}, {token: "keyword", regex: t("^")}, {
                token: "keyword",
                regex: t("~")
            }, {token: "keyword", regex: /##?/}, {token: "keyword", regex: /(?:\B|^)``|\b''/}]
        };
        var n = {
            macro: "constant.character",
            tableBlock: "doc.comment",
            titleUnderline: "markup.heading",
            singleLineTitle: "markup.heading",
            pageBreak: "string",
            option: "string.regexp",
            otherBlock: "markup.list",
            literal: "support.function",
            optionalTitle: "constant.numeric",
            escape: "constant.language.escape",
            link: "markup.underline.list"
        };
        for (var r in this.$rules) {
            var i = this.$rules[r];
            for (var s = i.length; s--;) {
                var o = i[s];
                if (o.include || typeof o == "string") {
                    var u = [s, 1].concat(this.$rules[o.include || o]);
                    o.noEscape && (u = u.filter(function (e) {
                        return !e.next
                    })), i.splice.apply(i, u)
                } else o.token in n && (o.token = n[o.token])
            }
        }
    };
    r.inherits(s, i), t.AsciidocHighlightRules = s
}), define("ace/mode/folding/asciidoc", ["require", "exports", "module", "ace/lib/oop", "ace/mode/folding/fold_mode", "ace/range"], function (e, t, n) {
    "use strict";
    var r = e("../../lib/oop"), i = e("./fold_mode").FoldMode, s = e("../../range").Range, o = t.FoldMode = function () {
    };
    r.inherits(o, i), function () {
        this.foldingStartMarker = /^(?:\|={10,}|[\.\/=\-~^+]{4,}\s*$|={1,5} )/, this.singleLineHeadingRe = /^={1,5}(?=\s+\S)/, this.getFoldWidget = function (e, t, n) {
            var r = e.getLine(n);
            return this.foldingStartMarker.test(r) ? r[0] == "=" ? this.singleLineHeadingRe.test(r) ? "start" : e.getLine(n - 1).length != e.getLine(n).length ? "" : "start" : e.bgTokenizer.getState(n) == "dissallowDelimitedBlock" ? "end" : "start" : ""
        }, this.getFoldWidgetRange = function (e, t, n) {
            function l(t) {
                return f = e.getTokens(t)[0], f && f.type
            }

            function d() {
                var t = f.value.match(p);
                if (t)return t[0].length;
                var r = c.indexOf(f.value[0]) + 1;
                return r == 1 && e.getLine(n - 1).length != e.getLine(n).length ? Infinity : r
            }

            var r = e.getLine(n), i = r.length, o = e.getLength(), u = n, a = n;
            if (!r.match(this.foldingStartMarker))return;
            var f, c = ["=", "-", "~", "^", "+"], h = "markup.heading", p = this.singleLineHeadingRe;
            if (l(n) == h) {
                var v = d();
                while (++n < o) {
                    if (l(n) != h)continue;
                    var m = d();
                    if (m <= v)break
                }
                var g = f && f.value.match(this.singleLineHeadingRe);
                a = g ? n - 1 : n - 2;
                if (a > u)while (a > u && (!l(a) || f.value[0] == "["))a--;
                if (a > u) {
                    var y = e.getLine(a).length;
                    return new s(u, i, a, y)
                }
            } else {
                var b = e.bgTokenizer.getState(n);
                if (b == "dissallowDelimitedBlock") {
                    while (n-- > 0)if (e.bgTokenizer.getState(n).lastIndexOf("Block") == -1)break;
                    a = n + 1;
                    if (a < u) {
                        var y = e.getLine(n).length;
                        return new s(a, 5, u, i - 5)
                    }
                } else {
                    while (++n < o)if (e.bgTokenizer.getState(n) == "dissallowDelimitedBlock")break;
                    a = n;
                    if (a > u) {
                        var y = e.getLine(n).length;
                        return new s(u, 5, a, y - 5)
                    }
                }
            }
        }
    }.call(o.prototype)
}), define("ace/mode/asciidoc", ["require", "exports", "module", "ace/lib/oop", "ace/mode/text", "ace/mode/asciidoc_highlight_rules", "ace/mode/folding/asciidoc"], function (e, t, n) {
    "use strict";
    var r = e("../lib/oop"), i = e("./text").Mode, s = e("./asciidoc_highlight_rules").AsciidocHighlightRules, o = e("./folding/asciidoc").FoldMode, u = function () {
        this.HighlightRules = s, this.foldingRules = new o
    };
    r.inherits(u, i), function () {
        this.type = "text", this.getNextLineIndent = function (e, t, n) {
            if (e == "listblock") {
                var r = /^((?:.+)?)([-+*][ ]+)/.exec(t);
                return r ? (new Array(r[1].length + 1)).join(" ") + r[2] : ""
            }
            return this.$getIndent(t)
        }, this.$id = "ace/mode/asciidoc"
    }.call(u.prototype), t.Mode = u
})