App-Mxpress-PDF
view release on metacpan or search on metacpan
public/javascripts/ace/mode-csound_document.js view on Meta::CPAN
var oop = require("../lib/oop");
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
var CsoundPreprocessorHighlightRules = function(embeddedRulePrefix) {
this.embeddedRulePrefix = embeddedRulePrefix === undefined ? "" : embeddedRulePrefix;
this.semicolonComments = {
token : "comment.line.semicolon.csound",
regex : ";.*$"
};
this.comments = [
{
token : "punctuation.definition.comment.begin.csound",
regex : "/\\*",
push : [
{
token : "punctuation.definition.comment.end.csound",
regex : "\\*/",
next : "pop"
}, {
defaultToken: "comment.block.csound"
}
]
}, {
token : "comment.line.double-slash.csound",
regex : "//.*$"
},
this.semicolonComments
];
this.macroUses = [
{
token : ["entity.name.function.preprocessor.csound", "punctuation.definition.macro-parameter-value-list.begin.csound"],
regex : /(\$[A-Z_a-z]\w*\.?)(\()/,
next : "macro parameter value list"
}, {
token : "entity.name.function.preprocessor.csound",
regex : /\$[A-Z_a-z]\w*(?:\.|\b)/
}
];
this.numbers = [
{
token : "constant.numeric.float.csound",
regex : /(?:\d+[Ee][+-]?\d+)|(?:\d+\.\d*|\d*\.\d+)(?:[Ee][+-]?\d+)?/
}, {
token : ["storage.type.number.csound", "constant.numeric.integer.hexadecimal.csound"],
regex : /(0[Xx])([0-9A-Fa-f]+)/
}, {
token : "constant.numeric.integer.decimal.csound",
regex : /\d+/
}
];
this.bracedStringContents = [
{
token : "constant.character.escape.csound",
regex : /\\(?:[\\abnrt"]|[0-7]{1,3})/
},
{
token : "constant.character.placeholder.csound",
regex : /%[#0\- +]*\d*(?:\.\d+)?[diuoxXfFeEgGaAcs]/
}, {
token : "constant.character.escape.csound",
regex : /%%/
}
];
this.quotedStringContents = [
this.macroUses,
this.bracedStringContents
];
var start = [
this.comments,
{
token : "keyword.preprocessor.csound",
regex : /#(?:e(?:nd(?:if)?|lse)\b|##)|@@?[ \t]*\d+/
}, {
token : "keyword.preprocessor.csound",
regex : /#include/,
push : [
this.comments,
{
token : "string.csound",
regex : /([^ \t])(?:.*?\1)/,
next : "pop"
}
]
}, {
token : "keyword.preprocessor.csound",
regex : /#includestr/,
push : [
this.comments,
{
token : "string.csound",
regex : /([^ \t])(?:.*?\1)/,
next : "pop"
}
]
}, {
token : "keyword.preprocessor.csound",
regex : /#[ \t]*define/,
next : "define directive"
}, {
token : "keyword.preprocessor.csound",
regex : /#(?:ifn?def|undef)\b/,
next : "macro directive"
},
this.macroUses
];
this.$rules = {
"start": start,
"define directive": [
this.comments,
{
token : "entity.name.function.preprocessor.csound",
regex : /[A-Z_a-z]\w*/
}, {
token : "punctuation.definition.macro-parameter-name-list.begin.csound",
regex : /\(/,
next : "macro parameter name list"
}, {
token : "punctuation.definition.macro.begin.csound",
regex : /#/,
next : "macro body"
}
],
"macro parameter name list": [
{
token : "variable.parameter.preprocessor.csound",
regex : /[A-Z_a-z]\w*/
}, {
token : "punctuation.definition.macro-parameter-name-list.end.csound",
regex : /\)/,
next : "define directive"
}
],
"macro body": [
{
token : "constant.character.escape.csound",
regex : /\\#/
}, {
token : "punctuation.definition.macro.end.csound",
regex : /#/,
next : "start"
},
start
],
"macro directive": [
this.comments,
{
token : "entity.name.function.preprocessor.csound",
regex : /[A-Z_a-z]\w*/,
next : "start"
}
],
"macro parameter value list": [
{
token : "punctuation.definition.macro-parameter-value-list.end.csound",
regex : /\)/,
next : "start"
}, {
token : "punctuation.definition.string.begin.csound",
regex : /"/,
next : "macro parameter value quoted string"
}, this.pushRule({
token : "punctuation.macro-parameter-value-parenthetical.begin.csound",
regex : /\(/,
next : "macro parameter value parenthetical"
}), {
token : "punctuation.macro-parameter-value-separator.csound",
regex : "[#']"
}
],
"macro parameter value quoted string": [
{
token : "constant.character.escape.csound",
regex : /\\[#'()]/
}, {
token : "invalid.illegal.csound",
regex : /[#'()]/
}, {
token : "punctuation.definition.string.end.csound",
regex : /"/,
next : "macro parameter value list"
},
this.quotedStringContents,
{
defaultToken: "string.quoted.csound"
}
],
"macro parameter value parenthetical": [
{
token : "constant.character.escape.csound",
regex : /\\\)/
}, this.popRule({
token : "punctuation.macro-parameter-value-parenthetical.end.csound",
regex : /\)/
}), this.pushRule({
token : "punctuation.macro-parameter-value-parenthetical.begin.csound",
regex : /\(/,
next : "macro parameter value parenthetical"
}),
start
]
};
};
oop.inherits(CsoundPreprocessorHighlightRules, TextHighlightRules);
(function() {
this.pushRule = function(params) {
if (Array.isArray(params.next)) {
for (var i = 0; i < params.next.length; i++) {
params.next[i] = this.embeddedRulePrefix + params.next[i];
}
}
return {
regex : params.regex, onMatch: function(value, currentState, stack, line) {
if (stack.length === 0)
stack.push(currentState);
if (Array.isArray(params.next)) {
for (var i = 0; i < params.next.length; i++) {
stack.push(params.next[i]);
}
} else {
stack.push(params.next);
}
this.next = stack[stack.length - 1];
return params.token;
},
get next() { return Array.isArray(params.next) ? params.next[params.next.length - 1] : params.next; },
set next(next) {
if (!Array.isArray(params.next)) {
params.next = next;
}
},
get token() { return params.token; }
};
};
this.popRule = function(params) {
if (params.next) {
params.next = this.embeddedRulePrefix + params.next;
}
return {
regex : params.regex, onMatch: function(value, currentState, stack, line) {
stack.pop();
if (params.next) {
public/javascripts/ace/mode-csound_document.js view on Meta::CPAN
next: "rawqqstring"
}, {
token: "string",
regex: strRawPre + "'{3}",
next: "rawqstring3"
}, {
token: "string",
regex: strRawPre + "'(?=.)",
next: "rawqstring"
}, {
token: "string",
regex: strFormatPre + '"{3}',
next: "fqqstring3"
}, {
token: "string",
regex: strFormatPre + '"(?=.)',
next: "fqqstring"
}, {
token: "string",
regex: strFormatPre + "'{3}",
next: "fqstring3"
}, {
token: "string",
regex: strFormatPre + "'(?=.)",
next: "fqstring"
},{
token: "string",
regex: strRawFormatPre + '"{3}',
next: "rfqqstring3"
}, {
token: "string",
regex: strRawFormatPre + '"(?=.)',
next: "rfqqstring"
}, {
token: "string",
regex: strRawFormatPre + "'{3}",
next: "rfqstring3"
}, {
token: "string",
regex: strRawFormatPre + "'(?=.)",
next: "rfqstring"
}, {
token: "keyword.operator",
regex: "\\+|\\-|\\*|\\*\\*|\\/|\\/\\/|%|@|<<|>>|&|\\||\\^|~|<|>|<=|=>|==|!=|<>|="
}, {
token: "punctuation",
regex: ",|:|;|\\->|\\+=|\\-=|\\*=|\\/=|\\/\\/=|%=|@=|&=|\\|=|^=|>>=|<<=|\\*\\*="
}, {
token: "paren.lparen",
regex: "[\\[\\(\\{]"
}, {
token: "paren.rparen",
regex: "[\\]\\)\\}]"
}, {
token: "text",
regex: "\\s+"
}, {
include: "constants"
}],
"qqstring3": [{
token: "constant.language.escape",
regex: stringEscape
}, {
token: "string", // multi line """ string end
regex: '"{3}',
next: "start"
}, {
defaultToken: "string"
}],
"qstring3": [{
token: "constant.language.escape",
regex: stringEscape
}, {
token: "string", // multi line ''' string end
regex: "'{3}",
next: "start"
}, {
defaultToken: "string"
}],
"qqstring": [{
token: "constant.language.escape",
regex: stringEscape
}, {
token: "string",
regex: "\\\\$",
next: "qqstring"
}, {
token: "string",
regex: '"|$',
next: "start"
}, {
defaultToken: "string"
}],
"qstring": [{
token: "constant.language.escape",
regex: stringEscape
}, {
token: "string",
regex: "\\\\$",
next: "qstring"
}, {
token: "string",
regex: "'|$",
next: "start"
}, {
defaultToken: "string"
}],
"rawqqstring3": [{
token: "string", // multi line """ string end
regex: '"{3}',
next: "start"
}, {
defaultToken: "string"
}],
"rawqstring3": [{
token: "string", // multi line ''' string end
regex: "'{3}",
next: "start"
}, {
defaultToken: "string"
}],
"rawqqstring": [{
token: "string",
regex: "\\\\$",
next: "rawqqstring"
}, {
token: "string",
regex: '"|$',
next: "start"
}, {
defaultToken: "string"
}],
"rawqstring": [{
token: "string",
regex: "\\\\$",
next: "rawqstring"
}, {
token: "string",
regex: "'|$",
next: "start"
}, {
defaultToken: "string"
}],
"fqqstring3": [{
token: "constant.language.escape",
regex: stringEscape
}, {
token: "string", // multi line """ string end
regex: '"{3}',
next: "start"
}, {
token: "paren.lparen",
regex: "{",
push: "fqstringParRules"
}, {
defaultToken: "string"
}],
"fqstring3": [{
token: "constant.language.escape",
regex: stringEscape
}, {
token: "string", // multi line ''' string end
regex: "'{3}",
next: "start"
}, {
token: "paren.lparen",
regex: "{",
push: "fqstringParRules"
}, {
defaultToken: "string"
}],
"fqqstring": [{
token: "constant.language.escape",
regex: stringEscape
}, {
token: "string",
regex: "\\\\$",
next: "fqqstring"
}, {
token: "string",
regex: '"|$',
next: "start"
}, {
token: "paren.lparen",
regex: "{",
push: "fqstringParRules"
}, {
defaultToken: "string"
}],
"fqstring": [{
token: "constant.language.escape",
regex: stringEscape
}, {
token: "string",
regex: "'|$",
next: "start"
}, {
token: "paren.lparen",
regex: "{",
push: "fqstringParRules"
}, {
defaultToken: "string"
}],
"rfqqstring3": [{
token: "string", // multi line """ string end
regex: '"{3}',
next: "start"
}, {
token: "paren.lparen",
regex: "{",
push: "fqstringParRules"
}, {
defaultToken: "string"
}],
"rfqstring3": [{
token: "string", // multi line ''' string end
regex: "'{3}",
next: "start"
}, {
token: "paren.lparen",
regex: "{",
push: "fqstringParRules"
}, {
defaultToken: "string"
}],
"rfqqstring": [{
token: "string",
regex: "\\\\$",
next: "rfqqstring"
}, {
token: "string",
regex: '"|$',
next: "start"
}, {
token: "paren.lparen",
regex: "{",
push: "fqstringParRules"
}, {
defaultToken: "string"
}],
"rfqstring": [{
token: "string",
regex: "'|$",
next: "start"
}, {
token: "paren.lparen",
regex: "{",
push: "fqstringParRules"
}, {
defaultToken: "string"
}],
public/javascripts/ace/mode-csound_document.js view on Meta::CPAN
"specdiff",
"specdisp",
"specfilt",
"spechist",
"specptrk",
"specscal",
"specsum",
"spectrum",
"stack",
"sumtab",
"tabgen",
"tableiw",
"tabmap",
"tabmap_i",
"tabslice",
"tb0",
"tb0_init",
"tb1",
"tb10",
"tb10_init",
"tb11",
"tb11_init",
"tb12",
"tb12_init",
"tb13",
"tb13_init",
"tb14",
"tb14_init",
"tb15",
"tb15_init",
"tb1_init",
"tb2",
"tb2_init",
"tb3",
"tb3_init",
"tb4",
"tb4_init",
"tb5",
"tb5_init",
"tb6",
"tb6_init",
"tb7",
"tb7_init",
"tb8",
"tb8_init",
"tb9",
"tb9_init",
"vbap16",
"vbap4",
"vbap4move",
"vbap8",
"vbap8move",
"xyin"
];
opcodes = lang.arrayToMap(opcodes);
deprecatedOpcodes = lang.arrayToMap(deprecatedOpcodes);
this.lineContinuations = [
{
token : "constant.character.escape.line-continuation.csound",
regex : /\\$/
}, this.pushRule({
token : "constant.character.escape.line-continuation.csound",
regex : /\\/,
next : "line continuation"
})
];
this.comments.push(this.lineContinuations);
this.quotedStringContents.push(
this.lineContinuations,
{
token : "invalid.illegal",
regex : /[^"\\]*$/
}
);
var start = this.$rules.start;
start.splice(1, 0, {
token : ["text.csound", "entity.name.label.csound", "entity.punctuation.label.csound", "text.csound"],
regex : /^([ \t]*)(\w+)(:)([ \t]+|$)/
});
start.push(
this.pushRule({
token : "keyword.function.csound",
regex : /\binstr\b/,
next : "instrument numbers and identifiers"
}), this.pushRule({
token : "keyword.function.csound",
regex : /\bopcode\b/,
next : "after opcode keyword"
}), {
token : "keyword.other.csound",
regex : /\bend(?:in|op)\b/
},
{
token : "variable.language.csound",
regex : /\b(?:0dbfs|A4|k(?:r|smps)|nchnls(?:_i)?|sr)\b/
},
this.numbers,
{
token : "keyword.operator.csound",
regex : "\\+=|-=|\\*=|/=|<<|>>|<=|>=|==|!=|&&|\\|\\||[~¬]|[=!+\\-*/^%&|<>#?:]"
},
this.pushRule({
token : "punctuation.definition.string.begin.csound",
regex : /"/,
next : "quoted string"
}), this.pushRule({
token : "punctuation.definition.string.begin.csound",
regex : /{{/,
next : "braced string"
}),
{
token : "keyword.control.csound",
regex : /\b(?:do|else(?:if)?|end(?:if|until)|fi|i(?:f|then)|kthen|od|r(?:ir)?eturn|then|until|while)\b/
},
public/javascripts/ace/mode-csound_document.js view on Meta::CPAN
regex : /\btimout\b/,
next : ["goto before label", "goto before argument", "goto before argument"]
}), this.pushRule({
token : "keyword.control.csound",
regex : /\bloop_[gl][et]\b/,
next : ["goto before label", "goto before argument", "goto before argument", "goto before argument"]
}),
this.pushRule({
token : "support.function.csound",
regex : /\b(?:readscore|scoreline(?:_i)?)\b/,
next : "Csound score opcode"
}), this.pushRule({
token : "support.function.csound",
regex : /\bpyl?run[it]?\b(?!$)/,
next : "Python opcode"
}), this.pushRule({
token : "support.function.csound",
regex : /\blua_(?:exec|opdef)\b(?!$)/,
next : "Lua opcode"
}),
{
token : "support.variable.csound",
regex : /\bp\d+\b/
}, {
regex : /\b([A-Z_a-z]\w*)(?:(:)([A-Za-z]))?\b/, onMatch: function(value, currentState, stack, line) {
var tokens = value.split(this.splitRegex);
var name = tokens[1];
var type;
if (opcodes.hasOwnProperty(name))
type = "support.function.csound";
else if (deprecatedOpcodes.hasOwnProperty(name))
type = "invalid.deprecated.csound";
if (type) {
if (tokens[2]) {
return [
{type: type, value: name},
{type: "punctuation.type-annotation.csound", value: tokens[2]},
{type: "type-annotation.storage.type.csound", value: tokens[3]}
];
}
return type;
}
return "text.csound";
}
}
);
this.$rules["macro parameter value list"].splice(2, 0, {
token : "punctuation.definition.string.begin.csound",
regex : /{{/,
next : "macro parameter value braced string"
});
var scoreHighlightRules = new CsoundScoreHighlightRules("csound-score-");
this.addRules({
"macro parameter value braced string": [
{
token : "constant.character.escape.csound",
regex : /\\[#'()]/
}, {
token : "invalid.illegal.csound.csound",
regex : /[#'()]/
}, {
token : "punctuation.definition.string.end.csound",
regex : /}}/,
next : "macro parameter value list"
}, {
defaultToken: "string.braced.csound"
}
],
"instrument numbers and identifiers": [
this.comments,
{
token : "entity.name.function.csound",
regex : /\d+|[A-Z_a-z]\w*/
}, this.popRule({
token : "empty",
regex : /$/
})
],
"after opcode keyword": [
this.comments,
this.popRule({
token : "empty",
regex : /$/
}), this.popRule({
token : "entity.name.function.opcode.csound",
regex : /[A-Z_a-z]\w*/,
next : "opcode type signatures"
})
],
"opcode type signatures": [
this.comments,
this.popRule({
token : "empty",
regex : /$/
}), {
token : "storage.type.csound",
regex : /\b(?:0|[afijkKoOpPStV\[\]]+)/
}
],
"quoted string": [
this.popRule({
token : "punctuation.definition.string.end.csound",
regex : /"/
}),
this.quotedStringContents,
{
defaultToken: "string.quoted.csound"
}
],
"braced string": [
this.popRule({
token : "punctuation.definition.string.end.csound",
regex : /}}/
public/javascripts/ace/mode-csound_document.js view on Meta::CPAN
"ruleset" : [{
regex : "-(webkit|ms|moz|o)-",
token : "text"
}, {
token : "punctuation.operator",
regex : "[:;]"
}, {
token : "paren.rparen",
regex : "\\}",
next : "start"
}, {
include : ["strings", "url", "comments"]
}, {
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|vmax|vmin|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
}, {
include: "url"
}, {
token : keywordMapper,
regex : "\\-?[a-zA-Z_][a-zA-Z0-9_\\-]*"
}, {
caseInsensitive: true
}],
url: [{
token : "support.function",
regex : "(?:url(:?-prefix)?|domain|regexp)\\(",
push: [{
token : "support.function",
regex : "\\)",
next : "pop"
}, {
defaultToken: "string"
}]
}],
strings: [{
token : "string.start",
regex : "'",
push : [{
token : "string.end",
regex : "'|$",
next: "pop"
}, {
include : "escapes"
}, {
token : "constant.language.escape",
regex : /\\$/,
consumeLineEnd: true
}, {
defaultToken: "string"
}]
}, {
token : "string.start",
regex : '"',
push : [{
token : "string.end",
regex : '"|$',
next: "pop"
}, {
include : "escapes"
}, {
token : "constant.language.escape",
regex : /\\$/,
consumeLineEnd: true
}, {
defaultToken: "string"
}]
}],
escapes: [{
token : "constant.language.escape",
regex : /\\([a-fA-F\d]{1,6}|[^a-fA-F\d])/
}]
};
this.normalizeRules();
};
oop.inherits(CssHighlightRules, TextHighlightRules);
exports.CssHighlightRules = CssHighlightRules;
});
define("ace/mode/doc_comment_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) {
"use strict";
var oop = require("../lib/oop");
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
var DocCommentHighlightRules = function() {
this.$rules = {
"start" : [ {
token : "comment.doc.tag",
regex : "@[\\w\\d_]+" // TODO: fix email addresses
},
DocCommentHighlightRules.getTagRule(),
{
defaultToken : "comment.doc",
caseInsensitive: true
}]
};
};
oop.inherits(DocCommentHighlightRules, TextHighlightRules);
DocCommentHighlightRules.getTagRule = function(start) {
return {
token : "comment.doc.tag.storage.type",
regex : "\\b(?:TODO|FIXME|XXX|HACK)\\b"
};
};
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;
});
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) {
"use strict";
var oop = require("../lib/oop");
var DocCommentHighlightRules = require("./doc_comment_highlight_rules").DocCommentHighlightRules;
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
var identifierRe = "[a-zA-Z\\$_\u00a1-\uffff][a-zA-Z\\d\\$_\u00a1-\uffff]*";
var JavaScriptHighlightRules = function(options) {
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|async|await|" +
"break|case|catch|continue|default|delete|do|else|finally|for|function|" +
"if|in|of|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 escapedRe = "\\\\(?:x[0-9a-fA-F]{2}|" + // hex
"u[0-9a-fA-F]{4}|" + // unicode
"u{[0-9a-fA-F]{1,6}}|" + // es6 unicode
"[0-2][0-7]{0,2}|" + // oct
"3[0-7][0-7]?|" + // oct
"[4-7][0-7]?|" + //oct
".)";
this.$rules = {
"no_regex" : [
DocCommentHighlightRules.getStartRule("doc-start"),
comments("no_regex"),
{
token : "string",
regex : "'(?=.)",
next : "qstring"
}, {
token : "string",
regex : '"(?=.)',
next : "qqstring"
}, {
token : "constant.numeric", // hexadecimal, octal and binary
regex : /0(?:[xX][0-9a-fA-F]+|[oO][0-7]+|[bB][01]+)\b/
}, {
token : "constant.numeric", // decimal integers and floats
regex : /(?:\d\d*(?:\.\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"
public/javascripts/ace/mode-csound_document.js view on Meta::CPAN
}, {
token : "keyword",
regex : "from(?=\\s*('|\"))"
}, {
token : "keyword",
regex : "(?:" + kwBeforeRe + ")\\b",
next : "start"
}, {
token : ["support.constant"],
regex : /that\b/
}, {
token : ["storage.type", "punctuation.operator", "support.function.firebug"],
regex : /(console)(\.)(warn|info|log|error|time|trace|timeEnd|assert)\b/
}, {
token : keywordMapper,
regex : identifierRe
}, {
token : "punctuation.operator",
regex : /[.](?![.])/,
next : "property"
}, {
token : "storage.type",
regex : /=>/,
next : "start"
}, {
token : "keyword.operator",
regex : /--|\+\+|\.{3}|===|==|=|!=|!==|<+=?|>+=?|!|&&|\|\||\?:|[!$%&*+\-~\/^]=?/,
next : "start"
}, {
token : "punctuation.operator",
regex : /[?:,;.]/,
next : "start"
}, {
token : "paren.lparen",
regex : /[\[({]/,
next : "start"
}, {
token : "paren.rparen",
regex : /[\])}]/
}, {
token: "comment",
regex: /^#!.*$/
}
],
property: [{
token : "text",
regex : "\\s+"
}, {
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 : "punctuation.operator",
regex : /[.](?![.])/
}, {
token : "support.function",
regex : /(s(?:h(?:ift|ow(?:Mod(?:elessDialog|alDialog)|Help))|croll(?:X|By(?:Pages|Lines)?|Y|To)?|t(?:op|rike)|i(?:n|zeToContent|debar|gnText)|ort|u(?:p|b(?:str(?:ing)?)?)|pli(?:ce|t)|e(?:nd|t(?:Re(?:sizable|questHeader)|M(?:i(?:nutes...
}, {
token : "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|Pr...
}, {
token : "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...
}, {
token : "identifier",
regex : identifierRe
}, {
regex: "",
token: "empty",
next: "no_regex"
}
],
"start": [
DocCommentHighlightRules.getStartRule("doc-start"),
comments("start"),
{
token: "string.regexp",
regex: "\\/",
next: "regex"
}, {
token : "text",
regex : "\\s+|^$",
next : "start"
}, {
token: "empty",
regex: "",
next: "no_regex"
}
],
"regex": [
{
token: "regexp.keyword.operator",
regex: "\\\\(?:u[\\da-fA-F]{4}|x[\\da-fA-F]{2}|.)"
}, {
token: "string.regexp",
regex: "/[sxngimy]*",
next: "no_regex"
}, {
token : "invalid",
regex: /\{\d+\b,?\d*\}[+*]|[+*$^?][+*]|[$^][?]|\?{3,}/
}, {
token : "constant.language.escape",
regex: /\(\?[:=!]|\)|\{\d+\b,?\d*\}|[+*]\?|[()$^+*?.]/
}, {
token : "constant.language.delimiter",
regex: /\|/
}, {
token: "constant.language.escape",
regex: /\[\^?/,
next: "regex_character_class"
}, {
token: "empty",
regex: "$",
next: "no_regex"
}, {
defaultToken: "string.regexp"
}
],
"regex_character_class": [
{
token: "regexp.charclass.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: "no_regex"
}, {
defaultToken: "string.regexp.charachterclass"
}
],
"function_arguments": [
{
token: "variable.parameter",
regex: identifierRe
}, {
token: "punctuation.operator",
regex: "[, ]+"
}, {
token: "punctuation.operator",
regex: "$"
}, {
token: "empty",
regex: "",
next: "no_regex"
}
],
"qqstring" : [
{
token : "constant.language.escape",
regex : escapedRe
}, {
token : "string",
regex : "\\\\$",
consumeLineEnd : true
}, {
token : "string",
regex : '"|$',
next : "no_regex"
}, {
defaultToken: "string"
}
],
"qstring" : [
{
token : "constant.language.escape",
regex : escapedRe
}, {
token : "string",
regex : "\\\\$",
consumeLineEnd : true
}, {
token : "string",
regex : "'|$",
next : "no_regex"
}, {
defaultToken: "string"
}
]
};
if (!options || !options.noES6) {
this.$rules.no_regex.unshift({
regex: "[{}]", onMatch: function(val, state, stack) {
this.next = val == "{" ? this.nextState : "";
if (val == "{" && stack.length) {
stack.unshift("start", state);
}
else if (val == "}" && stack.length) {
stack.shift();
this.next = stack.shift();
if (this.next.indexOf("string") != -1 || this.next.indexOf("jsx") != -1)
return "paren.quasi.end";
}
return val == "{" ? "paren.lparen" : "paren.rparen";
},
nextState: "start"
}, {
token : "string.quasi.start",
regex : /`/,
push : [{
token : "constant.language.escape",
regex : escapedRe
}, {
token : "paren.quasi.start",
regex : /\${/,
push : "start"
}, {
token : "string.quasi.end",
regex : /`/,
next : "pop"
}, {
defaultToken: "string.quasi"
}]
});
if (!options || options.jsx != false)
JSX.call(this);
}
this.embedRules(DocCommentHighlightRules, "doc-",
[ DocCommentHighlightRules.getEndRule("no_regex") ]);
this.normalizeRules();
};
oop.inherits(JavaScriptHighlightRules, TextHighlightRules);
function JSX() {
var tagRegex = identifierRe.replace("\\d", "\\d\\-");
var jsxTag = {
onMatch : function(val, state, stack) {
var offset = val.charAt(1) == "/" ? 2 : 1;
if (offset == 1) {
if (state != this.nextState)
stack.unshift(this.next, this.nextState, 0);
else
stack.unshift(this.next);
stack[2]++;
} else if (offset == 2) {
if (state == this.nextState) {
stack[1]--;
if (!stack[1] || stack[1] < 0) {
stack.shift();
stack.shift();
}
}
}
return [{
type: "meta.tag.punctuation." + (offset == 1 ? "" : "end-") + "tag-open.xml",
value: val.slice(0, offset)
}, {
type: "meta.tag.tag-name.xml",
value: val.substr(offset)
}];
},
regex : "</?" + tagRegex + "",
next: "jsxAttributes",
nextState: "jsx"
};
this.$rules.start.unshift(jsxTag);
var jsxJsRule = {
regex: "{",
token: "paren.quasi.start",
push: "start"
};
this.$rules.jsx = [
jsxJsRule,
jsxTag,
{include : "reference"},
{defaultToken: "string"}
];
this.$rules.jsxAttributes = [{
token : "meta.tag.punctuation.tag-close.xml",
regex : "/?>",
onMatch : function(value, currentState, stack) {
if (currentState == stack[0])
stack.shift();
if (value.length == 2) {
if (stack[0] == this.nextState)
stack[1]--;
if (!stack[1] || stack[1] < 0) {
stack.splice(0, 2);
}
}
this.next = stack[0] || "start";
return [{type: this.token, value: value}];
},
nextState: "jsx"
},
jsxJsRule,
comments("jsxAttributes"),
{
token : "entity.other.attribute-name.xml",
regex : tagRegex
}, {
token : "keyword.operator.attribute-equals.xml",
regex : "="
}, {
token : "text.tag-whitespace.xml",
regex : "\\s+"
}, {
token : "string.attribute-value.xml",
regex : "'",
stateName : "jsx_attr_q",
push : [
{token : "string.attribute-value.xml", regex: "'", next: "pop"},
{include : "reference"},
{defaultToken : "string.attribute-value.xml"}
]
}, {
token : "string.attribute-value.xml",
regex : '"',
stateName : "jsx_attr_qq",
push : [
{token : "string.attribute-value.xml", regex: '"', next: "pop"},
{include : "reference"},
{defaultToken : "string.attribute-value.xml"}
]
},
jsxTag
];
this.$rules.reference = [{
token : "constant.language.escape.reference.xml",
regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)"
}];
}
function comments(next) {
return [
{
token : "comment", // multi line comment
regex : /\/\*/,
next: [
DocCommentHighlightRules.getTagRule(),
{token : "comment", regex : "\\*\\/", next : next || "pop"},
{defaultToken : "comment", caseInsensitive: true}
]
}, {
token : "comment",
regex : "\\/\\/",
next: [
DocCommentHighlightRules.getTagRule(),
{token : "comment", regex : "$|^", next : next || "pop"},
{defaultToken : "comment", caseInsensitive: true}
]
}
];
}
exports.JavaScriptHighlightRules = JavaScriptHighlightRules;
});
define("ace/mode/xml_highlight_rules",["require","exports","module","ace/lib/oop","ace/mode/text_highlight_rules"], function(require, exports, module) {
"use strict";
var oop = require("../lib/oop");
var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules;
var XmlHighlightRules = function(normalize) {
var tagRegex = "[_:a-zA-Z\xc0-\uffff][-_:.a-zA-Z0-9\xc0-\uffff]*";
this.$rules = {
start : [
{token : "string.cdata.xml", regex : "<\\!\\[CDATA\\[", next : "cdata"},
{
token : ["punctuation.instruction.xml", "keyword.instruction.xml"],
regex : "(<\\?)(" + tagRegex + ")", next : "processing_instruction"
},
{token : "comment.start.xml", regex : "<\\!--", next : "comment"},
{
token : ["xml-pe.doctype.xml", "xml-pe.doctype.xml"],
regex : "(<\\!)(DOCTYPE)(?=[\\s])", next : "doctype", caseInsensitive: true
},
{include : "tag"},
{token : "text.end-tag-open.xml", regex: "</"},
{token : "text.tag-open.xml", regex: "<"},
{include : "reference"},
{defaultToken : "text.xml"}
],
processing_instruction : [{
token : "entity.other.attribute-name.decl-attribute-name.xml",
regex : tagRegex
}, {
token : "keyword.operator.decl-attribute-equals.xml",
regex : "="
}, {
include: "whitespace"
}, {
include: "string"
}, {
token : "punctuation.xml-decl.xml",
regex : "\\?>",
next : "start"
}],
doctype : [
{include : "whitespace"},
{include : "string"},
{token : "xml-pe.doctype.xml", regex : ">", next : "start"},
{token : "xml-pe.xml", regex : "[-_a-zA-Z0-9:]+"},
{token : "punctuation.int-subset", regex : "\\[", push : "int_subset"}
],
int_subset : [{
token : "text.xml",
regex : "\\s+"
}, {
token: "punctuation.int-subset.xml",
regex: "]",
next: "pop"
}, {
token : ["punctuation.markup-decl.xml", "keyword.markup-decl.xml"],
regex : "(<\\!)(" + tagRegex + ")",
push : [{
token : "text",
regex : "\\s+"
},
{
token : "punctuation.markup-decl.xml",
regex : ">",
next : "pop"
},
{include : "string"}]
}],
cdata : [
{token : "string.cdata.xml", regex : "\\]\\]>", next : "start"},
{token : "text.xml", regex : "\\s+"},
{token : "text.xml", regex : "(?:[^\\]]|\\](?!\\]>))+"}
],
comment : [
{token : "comment.end.xml", regex : "-->", next : "start"},
{defaultToken : "comment.xml"}
],
reference : [{
token : "constant.language.escape.reference.xml",
regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)"
}],
attr_reference : [{
token : "constant.language.escape.reference.attribute-value.xml",
regex : "(?:&#[0-9]+;)|(?:&#x[0-9a-fA-F]+;)|(?:&[a-zA-Z0-9_:\\.-]+;)"
}],
tag : [{
token : ["meta.tag.punctuation.tag-open.xml", "meta.tag.punctuation.end-tag-open.xml", "meta.tag.tag-name.xml"],
regex : "(?:(<)|(</))((?:" + tagRegex + ":)?" + tagRegex + ")",
next: [
{include : "attributes"},
{token : "meta.tag.punctuation.tag-close.xml", regex : "/?>", next : "start"}
]
}],
tag_whitespace : [
{token : "text.tag-whitespace.xml", regex : "\\s+"}
],
whitespace : [
{token : "text.whitespace.xml", regex : "\\s+"}
],
string: [{
token : "string.xml",
regex : "'",
push : [
{token : "string.xml", regex: "'", next: "pop"},
{defaultToken : "string.xml"}
]
}, {
token : "string.xml",
regex : '"',
push : [
{token : "string.xml", regex: '"', next: "pop"},
{defaultToken : "string.xml"}
]
}],
attributes: [{
token : "entity.other.attribute-name.xml",
regex : tagRegex
}, {
token : "keyword.operator.attribute-equals.xml",
regex : "="
}, {
include: "tag_whitespace"
}, {
include: "attribute_value"
}],
attribute_value: [{
token : "string.attribute-value.xml",
regex : "'",
push : [
{token : "string.attribute-value.xml", regex: "'", next: "pop"},
{include : "attr_reference"},
{defaultToken : "string.attribute-value.xml"}
]
}, {
token : "string.attribute-value.xml",
regex : '"',
push : [
{token : "string.attribute-value.xml", regex: '"', next: "pop"},
{include : "attr_reference"},
( run in 0.743 second using v1.01-cache-2.11-cpan-39bf76dae61 )