c0ckp1t 1.0.0

package/js_ext/ace-editor/mode-lisp.js

@@ -0,0 +1,104 @@
+ace.define("ace/mode/lisp_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module){/*
+  THIS FILE WAS AUTOGENERATED BY Lisp.tmlanguage (UUID: 00D451C9-6B1D-11D9-8DFA-000D93589AF6) */
+"use strict";
+var oop = require("../lib/oop");
+var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
+var LispHighlightRules = function () {
+    var keywordControl = "case|do|let|loop|if|else|when";
+    var keywordOperator = "eq|neq|and|or";
+    var constantLanguage = "null|nil";
+    var supportFunctions = "cons|car|cdr|cond|lambda|format|setq|setf|quote|eval|append|list|listp|memberp|t|load|progn";
+    var keywordMapper = this.createKeywordMapper({
+        "keyword.control": keywordControl,
+        "keyword.operator": keywordOperator,
+        "constant.language": constantLanguage,
+        "support.function": supportFunctions
+    }, "identifier", true);
+    this.$rules =
+        {
+            "start": [
+                {
+                    token: "comment",
+                    regex: ";.*$"
+                },
+                {
+                    token: ["storage.type.function-type.lisp", "text", "entity.name.function.lisp"],
+                    regex: "(?:\\b(?:(defun|defmethod|defmacro))\\b)(\\s+)((?:\\w|\\-|\\!|\\?)*)"
+                },
+                {
+                    token: ["punctuation.definition.constant.character.lisp", "constant.character.lisp"],
+                    regex: "(#)((?:\\w|[\\\\+-=<>'\"&#])+)"
+                },
+                {
+                    token: ["punctuation.definition.variable.lisp", "variable.other.global.lisp", "punctuation.definition.variable.lisp"],
+                    regex: "(\\*)(\\S*)(\\*)"
+                },
+                {
+                    token: "constant.numeric", // hex
+                    regex: "0[xX][0-9a-fA-F]+(?:L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\\b"
+                },
+                {
+                    token: "constant.numeric", // float
+                    regex: "[+-]?\\d+(?:(?:\\.\\d*)?(?:[eE][+-]?\\d+)?)?(?:L|l|UL|ul|u|U|F|f|ll|LL|ull|ULL)?\\b"
+                },
+                {
+                    token: keywordMapper,
+                    regex: "[a-zA-Z_$][a-zA-Z0-9_$]*\\b"
+                },
+                {
+                    token: "string",
+                    regex: '"(?=.)',
+                    next: "qqstring"
+                }
+            ],
+            "qqstring": [
+                {
+                    token: "constant.character.escape.lisp",
+                    regex: "\\\\."
+                },
+                {
+                    token: "string",
+                    regex: '[^"\\\\]+'
+                }, {
+                    token: "string",
+                    regex: "\\\\$",
+                    next: "qqstring"
+                }, {
+                    token: "string",
+                    regex: '"|$',
+                    next: "start"
+                }
+            ]
+        };
+};
+oop.inherits(LispHighlightRules, TextHighlightRules);
+exports.LispHighlightRules = LispHighlightRules;
+
+});
+
+ace.define("ace/mode/lisp",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/lisp_highlight_rules"], function(require, exports, module){/*
+  THIS FILE WAS AUTOGENERATED BY mode.tmpl.js
+*/
+"use strict";
+var oop = require("../lib/oop");
+var TextMode = require("./text").Mode;
+var LispHighlightRules = require("./lisp_highlight_rules").LispHighlightRules;
+var Mode = function () {
+    this.HighlightRules = LispHighlightRules;
+    this.$behaviour = this.$defaultBehaviour;
+};
+oop.inherits(Mode, TextMode);
+(function () {
+    this.lineCommentStart = ";";
+    this.$id = "ace/mode/lisp";
+}).call(Mode.prototype);
+exports.Mode = Mode;
+
+});                (function() {
+                    ace.require(["ace/mode/lisp"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

package/js_ext/ace-editor/mode-livescript.js

@@ -0,0 +1,272 @@
+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 () { };
+(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/livescript",["require","exports","module","ace/tokenizer","ace/mode/matching_brace_outdent","ace/mode/behaviour/cstyle","ace/mode/text"], function(require, exports, module){var identifier, LiveScriptMode, keywordend, stringfill;
+identifier = '(?![\\d\\s])[$\\w\\xAA-\\uFFDC](?:(?!\\s)[$\\w\\xAA-\\uFFDC]|-[A-Za-z])*';
+exports.Mode = LiveScriptMode = (function (superclass) {
+    var indenter, prototype = extend$((import$(LiveScriptMode, superclass).displayName = 'LiveScriptMode', LiveScriptMode), superclass).prototype, constructor = LiveScriptMode;
+    function LiveScriptMode() {
+        var that;
+        this.$tokenizer = new (require('../tokenizer')).Tokenizer(LiveScriptMode.Rules);
+        if (that = require('../mode/matching_brace_outdent')) {
+            this.$outdent = new that.MatchingBraceOutdent;
+        }
+        this.$id = "ace/mode/livescript";
+        this.$behaviour = new (require("./behaviour/cstyle").CstyleBehaviour)();
+    }
+    indenter = RegExp('(?:[({[=:]|[-~]>|\\b(?:e(?:lse|xport)|d(?:o|efault)|t(?:ry|hen)|finally|import(?:\\s*all)?|const|var|let|new|catch(?:\\s*' + identifier + ')?))\\s*$');
+    prototype.getNextLineIndent = function (state, line, tab) {
+        var indent, tokens;
+        indent = this.$getIndent(line);
+        tokens = this.$tokenizer.getLineTokens(line, state).tokens;
+        if (!(tokens.length && tokens[tokens.length - 1].type === 'comment')) {
+            if (state === 'start' && indenter.test(line)) {
+                indent += tab;
+            }
+        }
+        return indent;
+    };
+    prototype.lineCommentStart = "#";
+    prototype.blockComment = { start: "###", end: "###" };
+    prototype.checkOutdent = function (state, line, input) {
+        var ref$;
+        return (ref$ = this.$outdent) != null ? ref$.checkOutdent(line, input) : void 8;
+    };
+    prototype.autoOutdent = function (state, doc, row) {
+        var ref$;
+        return (ref$ = this.$outdent) != null ? ref$.autoOutdent(doc, row) : void 8;
+    };
+    return LiveScriptMode;
+}(require('../mode/text').Mode));
+keywordend = '(?![$\\w]|-[A-Za-z]|\\s*:(?![:=]))';
+stringfill = {
+    defaultToken: 'string'
+};
+LiveScriptMode.Rules = {
+    start: [
+        {
+            token: 'keyword',
+            regex: '(?:t(?:h(?:is|row|en)|ry|ypeof!?)|c(?:on(?:tinue|st)|a(?:se|tch)|lass)|i(?:n(?:stanceof)?|mp(?:ort(?:\\s+all)?|lements)|[fs])|d(?:e(?:fault|lete|bugger)|o)|f(?:or(?:\\s+own)?|inally|unction)|s(?:uper|witch)|e(?:lse|x(?:tends|port)|val)|a(?:nd|rguments)|n(?:ew|ot)|un(?:less|til)|w(?:hile|ith)|o[fr]|return|break|let|var|loop)' + keywordend
+        }, {
+            token: 'constant.language',
+            regex: '(?:true|false|yes|no|on|off|null|void|undefined)' + keywordend
+        }, {
+            token: 'invalid.illegal',
+            regex: '(?:p(?:ackage|r(?:ivate|otected)|ublic)|i(?:mplements|nterface)|enum|static|yield)' + keywordend
+        }, {
+            token: 'language.support.class',
+            regex: '(?:R(?:e(?:gExp|ferenceError)|angeError)|S(?:tring|yntaxError)|E(?:rror|valError)|Array|Boolean|Date|Function|Number|Object|TypeError|URIError)' + keywordend
+        }, {
+            token: 'language.support.function',
+            regex: '(?:is(?:NaN|Finite)|parse(?:Int|Float)|Math|JSON|(?:en|de)codeURI(?:Component)?)' + keywordend
+        }, {
+            token: 'variable.language',
+            regex: '(?:t(?:hat|il|o)|f(?:rom|allthrough)|it|by|e)' + keywordend
+        }, {
+            token: 'identifier',
+            regex: identifier + '\\s*:(?![:=])'
+        }, {
+            token: 'variable',
+            regex: identifier
+        }, {
+            token: 'keyword.operator',
+            regex: '(?:\\.{3}|\\s+\\?)'
+        }, {
+            token: 'keyword.variable',
+            regex: '(?:@+|::|\\.\\.)',
+            next: 'key'
+        }, {
+            token: 'keyword.operator',
+            regex: '\\.\\s*',
+            next: 'key'
+        }, {
+            token: 'string',
+            regex: '\\\\\\S[^\\s,;)}\\]]*'
+        }, {
+            token: 'string.doc',
+            regex: '\'\'\'',
+            next: 'qdoc'
+        }, {
+            token: 'string.doc',
+            regex: '"""',
+            next: 'qqdoc'
+        }, {
+            token: 'string',
+            regex: '\'',
+            next: 'qstring'
+        }, {
+            token: 'string',
+            regex: '"',
+            next: 'qqstring'
+        }, {
+            token: 'string',
+            regex: '`',
+            next: 'js'
+        }, {
+            token: 'string',
+            regex: '<\\[',
+            next: 'words'
+        }, {
+            token: 'string.regex',
+            regex: '//',
+            next: 'heregex'
+        }, {
+            token: 'comment.doc',
+            regex: '/\\*',
+            next: 'comment'
+        }, {
+            token: 'comment',
+            regex: '#.*'
+        }, {
+            token: 'string.regex',
+            regex: '\\/(?:[^[\\/\\n\\\\]*(?:(?:\\\\.|\\[[^\\]\\n\\\\]*(?:\\\\.[^\\]\\n\\\\]*)*\\])[^[\\/\\n\\\\]*)*)\\/[gimy$]{0,4}',
+            next: 'key'
+        }, {
+            token: 'constant.numeric',
+            regex: '(?:0x[\\da-fA-F][\\da-fA-F_]*|(?:[2-9]|[12]\\d|3[0-6])r[\\da-zA-Z][\\da-zA-Z_]*|(?:\\d[\\d_]*(?:\\.\\d[\\d_]*)?|\\.\\d[\\d_]*)(?:e[+-]?\\d[\\d_]*)?[\\w$]*)'
+        }, {
+            token: 'lparen',
+            regex: '[({[]'
+        }, {
+            token: 'rparen',
+            regex: '[)}\\]]',
+            next: 'key'
+        }, {
+            token: 'keyword.operator',
+            regex: '[\\^!|&%+\\-]+'
+        }, {
+            token: 'text',
+            regex: '\\s+'
+        }
+    ],
+    heregex: [
+        {
+            token: 'string.regex',
+            regex: '.*?//[gimy$?]{0,4}',
+            next: 'start'
+        }, {
+            token: 'string.regex',
+            regex: '\\s*#{'
+        }, {
+            token: 'comment.regex',
+            regex: '\\s+(?:#.*)?'
+        }, {
+            defaultToken: 'string.regex'
+        }
+    ],
+    key: [
+        {
+            token: 'keyword.operator',
+            regex: '[.?@!]+'
+        }, {
+            token: 'identifier',
+            regex: identifier,
+            next: 'start'
+        }, {
+            token: 'text',
+            regex: '',
+            next: 'start'
+        }
+    ],
+    comment: [
+        {
+            token: 'comment.doc',
+            regex: '.*?\\*/',
+            next: 'start'
+        }, {
+            defaultToken: 'comment.doc'
+        }
+    ],
+    qdoc: [
+        {
+            token: 'string',
+            regex: ".*?'''",
+            next: 'key'
+        }, stringfill
+    ],
+    qqdoc: [
+        {
+            token: 'string',
+            regex: '.*?"""',
+            next: 'key'
+        }, stringfill
+    ],
+    qstring: [
+        {
+            token: 'string',
+            regex: '[^\\\\\']*(?:\\\\.[^\\\\\']*)*\'',
+            next: 'key'
+        }, stringfill
+    ],
+    qqstring: [
+        {
+            token: 'string',
+            regex: '[^\\\\"]*(?:\\\\.[^\\\\"]*)*"',
+            next: 'key'
+        }, stringfill
+    ],
+    js: [
+        {
+            token: 'string',
+            regex: '[^\\\\`]*(?:\\\\.[^\\\\`]*)*`',
+            next: 'key'
+        }, stringfill
+    ],
+    words: [
+        {
+            token: 'string',
+            regex: '.*?\\]>',
+            next: 'key'
+        }, stringfill
+    ]
+};
+function extend$(sub, sup) {
+    function fun() { }
+    fun.prototype = (sub.superclass = sup).prototype;
+    (sub.prototype = new fun).constructor = sub;
+    if (typeof sup.extended == 'function')
+        sup.extended(sub);
+    return sub;
+}
+function import$(obj, src) {
+    var own = {}.hasOwnProperty;
+    for (var key in src)
+        if (own.call(src, key))
+            obj[key] = src[key];
+    return obj;
+}
+
+});                (function() {
+                    ace.require(["ace/mode/livescript"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+            

package/js_ext/ace-editor/mode-logiql.js

@@ -0,0 +1,272 @@
+ace.define("ace/mode/logiql_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module){/* THIS FILE WAS AUTOGENERATED FROM tool\LogicBlox.tmbundle\Syntaxes\LogicBlox.tmLanguage (UUID: 59bf5022-e261-453f-b1cb-9f9fa0712413) */
+"use strict";
+var oop = require("../lib/oop");
+var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
+var LogiQLHighlightRules = function () {
+    this.$rules = { start: [{ token: 'comment.block',
+                regex: '/\\*',
+                push: [{ token: 'comment.block', regex: '\\*/', next: 'pop' },
+                    { defaultToken: 'comment.block' }]
+            },
+            { token: 'comment.single',
+                regex: '//.*'
+            },
+            { token: 'constant.numeric',
+                regex: '\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?[fd]?'
+            },
+            { token: 'string',
+                regex: '"',
+                push: [{ token: 'string', regex: '"', next: 'pop' },
+                    { defaultToken: 'string' }]
+            },
+            { token: 'constant.language',
+                regex: '\\b(true|false)\\b'
+            },
+            { token: 'entity.name.type.logicblox',
+                regex: '`[a-zA-Z_:]+(\\d|\\a)*\\b'
+            },
+            { token: 'keyword.start', regex: '->', comment: 'Constraint' },
+            { token: 'keyword.start', regex: '-->', comment: 'Level 1 Constraint' },
+            { token: 'keyword.start', regex: '<-', comment: 'Rule' },
+            { token: 'keyword.start', regex: '<--', comment: 'Level 1 Rule' },
+            { token: 'keyword.end', regex: '\\.', comment: 'Terminator' },
+            { token: 'keyword.other', regex: '!', comment: 'Negation' },
+            { token: 'keyword.other', regex: ',', comment: 'Conjunction' },
+            { token: 'keyword.other', regex: ';', comment: 'Disjunction' },
+            { token: 'keyword.operator', regex: '<=|>=|!=|<|>', comment: 'Equality' },
+            { token: 'keyword.other', regex: '@', comment: 'Equality' },
+            { token: 'keyword.operator', regex: '\\+|-|\\*|/', comment: 'Arithmetic operations' },
+            { token: 'keyword', regex: '::', comment: 'Colon colon' },
+            { token: 'support.function',
+                regex: '\\b(agg\\s*<<)',
+                push: [{ include: '$self' },
+                    { token: 'support.function',
+                        regex: '>>',
+                        next: 'pop' }]
+            },
+            { token: 'storage.modifier',
+                regex: '\\b(lang:[\\w:]*)'
+            },
+            { token: ['storage.type', 'text'],
+                regex: '(export|sealed|clauses|block|alias|alias_all)(\\s*\\()(?=`)'
+            },
+            { token: 'entity.name',
+                regex: '[a-zA-Z_][a-zA-Z_0-9:]*(@prev|@init|@final)?(?=(\\(|\\[))'
+            },
+            { token: 'variable.parameter',
+                regex: '([a-zA-Z][a-zA-Z_0-9]*|_)\\s*(?=(,|\\.|<-|->|\\)|\\]|=))'
+            }] };
+    this.normalizeRules();
+};
+oop.inherits(LogiQLHighlightRules, TextHighlightRules);
+exports.LogiQLHighlightRules = LogiQLHighlightRules;
+
+});
+
+ace.define("ace/mode/folding/coffee",["require","exports","module","ace/lib/oop","ace/mode/folding/fold_mode","ace/range"], function(require, exports, module){"use strict";
+var oop = require("../../lib/oop");
+var BaseFoldMode = require("./fold_mode").FoldMode;
+var Range = require("../../range").Range;
+var FoldMode = exports.FoldMode = function () { };
+oop.inherits(FoldMode, BaseFoldMode);
+(function () {
+    this.commentBlock = function (session, row) {
+        var re = /\S/;
+        var line = session.getLine(row);
+        var startLevel = line.search(re);
+        if (startLevel == -1 || line[startLevel] != "#")
+            return;
+        var startColumn = line.length;
+        var maxRow = session.getLength();
+        var startRow = row;
+        var endRow = row;
+        while (++row < maxRow) {
+            line = session.getLine(row);
+            var level = line.search(re);
+            if (level == -1)
+                continue;
+            if (line[level] != "#")
+                break;
+            endRow = row;
+        }
+        if (endRow > startRow) {
+            var endColumn = session.getLine(endRow).length;
+            return new Range(startRow, startColumn, endRow, endColumn);
+        }
+    };
+    this.getFoldWidgetRange = function (session, foldStyle, row) {
+        var range = this.indentationBlock(session, row);
+        if (range)
+            return range;
+        range = this.commentBlock(session, row);
+        if (range)
+            return range;
+    };
+    this.getFoldWidget = function (session, foldStyle, row) {
+        var line = session.getLine(row);
+        var indent = line.search(/\S/);
+        var next = session.getLine(row + 1);
+        var prev = session.getLine(row - 1);
+        var prevIndent = prev.search(/\S/);
+        var nextIndent = next.search(/\S/);
+        if (indent == -1) {
+            session.foldWidgets[row - 1] = prevIndent != -1 && prevIndent < nextIndent ? "start" : "";
+            return "";
+        }
+        if (prevIndent == -1) {
+            if (indent == nextIndent && line[indent] == "#" && next[indent] == "#") {
+                session.foldWidgets[row - 1] = "";
+                session.foldWidgets[row + 1] = "";
+                return "start";
+            }
+        }
+        else if (prevIndent == indent && line[indent] == "#" && prev[indent] == "#") {
+            if (session.getLine(row - 2).search(/\S/) == -1) {
+                session.foldWidgets[row - 1] = "start";
+                session.foldWidgets[row + 1] = "";
+                return "";
+            }
+        }
+        if (prevIndent != -1 && prevIndent < indent)
+            session.foldWidgets[row - 1] = "start";
+        else
+            session.foldWidgets[row - 1] = "";
+        if (indent < nextIndent)
+            return "start";
+        else
+            return "";
+    };
+}).call(FoldMode.prototype);
+
+});
+
+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 () { };
+(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/logiql",["require","exports","module","ace/lib/oop","ace/mode/text","ace/mode/logiql_highlight_rules","ace/mode/folding/coffee","ace/token_iterator","ace/range","ace/mode/matching_brace_outdent"], function(require, exports, module){"use strict";
+var oop = require("../lib/oop");
+var TextMode = require("./text").Mode;
+var LogiQLHighlightRules = require("./logiql_highlight_rules").LogiQLHighlightRules;
+var FoldMode = require("./folding/coffee").FoldMode;
+var TokenIterator = require("../token_iterator").TokenIterator;
+var Range = require("../range").Range;
+var MatchingBraceOutdent = require("./matching_brace_outdent").MatchingBraceOutdent;
+var Mode = function () {
+    this.HighlightRules = LogiQLHighlightRules;
+    this.foldingRules = new FoldMode();
+    this.$outdent = new MatchingBraceOutdent();
+    this.$behaviour = this.$defaultBehaviour;
+};
+oop.inherits(Mode, TextMode);
+(function () {
+    this.lineCommentStart = "//";
+    this.blockComment = { start: "/*", end: "*/" };
+    this.getNextLineIndent = function (state, line, tab) {
+        var indent = this.$getIndent(line);
+        var tokenizedLine = this.getTokenizer().getLineTokens(line, state);
+        var tokens = tokenizedLine.tokens;
+        var endState = tokenizedLine.state;
+        if (/comment|string/.test(endState))
+            return indent;
+        if (tokens.length && tokens[tokens.length - 1].type == "comment.single")
+            return indent;
+        var match = line.match();
+        if (/(-->|<--|<-|->|{)\s*$/.test(line))
+            indent += tab;
+        return indent;
+    };
+    this.checkOutdent = function (state, line, input) {
+        if (this.$outdent.checkOutdent(line, input))
+            return true;
+        if (input !== "\n" && input !== "\r\n")
+            return false;
+        if (!/^\s+/.test(line))
+            return false;
+        return true;
+    };
+    this.autoOutdent = function (state, doc, row) {
+        if (this.$outdent.autoOutdent(doc, row))
+            return;
+        var prevLine = doc.getLine(row);
+        var match = prevLine.match(/^\s+/);
+        var column = prevLine.lastIndexOf(".") + 1;
+        if (!match || !row || !column)
+            return 0;
+        var line = doc.getLine(row + 1);
+        var startRange = this.getMatching(doc, { row: row, column: column });
+        if (!startRange || startRange.start.row == row)
+            return 0;
+        column = match[0].length;
+        var indent = this.$getIndent(doc.getLine(startRange.start.row));
+        doc.replace(new Range(row + 1, 0, row + 1, column), indent);
+    };
+    this.getMatching = function (session, row, column) {
+        if (row == undefined)
+            row = session.selection.lead;
+        if (typeof row == "object") {
+            column = row.column;
+            row = row.row;
+        }
+        var startToken = session.getTokenAt(row, column);
+        var KW_START = "keyword.start", KW_END = "keyword.end";
+        var tok;
+        if (!startToken)
+            return;
+        if (startToken.type == KW_START) {
+            var it = new TokenIterator(session, row, column);
+            it.step = it.stepForward;
+        }
+        else if (startToken.type == KW_END) {
+            var it = new TokenIterator(session, row, column);
+            it.step = it.stepBackward;
+        }
+        else
+            return;
+        while (tok = it.step()) {
+            if (tok.type == KW_START || tok.type == KW_END)
+                break;
+        }
+        if (!tok || tok.type == startToken.type)
+            return;
+        var col = it.getCurrentTokenColumn();
+        var row = it.getCurrentTokenRow();
+        return new Range(row, col, row, col + tok.value.length);
+    };
+    this.$id = "ace/mode/logiql";
+}).call(Mode.prototype);
+exports.Mode = Mode;
+
+});                (function() {
+                    ace.require(["ace/mode/logiql"], function(m) {
+                        if (typeof module == "object" && typeof exports == "object" && module) {
+                            module.exports = m;
+                        }
+                    });
+                })();
+