Threethousand.js

/* ***** BEGIN LICENSE BLOCK *****
* Distributed under the BSD license:
*
* Copyright (c) 2010, Ajax.org B.V.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Ajax.org B.V. nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* ***** END LICENSE BLOCK ***** */

ace.define(‘ace/mode/html’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/text’, ‘ace/mode/javascript’, ‘ace/mode/css’, ‘ace/tokenizer’, ‘ace/mode/html_highlight_rules’, ‘ace/mode/behaviour/html’, ‘ace/mode/folding/html’], function(require, exports, module) {

var oop = require(“../lib/oop”);
var TextMode = require(“./text”).Mode;
var JavaScriptMode = require(“./javascript”).Mode;
var CssMode = require(“./css”).Mode;
var Tokenizer = require(“../tokenizer”).Tokenizer;
var HtmlHighlightRules = require(“./html_highlight_rules”).HtmlHighlightRules;
var HtmlBehaviour = require(“./behaviour/html”).HtmlBehaviour;
var HtmlFoldMode = require(“./folding/html”).FoldMode;

var Mode = function() {
var highlighter = new HtmlHighlightRules();
this.$tokenizer = new Tokenizer(highlighter.getRules());
this.$behaviour = new HtmlBehaviour();

this.$embeds = highlighter.getEmbeds();
this.createModeDelegates({
“js-“: JavaScriptMode,
“css-“: CssMode
});

this.foldingRules = new HtmlFoldMode();
};
oop.inherits(Mode, TextMode);

(function() {

this.toggleCommentLines = function(state, doc, startRow, endRow) {
return 0;
};

this.getNextLineIndent = function(state, line, tab) {
return this.$getIndent(line);
};

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

}).call(Mode.prototype);

exports.Mode = Mode;
});

