1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
!(function (e) {
for (var a = '/\\*(?:[^*/]|\\*(?!/)|/(?!\\*)|<self>)*\\*/', t = 0; t < 2; t++)
a = a.replace(/<self>/g, function () {
return a;
});
(a = a.replace(/<self>/g, function () {
return '[^\\s\\S]';
})),
(e.languages.rust = {
comment: [
{ pattern: RegExp('(^|[^\\\\])' + a), lookbehind: !0, greedy: !0 },
{ pattern: /(^|[^\\:])\/\/.*/, lookbehind: !0, greedy: !0 },
],
string: {
pattern: /b?"(?:\\[\s\S]|[^\\"])*"|b?r(#*)"(?:[^"]|"(?!\1))*"\1/,
greedy: !0,
},
char: {
pattern:
/b?'(?:\\(?:x[0-7][\da-fA-F]|u\{(?:[\da-fA-F]_*){1,6}\}|.)|[^\\\r\n\t'])'/,
greedy: !0,
},
attribute: {
pattern: /#!?\[(?:[^\[\]"]|"(?:\\[\s\S]|[^\\"])*")*\]/,
greedy: !0,
alias: 'attr-name',
inside: { string: null },
},
'closure-params': {
pattern: /([=(,:]\s*|\bmove\s*)\|[^|]*\||\|[^|]*\|(?=\s*(?:\{|->))/,
lookbehind: !0,
greedy: !0,
inside: {
'closure-punctuation': { pattern: /^\||\|$/, alias: 'punctuation' },
rest: null,
},
},
'lifetime-annotation': { pattern: /'\w+/, alias: 'symbol' },
'fragment-specifier': {
pattern: /(\$\w+:)[a-z]+/,
lookbehind: !0,
alias: 'punctuation',
},
variable: /\$\w+/,
'function-definition': {
pattern: /(\bfn\s+)\w+/,
lookbehind: !0,
alias: 'function',
},
'type-definition': {
pattern: /(\b(?:enum|struct|trait|type|union)\s+)\w+/,
lookbehind: !0,
alias: 'class-name',
},
'module-declaration': [
{
pattern: /(\b(?:crate|mod)\s+)[a-z][a-z_\d]*/,
lookbehind: !0,
alias: 'namespace',
},
{
pattern:
/(\b(?:crate|self|super)\s*)::\s*[a-z][a-z_\d]*\b(?:\s*::(?:\s*[a-z][a-z_\d]*\s*::)*)?/,
lookbehind: !0,
alias: 'namespace',
inside: { punctuation: /::/ },
},
],
keyword: [
/\b(?:Self|abstract|as|async|await|become|box|break|const|continue|crate|do|dyn|else|enum|extern|final|fn|for|if|impl|in|let|loop|macro|match|mod|move|mut|override|priv|pub|ref|return|self|static|struct|super|trait|try|type|typeof|union|unsafe|unsized|use|virtual|where|while|yield)\b/,
/\b(?:bool|char|f(?:32|64)|[ui](?:8|16|32|64|128|size)|str)\b/,
],
function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())/,
macro: { pattern: /\b\w+!/, alias: 'property' },
constant: /\b[A-Z_][A-Z_\d]+\b/,
'class-name': /\b[A-Z]\w*\b/,
namespace: {
pattern: /(?:\b[a-z][a-z_\d]*\s*::\s*)*\b[a-z][a-z_\d]*\s*::(?!\s*<)/,
inside: { punctuation: /::/ },
},
number:
/\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0o[0-7](?:_?[0-7])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)(?:_?(?:f32|f64|[iu](?:8|16|32|64|size)?))?\b/,
boolean: /\b(?:false|true)\b/,
punctuation: /->|\.\.=|\.{1,3}|::|[{}[\];(),:]/,
operator: /[-+*\/%!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?=?|[@?]/,
}),
(e.languages.rust['closure-params'].inside.rest = e.languages.rust),
(e.languages.rust.attribute.inside.string = e.languages.rust.string);
})(Prism);
|
