1
|
|
|
// CodeMirror, copyright (c) by Marijn Haverbeke and others |
2
|
|
|
// Distributed under an MIT license: http://codemirror.net/LICENSE |
3
|
|
|
|
4
|
|
|
(function(mod) { |
5
|
|
|
if (typeof exports == "object" && typeof module == "object") // CommonJS |
6
|
|
|
mod(require("../../lib/codemirror"), require("../javascript/javascript"), require("../css/css"), require("../htmlmixed/htmlmixed")); |
7
|
|
|
else if (typeof define == "function" && define.amd) // AMD |
|
|
|
|
8
|
|
|
define(["../../lib/codemirror", "../javascript/javascript", "../css/css", "../htmlmixed/htmlmixed"], mod); |
9
|
|
|
else // Plain browser env |
10
|
|
|
mod(CodeMirror); |
|
|
|
|
11
|
|
|
})(function(CodeMirror) { |
12
|
|
|
"use strict"; |
13
|
|
|
|
14
|
|
|
CodeMirror.defineMode('jade', function (config) { |
15
|
|
|
// token types |
16
|
|
|
var KEYWORD = 'keyword'; |
17
|
|
|
var DOCTYPE = 'meta'; |
18
|
|
|
var ID = 'builtin'; |
19
|
|
|
var CLASS = 'qualifier'; |
20
|
|
|
|
21
|
|
|
var ATTRS_NEST = { |
22
|
|
|
'{': '}', |
23
|
|
|
'(': ')', |
24
|
|
|
'[': ']' |
25
|
|
|
}; |
26
|
|
|
|
27
|
|
|
var jsMode = CodeMirror.getMode(config, 'javascript'); |
28
|
|
|
|
29
|
|
|
function State() { |
30
|
|
|
this.javaScriptLine = false; |
31
|
|
|
this.javaScriptLineExcludesColon = false; |
32
|
|
|
|
33
|
|
|
this.javaScriptArguments = false; |
34
|
|
|
this.javaScriptArgumentsDepth = 0; |
35
|
|
|
|
36
|
|
|
this.isInterpolating = false; |
37
|
|
|
this.interpolationNesting = 0; |
38
|
|
|
|
39
|
|
|
this.jsState = jsMode.startState(); |
40
|
|
|
|
41
|
|
|
this.restOfLine = ''; |
42
|
|
|
|
43
|
|
|
this.isIncludeFiltered = false; |
44
|
|
|
this.isEach = false; |
45
|
|
|
|
46
|
|
|
this.lastTag = ''; |
47
|
|
|
this.scriptType = ''; |
48
|
|
|
|
49
|
|
|
// Attributes Mode |
50
|
|
|
this.isAttrs = false; |
51
|
|
|
this.attrsNest = []; |
52
|
|
|
this.inAttributeName = true; |
53
|
|
|
this.attributeIsType = false; |
54
|
|
|
this.attrValue = ''; |
55
|
|
|
|
56
|
|
|
// Indented Mode |
57
|
|
|
this.indentOf = Infinity; |
58
|
|
|
this.indentToken = ''; |
59
|
|
|
|
60
|
|
|
this.innerMode = null; |
61
|
|
|
this.innerState = null; |
62
|
|
|
|
63
|
|
|
this.innerModeForLine = false; |
64
|
|
|
} |
65
|
|
|
/** |
66
|
|
|
* Safely copy a state |
67
|
|
|
* |
68
|
|
|
* @return {State} |
69
|
|
|
*/ |
70
|
|
|
State.prototype.copy = function () { |
71
|
|
|
var res = new State(); |
72
|
|
|
res.javaScriptLine = this.javaScriptLine; |
73
|
|
|
res.javaScriptLineExcludesColon = this.javaScriptLineExcludesColon; |
74
|
|
|
res.javaScriptArguments = this.javaScriptArguments; |
75
|
|
|
res.javaScriptArgumentsDepth = this.javaScriptArgumentsDepth; |
76
|
|
|
res.isInterpolating = this.isInterpolating; |
77
|
|
|
res.interpolationNesting = this.intpolationNesting; |
78
|
|
|
|
79
|
|
|
res.jsState = CodeMirror.copyState(jsMode, this.jsState); |
80
|
|
|
|
81
|
|
|
res.innerMode = this.innerMode; |
82
|
|
|
if (this.innerMode && this.innerState) { |
83
|
|
|
res.innerState = CodeMirror.copyState(this.innerMode, this.innerState); |
84
|
|
|
} |
85
|
|
|
|
86
|
|
|
res.restOfLine = this.restOfLine; |
87
|
|
|
|
88
|
|
|
res.isIncludeFiltered = this.isIncludeFiltered; |
89
|
|
|
res.isEach = this.isEach; |
90
|
|
|
res.lastTag = this.lastTag; |
91
|
|
|
res.scriptType = this.scriptType; |
92
|
|
|
res.isAttrs = this.isAttrs; |
93
|
|
|
res.attrsNest = this.attrsNest.slice(); |
94
|
|
|
res.inAttributeName = this.inAttributeName; |
95
|
|
|
res.attributeIsType = this.attributeIsType; |
96
|
|
|
res.attrValue = this.attrValue; |
97
|
|
|
res.indentOf = this.indentOf; |
98
|
|
|
res.indentToken = this.indentToken; |
99
|
|
|
|
100
|
|
|
res.innerModeForLine = this.innerModeForLine; |
101
|
|
|
|
102
|
|
|
return res; |
103
|
|
|
}; |
104
|
|
|
|
105
|
|
|
function javaScript(stream, state) { |
106
|
|
|
if (stream.sol()) { |
107
|
|
|
// if javaScriptLine was set at end of line, ignore it |
108
|
|
|
state.javaScriptLine = false; |
109
|
|
|
state.javaScriptLineExcludesColon = false; |
110
|
|
|
} |
111
|
|
|
if (state.javaScriptLine) { |
|
|
|
|
112
|
|
|
if (state.javaScriptLineExcludesColon && stream.peek() === ':') { |
113
|
|
|
state.javaScriptLine = false; |
114
|
|
|
state.javaScriptLineExcludesColon = false; |
115
|
|
|
return; |
|
|
|
|
116
|
|
|
} |
117
|
|
|
var tok = jsMode.token(stream, state.jsState); |
118
|
|
|
if (stream.eol()) state.javaScriptLine = false; |
119
|
|
|
return tok || true; |
120
|
|
|
} |
121
|
|
|
} |
122
|
|
|
function javaScriptArguments(stream, state) { |
123
|
|
|
if (state.javaScriptArguments) { |
|
|
|
|
124
|
|
|
if (state.javaScriptArgumentsDepth === 0 && stream.peek() !== '(') { |
125
|
|
|
state.javaScriptArguments = false; |
126
|
|
|
return; |
|
|
|
|
127
|
|
|
} |
128
|
|
|
if (stream.peek() === '(') { |
129
|
|
|
state.javaScriptArgumentsDepth++; |
130
|
|
|
} else if (stream.peek() === ')') { |
131
|
|
|
state.javaScriptArgumentsDepth--; |
132
|
|
|
} |
133
|
|
|
if (state.javaScriptArgumentsDepth === 0) { |
134
|
|
|
state.javaScriptArguments = false; |
135
|
|
|
return; |
|
|
|
|
136
|
|
|
} |
137
|
|
|
|
138
|
|
|
var tok = jsMode.token(stream, state.jsState); |
139
|
|
|
return tok || true; |
140
|
|
|
} |
141
|
|
|
} |
142
|
|
|
|
143
|
|
|
function yieldStatement(stream) { |
144
|
|
|
if (stream.match(/^yield\b/)) { |
|
|
|
|
145
|
|
|
return 'keyword'; |
146
|
|
|
} |
147
|
|
|
} |
148
|
|
|
|
149
|
|
|
function doctype(stream) { |
150
|
|
|
if (stream.match(/^(?:doctype) *([^\n]+)?/)) { |
|
|
|
|
151
|
|
|
return DOCTYPE; |
152
|
|
|
} |
153
|
|
|
} |
154
|
|
|
|
155
|
|
|
function interpolation(stream, state) { |
156
|
|
|
if (stream.match('#{')) { |
|
|
|
|
157
|
|
|
state.isInterpolating = true; |
158
|
|
|
state.interpolationNesting = 0; |
159
|
|
|
return 'punctuation'; |
160
|
|
|
} |
161
|
|
|
} |
162
|
|
|
|
163
|
|
|
function interpolationContinued(stream, state) { |
164
|
|
|
if (state.isInterpolating) { |
|
|
|
|
165
|
|
|
if (stream.peek() === '}') { |
166
|
|
|
state.interpolationNesting--; |
167
|
|
|
if (state.interpolationNesting < 0) { |
168
|
|
|
stream.next(); |
169
|
|
|
state.isInterpolating = false; |
170
|
|
|
return 'puncutation'; |
171
|
|
|
} |
172
|
|
|
} else if (stream.peek() === '{') { |
173
|
|
|
state.interpolationNesting++; |
174
|
|
|
} |
175
|
|
|
return jsMode.token(stream, state.jsState) || true; |
176
|
|
|
} |
177
|
|
|
} |
178
|
|
|
|
179
|
|
|
function caseStatement(stream, state) { |
180
|
|
|
if (stream.match(/^case\b/)) { |
|
|
|
|
181
|
|
|
state.javaScriptLine = true; |
182
|
|
|
return KEYWORD; |
183
|
|
|
} |
184
|
|
|
} |
185
|
|
|
|
186
|
|
|
function when(stream, state) { |
187
|
|
|
if (stream.match(/^when\b/)) { |
|
|
|
|
188
|
|
|
state.javaScriptLine = true; |
189
|
|
|
state.javaScriptLineExcludesColon = true; |
190
|
|
|
return KEYWORD; |
191
|
|
|
} |
192
|
|
|
} |
193
|
|
|
|
194
|
|
|
function defaultStatement(stream) { |
195
|
|
|
if (stream.match(/^default\b/)) { |
|
|
|
|
196
|
|
|
return KEYWORD; |
197
|
|
|
} |
198
|
|
|
} |
199
|
|
|
|
200
|
|
|
function extendsStatement(stream, state) { |
201
|
|
|
if (stream.match(/^extends?\b/)) { |
|
|
|
|
202
|
|
|
state.restOfLine = 'string'; |
203
|
|
|
return KEYWORD; |
204
|
|
|
} |
205
|
|
|
} |
206
|
|
|
|
207
|
|
|
function append(stream, state) { |
208
|
|
|
if (stream.match(/^append\b/)) { |
|
|
|
|
209
|
|
|
state.restOfLine = 'variable'; |
210
|
|
|
return KEYWORD; |
211
|
|
|
} |
212
|
|
|
} |
213
|
|
|
function prepend(stream, state) { |
214
|
|
|
if (stream.match(/^prepend\b/)) { |
|
|
|
|
215
|
|
|
state.restOfLine = 'variable'; |
216
|
|
|
return KEYWORD; |
217
|
|
|
} |
218
|
|
|
} |
219
|
|
|
function block(stream, state) { |
220
|
|
|
if (stream.match(/^block\b *(?:(prepend|append)\b)?/)) { |
|
|
|
|
221
|
|
|
state.restOfLine = 'variable'; |
222
|
|
|
return KEYWORD; |
223
|
|
|
} |
224
|
|
|
} |
225
|
|
|
|
226
|
|
|
function include(stream, state) { |
227
|
|
|
if (stream.match(/^include\b/)) { |
|
|
|
|
228
|
|
|
state.restOfLine = 'string'; |
229
|
|
|
return KEYWORD; |
230
|
|
|
} |
231
|
|
|
} |
232
|
|
|
|
233
|
|
|
function includeFiltered(stream, state) { |
234
|
|
|
if (stream.match(/^include:([a-zA-Z0-9\-]+)/, false) && stream.match('include')) { |
|
|
|
|
235
|
|
|
state.isIncludeFiltered = true; |
236
|
|
|
return KEYWORD; |
237
|
|
|
} |
238
|
|
|
} |
239
|
|
|
|
240
|
|
|
function includeFilteredContinued(stream, state) { |
241
|
|
|
if (state.isIncludeFiltered) { |
|
|
|
|
242
|
|
|
var tok = filter(stream, state); |
243
|
|
|
state.isIncludeFiltered = false; |
244
|
|
|
state.restOfLine = 'string'; |
245
|
|
|
return tok; |
246
|
|
|
} |
247
|
|
|
} |
248
|
|
|
|
249
|
|
|
function mixin(stream, state) { |
250
|
|
|
if (stream.match(/^mixin\b/)) { |
|
|
|
|
251
|
|
|
state.javaScriptLine = true; |
252
|
|
|
return KEYWORD; |
253
|
|
|
} |
254
|
|
|
} |
255
|
|
|
|
256
|
|
|
function call(stream, state) { |
257
|
|
|
if (stream.match(/^\+([-\w]+)/)) { |
258
|
|
|
if (!stream.match(/^\( *[-\w]+ *=/, false)) { |
259
|
|
|
state.javaScriptArguments = true; |
260
|
|
|
state.javaScriptArgumentsDepth = 0; |
261
|
|
|
} |
262
|
|
|
return 'variable'; |
263
|
|
|
} |
264
|
|
|
if (stream.match(/^\+#{/, false)) { |
|
|
|
|
265
|
|
|
stream.next(); |
266
|
|
|
state.mixinCallAfter = true; |
267
|
|
|
return interpolation(stream, state); |
268
|
|
|
} |
269
|
|
|
} |
270
|
|
|
function callArguments(stream, state) { |
271
|
|
|
if (state.mixinCallAfter) { |
|
|
|
|
272
|
|
|
state.mixinCallAfter = false; |
273
|
|
|
if (!stream.match(/^\( *[-\w]+ *=/, false)) { |
274
|
|
|
state.javaScriptArguments = true; |
275
|
|
|
state.javaScriptArgumentsDepth = 0; |
276
|
|
|
} |
277
|
|
|
return true; |
278
|
|
|
} |
279
|
|
|
} |
280
|
|
|
|
281
|
|
|
function conditional(stream, state) { |
282
|
|
|
if (stream.match(/^(if|unless|else if|else)\b/)) { |
|
|
|
|
283
|
|
|
state.javaScriptLine = true; |
284
|
|
|
return KEYWORD; |
285
|
|
|
} |
286
|
|
|
} |
287
|
|
|
|
288
|
|
|
function each(stream, state) { |
289
|
|
|
if (stream.match(/^(- *)?(each|for)\b/)) { |
|
|
|
|
290
|
|
|
state.isEach = true; |
291
|
|
|
return KEYWORD; |
292
|
|
|
} |
293
|
|
|
} |
294
|
|
|
function eachContinued(stream, state) { |
295
|
|
|
if (state.isEach) { |
|
|
|
|
296
|
|
|
if (stream.match(/^ in\b/)) { |
297
|
|
|
state.javaScriptLine = true; |
298
|
|
|
state.isEach = false; |
299
|
|
|
return KEYWORD; |
300
|
|
|
} else if (stream.sol() || stream.eol()) { |
301
|
|
|
state.isEach = false; |
|
|
|
|
302
|
|
|
} else if (stream.next()) { |
|
|
|
|
303
|
|
|
while (!stream.match(/^ in\b/, false) && stream.next()); |
|
|
|
|
304
|
|
|
return 'variable'; |
305
|
|
|
} |
306
|
|
|
} |
307
|
|
|
} |
308
|
|
|
|
309
|
|
|
function whileStatement(stream, state) { |
310
|
|
|
if (stream.match(/^while\b/)) { |
|
|
|
|
311
|
|
|
state.javaScriptLine = true; |
312
|
|
|
return KEYWORD; |
313
|
|
|
} |
314
|
|
|
} |
315
|
|
|
|
316
|
|
|
function tag(stream, state) { |
317
|
|
|
var captures; |
318
|
|
|
if (captures = stream.match(/^(\w(?:[-:\w]*\w)?)\/?/)) { |
|
|
|
|
319
|
|
|
state.lastTag = captures[1].toLowerCase(); |
320
|
|
|
if (state.lastTag === 'script') { |
321
|
|
|
state.scriptType = 'application/javascript'; |
322
|
|
|
} |
323
|
|
|
return 'tag'; |
324
|
|
|
} |
325
|
|
|
} |
326
|
|
|
|
327
|
|
|
function filter(stream, state) { |
328
|
|
|
if (stream.match(/^:([\w\-]+)/)) { |
|
|
|
|
329
|
|
|
var innerMode; |
330
|
|
|
if (config && config.innerModes) { |
331
|
|
|
innerMode = config.innerModes(stream.current().substring(1)); |
332
|
|
|
} |
333
|
|
|
if (!innerMode) { |
334
|
|
|
innerMode = stream.current().substring(1); |
335
|
|
|
} |
336
|
|
|
if (typeof innerMode === 'string') { |
337
|
|
|
innerMode = CodeMirror.getMode(config, innerMode); |
338
|
|
|
} |
339
|
|
|
setInnerMode(stream, state, innerMode); |
340
|
|
|
return 'atom'; |
341
|
|
|
} |
342
|
|
|
} |
343
|
|
|
|
344
|
|
|
function code(stream, state) { |
345
|
|
|
if (stream.match(/^(!?=|-)/)) { |
|
|
|
|
346
|
|
|
state.javaScriptLine = true; |
347
|
|
|
return 'punctuation'; |
348
|
|
|
} |
349
|
|
|
} |
350
|
|
|
|
351
|
|
|
function id(stream) { |
352
|
|
|
if (stream.match(/^#([\w-]+)/)) { |
|
|
|
|
353
|
|
|
return ID; |
354
|
|
|
} |
355
|
|
|
} |
356
|
|
|
|
357
|
|
|
function className(stream) { |
358
|
|
|
if (stream.match(/^\.([\w-]+)/)) { |
|
|
|
|
359
|
|
|
return CLASS; |
360
|
|
|
} |
361
|
|
|
} |
362
|
|
|
|
363
|
|
|
function attrs(stream, state) { |
364
|
|
|
if (stream.peek() == '(') { |
|
|
|
|
365
|
|
|
stream.next(); |
366
|
|
|
state.isAttrs = true; |
367
|
|
|
state.attrsNest = []; |
368
|
|
|
state.inAttributeName = true; |
369
|
|
|
state.attrValue = ''; |
370
|
|
|
state.attributeIsType = false; |
371
|
|
|
return 'punctuation'; |
372
|
|
|
} |
373
|
|
|
} |
374
|
|
|
|
375
|
|
|
function attrsContinued(stream, state) { |
376
|
|
|
if (state.isAttrs) { |
|
|
|
|
377
|
|
|
if (ATTRS_NEST[stream.peek()]) { |
378
|
|
|
state.attrsNest.push(ATTRS_NEST[stream.peek()]); |
379
|
|
|
} |
380
|
|
|
if (state.attrsNest[state.attrsNest.length - 1] === stream.peek()) { |
381
|
|
|
state.attrsNest.pop(); |
382
|
|
|
} else if (stream.eat(')')) { |
383
|
|
|
state.isAttrs = false; |
384
|
|
|
return 'punctuation'; |
385
|
|
|
} |
386
|
|
|
if (state.inAttributeName && stream.match(/^[^=,\)!]+/)) { |
387
|
|
|
if (stream.peek() === '=' || stream.peek() === '!') { |
388
|
|
|
state.inAttributeName = false; |
389
|
|
|
state.jsState = jsMode.startState(); |
390
|
|
|
if (state.lastTag === 'script' && stream.current().trim().toLowerCase() === 'type') { |
391
|
|
|
state.attributeIsType = true; |
392
|
|
|
} else { |
393
|
|
|
state.attributeIsType = false; |
394
|
|
|
} |
395
|
|
|
} |
396
|
|
|
return 'attribute'; |
397
|
|
|
} |
398
|
|
|
|
399
|
|
|
var tok = jsMode.token(stream, state.jsState); |
400
|
|
|
if (state.attributeIsType && tok === 'string') { |
401
|
|
|
state.scriptType = stream.current().toString(); |
402
|
|
|
} |
403
|
|
|
if (state.attrsNest.length === 0 && (tok === 'string' || tok === 'variable' || tok === 'keyword')) { |
404
|
|
|
try { |
405
|
|
|
Function('', 'var x ' + state.attrValue.replace(/,\s*$/, '').replace(/^!/, '')); |
|
|
|
|
406
|
|
|
state.inAttributeName = true; |
407
|
|
|
state.attrValue = ''; |
408
|
|
|
stream.backUp(stream.current().length); |
409
|
|
|
return attrsContinued(stream, state); |
410
|
|
|
} catch (ex) { |
|
|
|
|
411
|
|
|
//not the end of an attribute |
412
|
|
|
} |
413
|
|
|
} |
414
|
|
|
state.attrValue += stream.current(); |
415
|
|
|
return tok || true; |
416
|
|
|
} |
417
|
|
|
} |
418
|
|
|
|
419
|
|
|
function attributesBlock(stream, state) { |
420
|
|
|
if (stream.match(/^&attributes\b/)) { |
|
|
|
|
421
|
|
|
state.javaScriptArguments = true; |
422
|
|
|
state.javaScriptArgumentsDepth = 0; |
423
|
|
|
return 'keyword'; |
424
|
|
|
} |
425
|
|
|
} |
426
|
|
|
|
427
|
|
|
function indent(stream) { |
428
|
|
|
if (stream.sol() && stream.eatSpace()) { |
|
|
|
|
429
|
|
|
return 'indent'; |
430
|
|
|
} |
431
|
|
|
} |
432
|
|
|
|
433
|
|
|
function comment(stream, state) { |
434
|
|
|
if (stream.match(/^ *\/\/(-)?([^\n]*)/)) { |
|
|
|
|
435
|
|
|
state.indentOf = stream.indentation(); |
436
|
|
|
state.indentToken = 'comment'; |
437
|
|
|
return 'comment'; |
438
|
|
|
} |
439
|
|
|
} |
440
|
|
|
|
441
|
|
|
function colon(stream) { |
442
|
|
|
if (stream.match(/^: */)) { |
|
|
|
|
443
|
|
|
return 'colon'; |
444
|
|
|
} |
445
|
|
|
} |
446
|
|
|
|
447
|
|
|
function text(stream, state) { |
448
|
|
|
if (stream.match(/^(?:\| ?| )([^\n]+)/)) { |
449
|
|
|
return 'string'; |
450
|
|
|
} |
451
|
|
|
if (stream.match(/^(<[^\n]*)/, false)) { |
|
|
|
|
452
|
|
|
// html string |
453
|
|
|
setInnerMode(stream, state, 'htmlmixed'); |
454
|
|
|
state.innerModeForLine = true; |
455
|
|
|
return innerMode(stream, state, true); |
456
|
|
|
} |
457
|
|
|
} |
458
|
|
|
|
459
|
|
|
function dot(stream, state) { |
460
|
|
|
if (stream.eat('.')) { |
|
|
|
|
461
|
|
|
var innerMode = null; |
462
|
|
|
if (state.lastTag === 'script' && state.scriptType.toLowerCase().indexOf('javascript') != -1) { |
463
|
|
|
innerMode = state.scriptType.toLowerCase().replace(/"|'/g, ''); |
464
|
|
|
} else if (state.lastTag === 'style') { |
465
|
|
|
innerMode = 'css'; |
466
|
|
|
} |
467
|
|
|
setInnerMode(stream, state, innerMode); |
468
|
|
|
return 'dot'; |
469
|
|
|
} |
470
|
|
|
} |
471
|
|
|
|
472
|
|
|
function fail(stream) { |
473
|
|
|
stream.next(); |
474
|
|
|
return null; |
475
|
|
|
} |
476
|
|
|
|
477
|
|
|
|
478
|
|
|
function setInnerMode(stream, state, mode) { |
479
|
|
|
mode = CodeMirror.mimeModes[mode] || mode; |
480
|
|
|
mode = config.innerModes ? config.innerModes(mode) || mode : mode; |
481
|
|
|
mode = CodeMirror.mimeModes[mode] || mode; |
482
|
|
|
mode = CodeMirror.getMode(config, mode); |
483
|
|
|
state.indentOf = stream.indentation(); |
484
|
|
|
|
485
|
|
|
if (mode && mode.name !== 'null') { |
486
|
|
|
state.innerMode = mode; |
487
|
|
|
} else { |
488
|
|
|
state.indentToken = 'string'; |
489
|
|
|
} |
490
|
|
|
} |
491
|
|
|
function innerMode(stream, state, force) { |
492
|
|
|
if (stream.indentation() > state.indentOf || (state.innerModeForLine && !stream.sol()) || force) { |
493
|
|
|
if (state.innerMode) { |
494
|
|
|
if (!state.innerState) { |
495
|
|
|
state.innerState = state.innerMode.startState ? state.innerMode.startState(stream.indentation()) : {}; |
496
|
|
|
} |
497
|
|
|
return stream.hideFirstChars(state.indentOf + 2, function () { |
498
|
|
|
return state.innerMode.token(stream, state.innerState) || true; |
499
|
|
|
}); |
500
|
|
|
} else { |
|
|
|
|
501
|
|
|
stream.skipToEnd(); |
502
|
|
|
return state.indentToken; |
503
|
|
|
} |
504
|
|
|
} else if (stream.sol()) { |
|
|
|
|
505
|
|
|
state.indentOf = Infinity; |
506
|
|
|
state.indentToken = null; |
507
|
|
|
state.innerMode = null; |
508
|
|
|
state.innerState = null; |
|
|
|
|
509
|
|
|
} |
510
|
|
|
} |
511
|
|
|
function restOfLine(stream, state) { |
512
|
|
|
if (stream.sol()) { |
513
|
|
|
// if restOfLine was set at end of line, ignore it |
514
|
|
|
state.restOfLine = ''; |
515
|
|
|
} |
516
|
|
|
if (state.restOfLine) { |
|
|
|
|
517
|
|
|
stream.skipToEnd(); |
518
|
|
|
var tok = state.restOfLine; |
519
|
|
|
state.restOfLine = ''; |
520
|
|
|
return tok; |
521
|
|
|
} |
522
|
|
|
} |
523
|
|
|
|
524
|
|
|
|
525
|
|
|
function startState() { |
526
|
|
|
return new State(); |
527
|
|
|
} |
528
|
|
|
function copyState(state) { |
529
|
|
|
return state.copy(); |
530
|
|
|
} |
531
|
|
|
/** |
532
|
|
|
* Get the next token in the stream |
533
|
|
|
* |
534
|
|
|
* @param {Stream} stream |
535
|
|
|
* @param {State} state |
536
|
|
|
*/ |
537
|
|
|
function nextToken(stream, state) { |
538
|
|
|
var tok = innerMode(stream, state) |
539
|
|
|
|| restOfLine(stream, state) |
540
|
|
|
|| interpolationContinued(stream, state) |
541
|
|
|
|| includeFilteredContinued(stream, state) |
542
|
|
|
|| eachContinued(stream, state) |
543
|
|
|
|| attrsContinued(stream, state) |
544
|
|
|
|| javaScript(stream, state) |
545
|
|
|
|| javaScriptArguments(stream, state) |
546
|
|
|
|| callArguments(stream, state) |
547
|
|
|
|
548
|
|
|
|| yieldStatement(stream, state) |
|
|
|
|
549
|
|
|
|| doctype(stream, state) |
|
|
|
|
550
|
|
|
|| interpolation(stream, state) |
551
|
|
|
|| caseStatement(stream, state) |
552
|
|
|
|| when(stream, state) |
553
|
|
|
|| defaultStatement(stream, state) |
|
|
|
|
554
|
|
|
|| extendsStatement(stream, state) |
555
|
|
|
|| append(stream, state) |
556
|
|
|
|| prepend(stream, state) |
557
|
|
|
|| block(stream, state) |
558
|
|
|
|| include(stream, state) |
559
|
|
|
|| includeFiltered(stream, state) |
560
|
|
|
|| mixin(stream, state) |
561
|
|
|
|| call(stream, state) |
562
|
|
|
|| conditional(stream, state) |
563
|
|
|
|| each(stream, state) |
564
|
|
|
|| whileStatement(stream, state) |
565
|
|
|
|| tag(stream, state) |
566
|
|
|
|| filter(stream, state) |
567
|
|
|
|| code(stream, state) |
568
|
|
|
|| id(stream, state) |
|
|
|
|
569
|
|
|
|| className(stream, state) |
|
|
|
|
570
|
|
|
|| attrs(stream, state) |
571
|
|
|
|| attributesBlock(stream, state) |
572
|
|
|
|| indent(stream, state) |
|
|
|
|
573
|
|
|
|| text(stream, state) |
574
|
|
|
|| comment(stream, state) |
575
|
|
|
|| colon(stream, state) |
|
|
|
|
576
|
|
|
|| dot(stream, state) |
577
|
|
|
|| fail(stream, state); |
|
|
|
|
578
|
|
|
|
579
|
|
|
return tok === true ? null : tok; |
580
|
|
|
} |
581
|
|
|
return { |
582
|
|
|
startState: startState, |
583
|
|
|
copyState: copyState, |
584
|
|
|
token: nextToken |
585
|
|
|
}; |
586
|
|
|
}); |
587
|
|
|
|
588
|
|
|
CodeMirror.defineMIME('text/x-jade', 'jade'); |
589
|
|
|
|
590
|
|
|
}); |
591
|
|
|
|
This checks looks for references to variables that have not been declared. This is most likey a typographical error or a variable has been renamed.
To learn more about declaring variables in Javascript, see the MDN.