ace.define(‘ace/mode/javascript’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/text’, ‘ace/tokenizer’, ‘ace/mode/javascript_highlight_rules’, ‘ace/mode/matching_brace_outdent’, ‘ace/range’, ‘ace/worker/worker_client’, ‘ace/mode/behaviour/cstyle’, ‘ace/mode/folding/cstyle’], function(require, exports, module) {

var oop = require(“../lib/oop”);
var TextMode = require(“./text”).Mode;
var Tokenizer = require(“../tokenizer”).Tokenizer;
var JavaScriptHighlightRules = require(“./javascript_highlight_rules”).JavaScriptHighlightRules;
var MatchingBraceOutdent = require(“./matching_brace_outdent”).MatchingBraceOutdent;
var Range = require(“../range”).Range;
var WorkerClient = require(“../worker/worker_client”).WorkerClient;
var CstyleBehaviour = require(“./behaviour/cstyle”).CstyleBehaviour;
var CStyleFoldMode = require(“./folding/cstyle”).FoldMode;

var Mode = function() {
this.$tokenizer = new Tokenizer(new JavaScriptHighlightRules().getRules());
this.$outdent = new MatchingBraceOutdent();
this.$behaviour = new CstyleBehaviour();
this.foldingRules = new CStyleFoldMode();
};
oop.inherits(Mode, TextMode);

(function() {

this.toggleCommentLines = function(state, doc, startRow, endRow) {
var outdent = true;
var re = /^(\s*)\/\//;

for (var i=startRow; i<= endRow; i++) {
if (!re.test(doc.getLine(i))) {
outdent = false;
break;
}
}

    if (outdent) {
        var deleteRange = new Range(0, 0, 0, 0);
        for (var i=startRow; i&lt;= endRow; i++)
        {
            var line = doc.getLine(i);
            var m = line.match(re);
            deleteRange.start.row = i;
            deleteRange.end.row = i;
            deleteRange.end.column = m[0].length;
            doc.replace(deleteRange, m[1]);
        }
    }
    else {
        doc.indentRows(startRow, endRow, "//");
    }
};

this.getNextLineIndent = function(state, line, tab) {
    var indent = this.$getIndent(line);

    var tokenizedLine = this.$tokenizer.getLineTokens(line, state);
    var tokens = tokenizedLine.tokens;
    var endState = tokenizedLine.state;

    if (tokens.length &amp;&amp; tokens[tokens.length-1].type == "comment") {
        return indent;
    }

    if (state == "start" || state == "regex_allowed") {
        var match = line.match(/^.*(?:\bcase\b.*\:|[\{\(\[])\s*$/);
        if (match) {
            indent += tab;
        }
    } else if (state == "doc-start") {
        if (endState == "start" || state == "regex_allowed") {
            return "";
        }
        var match = line.match(/^\s*(\/?)\*/);
        if (match) {
            if (match[1]) {
                indent += " ";
            }
            indent += "* ";
        }
    }

    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.createWorker = function(session) {
    var worker = new WorkerClient(["ace"], "ace/mode/javascript_worker", "JavaScriptWorker");
    worker.attachToDocument(session.getDocument());

    worker.on("jslint", function(results) {
        session.setAnnotations(results.data);
    });

    worker.on("terminate", function() {
        session.clearAnnotations();
    });

    return worker;
};

}).call(Mode.prototype);

exports.Mode = Mode;
});

ace.define(‘ace/mode/javascript_highlight_rules’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/doc_comment_highlight_rules’, ‘ace/mode/text_highlight_rules’], function(require, exports, module) {

var oop = require(“../lib/oop”);
var DocCommentHighlightRules = require(“./doc_comment_highlight_rules”).DocCommentHighlightRules;
var TextHighlightRules = require(“./text_highlight_rules”).TextHighlightRules;

var JavaScriptHighlightRules = function() {
var keywordMapper = this.createKeywordMapper({
“variable.language”:
“Array|Boolean|Date|Function|Iterator|Number|Object|RegExp|String|Proxy|” + // Constructors
“Namespace|QName|XML|XMLList|” + // E4X
“ArrayBuffer|Float32Array|Float64Array|Int16Array|Int32Array|Int8Array|” +
“Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray|” +
“Error|EvalError|InternalError|RangeError|ReferenceError|StopIteration|” + // Errors
“SyntaxError|TypeError|URIError|” +
“decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|eval|isFinite|” + // Non-constructor functions
“isNaN|parseFloat|parseInt|” +
“JSON|Math|” + // Other
“this|arguments|prototype|window|document” , // Pseudo
“keyword”:
“const|yield|import|get|set|” +
“break|case|catch|continue|default|delete|do|else|finally|for|function|” +
“if|in|instanceof|new|return|switch|throw|try|typeof|let|var|while|with|debugger|” +
parent|count|escape|unescape|with|proto|” +
“class|enum|extends|super|export|implements|private|public|interface|package|protected|static”,
“storage.type”:
“const|let|var|function”,
“constant.language”:
“null|Infinity|NaN|undefined”,
“support.function”:
“alert”,
“constant.language.boolean”: “true|false”
}, “identifier”);
var kwBeforeRe = “case|do|else|finally|in|instanceof|return|throw|try|typeof|yield|void”;
var identifierRe = “[a-zA-Z\$\u00a1-\uffff][a-zA-Z\d\$\u00a1-\uffff]*\b”;

var escapedRe = "\\\\(?:x[0-9a-fA-F]{2}|" + // hex
    "u[0-9a-fA-F]{4}|" + // unicode
    "[0-2][0-7]{0,2}|" + // oct
    "3[0-6][0-7]?|" + // oct
    "37[0-7]?|" + // oct
    "[4-7][0-7]?|" + //oct
    ".)";

this.$rules = {
    "start" : [
        {
            token : "comment",
            regex : /\/\/.*$/
        },
        DocCommentHighlightRules.getStartRule("doc-start"),
        {
            token : "comment", // multi line comment
            regex : /\/\*/,
            next : "comment"
        }, {
            token : "string",
            regex : "'(?=.)",
            next  : "qstring"
        }, {
            token : "string",
            regex : '"(?=.)',
            next  : "qqstring"
        }, {
            token : "constant.numeric", // hex
            regex : /0[xX][0-9a-fA-F]+\b/
        }, {
            token : "constant.numeric", // float
            regex : /[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b/
        }, {
            token : [
                "storage.type", "punctuation.operator", "support.function",
                "punctuation.operator", "entity.name.function", "text","keyword.operator"
            ],
            regex : "(" + identifierRe + ")(\\.)(prototype)(\\.)(" + identifierRe +")(\\s*)(=)",
            next: "function_arguments"
        }, {
            token : [
                "storage.type", "punctuation.operator", "entity.name.function", "text",
                "keyword.operator", "text", "storage.type", "text", "paren.lparen"
            ],
            regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",
            next: "function_arguments"
        }, {
            token : [
                "entity.name.function", "text", "keyword.operator", "text", "storage.type",
                "text", "paren.lparen"
            ],
            regex : "(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s*)(\\()",
            next: "function_arguments"
        }, {
            token : [
                "storage.type", "punctuation.operator", "entity.name.function", "text",
                "keyword.operator", "text",
                "storage.type", "text", "entity.name.function", "text", "paren.lparen"
            ],
            regex : "(" + identifierRe + ")(\\.)(" + identifierRe +")(\\s*)(=)(\\s*)(function)(\\s+)(\\w+)(\\s*)(\\()",
            next: "function_arguments"
        }, {
            token : [
                "storage.type", "text", "entity.name.function", "text", "paren.lparen"
            ],
            regex : "(function)(\\s+)(" + identifierRe + ")(\\s*)(\\()",
            next: "function_arguments"
        }, {
            token : [
                "entity.name.function", "text", "punctuation.operator",
                "text", "storage.type", "text", "paren.lparen"
            ],
            regex : "(" + identifierRe + ")(\\s*)(:)(\\s*)(function)(\\s*)(\\()",
            next: "function_arguments"
        }, {
            token : [
                "text", "text", "storage.type", "text", "paren.lparen"
            ],
            regex : "(:)(\\s*)(function)(\\s*)(\\()",
            next: "function_arguments"
        }, {
            token : "keyword",
            regex : "(?:" + kwBeforeRe + ")\\b",
            next : "regex_allowed"
        }, {
            token : ["punctuation.operator", "support.function"],
            regex : /(\.)(s(?:h(?:ift|ow(?:Mod(?:elessDialog|alDialog)|Help))|croll(?:X|By(?:Pages|Lines)?|Y|To)?|t(?:opzzzz|rike)|i(?:n|zeToContent|debar|gnText)|ort|u(?:p|b(?:str(?:ing)?)?)|pli(?:ce|t)|e(?:nd|t(?:Re(?:sizable|questHeader)|M(?:i(?:nutes|lliseconds)|onth)|Seconds|Ho(?:tKeys|urs)|Year|Cursor|Time(?:out)?|Interval|ZOptions|Date|UTC(?:M(?:i(?:nutes|lliseconds)|onth)|Seconds|Hours|Date|FullYear)|FullYear|Active)|arch)|qrt|lice|avePreferences|mall)|h(?:ome|andleEvent)|navigate|c(?:har(?:CodeAt|At)|o(?:s|n(?:cat|textual|firm)|mpile)|eil|lear(?:Timeout|Interval)?|a(?:ptureEvents|ll)|reate(?:StyleSheet|Popup|EventObject))|t(?:o(?:GMTString|S(?:tring|ource)|U(?:TCString|pperCase)|Lo(?:caleString|werCase))|est|a(?:n|int(?:Enabled)?))|i(?:s(?:NaN|Finite)|ndexOf|talics)|d(?:isableExternalCapture|ump|etachEvent)|u(?:n(?:shift|taint|escape|watch)|pdateCommands)|j(?:oin|avaEnabled)|p(?:o(?:p|w)|ush|lugins.refresh|a(?:ddings|rse(?:Int|Float)?)|r(?:int|ompt|eference))|e(?:scape|nableExternalCapture|val|lementFromPoint|x(?:p|ec(?:Script|Command)?))|valueOf|UTC|queryCommand(?:State|Indeterm|Enabled|Value)|f(?:i(?:nd|le(?:ModifiedDate|Size|CreatedDate|UpdatedDate)|xed)|o(?:nt(?:size|color)|rward)|loor|romCharCode)|watch|l(?:ink|o(?:ad|g)|astIndexOf)|a(?:sin|nchor|cos|t(?:tachEvent|ob|an(?:2)?)|pply|lert|b(?:s|ort))|r(?:ou(?:nd|teEvents)|e(?:size(?:By|To)|calc|turnValue|place|verse|l(?:oad|ease(?:Capture|Events)))|andom)|g(?:o|et(?:ResponseHeader|M(?:i(?:nutes|lliseconds)|onth)|Se(?:conds|lection)|Hours|Year|Time(?:zoneOffset)?|Da(?:y|te)|UTC(?:M(?:i(?:nutes|lliseconds)|onth)|Seconds|Hours|Da(?:y|te)|FullYear)|FullYear|A(?:ttention|llResponseHeaders)))|m(?:in|ove(?:B(?:y|elow)|To(?:Absolute)?|Above)|ergeAttributes|a(?:tch|rgins|x))|b(?:toa|ig|o(?:ld|rderWidths)|link|ack))\b(?=\()/
        }, {
            token : ["punctuation.operator", "support.function.dom"],
            regex : /(\.)(s(?:ub(?:stringData|mit)|plitText|e(?:t(?:NamedItem|Attribute(?:Node)?)|lect))|has(?:ChildNodes|Feature)|namedItem|c(?:l(?:ick|o(?:se|neNode))|reate(?:C(?:omment|DATASection|aption)|T(?:Head|extNode|Foot)|DocumentFragment|ProcessingInstruction|E(?:ntityReference|lement)|Attribute))|tabIndex|i(?:nsert(?:Row|Before|Cell|Data)|tem)|open|delete(?:Row|C(?:ell|aption)|T(?:Head|Foot)|Data)|focus|write(?:ln)?|a(?:dd|ppend(?:Child|Data))|re(?:set|place(?:Child|Data)|move(?:NamedItem|Child|Attribute(?:Node)?)?)|get(?:NamedItem|Element(?:sBy(?:Name|TagName)|ById)|Attribute(?:Node)?)|blur)\b(?=\()/
        }, {
            token : ["punctuation.operator", "support.constant"],
            regex : /(\.)(s(?:ystemLanguage|cr(?:ipts|ollbars|een(?:X|Y|Top|Left))|t(?:yle(?:Sheets)?|atus(?:Text|bar)?)|ibling(?:Below|Above)|ource|uffixes|e(?:curity(?:Policy)?|l(?:ection|f)))|h(?:istory|ost(?:name)?|as(?:h|Focus))|y|X(?:MLDocument|SLDocument)|n(?:ext|ame(?:space(?:s|URI)|Prop))|M(?:IN_VALUE|AX_VALUE)|c(?:haracterSet|o(?:n(?:structor|trollers)|okieEnabled|lorDepth|mp(?:onents|lete))|urrent|puClass|l(?:i(?:p(?:boardData)?|entInformation)|osed|asses)|alle(?:e|r)|rypto)|t(?:o(?:olbar|p)|ext(?:Transform|Indent|Decoration|Align)|ags)|SQRT(?:1_2|2)|i(?:n(?:ner(?:Height|Width)|put)|ds|gnoreCase)|zIndex|o(?:scpu|n(?:readystatechange|Line)|uter(?:Height|Width)|p(?:sProfile|ener)|ffscreenBuffering)|NEGATIVE_INFINITY|d(?:i(?:splay|alog(?:Height|Top|Width|Left|Arguments)|rectories)|e(?:scription|fault(?:Status|Ch(?:ecked|arset)|View)))|u(?:ser(?:Profile|Language|Agent)|n(?:iqueID|defined)|pdateInterval)|_content|p(?:ixelDepth|ort|ersonalbar|kcs11|l(?:ugins|atform)|a(?:thname|dding(?:Right|Bottom|Top|Left)|rent(?:Window|Layer)?|ge(?:X(?:Offset)?|Y(?:Offset)?))|r(?:o(?:to(?:col|type)|duct(?:Sub)?|mpter)|e(?:vious|fix)))|e(?:n(?:coding|abledPlugin)|x(?:ternal|pando)|mbeds)|v(?:isibility|endor(?:Sub)?|Linkcolor)|URLUnencoded|P(?:I|OSITIVE_INFINITY)|f(?:ilename|o(?:nt(?:Size|Family|Weight)|rmName)|rame(?:s|Element)|gColor)|E|whiteSpace|l(?:i(?:stStyleType|n(?:eHeight|kColor))|o(?:ca(?:tion(?:bar)?|lName)|wsrc)|e(?:ngth|ft(?:Context)?)|a(?:st(?:M(?:odified|atch)|Index|Paren)|yer(?:s|X)|nguage))|a(?:pp(?:MinorVersion|Name|Co(?:deName|re)|Version)|vail(?:Height|Top|Width|Left)|ll|r(?:ity|guments)|Linkcolor|bove)|r(?:ight(?:Context)?|e(?:sponse(?:XML|Text)|adyState))|global|x|m(?:imeTypes|ultiline|enubar|argin(?:Right|Bottom|Top|Left))|L(?:N(?:10|2)|OG(?:10E|2E))|b(?:o(?:ttom|rder(?:Width|RightWidth|BottomWidth|Style|Color|TopWidth|LeftWidth))|ufferDepth|elow|ackground(?:Color|Image)))\b/
        }, {
            token : ["storage.type", "punctuation.operator", "support.function.firebug"],
            regex : /(console)(\.)(warn|info|log|error|time|timeEnd|assert)\b/
        }, {
            token : keywordMapper,
            regex : identifierRe
        }, {
            token : "keyword.operator",
            regex : /--|\+\+|[!$%&amp;*+\-~]|===|==|=|!=|!==|&lt;=|&gt;=|&lt;&lt;=|&gt;&gt;=|&gt;&gt;&gt;=|&lt;&gt;|&lt;|&gt;|!|&amp;&amp;|\|\||\?\:|\*=|%=|\+=|\-=|&amp;=|\^=/,

next : “regex_allowed”
}, {
token : “punctuation.operator”,
regex : /\?|:|\,|\;|./,
next : “regex_allowed”
}, {
token : “paren.lparen”,
regex : /[[({]/,
next : “regex_allowed”
}, {
token : “paren.rparen”,
regex : /[])}]/
}, {
token : “keyword.operator”,
regex : /\/=?/,
next : “regex_allowed”
}, {
token: “comment”,
regex: /^#!.$/
}
],
“regex_allowed”: [
DocCommentHighlightRules.getStartRule(“doc-start”),
{
token : “comment”, // multi line comment
regex : “\/\
“,
next : “comment_regex_allowed”
}, {
token : “comment”,
regex : “\/\/.$”
}, {
token: “string.regexp”,
regex: “\/”,
next: “regex”,
}, {
token : “text”,
regex : “\s+”
}, {
token: “empty”,
regex: “”,
next: “start”
}
],
“regex”: [
{
token: “regexp.keyword.operator”,
regex: “\\(?:u[\da-fA-F]{4}|x[\da-fA-F]{2}|.)”
}, {
token: “string.regexp”,
regex: “/\w
“,
next: “start”,
}, {
token : “invalid”,
regex: /{\d+,?(?:\d+)?}[+]|[+$^?][+]|[$^][?]|\?{3,}/
}, {
token : “constant.language.escape”,
regex: /(\?[:=!]|)|{\d+,?(?:\d+)?}|{,\d+}|[+
]\?|[()$^+?]/
}, {
token : “constant.language.delimiter”,
regex: /|/
}, {
token: “constant.language.escape”,
regex: /[\^?/,
next: “regex_character_class”,
}, {
token: “empty”,
regex: “$”,
next: “start”
}, {
defaultToken: “string.regexp”
}
],
“regex_character_class”: [
{
token: “regexp.keyword.operator”,
regex: “\\(?:u[\da-fA-F]{4}|x[\da-fA-F]{2}|.)”
}, {
token: “constant.language.escape”,
regex: “]”,
next: “regex”,
}, {
token: “constant.language.escape”,
regex: “-”
}, {
token: “empty”,
regex: “$”,
next: “start”
}, {
defaultToken: “string.regexp.charachterclass”
}
],
“function_arguments”: [
{
token: “variable.parameter”,
regex: identifierRe
}, {
token: “punctuation.operator”,
regex: “[, ]+”,
}, {
token: “punctuation.operator”,
regex: “$”,
}, {
token: “empty”,
regex: “”,
next: “start”
}
],
“comment_regex_allowed” : [
{token : “comment”, regex : “\
\/”, next : “regex_allowed”},
{defaultToken : “comment”}
],
“comment” : [
{token : “comment”, regex : “\*\/”, next : “start”},
{defaultToken : “comment”}
],
“qqstring” : [
{
token : “constant.language.escape”,
regex : escapedRe
}, {
token : “string”,
regex : “\\$”,
next : “qqstring”,
}, {
token : “string”,
regex : ‘”|$’,
next : “start”,
}, {
defaultToken: “string”
}
],
“qstring” : [
{
token : “constant.language.escape”,
regex : escapedRe
}, {
token : “string”,
regex : “\\$”,
next : “qstring”,
}, {
token : “string”,
regex : “‘|$”,
next : “start”,
}, {
defaultToken: “string”
}
]
};

this.embedRules(DocCommentHighlightRules, “doc-“,
[ DocCommentHighlightRules.getEndRule(“start”) ]);
};

oop.inherits(JavaScriptHighlightRules, TextHighlightRules);

exports.JavaScriptHighlightRules = JavaScriptHighlightRules;
});

ace.define(‘ace/mode/doc_comment_highlight_rules’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/text_highlight_rules’], function(require, exports, module) {

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

var DocCommentHighlightRules = function() {

this.$rules = {
“start” : [ {
token : “comment.doc.tag”,
regex : “@[\w\d_]+” // TODO: fix email addresses
}, {
token : “comment.doc.tag”,
regex : “\bTODO\b”
}, {
defaultToken : “comment.doc”
}]
};
};

oop.inherits(DocCommentHighlightRules, TextHighlightRules);

DocCommentHighlightRules.getStartRule = function(start) {
return {
token : “comment.doc”, // doc comment
regex : “\/\(?=\)”,
next : start
};
};

DocCommentHighlightRules.getEndRule = function (start) {
return {
token : “comment.doc”, // closing comment
regex : “\*\/”,
next : start
};
};

exports.DocCommentHighlightRules = DocCommentHighlightRules;

});

ace.define(‘ace/mode/matching_brace_outdent’, [‘require’, ‘exports’, ‘module’ , ‘ace/range’], function(require, exports, module) {

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) {
var match = line.match(/^(\s+)/);
if (match) {
return match[1];
}

return “”;
};

}).call(MatchingBraceOutdent.prototype);

exports.MatchingBraceOutdent = MatchingBraceOutdent;
});

ace.define(‘ace/mode/behaviour/cstyle’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/behaviour’, ‘ace/token_iterator’, ‘ace/lib/lang’], function(require, exports, module) {

var oop = require(“../../lib/oop”);
var Behaviour = require(“../behaviour”).Behaviour;
var TokenIterator = require(“../../token_iterator”).TokenIterator;
var lang = require(“../../lib/lang”);

var SAFE_INSERT_IN_TOKENS =
[“text”, “paren.rparen”, “punctuation.operator”];
var SAFE_INSERT_BEFORE_TOKENS =
[“text”, “paren.rparen”, “punctuation.operator”, “comment”];

var autoInsertedBrackets = 0;
var autoInsertedRow = -1;
var autoInsertedLineEnd = “”;
var maybeInsertedBrackets = 0;
var maybeInsertedRow = -1;
var maybeInsertedLineStart = “”;
var maybeInsertedLineEnd = “”;

var CstyleBehaviour = function () {

CstyleBehaviour.isSaneInsertion = function(editor, session) {
var cursor = editor.getCursorPosition();
var iterator = new TokenIterator(session, cursor.row, cursor.column);
if (!this.$matchTokenType(iterator.getCurrentToken() || “text”, SAFE_INSERT_IN_TOKENS)) {
var iterator2 = new TokenIterator(session, cursor.row, cursor.column + 1);
if (!this.$matchTokenType(iterator2.getCurrentToken() || “text”, SAFE_INSERT_IN_TOKENS))
return false;
}
iterator.stepForward();
return iterator.getCurrentTokenRow() !== cursor.row ||
this.$matchTokenType(iterator.getCurrentToken() || “text”, SAFE_INSERT_BEFORE_TOKENS);
};

CstyleBehaviour.$matchTokenType = function(token, types) {
return types.indexOf(token.type || token) > -1;
};

CstyleBehaviour.recordAutoInsert = function(editor, session, bracket) {
var cursor = editor.getCursorPosition();
var line = session.doc.getLine(cursor.row);
if (!this.isAutoInsertedClosing(cursor, line, autoInsertedLineEnd[0]))
autoInsertedBrackets = 0;
autoInsertedRow = cursor.row;
autoInsertedLineEnd = bracket + line.substr(cursor.column);
autoInsertedBrackets++;
};

CstyleBehaviour.recordMaybeInsert = function(editor, session, bracket) {
var cursor = editor.getCursorPosition();
var line = session.doc.getLine(cursor.row);
if (!this.isMaybeInsertedClosing(cursor, line))
maybeInsertedBrackets = 0;
maybeInsertedRow = cursor.row;
maybeInsertedLineStart = line.substr(0, cursor.column) + bracket;
maybeInsertedLineEnd = line.substr(cursor.column);
maybeInsertedBrackets++;
};

CstyleBehaviour.isAutoInsertedClosing = function(cursor, line, bracket) {
return autoInsertedBrackets > 0 &&
cursor.row === autoInsertedRow &&
bracket === autoInsertedLineEnd[0] &&
line.substr(cursor.column) === autoInsertedLineEnd;
};

CstyleBehaviour.isMaybeInsertedClosing = function(cursor, line) {
return maybeInsertedBrackets > 0 &&
cursor.row === maybeInsertedRow &&
line.substr(cursor.column) === maybeInsertedLineEnd &&
line.substr(0, cursor.column) == maybeInsertedLineStart;
};

CstyleBehaviour.popAutoInsertedClosing = function() {
autoInsertedLineEnd = autoInsertedLineEnd.substr(1);
autoInsertedBrackets–;
};

CstyleBehaviour.clearMaybeInsertedClosing = function() {
maybeInsertedBrackets = 0;
maybeInsertedRow = -1;
};

this.add(“braces”, “insertion”, function (state, action, editor, session, text) {
var cursor = editor.getCursorPosition();
var line = session.doc.getLine(cursor.row);
if (text == ‘{‘) {
var selection = editor.getSelectionRange();
var selected = session.doc.getTextRange(selection);
if (selected !== “” && selected !== “{” && editor.getWrapBehavioursEnabled()) {
return {
text: ‘{‘ + selected + ‘}’,
selection: false
};
} else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
if (/[]})]/.test(line[cursor.column])) {
CstyleBehaviour.recordAutoInsert(editor, session, “}”);
return {
text: ‘{}’,
selection: [1, 1]
};
} else {
CstyleBehaviour.recordMaybeInsert(editor, session, “{“);
return {
text: ‘{‘,
selection: [1, 1]
};
}
}
} else if (text == ‘}’) {
var rightChar = line.substring(cursor.column, cursor.column + 1);
if (rightChar == ‘}’) {
var matching = session.$findOpeningBracket(‘}’, {column: cursor.column + 1, row: cursor.row});
if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
CstyleBehaviour.popAutoInsertedClosing();
return {
text: ”,
selection: [1, 1]
};
}
}
} else if (text == “\n” || text == “\r\n”) {
var closing = “”;
if (CstyleBehaviour.isMaybeInsertedClosing(cursor, line)) {
closing = lang.stringRepeat(“}”, maybeInsertedBrackets);
CstyleBehaviour.clearMaybeInsertedClosing();
}
var rightChar = line.substring(cursor.column, cursor.column + 1);
if (rightChar == ‘}’ || closing !== “”) {
var openBracePos = session.findMatchingBracket({row: cursor.row, column: cursor.column}, ‘}’);
if (!openBracePos)
return null;

