App-Mxpress-PDF
view release on metacpan or search on metacpan
public/javascripts/ace/mode-html_elixir.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"
}
public/javascripts/ace/mode-html_elixir.js view on Meta::CPAN
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
comment: 'Double-quoted heredocs sigils' },
{ token: 'punctuation.definition.string.begin.elixir',
regex: '~[A-Z]\\{',
push:
[ { token: 'punctuation.definition.string.end.elixir',
regex: '\\}[a-z]*',
next: 'pop' },
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
comment: 'sigil (without interpolation)' },
{ token: 'punctuation.definition.string.begin.elixir',
regex: '~[A-Z]\\[',
push:
[ { token: 'punctuation.definition.string.end.elixir',
regex: '\\][a-z]*',
next: 'pop' },
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
comment: 'sigil (without interpolation)' },
{ token: 'punctuation.definition.string.begin.elixir',
regex: '~[A-Z]\\<',
push:
[ { token: 'punctuation.definition.string.end.elixir',
regex: '\\>[a-z]*',
next: 'pop' },
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
comment: 'sigil (without interpolation)' },
{ token: 'punctuation.definition.string.begin.elixir',
regex: '~[A-Z]\\(',
push:
[ { token: 'punctuation.definition.string.end.elixir',
regex: '\\)[a-z]*',
next: 'pop' },
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
comment: 'sigil (without interpolation)' },
{ token: 'punctuation.definition.string.begin.elixir',
regex: '~[A-Z][^\\w]',
push:
[ { token: 'punctuation.definition.string.end.elixir',
regex: '[^\\w][a-z]*',
next: 'pop' },
{ defaultToken: 'string.quoted.other.literal.upper.elixir' } ],
comment: 'sigil (without interpolation)' },
{ token: ['punctuation.definition.constant.elixir', 'constant.other.symbol.elixir'],
regex: '(:)([a-zA-Z_][\\w@]*(?:[?!]|=(?![>=]))?|\\<\\>|===?|!==?|<<>>|<<<|>>>|~~~|::|<\\-|\\|>|=>|~|~=|=|/|\\\\\\\\|\\*\\*?|\\.\\.?\\.?|>=?|<=?|&&?&?|\\+\\+?|\\-\\-?|\\|\\|?\\|?|\\!|@|\\%?\\{\\}|%|\\[\\]|\\^(?:\\^\\^)?)',
TODO: 'FIXME: regexp doesn\'t have js equivalent',
originalRegex: '(?<!:)(:)(?>[a-zA-Z_][\\w@]*(?>[?!]|=(?![>=]))?|\\<\\>|===?|!==?|<<>>|<<<|>>>|~~~|::|<\\-|\\|>|=>|~|~=|=|/|\\\\\\\\|\\*\\*?|\\.\\.?\\.?|>=?|<=?|&&?&?|\\+\\+?|\\-\\-?|\\|\\|?\\|?|\\!|@|\\%?\\{\\}|%|\\[\\]|\\^(\\^\\^)?)',
comment: 'symbols' },
{ token: 'punctuation.definition.constant.elixir',
regex: '(?:[a-zA-Z_][\\w@]*(?:[?!])?):(?!:)',
TODO: 'FIXME: regexp doesn\'t have js equivalent',
originalRegex: '(?>[a-zA-Z_][\\w@]*(?>[?!])?)(:)(?!:)',
comment: 'symbols' },
{ token:
[ 'punctuation.definition.comment.elixir',
'comment.line.number-sign.elixir' ],
regex: '(#)(.*)' },
{ token: 'constant.numeric.elixir',
regex: '\\?(?:\\\\(?:x[\\da-fA-F]{1,2}(?![\\da-fA-F])\\b|[^xMC])|[^\\s\\\\])',
TODO: 'FIXME: regexp doesn\'t have js equivalent',
originalRegex: '(?<!\\w)\\?(\\\\(x\\h{1,2}(?!\\h)\\b|[^xMC])|[^\\s\\\\])',
comment: '\n\t\t\tmatches questionmark-letters.\n\n\t\t\texamples (1st alternation = hex):\n\t\t\t?\\x1 ?\\x61\n\n\t\t\texamples (2rd alternation = escaped):\n\t\t\t?\\n ?\\b\n\n\t\t\texamples (3rd alternation = normal):\n\t\t\t?a...
{ token: 'keyword.operator.assignment.augmented.elixir',
regex: '\\+=|\\-=|\\|\\|=|~=|&&=' },
{ token: 'keyword.operator.comparison.elixir',
regex: '===?|!==?|<=?|>=?' },
{ token: 'keyword.operator.bitwise.elixir',
regex: '\\|{3}|&{3}|\\^{3}|<{3}|>{3}|~{3}' },
{ token: 'keyword.operator.logical.elixir',
regex: '!+|\\bnot\\b|&&|\\band\\b|\\|\\||\\bor\\b|\\bxor\\b',
originalRegex: '(?<=[ \\t])!+|\\bnot\\b|&&|\\band\\b|\\|\\||\\bor\\b|\\bxor\\b' },
{ token: 'keyword.operator.arithmetic.elixir',
regex: '\\*|\\+|\\-|/' },
{ token: 'keyword.operator.other.elixir',
regex: '\\||\\+\\+|\\-\\-|\\*\\*|\\\\\\\\|\\<\\-|\\<\\>|\\<\\<|\\>\\>|\\:\\:|\\.\\.|\\|>|~|=>' },
{ token: 'keyword.operator.assignment.elixir', regex: '=' },
{ token: 'punctuation.separator.other.elixir', regex: ':' },
{ token: 'punctuation.separator.statement.elixir',
regex: '\\;' },
{ token: 'punctuation.separator.object.elixir', regex: ',' },
{ token: 'punctuation.separator.method.elixir', regex: '\\.' },
{ token: 'punctuation.section.scope.elixir', regex: '\\{|\\}' },
{ token: 'punctuation.section.array.elixir', regex: '\\[|\\]' },
{ token: 'punctuation.section.function.elixir',
regex: '\\(|\\)' } ],
'#escaped_char':
[ { token: 'constant.character.escape.elixir',
regex: '\\\\(?:x[\\da-fA-F]{1,2}|.)' } ],
'#interpolated_elixir':
[ { token:
[ 'source.elixir.embedded.source',
'source.elixir.embedded.source.empty' ],
regex: '(#\\{)(\\})' },
{ todo:
{ token: 'punctuation.section.embedded.elixir',
regex: '#\\{',
push:
[ { token: 'punctuation.section.embedded.elixir',
regex: '\\}',
next: 'pop' },
{ include: '#nest_curly_and_self' },
{ include: '$self' },
{ defaultToken: 'source.elixir.embedded.source' } ] } } ],
'#nest_curly_and_self':
[ { token: 'punctuation.section.scope.elixir',
regex: '\\{',
push:
[ { token: 'punctuation.section.scope.elixir',
regex: '\\}',
next: 'pop' },
{ include: '#nest_curly_and_self' } ] },
{ include: '$self' } ],
'#regex_sub':
[ { include: '#interpolated_elixir' },
{ include: '#escaped_char' },
{ token:
[ 'punctuation.definition.arbitrary-repitition.elixir',
'string.regexp.arbitrary-repitition.elixir',
'string.regexp.arbitrary-repitition.elixir',
'punctuation.definition.arbitrary-repitition.elixir' ],
regex: '(\\{)(\\d+)((?:,\\d+)?)(\\})' },
{ token: 'punctuation.definition.character-class.elixir',
( run in 1.484 second using v1.01-cache-2.11-cpan-8f98c5d2c55 )