var indent = this.getNextLineIndent(state, line.substring(0, cursor.column), session.getTabString());
var next_indent = this.$getIndent(line);

return {
text: ‘\n’ + indent + ‘\n’ + next_indent + closing,
selection: [1, indent.length, 1, indent.length]
};
}
}
});

this.add(“braces”, “deletion”, function (state, action, editor, session, range) {
var selected = session.doc.getTextRange(range);
if (!range.isMultiLine() && selected == ‘{‘) {
var line = session.doc.getLine(range.start.row);
var rightChar = line.substring(range.end.column, range.end.column + 1);
if (rightChar == ‘}’) {
range.end.column++;
return range;
} else {
maybeInsertedBrackets–;
}
}
});

this.add(“parens”, “insertion”, function (state, action, editor, session, text) {
if (text == ‘(‘) {
var selection = editor.getSelectionRange();
var selected = session.doc.getTextRange(selection);
if (selected !== “” && editor.getWrapBehavioursEnabled()) {
return {
text: ‘(‘ + selected + ‘)’,
selection: false
};
} else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
CstyleBehaviour.recordAutoInsert(editor, session, “)”);
return {
text: ‘()’,
selection: [1, 1]
};
}
} else if (text == ‘)’) {
var cursor = editor.getCursorPosition();
var line = session.doc.getLine(cursor.row);
var rightChar = line.substring(cursor.column, cursor.column + 1);
if (rightChar == ‘)’) {
var matching = session.$findOpeningBracket(‘)’, {column: cursor.column + 1, row: cursor.row});
if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
CstyleBehaviour.popAutoInsertedClosing();
return {
text: ”,
selection: [1, 1]
};
}
}
}
});

this.add(“parens”, “deletion”, function (state, action, editor, session, range) {
var selected = session.doc.getTextRange(range);
if (!range.isMultiLine() && selected == ‘(‘) {
var line = session.doc.getLine(range.start.row);
var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
if (rightChar == ‘)’) {
range.end.column++;
return range;
}
}
});

this.add(“brackets”, “insertion”, function (state, action, editor, session, text) {
if (text == ‘[‘) {
var selection = editor.getSelectionRange();
var selected = session.doc.getTextRange(selection);
if (selected !== “” && editor.getWrapBehavioursEnabled()) {
return {
text: ‘[‘ + selected + ‘]’,
selection: false
};
} else if (CstyleBehaviour.isSaneInsertion(editor, session)) {
CstyleBehaviour.recordAutoInsert(editor, session, “]”);
return {
text: ‘[]’,
selection: [1, 1]
};
}
} else if (text == ‘]’) {
var cursor = editor.getCursorPosition();
var line = session.doc.getLine(cursor.row);
var rightChar = line.substring(cursor.column, cursor.column + 1);
if (rightChar == ‘]’) {
var matching = session.$findOpeningBracket(‘]’, {column: cursor.column + 1, row: cursor.row});
if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) {
CstyleBehaviour.popAutoInsertedClosing();
return {
text: ”,
selection: [1, 1]
};
}
}
}
});

this.add(“brackets”, “deletion”, function (state, action, editor, session, range) {
var selected = session.doc.getTextRange(range);
if (!range.isMultiLine() && selected == ‘[‘) {
var line = session.doc.getLine(range.start.row);
var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
if (rightChar == ‘]’) {
range.end.column++;
return range;
}
}
});

this.add(“string_dquotes”, “insertion”, function (state, action, editor, session, text) {
if (text == ‘”‘ || text == “‘”) {
var quote = text;
var selection = editor.getSelectionRange();
var selected = session.doc.getTextRange(selection);
if (selected !== “” && selected !== “‘” && selected != ‘”‘ && editor.getWrapBehavioursEnabled()) {
return {
text: quote + selected + quote,
selection: false
};
} else {
var cursor = editor.getCursorPosition();
var line = session.doc.getLine(cursor.row);
var leftChar = line.substring(cursor.column-1, cursor.column);
if (leftChar == ‘\’) {
return null;
}
var tokens = session.getTokens(selection.start.row);
var col = 0, token;
var quotepos = -1; // Track whether we’re inside an open quote.

for (var x = 0; x < tokens.length; x++) {
token = tokens[x];
if (token.type == “string”) {
quotepos = -1;
} else if (quotepos < 0) {
quotepos = token.value.indexOf(quote);
}
if ((token.value.length + col) > selection.start.column) {
break;
}
col += tokens[x].value.length;
}
if (!token || (quotepos < 0 && token.type !== “comment” && (token.type !== “string” || ((selection.start.column !== token.value.length+col-1) && token.value.lastIndexOf(quote) === token.value.length-1)))) {
if (!CstyleBehaviour.isSaneInsertion(editor, session))
return;
return {
text: quote + quote,
selection: [1,1]
};
} else if (token && token.type === “string”) {
var rightChar = line.substring(cursor.column, cursor.column + 1);
if (rightChar == quote) {
return {
text: ”,
selection: [1, 1]
};
}
}
}
}
});

this.add("string_dquotes", "deletion", function (state, action, editor, session, range) {
    var selected = session.doc.getTextRange(range);
    if (!range.isMultiLine() &amp;&amp; (selected == '"' || selected == "'")) {
        var line = session.doc.getLine(range.start.row);
        var rightChar = line.substring(range.start.column + 1, range.start.column + 2);
        if (rightChar == selected) {
            range.end.column++;
            return range;
        }
    }
});

};

oop.inherits(CstyleBehaviour, Behaviour);

exports.CstyleBehaviour = CstyleBehaviour;
});

ace.define(‘ace/mode/folding/cstyle’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/range’, ‘ace/mode/folding/fold_mode’], function(require, exports, module) {

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*(\/\*)/;
this.foldingStopMarker = /^[^\[\{]*(\}|\])|^[\s\*]*(\*\/)/;

this.getFoldWidgetRange = function(session, foldStyle, row) {
    var line = session.getLine(row);
    var match = line.match(this.foldingStartMarker);
    if (match) {
        var i = match.index;

        if (match[1])
            return this.openingBracketBlock(session, match[1], row, i);

        return session.getCommentFoldRange(row, i + match[0].length, 1);
    }

    if (foldStyle !== "markbeginend")
        return;

    var match = line.match(this.foldingStopMarker);
    if (match) {
        var i = match.index + match[0].length;

        if (match[1])
            return this.closingBracketBlock(session, match[1], row, i);

        return session.getCommentFoldRange(row, i, -1);
    }
};

}).call(FoldMode.prototype);

});

ace.define(‘ace/mode/css’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/text’, ‘ace/tokenizer’, ‘ace/mode/css_highlight_rules’, ‘ace/mode/matching_brace_outdent’, ‘ace/worker/worker_client’, ‘ace/mode/behaviour/css’, ‘ace/mode/folding/cstyle’], function(require, exports, module) {

var oop = require(“../lib/oop”);
var TextMode = require(“./text”).Mode;
var Tokenizer = require(“../tokenizer”).Tokenizer;
var CssHighlightRules = require(“./css_highlight_rules”).CssHighlightRules;
var MatchingBraceOutdent = require(“./matching_brace_outdent”).MatchingBraceOutdent;
var WorkerClient = require(“../worker/worker_client”).WorkerClient;
var CssBehaviour = require(“./behaviour/css”).CssBehaviour;
var CStyleFoldMode = require(“./folding/cstyle”).FoldMode;

var Mode = function() {
this.$tokenizer = new Tokenizer(new CssHighlightRules().getRules(), “i”);
this.$outdent = new MatchingBraceOutdent();
this.$behaviour = new CssBehaviour();
this.foldingRules = new CStyleFoldMode();
};
oop.inherits(Mode, TextMode);

(function() {

this.foldingRules = "cStyle";

this.getNextLineIndent = function(state, line, tab) {
    var indent = this.$getIndent(line);
    var tokens = this.$tokenizer.getLineTokens(line, state).tokens;
    if (tokens.length &amp;&amp; tokens[tokens.length-1].type == "comment") {
        return indent;
    }

    var match = line.match(/^.*\{\s*$/);
    if (match) {
        indent += tab;
    }

    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.createWorker = function(session) {
    var worker = new WorkerClient(["ace"], "ace/mode/css_worker", "Worker");
    worker.attachToDocument(session.getDocument());

    worker.on("csslint", function(e) {
        session.setAnnotations(e.data);
    });

    worker.on("terminate", function() {
        session.clearAnnotations();
    });

    return worker;
};

}).call(Mode.prototype);

exports.Mode = Mode;

});

ace.define(‘ace/mode/css_highlight_rules’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/lib/lang’, ‘ace/mode/text_highlight_rules’], function(require, exports, module) {

var oop = require(“../lib/oop”);
var lang = require(“../lib/lang”);
var TextHighlightRules = require(“./text_highlight_rules”).TextHighlightRules;
var supportType = exports.supportType = “animation-fill-mode|alignment-adjust|alignment-baseline|animation-delay|animation-direction|animation-duration|animation-iteration-count|animation-name|animation-play-state|animation-timing-function|animation|appearance|azimuth|backface-visibility|background-attachment|background-break|background-clip|background-color|background-image|background-origin|background-position|background-repeat|background-size|background|baseline-shift|binding|bleed|bookmark-label|bookmark-level|bookmark-state|bookmark-target|border-bottom|border-bottom-color|border-bottom-left-radius|border-bottom-right-radius|border-bottom-style|border-bottom-width|border-collapse|border-color|border-image|border-image-outset|border-image-repeat|border-image-slice|border-image-source|border-image-width|border-left|border-left-color|border-left-style|border-left-width|border-radius|border-right|border-right-color|border-right-style|border-right-width|border-spacing|border-style|border-top|border-top-color|border-top-left-radius|border-top-right-radius|border-top-style|border-top-width|border-width|border|bottom|box-align|box-decoration-break|box-direction|box-flex-group|box-flex|box-lines|box-ordinal-group|box-orient|box-pack|box-shadow|box-sizing|break-after|break-before|break-inside|caption-side|clear|clip|color-profile|color|column-count|column-fill|column-gap|column-rule|column-rule-color|column-rule-style|column-rule-width|column-span|column-width|columns|content|counter-increment|counter-reset|crop|cue-after|cue-before|cue|cursor|direction|display|dominant-baseline|drop-initial-after-adjust|drop-initial-after-align|drop-initial-before-adjust|drop-initial-before-align|drop-initial-size|drop-initial-value|elevation|empty-cells|fit|fit-position|float-offset|float|font-family|font-size|font-size-adjust|font-stretch|font-style|font-variant|font-weight|font|grid-columns|grid-rows|hanging-punctuation|height|hyphenate-after|hyphenate-before|hyphenate-character|hyphenate-lines|hyphenate-resource|hyphens|icon|image-orientation|image-rendering|image-resolution|inline-box-align|left|letter-spacing|line-height|line-stacking-ruby|line-stacking-shift|line-stacking-strategy|line-stacking|list-style-image|list-style-position|list-style-type|list-style|margin-bottom|margin-left|margin-right|margin-top|margin|mark-after|mark-before|mark|marks|marquee-direction|marquee-play-count|marquee-speed|marquee-style|max-height|max-width|min-height|min-width|move-to|nav-down|nav-index|nav-left|nav-right|nav-up|opacity|orphans|outline-color|outline-offset|outline-style|outline-width|outline|overflow-style|overflow-x|overflow-y|overflow|padding-bottom|padding-left|padding-right|padding-top|padding|page-break-after|page-break-before|page-break-inside|page-policy|page|pause-after|pause-before|pause|perspective-origin|perspective|phonemes|pitch-range|pitch|play-during|position|presentation-level|punctuation-trim|quotes|rendering-intent|resize|rest-after|rest-before|rest|richness|right|rotation-point|rotation|ruby-align|ruby-overhang|ruby-position|ruby-span|size|speak-header|speak-numeral|speak-punctuation|speak|speech-rate|stress|string-set|table-layout|target-name|target-new|target-position|target|text-align-last|text-align|text-decoration|text-emphasis|text-height|text-indent|text-justify|text-outline|text-shadow|text-transform|text-wrap|top|transform-origin|transform-style|transform|transition-delay|transition-duration|transition-property|transition-timing-function|transition|unicode-bidi|vertical-align|visibility|voice-balance|voice-duration|voice-family|voice-pitch-range|voice-pitch|voice-rate|voice-stress|voice-volume|volume|white-space-collapse|white-space|widows|width|word-break|word-spacing|word-wrap|z-index”;
var supportFunction = exports.supportFunction = “rgb|rgba|url|attr|counter|counters”;
var supportConstant = exports.supportConstant = “absolute|after-edge|after|all-scroll|all|alphabetic|always|antialiased|armenian|auto|avoid-column|avoid-page|avoid|balance|baseline|before-edge|before|below|bidi-override|block-line-height|block|bold|bolder|border-box|both|bottom|box|break-all|break-word|capitalize|caps-height|caption|center|central|char|circle|cjk-ideographic|clone|close-quote|col-resize|collapse|column|consider-shifts|contain|content-box|cover|crosshair|cubic-bezier|dashed|decimal-leading-zero|decimal|default|disabled|disc|disregard-shifts|distribute-all-lines|distribute-letter|distribute-space|distribute|dotted|double|e-resize|ease-in|ease-in-out|ease-out|ease|ellipsis|end|exclude-ruby|fill|fixed|georgian|glyphs|grid-height|groove|hand|hanging|hebrew|help|hidden|hiragana-iroha|hiragana|horizontal|icon|ideograph-alpha|ideograph-numeric|ideograph-parenthesis|ideograph-space|ideographic|inactive|include-ruby|inherit|initial|inline-block|inline-box|inline-line-height|inline-table|inline|inset|inside|inter-ideograph|inter-word|invert|italic|justify|katakana-iroha|katakana|keep-all|last|left|lighter|line-edge|line-through|line|linear|list-item|local|loose|lower-alpha|lower-greek|lower-latin|lower-roman|lowercase|lr-tb|ltr|mathematical|max-height|max-size|medium|menu|message-box|middle|move|n-resize|ne-resize|newspaper|no-change|no-close-quote|no-drop|no-open-quote|no-repeat|none|normal|not-allowed|nowrap|nw-resize|oblique|open-quote|outset|outside|overline|padding-box|page|pointer|pre-line|pre-wrap|pre|preserve-3d|progress|relative|repeat-x|repeat-y|repeat|replaced|reset-size|ridge|right|round|row-resize|rtl|s-resize|scroll|se-resize|separate|slice|small-caps|small-caption|solid|space|square|start|static|status-bar|step-end|step-start|steps|stretch|strict|sub|super|sw-resize|table-caption|table-cell|table-column-group|table-column|table-footer-group|table-header-group|table-row-group|table-row|table|tb-rl|text-after-edge|text-before-edge|text-bottom|text-size|text-top|text|thick|thin|transparent|underline|upper-alpha|upper-latin|upper-roman|uppercase|use-script|vertical-ideographic|vertical-text|visible|w-resize|wait|whitespace|z-index|zero”;
var supportConstantColor = exports.supportConstantColor = “aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow”;
var supportConstantFonts = exports.supportConstantFonts = “arial|century|comic|courier|garamond|georgia|helvetica|impact|lucida|symbol|system|tahoma|times|trebuchet|utopia|verdana|webdings|sans-serif|serif|monospace”;

var numRe = exports.numRe = “\-?(?:(?:[0-9]+)|(?:[0-9]*\.[0-9]+))”;
var pseudoElements = exports.pseudoElements = “(\:+)\b(after|before|first-letter|first-line|moz-selection|selection)\b”;
var pseudoClasses = exports.pseudoClasses = “(:)\b(active|checked|disabled|empty|enabled|first-child|first-of-type|focus|hover|indeterminate|invalid|last-child|last-of-type|link|not|nth-child|nth-last-child|nth-last-of-type|nth-of-type|only-child|only-of-type|required|root|target|valid|visited)\b”;

var CssHighlightRules = function() {

var keywordMapper = this.createKeywordMapper({
    "support.function": supportFunction,
    "support.constant": supportConstant,
    "support.type": supportType,
    "support.constant.color": supportConstantColor,
    "support.constant.fonts": supportConstantFonts
}, "text", true);

var base_ruleset = [
    {
        token : "comment", // multi line comment
        regex : "\\/\\*",
        next : "ruleset_comment"
    }, {
        token : "string", // single line
        regex : '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
    }, {
        token : "string", // single line
        regex : "['](?:(?:\\\\.)|(?:[^'\\\\]))*?[']"
    }, {
        token : ["constant.numeric", "keyword"],
        regex : "(" + numRe + ")(ch|cm|deg|em|ex|fr|gd|grad|Hz|in|kHz|mm|ms|pc|pt|px|rad|rem|s|turn|vh|vm|vw|%)"
    }, {
        token : "constant.numeric",
        regex : numRe
    }, {
        token : "constant.numeric",  // hex6 color
        regex : "#[a-f0-9]{6}"
    }, {
        token : "constant.numeric", // hex3 color
        regex : "#[a-f0-9]{3}"
    }, {
        token : ["punctuation", "entity.other.attribute-name.pseudo-element.css"],
        regex : pseudoElements
    }, {
        token : ["punctuation", "entity.other.attribute-name.pseudo-class.css"],
        regex : pseudoClasses
    }, {
        token : keywordMapper,
        regex : "\\-?[a-zA-Z_][a-zA-Z0-9_\\-]*"
    }
  ];

var ruleset = lang.copyArray(base_ruleset);
ruleset.unshift({
    token : "paren.rparen",
    regex : "\\}",
    next:   "start"
});

var media_ruleset = lang.copyArray( base_ruleset );
media_ruleset.unshift({
    token : "paren.rparen",
    regex : "\\}",
    next:   "media"
});

var base_comment = [{
      token : "comment", // comment spanning whole line
      regex : ".+"
}];

var comment = lang.copyArray(base_comment);
comment.unshift({
      token : "comment", // closing comment
      regex : ".*?\\*\\/",
      next : "start"
});

var media_comment = lang.copyArray(base_comment);
media_comment.unshift({
      token : "comment", // closing comment
      regex : ".*?\\*\\/",
      next : "media"
});

var ruleset_comment = lang.copyArray(base_comment);
ruleset_comment.unshift({
      token : "comment", // closing comment
      regex : ".*?\\*\\/",
      next : "ruleset"
});

this.$rules = {
    "start" : [{
        token : "comment", // multi line comment
        regex : "\\/\\*",
        next : "comment"
    }, {
        token: "paren.lparen",
        regex: "\\{",
        next:  "ruleset"
    }, {
        token: "string",
        regex: "@.*?{",
        next:  "media"
    },{
        token: "keyword",
        regex: "#[a-z0-9-_]+"
    },{
        token: "variable",
        regex: "\\.[a-z0-9-_]+"
    },{
        token: "string",
        regex: ":[a-z0-9-_]+"
    },{
        token: "constant",
        regex: "[a-z0-9-_]+"
    }],

    "media" : [ {
        token : "comment", // multi line comment
        regex : "\\/\\*",
        next : "media_comment"
    }, {
        token: "paren.lparen",
        regex: "\\{",
        next:  "media_ruleset"
    },{
        token: "string",
        regex: "\\}",
        next:  "start"
    },{
        token: "keyword",
        regex: "#[a-z0-9-_]+"
    },{
        token: "variable",
        regex: "\\.[a-z0-9-_]+"
    },{
        token: "string",
        regex: ":[a-z0-9-_]+"
    },{
        token: "constant",
        regex: "[a-z0-9-_]+"
    }],

    "comment" : comment,

    "ruleset" : ruleset,
    "ruleset_comment" : ruleset_comment,

    "media_ruleset" : media_ruleset,
    "media_comment" : media_comment
};

};

oop.inherits(CssHighlightRules, TextHighlightRules);

exports.CssHighlightRules = CssHighlightRules;

});

ace.define(‘ace/mode/behaviour/css’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/behaviour’, ‘ace/mode/behaviour/cstyle’, ‘ace/token_iterator’], function(require, exports, module) {

var oop = require(“../../lib/oop”);
var Behaviour = require(“../behaviour”).Behaviour;
var CstyleBehaviour = require(“./cstyle”).CstyleBehaviour;
var TokenIterator = require(“../../token_iterator”).TokenIterator;

var CssBehaviour = function () {

this.inherit(CstyleBehaviour);

this.add("colon", "insertion", function (state, action, editor, session, text) {
    if (text === ':') {
        var cursor = editor.getCursorPosition();
        var iterator = new TokenIterator(session, cursor.row, cursor.column);
        var token = iterator.getCurrentToken();
        if (token &amp;&amp; token.value.match(/\s+/)) {
            token = iterator.stepBackward();
        }
        if (token &amp;&amp; token.type === 'support.type') {
            var line = session.doc.getLine(cursor.row);
            var rightChar = line.substring(cursor.column, cursor.column + 1);
            if (rightChar === ':') {
                return {
                   text: '',
                   selection: [1, 1]
                }
            }
            if (!line.substring(cursor.column).match(/^\s*;/)) {
                return {
                   text: ':;',
                   selection: [1, 1]
                }
            }
        }
    }
});

this.add("colon", "deletion", function (state, action, editor, session, range) {
    var selected = session.doc.getTextRange(range);
    if (!range.isMultiLine() &amp;&amp; selected === ':') {
        var line = session.doc.getLine(range.start.row);
        var rightChar = line.substring(range.end.column, range.end.column + 1);
        if (rightChar === ';') {
            range.end.column ++;
            return range;
        }
    }
});

this.add("semicolon", "insertion", function (state, action, editor, session, text) {
    if (text === ';') {
        var cursor = editor.getCursorPosition();
        var line = session.doc.getLine(cursor.row);
        var rightChar = line.substring(cursor.column, cursor.column + 1);
        if (rightChar === ';') {
            return {
               text: '',
               selection: [1, 1]
            }
        }
    }
});

}
oop.inherits(CssBehaviour, CstyleBehaviour);

exports.CssBehaviour = CssBehaviour;
});

ace.define(‘ace/mode/html_highlight_rules’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/lib/lang’, ‘ace/mode/css_highlight_rules’, ‘ace/mode/javascript_highlight_rules’, ‘ace/mode/xml_util’, ‘ace/mode/text_highlight_rules’], function(require, exports, module) {

var oop = require(“../lib/oop”);
var lang = require(“../lib/lang”);
var CssHighlightRules = require(“./css_highlight_rules”).CssHighlightRules;
var JavaScriptHighlightRules = require(“./javascript_highlight_rules”).JavaScriptHighlightRules;
var xmlUtil = require(“./xml_util”);
var TextHighlightRules = require(“./text_highlight_rules”).TextHighlightRules;

var tagMap = lang.createMap({
a : ‘anchor’,
button : ‘form’,
form : ‘form’,
img : ‘image’,
input : ‘form’,
label : ‘form’,
script : ‘script’,
select : ‘form’,
textarea : ‘form’,
style : ‘style’,
table : ‘table’,
tbody : ‘table’,
td : ‘table’,
tfoot : ‘table’,
th : ‘table’,
tr : ‘table’
});

var HtmlHighlightRules = function() {
this.$rules = {
start : [{
token : “text”,
regex : “<\!\[CDATA\[“,
next : “cdata”
}, {
token : “xml-pe”,
regex : “<\?.?\?>”
}, {
token : “comment”,
regex : “<\!–“,
next : “comment”
}, {
token : “xml-pe”,
regex : “<\!.
?>”
}, {
token : “meta.tag”,
regex : “<(?=script\b)”,
next : “script”
}, {
token : “meta.tag”,
regex : “<(?=style\b)”,
next : “style”
}, {
token : “meta.tag”, // opening tag
regex : “<\/?”,
next : “tag”
}, {
token : “text”,
regex : “\s+”
}, {
token : “constant.character.entity”,
regex : “(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\.-]+;)”
}],

    cdata : [ {
        token : "text",
        regex : "\\]\\]&gt;",

next : “start”
} ],

comment : [ {
token : “comment”,
regex : “.*?–>”,
next : “start”
}, {
defaultToken : “comment”
} ]
};

xmlUtil.tag(this.$rules, “tag”, “start”, tagMap);
xmlUtil.tag(this.$rules, “style”, “css-start”, tagMap);
xmlUtil.tag(this.$rules, “script”, “js-start”, tagMap);

this.embedRules(JavaScriptHighlightRules, “js-“, [{
token: “comment”,
regex: “\/\/.*(?=<\/script>)”,
next: “tag”
}, {
token: “meta.tag”,
regex: “<\/(?=script)”,
next: “tag”
}]);

this.embedRules(CssHighlightRules, "css-", [{
    token: "meta.tag",
    regex: "&lt;\\/(?=style)",
    next: "tag"
}]);

};

oop.inherits(HtmlHighlightRules, TextHighlightRules);

exports.HtmlHighlightRules = HtmlHighlightRules;
});

ace.define(‘ace/mode/xml_util’, [‘require’, ‘exports’, ‘module’ ], function(require, exports, module) {

function string(state) {
return [{
token : “string”,
regex : ‘”‘,
next : state + “_qqstring”
}, {
token : “string”,
regex : “‘”,
next : state + “_qstring”
}];
}

function multiLineString(quote, state) {
return [
{token : “string”, regex : quote, next : state},
{
token : “constant.language.escape”,
regex : “(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\.-]+;)”
},
{defaultToken : “string”}
];
}

exports.tag = function(states, name, nextState, tagMap) {
states[name] = [{
token : “text”,
regex : “\s+”
}, {

token : !tagMap ? "meta.tag.tag-name" : function(value) {
        if (tagMap[value])
            return "meta.tag.tag-name." + tagMap[value];
        else
            return "meta.tag.tag-name";
    },
    regex : "[-_a-zA-Z0-9:]+",
    next : name + "_embed_attribute_list" 
}, {
    token: "empty",
    regex: "",
    next : name + "_embed_attribute_list"
}];

states[name + "_qstring"] = multiLineString("'", name + "_embed_attribute_list");
states[name + "_qqstring"] = multiLineString("\"", name + "_embed_attribute_list");

states[name + "_embed_attribute_list"] = [{
    token : "meta.tag.r",
    regex : "/?&gt;",

next : nextState
}, {
token : “keyword.operator”,
regex : “=”
}, {
token : “entity.other.attribute-name”,
regex : “[-_a-zA-Z0-9:]+”
}, {
token : “constant.numeric”, // float
regex : “[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b”
}, {
token : “text”,
regex : “\s+”
}].concat(string(name));
};

});

ace.define(‘ace/mode/behaviour/html’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/behaviour/xml’, ‘ace/mode/behaviour/cstyle’, ‘ace/token_iterator’], function(require, exports, module) {

var oop = require(“../../lib/oop”);
var XmlBehaviour = require(“../behaviour/xml”).XmlBehaviour;
var CstyleBehaviour = require(“./cstyle”).CstyleBehaviour;
var TokenIterator = require(“../../token_iterator”).TokenIterator;
var voidElements = [‘area’, ‘base’, ‘br’, ‘col’, ‘command’, ’embed’, ‘hr’, ‘img’, ‘input’, ‘keygen’, ‘link’, ‘meta’, ‘param’, ‘source’, ‘track’, ‘wbr’];

function hasType(token, type) {
var hasType = true;
var typeList = token.type.split(‘.’);
var needleList = type.split(‘.’);
needleList.forEach(function(needle){
if (typeList.indexOf(needle) == -1) {
hasType = false;
return false;
}
});
return hasType;
}

var HtmlBehaviour = function () {

this.inherit(XmlBehaviour); // Get xml behaviour

this.add(“autoclosing”, “insertion”, function (state, action, editor, session, text) {
if (text == ‘>’) {
var position = editor.getCursorPosition();
var iterator = new TokenIterator(session, position.row, position.column);
var token = iterator.getCurrentToken();
var atCursor = false;
if (!token || !hasType(token, ‘meta.tag’) && !(hasType(token, ‘text’) && token.value.match(‘/’))){
do {
token = iterator.stepBackward();
} while (token && (hasType(token, ‘string’) || hasType(token, ‘keyword.operator’) || hasType(token, ‘entity.attribute-name’) || hasType(token, ‘text’)));
} else {
atCursor = true;
}
if (!token || !hasType(token, ‘meta.tag-name’) || iterator.stepBackward().value.match(‘/’)) {
return
}
var element = token.value;
if (atCursor){
var element = element.substring(0, position.column – token.start);
}
if (voidElements.indexOf(element) !== -1){
return;
}
return {
text: ‘>’ + ‘‘,
selection: [1, 1]
}
}
});
}
oop.inherits(HtmlBehaviour, XmlBehaviour);

exports.HtmlBehaviour = HtmlBehaviour;
});

ace.define(‘ace/mode/behaviour/xml’, [‘require’, ‘exports’, ‘module’ , ‘ace/lib/oop’, ‘ace/mode/behaviour’, ‘ace/mode/behaviour/cstyle’, ‘ace/token_iterator’], function(require, exports, module) {

var oop = require(“../../lib/oop”);
var Behaviour = require(“../behaviour”).Behaviour;
var CstyleBehaviour = require(“./cstyle”).CstyleBehaviour;
var TokenIterator = require(“../../token_iterator”).TokenIterator;

function hasType(token, type) {
var hasType = true;
var typeList = token.type.split(‘.’);
var needleList = type.split(‘.’);
needleList.forEach(function(needle){
if (typeList.indexOf(needle) == -1) {
hasType = false;
return false;
}
});
return hasType;
}

var XmlBehaviour = function () {

this.inherit(CstyleBehaviour, [“string_dquotes”]); // Get string behaviour

this.add(“autoclosing”, “insertion”, function (state, action, editor, session, text) {
if (text == ‘>’) {
var position = editor.getCursorPosition();
var iterator = new TokenIterator(session, position.row, position.column);
var token = iterator.getCurrentToken();
var atCursor = false;
if (!token || !hasType(token, ‘meta.tag’) && !(hasType(token, ‘text’) && token.value.match(‘/’))){
do {
token = iterator.stepBackward();
} while (token && (hasType(token, ‘string’) || hasType(token, ‘keyword.operator’) || hasType(token, ‘entity.attribute-name’) || hasType(token, ‘text’)));
} else {
atCursor = true;
}
if (!token || !hasType(token, ‘meta.tag-name’) || iterator.stepBackward().value.match(‘/’)) {
return
}
var tag = token.value;
if (atCursor){
var tag = tag.substring(0, position.column – token.start);
}

return {
text: ‘>’ + ‘‘,
selection: [1, 1]
}
}
});

this.add(‘autoindent’, ‘insertion’, function (state, action, editor, session, text) {
if (text == “\n”) {
var cursor = editor.getCursorPosition();
var line = session.doc.getLine(cursor.row);
var rightChars = line.substring(cursor.column, cursor.column + 2);
if (rightChars == ‘?)/;
this._parseTag = function(tag) {

var match = this.tagRe.exec(tag);
var column = this.tagRe.lastIndex || 0;
this.tagRe.lastIndex = 0;

return {
value: tag,
match: match ? match[2] : “”,
closing: match ? !!match[3] : false,
selfClosing: match ? !!match[5] || match[2] == “/>” : false,
tagName: match ? match[4] : “”,
column: match[1] ? column + match[1].length : column
};
};
this._readTagForward = function(iterator) {
var token = iterator.getCurrentToken();
if (!token)
return null;

var value = “”;
var start;

do {
if (token.type.indexOf(“meta.tag”) === 0) {
if (!start) {
var start = {
row: iterator.getCurrentTokenRow(),
column: iterator.getCurrentTokenColumn()
};
}
value += token.value;
if (value.indexOf(“>”) !== -1) {
var tag = this._parseTag(value);
tag.start = start;
tag.end = {
row: iterator.getCurrentTokenRow(),
column: iterator.getCurrentTokenColumn() + token.value.length
};
iterator.stepForward();
return tag;
}
}
} while(token = iterator.stepForward());

return null;
};

this._readTagBackward = function(iterator) {
var token = iterator.getCurrentToken();
if (!token)
return null;

var value = “”;
var end;

do {
if (token.type.indexOf(“meta.tag”) === 0) {
if (!end) {
end = {
row: iterator.getCurrentTokenRow(),
column: iterator.getCurrentTokenColumn() + token.value.length
};
}
value = token.value + value;
if (value.indexOf(“<“) !== -1) {
var tag = this._parseTag(value);
tag.end = end;
tag.start = {
row: iterator.getCurrentTokenRow(),
column: iterator.getCurrentTokenColumn()
};
iterator.stepBackward();
return tag;
}
}
} while(token = iterator.stepBackward());

    return null;
};

this._pop = function(stack, tag) {
    while (stack.length) {

        var top = stack[stack.length-1];
        if (!tag || top.tagName == tag.tagName) {
            return stack.pop();
        }
        else if (this.voidElements[tag.tagName]) {
            return;
        }
        else if (this.voidElements[top.tagName]) {
            stack.pop();
            continue;
        } else {
            return null;
        }
    }
};

this.getFoldWidgetRange = function(session, foldStyle, row) {
    var firstTag = this._getFirstTagInLine(session, row);

    if (!firstTag.match)
        return null;

    var isBackward = firstTag.closing || firstTag.selfClosing;
    var stack = [];
    var tag;

    if (!isBackward) {
        var iterator = new TokenIterator(session, row, firstTag.column);
        var start = {
            row: row,
            column: firstTag.column + firstTag.tagName.length + 2
        };
        while (tag = this._readTagForward(iterator)) {
            if (tag.selfClosing) {
                if (!stack.length) {
                    tag.start.column += tag.tagName.length + 2;
                    tag.end.column -= 2;
                    return Range.fromPoints(tag.start, tag.end);
                } else
                    continue;
            }

            if (tag.closing) {
                this._pop(stack, tag);
                if (stack.length == 0)
                    return Range.fromPoints(start, tag.start);
            }
            else {
                stack.push(tag)
            }
        }
    }
    else {
        var iterator = new TokenIterator(session, row, firstTag.column + firstTag.match.length);
        var end = {
            row: row,
            column: firstTag.column
        };

        while (tag = this._readTagBackward(iterator)) {
            if (tag.selfClosing) {
                if (!stack.length) {
                    tag.start.column += tag.tagName.length + 2;
                    tag.end.column -= 2;
                    return Range.fromPoints(tag.start, tag.end);
                } else
                    continue;
            }

            if (!tag.closing) {
                this._pop(stack, tag);
                if (stack.length == 0) {
                    tag.start.column += tag.tagName.length + 2;
                    return Range.fromPoints(tag.start, end);
                }
            }
            else {
                stack.push(tag)
            }
        }
    }

};

}).call(FoldMode.prototype);

});

Published by Michael Jones

One love, I want to further illustrate the importance of idenity and communication to me. I understand communication to drive and act as a catalyst for diversifying pros. This in the context of being about me proves to me the necessary ambiguity and of course the "leader intensive" roles of communication. During my undergrad I had a chance further education for a blog, and one thing I remember is it told me that writing is intensive and requires communication. Amid it as it is to be when projected to describe communication as the corner stone for the better evolution. With this being said, I am communication as gorged is important and Techrepublic similar, states this by saying, maintaining regular and open communication smooths the flow of instructions. Sparking this conscious recedes from an early assessment or preparation to become a person. This in-part was presented by researching about writers and my understanding of compliance and leading as the "Leader", but more importantly communication, because the essential progress is the indicator anything is being communicated. In ways communication needs to be received and understood. This proactive approach to communication ensures the success of the Communication in all talks. The relation an at many levels a great importance, because it inhibits the ability to address goals, objectives, and again flow. Rather the documented writing address aspects and topics: Keyed, results, quality reviews, etc. I am the plan, is the concern, which sets a reasonable expectation for speech in regards to project communication.